Pre-cleanup checkpoint: Save all work before cleanup

Author: avivsinai

package.json

@@ -90,7 +90,29 @@
         "promptcode.ignorePatterns": {
           "type": "string",
           "default": "",
-          "description": "Custom patterns to ignore when scanning files (one per line)"
+          "description": "[Deprecated] Use .promptcode_ignore file at workspace root instead. Custom patterns to ignore when scanning files (one per line)"
+        },
+        "promptcode.includeBuiltInTemplates": {
+          "type": "boolean",
+          "default": true,
+          "description": "Include built-in prompt templates in the PromptCode UI"
+        },
+        "promptcode.promptFolders": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [
+            ".promptcode/prompts",
+            ".cursor/rules",
+            ".github/copilot-instructions.md",
+            ".zed/",
+            ".windsurfrules",
+            ".clinerules",
+            ".ai-rules/",
+            "ai-docs/"
+          ],
+          "description": "Additional folders/files to scan for prompt templates"
         },
         "promptcode.enableTelemetry": {
           "type": "boolean",

packages/core/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "es2020",
+    "module": "commonjs",
     "lib": ["ES2020"],
     "declaration": true,
     "outDir": "./dist",
@@ -11,7 +11,7 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
-    "moduleResolution": "bundler"
+    "moduleResolution": "node"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

scripts/build-tests.js

@@ -10,6 +10,8 @@ const testEntryPoints = [
   'src/test/runTests.ts',
   'src/test/filePattern.test.ts',
   'src/test/generatePatternsFromSelection.test.ts',
+  'src/test/smoke.test.ts',
+  'src/test/migration.test.ts',
   // Also compile the utils that tests depend on
   'src/utils/filePattern.ts',
   'src/utils/generatePatternsFromSelection.ts'

src/extension.ts

@@ -17,6 +17,16 @@ import { FileListProcessor } from './fileListProcessor';
 // Import the moved type
 import type { SelectedFile } from '@promptcode/core';
 
+// Security helper to prevent path traversal attacks
+function resolveSecurePath(rootPath: string, relativePath: string): string {
+	const resolved = path.resolve(rootPath, relativePath);
+	const rootResolved = path.resolve(rootPath) + path.sep;
+	if (!resolved.startsWith(rootResolved)) {
+		throw new Error('Security Error: Path traversal attempt detected');
+	}
+	return resolved;
+}
+
 let lastGeneratedPrompt: string | null = null; // Variable to store the last generated prompt
 
 // Export a getter for the last generated prompt
@@ -99,7 +109,7 @@ export function activate(context: vscode.ExtensionContext) {
 
 	// Initialize output channel
 	const outputChannel = vscode.window.createOutputChannel('PromptCode');
-	outputChannel.show(true);
+	// Don't show automatically - only show on error or user request
 
 	// Get the workspace folder
 	const workspaceRoot = vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0
@@ -181,7 +191,7 @@ export function activate(context: vscode.ExtensionContext) {
 	// Register select all command
 	const selectAllCommand = vscode.commands.registerCommand('promptcode.selectAll', async () => {
 		await vscode.window.withProgress({
-			location: vscode.ProgressLocation.Notification,
+			location: vscode.ProgressLocation.Window,
 			title: "Selecting all files...",
 			cancellable: false
 		}, async () => {
@@ -193,7 +203,7 @@ export function activate(context: vscode.ExtensionContext) {
 	// Register deselect all command
 	const deselectAllCommand = vscode.commands.registerCommand('promptcode.deselectAll', async () => {
 		await vscode.window.withProgress({
-			location: vscode.ProgressLocation.Notification,
+			location: vscode.ProgressLocation.Window,
 			title: "Deselecting all files...",
 			cancellable: false
 		}, async () => {
@@ -236,7 +246,7 @@ export function activate(context: vscode.ExtensionContext) {
 	const generatePromptCommand = vscode.commands.registerCommand('promptcode.generatePrompt', async () => {
 		// Generate the prompt text
 		vscode.window.withProgress({
-			location: vscode.ProgressLocation.Notification,
+			location: vscode.ProgressLocation.Window,
 			title: 'Generating Prompt',
 			cancellable: false
 		}, async (progress) => {
@@ -353,7 +363,7 @@ export function activate(context: vscode.ExtensionContext) {
 	const copyPromptDirectlyCommand = vscode.commands.registerCommand('promptcode.copyPromptDirectly', async () => {
 		// Generate the prompt text and copy to clipboard
 		vscode.window.withProgress({
-			location: vscode.ProgressLocation.Notification,
+			location: vscode.ProgressLocation.Window,
 			title: 'Generating and Copying Prompt',
 			cancellable: false
 		}, async (progress) => {
@@ -440,7 +450,7 @@ export function activate(context: vscode.ExtensionContext) {
 			}
 
 			// Construct the full file path using the determined workspace folder
-			const fullPath = path.join(targetWorkspaceFolder.uri.fsPath, filePath);
+			const fullPath = resolveSecurePath(targetWorkspaceFolder.uri.fsPath, filePath);
 
 			// Handle different file operations
 			switch (fileOperation.toUpperCase()) {
@@ -457,6 +467,17 @@ export function activate(context: vscode.ExtensionContext) {
 					break;
 
 				case 'DELETE':
+					// Confirm deletion with user for security
+					const userChoice = await vscode.window.showWarningMessage(
+						`Are you sure you want to delete ${path.basename(fullPath)}?`,
+						{ modal: true, detail: `Full path: ${fullPath}` },
+						'Delete',
+						'Cancel'
+					);
+					if (userChoice !== 'Delete') {
+						vscode.window.showInformationMessage('Deletion cancelled');
+						return;
+					}
 					// Delete the file
 					await fs.promises.unlink(fullPath);
 					break;
@@ -687,7 +708,7 @@ export function activate(context: vscode.ExtensionContext) {
 
 		// Show progress indicator
 		await vscode.window.withProgress({
-			location: vscode.ProgressLocation.Notification,
+			location: vscode.ProgressLocation.Window,
 			title: "Processing selected files...",
 			cancellable: false
 		}, async (progress) => {
@@ -1112,7 +1133,8 @@ export function activate(context: vscode.ExtensionContext) {
 				} else {
 					// It's a relative path, check if workspaceFolderRootPath is provided and valid
 					if (workspaceFolderRootPath && fs.existsSync(workspaceFolderRootPath)) {
-						fileUri = vscode.Uri.file(path.join(workspaceFolderRootPath, filePath));
+						const securePath = resolveSecurePath(workspaceFolderRootPath, filePath);
+						fileUri = vscode.Uri.file(securePath);
 					} else {
 						// Try to find the file in one of the workspace folders
 						let found = false;

src/test/index.ts

@@ -6,7 +6,8 @@ export function run(): Promise<void> {
   // Create the mocha test
   const mocha = new Mocha({
     ui: 'tdd',
-    color: true
+    color: true,
+    timeout: 10000 // 10 second timeout
   });
 
   const testsRoot = path.resolve(__dirname, '.');
@@ -28,6 +29,10 @@ export function run(): Promise<void> {
           } else {
             c();
           }
+          // Force exit after tests complete
+          setTimeout(() => {
+            process.exit(failures > 0 ? 1 : 0);
+          }, 1000);
         });
       } catch (err) {
         console.error(err);

src/test/migration.test.ts

@@ -0,0 +1,151 @@
+import * as assert from 'assert';
+import { buildPrompt, buildTreeFromSelection, generatePatternsFromSelection, countTokens } from '@promptcode/core';
+import type { SelectedFile } from '@promptcode/core';
+
+suite('Core Migration Test', () => {
+    test('buildPrompt should generate correct output with tag compatibility', async () => {
+        const selectedFiles: SelectedFile[] = [
+            {
+                path: '/test/file1.ts',
+                name: 'file1.ts',
+                content: 'const hello = "world";',
+                relativePath: 'file1.ts',
+                rootPath: '/test',
+                tokens: 10
+            },
+            {
+                path: '/test/dir/file2.ts',
+                name: 'file2.ts',
+                content: 'export function test() { return true; }',
+                relativePath: 'dir/file2.ts',
+                rootPath: '/test',
+                tokens: 15
+            }
+        ];
+
+        const result = await buildPrompt(selectedFiles, 'Test instructions', {
+            includeFiles: true,
+            includeInstructions: true,
+            includeFileContents: true
+        });
+
+        const prompt = result.prompt;
+
+        // Verify the prompt contains expected tags
+        assert.ok(prompt.includes('<user_instructions>'));
+        assert.ok(prompt.includes('Test instructions'));
+        assert.ok(prompt.includes('</user_instructions>'));
+        assert.ok(prompt.includes('<file_tree>'));
+        assert.ok(prompt.includes('</file_tree>'));
+        assert.ok(prompt.includes('<files>'));
+        assert.ok(prompt.includes('file1.ts'));
+        assert.ok(prompt.includes('file2.ts'));
+        assert.ok(prompt.includes('const hello = "world";'));
+        assert.ok(prompt.includes('export function test() { return true; }'));
+        assert.ok(prompt.includes('</files>'));
+    });
+
+    test('buildTreeFromSelection should generate correct tree structure', () => {
+        const selectedFiles: SelectedFile[] = [
+            {
+                path: '/test/src/index.ts',
+                name: 'index.ts',
+                content: '',
+                relativePath: 'src/index.ts',
+                rootPath: '/test',
+                tokens: 0
+            },
+            {
+                path: '/test/src/utils/helper.ts',
+                name: 'helper.ts',
+                content: '',
+                relativePath: 'src/utils/helper.ts',
+                rootPath: '/test',
+                tokens: 0
+            },
+            {
+                path: '/test/README.md',
+                name: 'README.md',
+                content: '',
+                relativePath: 'README.md',
+                rootPath: '/test',
+                tokens: 0
+            }
+        ];
+
+        const tree = buildTreeFromSelection(selectedFiles);
+        
+        // Verify tree structure
+        assert.ok(tree.includes('src/'));
+        assert.ok(tree.includes('index.ts'));
+        assert.ok(tree.includes('utils/'));
+        assert.ok(tree.includes('helper.ts'));
+        assert.ok(tree.includes('README.md'));
+    });
+
+    test('generatePatternsFromSelection should create correct patterns', () => {
+        const selectedFiles: SelectedFile[] = [
+            {
+                path: '/test/src/components/Button.tsx',
+                name: 'Button.tsx',
+                content: '',
+                relativePath: 'src/components/Button.tsx',
+                rootPath: '/test',
+                tokens: 0
+            },
+            {
+                path: '/test/src/components/Input.tsx',
+                name: 'Input.tsx',
+                content: '',
+                relativePath: 'src/components/Input.tsx',
+                rootPath: '/test',
+                tokens: 0
+            },
+            {
+                path: '/test/src/utils/helper.ts',
+                name: 'helper.ts',
+                content: '',
+                relativePath: 'src/utils/helper.ts',
+                rootPath: '/test',
+                tokens: 0
+            }
+        ];
+
+        const patterns = generatePatternsFromSelection(selectedFiles);
+        
+        // Should consolidate to pattern
+        assert.ok(patterns.includes('src/components/*.tsx'));
+        assert.ok(patterns.includes('src/utils/helper.ts'));
+    });
+
+    test('countTokens should return consistent results', () => {
+        const text = 'This is a test string for counting tokens in the VS Code extension.';
+        const tokens = countTokens(text);
+        
+        // Verify token count is reasonable
+        assert.ok(tokens > 0);
+        assert.ok(tokens < 100); // Should be much less than 100 for this short string
+    });
+
+    test('Tag compatibility layer should transform old tags to new ones', () => {
+        // This tests the tag transformation that happens in extension.ts
+        const oldPrompt = '<instructions>Test</instructions><file_map>tree</file_map><file_contents>content</file_contents>';
+        
+        // Simulate the tag transformation logic from extension.ts
+        const TAG_MAP = {
+            'instructions': 'user_instructions',
+            '/instructions': '/user_instructions',
+            'file_map': 'file_tree',
+            '/file_map': '/file_tree',
+            'file_contents': 'files',
+            '/file_contents': '/files'
+        } as const;
+        
+        const newPrompt = oldPrompt.replace(/<(\/?)(instructions|file_map|file_contents)>/g, (match, slash, tag) => {
+            const key = `${slash}${tag}` as keyof typeof TAG_MAP;
+            return TAG_MAP[key] ? `<${TAG_MAP[key]}>` : match;
+        });
+        
+        assert.strictEqual(newPrompt, '<user_instructions>Test</user_instructions><file_tree>tree</file_tree><files>content</files>');
+    });
+});

src/test/smoke.test.ts

@@ -0,0 +1,48 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+suite('Extension Smoke Test', () => {
+    vscode.window.showInformationMessage('Start smoke tests.');
+
+    test('Extension should be present', () => {
+        assert.ok(vscode.extensions.getExtension('cogflows.promptcode'));
+    });
+
+    test('Extension should activate', async () => {
+        const ext = vscode.extensions.getExtension('cogflows.promptcode');
+        assert.ok(ext);
+        await ext!.activate();
+        assert.ok(ext!.isActive);
+    });
+
+    test('Commands should be registered', async () => {
+        const commands = await vscode.commands.getCommands(true);
+        
+        // Check that main commands are registered
+        assert.ok(commands.includes('promptcode.showPromptCodeView'));
+        assert.ok(commands.includes('promptcode.generatePrompt'));
+        assert.ok(commands.includes('promptcode.selectAll'));
+        assert.ok(commands.includes('promptcode.deselectAll'));
+        assert.ok(commands.includes('promptcode.clearTokenCache'));
+    });
+
+    test('Core integration should work', async () => {
+        // This test verifies that the core package is properly integrated
+        const ext = vscode.extensions.getExtension('cogflows.promptcode');
+        await ext!.activate();
+        
+        // Try to get selected files (should return empty array initially)
+        const result = await vscode.commands.executeCommand('promptcode.getSelectedFiles');
+        assert.ok(Array.isArray(result));
+    });
+
+    test('Should handle deactivation gracefully', () => {
+        // This test ensures the extension can deactivate without errors
+        const ext = vscode.extensions.getExtension('cogflows.promptcode');
+        if (ext && ext.exports && ext.exports.deactivate) {
+            assert.doesNotThrow(() => {
+                ext.exports.deactivate();
+            });
+        }
+    });
+});