sam-coder-cli 1.0.69 → 2.0.1

package/bin/agi-cli.js.bak

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+
+const fetch = require('node-fetch');
+const readline = require('readline');
+const path = require('path');
+const { CLIAgentUtils } = require('../src/cliAgentUtils');
+
+// Initialize CLIAgentUtils
+const agentUtils = new CLIAgentUtils();
+
+// OpenRouter configuration
+const OPENROUTER_API_KEY = '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';
+const MODEL = 'deepseek/deepseek-chat-v3-0324:free';
+const API_BASE_URL = 'https://openrouter.ai/api/v1';
+
+// System prompt matching the VS Code extension
+const SYSTEM_PROMPT = `You are a VS Code AI Assistant with agency capabilities. You can perform actions on the user's workspace.
+
+ENVIRONMENT CONTEXT:
+- OS: ${process.platform}
+- Working Directory: ${process.cwd()}
+
+When you need to perform actions, respond with JSON in the following format:
+\`\`\`json
+{
+  "thoughts": "Your reasoning about what needs to be done",
+  "actions": [
+    {
+      "type": "read|write|search|command|analyze|execute|stop",
+      "data": { ... action specific data ... }
+    }
+  ]
+}
+\`\`\`
+
+Action types and their data:
+- read: { "path": "relative/or/absolute/path" }
+- write: { "path": "relative/or/absolute/path", "content": "file content" }
+- search: { "type": "files", "pattern": "glob pattern" } or { "type": "text", "text": "search text" }
+- command: { "command": "command string to execute in terminal" }
+- execute: { "language": "js|python|bash|...", "code": "code to execute" }
+- analyze: { "code": "code to analyze", "question": "what you want to analyze" }
+- browse: { "query": "search query", "numResults": 5 } (free web search using DuckDuckGo, optional numResults)
+- edit: {
+    "path": "relative/or/absolute/path",
+    "edits": {
+      "operations": [
+        { "type": "replace", "startLine": 10, "endLine": 15, "newText": "new code here" },
+        { "type": "replace", "pattern": "oldFunction\\(\\)", "replacement": "newFunction()", "flags": "g" },
+        { "type": "insert", "line": 20, "text": "new line of code here" },
+        { "type": "insert", "position": "start", "text": "// Header comment" },
+        { "type": "insert", "position": "end", "text": "// Footer comment" },
+        { "type": "delete", "startLine": 25, "endLine": 30 }
+      ]
+    }
+  } (edit specific parts of an existing file)
+- stop: {} (use this to indicate you're done with the task and no more actions are needed)
+
+By default, you will continue to take actions in a loop until you decide to stop with the 'stop' action type.
+Always wrap your JSON in markdown code blocks with the json language specifier.
+When executing code or commands that might be potentially harmful, explain what the code does before executing it.`;
+
+async function callOpenRouter(messages, toolCalls = null) {
+  const body = {
+    model: MODEL,
+    messages: messages.map(msg => ({
+      role: msg.role,
+      content: msg.content || '',
+      ...(msg.name && { name: msg.name })
+    })),
+    ...(!toolCalls && { tools }),
+    ...(toolCalls && { tool_calls: toolCalls })
+  };
+  
+  // Remove any undefined values
+  const cleanBody = JSON.parse(JSON.stringify(body));
+
+  try {
+    console.log('Sending request to OpenRouter API...');
+    console.log('Model:', MODEL);
+    console.log('Headers:', {
+      'Content-Type': 'application/json',
+      'Authorization': 'Bearer ' + (OPENROUTER_API_KEY ? '***' + OPENROUTER_API_KEY.slice(-4) : 'undefined'),
+      'HTTP-Referer': 'https://github.com/yourusername/agi-cli',
+      'X-Title': 'AGI-CLI'
+    });
+    
+    console.log('Request body:', JSON.stringify(cleanBody, null, 2));
+    
+    const response = await fetch(`${API_BASE_URL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${OPENROUTER_API_KEY}`,
+        'HTTP-Referer': 'https://github.com/yourusername/agi-cli',
+        'X-Title': 'AGI-CLI'
+      },
+      body: JSON.stringify(cleanBody)
+    });
+
+    console.log('Response status:', response.status, response.statusText);
+    
+    if (!response.ok) {
+      let errorText;
+      try {
+        const errorData = await response.text();
+        console.error('Error response body:', errorData);
+        const parsedError = JSON.parse(errorData);
+        errorText = parsedError.error?.message || JSON.stringify(parsedError);
+      } catch (e) {
+        errorText = await response.text();
+      }
+      throw new Error(`API request failed with status ${response.status}: ${errorText}`);
+    }
+
+    const responseData = await response.json();
+    console.log('API Response:', JSON.stringify(responseData, null, 2));
+    return responseData;
+  } catch (error) {
+    console.error('Error in callOpenRouter:', error);
+    throw new Error(`Failed to call OpenRouter API: ${error.message}`);
+  }
+}
+
+async function handleToolCalls(toolCalls, messages) {
+  const results = [];
+  
+  for (const toolCall of toolCalls) {
+    const { name, arguments: args } = toolCall.function;
+    let result;
+    
+    try {
+      switch (name) {
+        case 'readFile':
+          result = await agentUtils.readFile(args.path);
+          break;
+        case 'writeFile':
+          await agentUtils.writeFile(args.path, args.content);
+      
+      results.push({
+        tool_call_id: toolCall.id,
+        role: 'tool',
+        name: functionName,
+        content: JSON.stringify(result)
+      });
+    } catch (error) {
+      console.error('❌ Tool execution failed:', error);
+      
+      results.push({
+        tool_call_id: toolCall.id,
+        role: 'tool',
+        name: functionName,
+        content: JSON.stringify({ error: error.message })
+      });
+    }
+  }
+  
+  return results;
+}
+
+async function extractJsonFromMarkdown(text) {
+  // Try to find a markdown code block with JSON content
+  const codeBlockRegex = /```json\n([\s\S]*?)\n```/g;
+  const match = codeBlockRegex.exec(text);
+  
+  if (match) {
+    try {
+      return JSON.parse(match[1]);
+    } catch (error) {
+      console.error('Error parsing JSON from markdown:', error);
+    }
+  }
+  
+  // If no code block, try to parse the entire text as JSON
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    console.error('Error parsing JSON:', error);
+    return null;
+  }
+}
+
+async function processQuery(query, conversation = []) {
+  try {
+    // Add user message to conversation
+    const userMessage = { role: 'user', content: query };
+    const messages = [...conversation, userMessage];
+
+    // Add system message if this is the first message
+    if (conversation.length === 0) {
+      messages.unshift({
+        role: 'system',
+        content: SYSTEM_PROMPT
+      });
+    }
+
+    let shouldContinue = true;
+    let iteration = 0;
+    const maxIterations = 10; // Prevent infinite loops
+    let finalResponse = '';
+
+    while (shouldContinue && iteration < maxIterations) {
+      iteration++;
+      console.log('🤖 Thinking...');
+      
+      const response = await callOpenRouter(messages);
+      const assistantMessage = response.choices[0].message;
+      
+      // Add assistant's message to the conversation
+      messages.push(assistantMessage);
+      
+      // Check if the response contains actions
+      const actionData = await extractJsonFromMarkdown(assistantMessage.content);
+      
+      if (actionData && actionData.actions && Array.isArray(actionData.actions)) {
+        console.log(`🔧 Processing ${actionData.actions.length} actions...`);
+        if (actionData.thoughts) {
+          console.log(`💭 ${actionData.thoughts}`);
+        }
+        
+        const actionResults = [];
+        
+        for (const action of actionData.actions) {
+          console.log(`🛠️  Executing action: ${action.type}`);
+          
+          // Handle stop action
+          if (action.type === 'stop') {
+            console.log('🛑 Stop action received, ending action processing');
+            shouldContinue = false;
+            finalResponse = 'Task completed successfully.';
+            break;
+          }
+          
+          try {
+            let result;
+            
+            switch (action.type) {
+              case 'read':
+                result = await agentUtils.readFile(action.data.path);
+                break;
+                
+              case 'write':
+                await agentUtils.writeFile(action.data.path, action.data.content);
+                result = `Successfully wrote to ${action.data.path}`;
+                break;
+                
+              case 'command':
+                result = await agentUtils.runCommand(action.data.command);
+                break;
+                
+              case 'search':
+                if (action.data.type === 'files') {
+                  result = await agentUtils.searchFiles(action.data.pattern);
+                } else {
+                  result = 'Text search not yet implemented';
+                }
+                break;
+                
+              default:
+                result = `Action type '${action.type}' is not supported yet.`;
+            }
+            
+            actionResults.push({
+              type: action.type,
+              success: true,
+              result: result
+            });
+            
+            console.log(`✅ Action ${action.type} completed successfully`);
+            
+          } catch (error) {
+            console.error(`❌ Action ${action.type} failed:`, error);
+            actionResults.push({
+              type: action.type,
+              success: false,
+              error: error.message
+            });
+          }
+        }
+        
+        // Add action results to the conversation
+        messages.push({
+          role: 'system',
+          content: `Action results:\n\`\`\`json\n${JSON.stringify(actionResults, null, 2)}\n\`\`\`\n` +
+          `Based on these results, determine what to do next. You can:\n` +
+          `1. Continue with more actions by returning a new JSON with "actions" array\n` +
+          `2. Stop the iteration by including an action with "type": "stop" if the task is completed\n` +
+          `3. Provide a final response to the user with your findings`
+        });
+        
+      } else {
+        // No actions, this is a regular response
+        shouldContinue = false;
+        finalResponse = assistantMessage.content;
+      }
+    }
+    
+    // If we hit max iterations, add a note
+    if (iteration >= maxIterations) {
+      finalResponse += '\n\n⚠️ Reached maximum number of iterations. Stopping execution.';
+    }
+    
+    return {
+      response: finalResponse,
+      conversation: messages
+    };
+    
+  } catch (error) {
+    console.error('Error processing query:', error);
+    return {
+      response: `Error: ${error.message}`,
+      conversation
+    };
+  }
+}
+
+async function chat() {
+  const conversation = [];
+  console.log('Welcome to AGI-CLI. Type your message, or "exit" to quit.');
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> '
+  });
+  
+  rl.prompt();
+  
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    
+    if (input.toLowerCase() === 'exit') {
+      rl.close();
+      return;
+    }
+    
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    
+    const result = await processQuery(input, conversation);
+    console.log(result.response);
+    rl.prompt();
+  }).on('close', () => {
+    console.log('Goodbye!');
+    process.exit(0);
+  });
+}
+
+// Start the chat
+chat();

package/bin/core/brainstorm.js

@@ -0,0 +1,198 @@
+/**
+ * Brainstorm Module - Start a New Brainstorm Session
+ * 
+ * Initializes a new brainstorm session and generates all project coordination files.
+ * Ported from Python to JavaScript.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { ProjectConfig, BrainstormSession } = require('./models');
+const templates = require('./templates');
+
+/**
+ * File templates mapping
+ */
+const FILE_TEMPLATES = {
+    'CLAUDE.md': templates.generateClaudeMd,
+    'PROJECT_STATUS.md': templates.generateProjectStatusMd,
+    'PROGRESS_REPORT.md': templates.generateProgressReportMd,
+    'GETTING_STARTED.md': templates.generateGettingStartedMd,
+    'SELF_IMPROVEMENT.md': templates.generateSelfImprovementMd,
+    'CEO-UPDATES-TODAY.md': templates.generateCeoUpdatesMd,
+    'CODE_OF_CONDUCT_OF_AI_WORKERS.md': templates.generateCodeOfConductMd
+};
+
+const MULTI_AGENT_TEMPLATES = {
+    'SECONDARY-AI-CHAT.md': templates.generateSecondaryAiChatMd
+};
+
+/**
+ * Start a new brainstorm session
+ * 
+ * @param {Object} options
+ * @param {ProjectConfig|Object} options.config - Project configuration
+ * @param {string} options.outputDir - Directory where files will be generated
+ * @param {string[]} options.agents - List of agent identities (e.g., ["CLAUDE-1", "CLAUDE-2"])
+ * @returns {Promise<BrainstormSession>}
+ */
+async function startBrainstorm({ config, outputDir, agents = ['CLAUDE-1'] }) {
+    // Convert to ProjectConfig if needed
+    const project = config instanceof ProjectConfig ? config : new ProjectConfig(config);
+
+    // Create output directory
+    await fs.mkdir(outputDir, { recursive: true });
+
+    // Create new session
+    const session = BrainstormSession.create({
+        project,
+        outputDirectory: outputDir,
+        agents
+    });
+
+    const generatedFiles = [];
+
+    // Generate standard files
+    for (const [fileName, templateFn] of Object.entries(FILE_TEMPLATES)) {
+        const content = templateFn({ project, agents, session });
+        const filePath = path.join(outputDir, fileName);
+        await fs.writeFile(filePath, content, 'utf-8');
+        generatedFiles.push(fileName);
+        session.fileVersions[fileName] = 1;
+    }
+
+    // Generate multi-agent files if more than one agent
+    if (agents.length > 1) {
+        for (const [fileName, templateFn] of Object.entries(MULTI_AGENT_TEMPLATES)) {
+            const content = templateFn({ project, agents, session });
+            const filePath = path.join(outputDir, fileName);
+            await fs.writeFile(filePath, content, 'utf-8');
+            generatedFiles.push(fileName);
+            session.fileVersions[fileName] = 1;
+        }
+    }
+
+    // Create directory structure if defined
+    if (project.directoryStructure && Object.keys(project.directoryStructure).length > 0) {
+        await createDirectoryStructure(outputDir, project.directoryStructure);
+    }
+
+    // Add event for file generation
+    session.addEvent({
+        eventType: 'UPDATED',
+        actor: 'BRAINSTORM',
+        description: `Generated ${generatedFiles.length} project files`,
+        affectedFiles: generatedFiles
+    });
+
+    // Save session state
+    await session.save();
+
+    return session;
+}
+
+/**
+ * Create directory structure recursively
+ */
+async function createDirectoryStructure(baseDir, structure, currentPath = null) {
+    const current = currentPath || baseDir;
+
+    for (const [name, children] of Object.entries(structure)) {
+        const itemPath = path.join(current, name);
+
+        if (typeof children === 'object' && children !== null && Object.keys(children).length > 0) {
+            // Directory with children
+            await fs.mkdir(itemPath, { recursive: true });
+            await createDirectoryStructure(baseDir, children, itemPath);
+        } else if (children === null || (typeof children === 'object' && Object.keys(children).length === 0)) {
+            // Empty directory
+            await fs.mkdir(itemPath, { recursive: true });
+        } else {
+            // File placeholder
+            await fs.mkdir(path.dirname(itemPath), { recursive: true });
+            try {
+                await fs.access(itemPath);
+            } catch {
+                await fs.writeFile(itemPath, '', 'utf-8');
+            }
+        }
+    }
+}
+
+/**
+ * Load an existing session from a directory
+ * 
+ * @param {string} sessionDir - Directory containing SESSION.json
+ * @returns {Promise<BrainstormSession|null>}
+ */
+async function getSession(sessionDir) {
+    const sessionFile = path.join(sessionDir, 'SESSION.json');
+
+    try {
+        await fs.access(sessionFile);
+        return await BrainstormSession.load(sessionFile);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * List all files in a brainstorm session with their versions
+ * 
+ * @param {BrainstormSession} session
+ * @returns {Array<Object>}
+ */
+async function listFiles(session) {
+    const files = [];
+
+    for (const [fileName, version] of Object.entries(session.fileVersions)) {
+        const filePath = path.join(session.outputDirectory, fileName);
+        let exists = false;
+
+        try {
+            await fs.access(filePath);
+            exists = true;
+        } catch { }
+
+        files.push({
+            name: fileName,
+            path: filePath,
+            version,
+            exists
+        });
+    }
+
+    return files;
+}
+
+/**
+ * Quick start function for creating a brainstorm session
+ * 
+ * @param {string} name - Project name
+ * @param {string} description - Project description
+ * @param {string} outputDir - Output directory
+ * @param {string[]} agents - List of agent identities
+ * @param {Object} options - Additional ProjectConfig fields
+ * @returns {Promise<BrainstormSession>}
+ */
+async function quickStart(name, description, outputDir, agents = ['CLAUDE-1'], options = {}) {
+    const config = new ProjectConfig({
+        name,
+        description,
+        ...options
+    });
+
+    return startBrainstorm({
+        config,
+        outputDir,
+        agents
+    });
+}
+
+module.exports = {
+    startBrainstorm,
+    getSession,
+    listFiles,
+    quickStart,
+    createDirectoryStructure
+};