sam-coder-cli 1.0.0

package/src/cliAgentUtils.js

@@ -0,0 +1,73 @@
+const fs = require('fs').promises;
+const path = require('path');
+const { exec } = require('child_process');
+const util = require('util');
+const execPromise = util.promisify(exec);
+
+class CLIAgentUtils {
+  constructor() {
+    this.workspaceRoot = process.cwd();
+  }
+
+  // Log to console
+  log(message) {
+    console.log(`[AGENT] ${message}`);
+  }
+
+  // Read a file
+  async readFile(filePath, maxTokens) {
+    try {
+      const resolvedPath = this._resolveFilePath(filePath);
+      const content = await fs.readFile(resolvedPath, 'utf-8');
+      
+      if (maxTokens && content.length > maxTokens) {
+        return content.substring(0, maxTokens) + '... [truncated]';
+      }
+      
+      return content;
+    } catch (error) {
+      throw new Error(`Error reading file: ${error.message}`);
+    }
+  }
+
+  // Write to a file
+  async writeFile(filePath, content) {
+    try {
+      const resolvedPath = this._resolveFilePath(filePath);
+      const dir = path.dirname(resolvedPath);
+      
+      // Create directory if it doesn't exist
+      await fs.mkdir(dir, { recursive: true });
+      
+      // Write file
+      await fs.writeFile(resolvedPath, content, 'utf-8');
+    } catch (error) {
+      throw new Error(`Error writing file: ${error.message}`);
+    }
+  }
+
+  // Run a command
+  async runCommand(command) {
+    try {
+      const { stdout, stderr } = await execPromise(command, { cwd: this.workspaceRoot });
+      
+      if (stderr) {
+        console.error(`Command stderr: ${stderr}`);
+      }
+      
+      return stdout;
+    } catch (error) {
+      throw new Error(`Command failed: ${error.message}\n${error.stderr || ''}`);
+    }
+  }
+
+  // Resolve file path (relative to workspace root if not absolute)
+  _resolveFilePath(filePath) {
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+    return path.resolve(this.workspaceRoot, filePath);
+  }
+}
+
+module.exports = { CLIAgentUtils };

package/src/extension.ts

@@ -0,0 +1,112 @@
+import * as vscode from 'vscode';
+import { AIAssistantViewProvider } from './aiAssistantViewProvider';
+
+export function activate(context: vscode.ExtensionContext) {
+	console.log('AI Assistant extension activated');
+
+	// Create the provider instance
+	const aiAssistantProvider = new AIAssistantViewProvider(context.extensionUri);
+
+	// Register the webview view provider first before anything else
+	context.subscriptions.push(
+		vscode.window.registerWebviewViewProvider(
+			'aiAssistantView',  // This must match exactly with the id in package.json
+			aiAssistantProvider,
+			{
+				webviewOptions: {
+					retainContextWhenHidden: true,
+				}
+			}
+		)
+	);
+
+	// Register commands
+	context.subscriptions.push(
+		vscode.commands.registerCommand('aiAssistant.sendQuery', () => {
+			vscode.window.showInputBox({
+				placeHolder: 'Enter your question for the AI Assistant',
+				prompt: 'Press Enter to send'
+			}).then((query: string | undefined) => {
+				if (query) {
+					aiAssistantProvider.sendQueryToAI(query);
+				}
+			});
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('aiAssistant.clear', () => {
+			aiAssistantProvider.clearConversation();
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('aiAssistant.toggleLanguage', () => {
+			aiAssistantProvider.toggleLanguage();
+		})
+	);
+
+	// Test command to verify file writing
+	context.subscriptions.push(
+		vscode.commands.registerCommand('aiAssistant.testFileWrite', async () => {
+			try {
+				const utils = aiAssistantProvider.getAgentUtils();
+				await utils.writeFile('test_file.txt', 'This is a test file to verify writing capabilities.');
+				vscode.window.showInformationMessage('Test file created successfully!');
+			} catch (error) {
+				vscode.window.showErrorMessage(`Error creating test file: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		})
+	);
+
+	// Create a status bar item to indicate when AI Assistant is ready
+	const statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+	statusBarItem.text = "$(zap) AI";
+	statusBarItem.tooltip = "AI Assistant (Ctrl+L to activate)";
+	statusBarItem.command = "aiAssistant.showView";
+	statusBarItem.show();
+	context.subscriptions.push(statusBarItem);
+
+	// Register command to show the AI Assistant view
+	context.subscriptions.push(
+		vscode.commands.registerCommand('aiAssistant.showView', async () => {
+			try {
+				// First try to focus the view directly
+				await vscode.commands.executeCommand('aiAssistantView.focus');
+			} catch (error) {
+				console.error('Error focusing AI Assistant view:', error);
+
+				// If that fails, try to show the view container first
+				try {
+					await vscode.commands.executeCommand('workbench.view.extension.ai-assistant-view');
+
+					// Then try to focus the view again
+					setTimeout(async () => {
+						try {
+							await vscode.commands.executeCommand('aiAssistantView.focus');
+						} catch (focusError) {
+							console.error('Error focusing view after showing container:', focusError);
+						}
+					}, 100);
+				} catch (fallbackError) {
+					console.error('Fallback also failed:', fallbackError);
+					vscode.window.showErrorMessage('Failed to open AI Assistant view.');
+				}
+			}
+		})
+	);
+
+	// Ensure the view provider is activated immediately
+	vscode.commands.executeCommand('setContext', 'aiAssistantViewEnabled', true);
+
+	// Force activation of the view after a short delay
+	setTimeout(() => {
+		try {
+			vscode.commands.executeCommand('workbench.view.extension.ai-assistant-view');
+		} catch (error) {
+			console.error('Failed to show AI Assistant view on startup:', error);
+		}
+	}, 1000);
+}
+
+export function deactivate() { }

package/src/fetch-polyfill.ts

@@ -0,0 +1,11 @@
+import fetch from 'node-fetch';
+export { fetch };
+
+export interface FetchResponse {
+	ok: boolean;
+	status: number;
+	statusText: string;
+	headers: Record<string, string>;
+	json(): Promise<any>;
+	text(): Promise<string>;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "dist",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noImplicitAny": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", ".vscode-test", "bin", "**/*.test.ts"]
+}

package/webpack.config.js

@@ -0,0 +1,45 @@
+//@ts-check
+'use strict';
+
+const path = require('path');
+
+/**@type {import('webpack').Configuration}*/
+const config = {
+	target: 'node',
+	entry: './src/extension.ts',
+	output: {
+		path: path.resolve(__dirname, 'out'),
+		filename: 'extension.js',
+		libraryTarget: 'commonjs2'
+	},
+	devtool: 'source-map',
+	externals: {
+		vscode: 'commonjs vscode'
+	},
+	resolve: {
+		extensions: ['.ts', '.js']
+	},
+	module: {
+		rules: [
+			{
+				test: /\.ts$/,
+				exclude: /node_modules/,
+				use: [
+					{
+						loader: 'ts-loader',
+						options: {
+							compilerOptions: {
+								module: 'commonjs'
+							}
+						}
+					}
+				]
+			}
+		]
+	},
+	performance: {
+		hints: false
+	}
+};
+
+module.exports = config;