sam-coder-cli 1.0.44 → 1.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {
@@ -24,6 +24,7 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
+    "@types/vscode": "^1.102.0",
     "eslint": "^7.27.0"
   },
   "engines": {

package/bin/agi-cli.js.new

@@ -1,328 +0,0 @@
-#!/usr/bin/env node
-
-const readline = require('readline');
-const path = require('path');
-const fs = require('fs').promises;
-const { exec } = require('child_process');
-const util = require('util');
-const execAsync = util.promisify(exec);
-
-// Configuration
-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.`;
-
-// Agent utilities
-const agentUtils = {
-  async readFile(filePath) {
-    try {
-      const content = await fs.readFile(filePath, 'utf-8');
-      return content;
-    } catch (error) {
-      throw new Error(`Failed to read file ${filePath}: ${error.message}`);
-    }
-  },
-
-  async writeFile(filePath, content) {
-    try {
-      await fs.writeFile(filePath, content, 'utf-8');
-      return `Successfully wrote to ${filePath}`;
-    } catch (error) {
-      throw new Error(`Failed to write to file ${filePath}: ${error.message}`);
-    }
-  },
-
-  async runCommand(command) {
-    try {
-      const { stdout, stderr } = await execAsync(command, { cwd: process.cwd() });
-      if (stderr) {
-        console.error('Command stderr:', stderr);
-      }
-      return stdout || 'Command executed successfully (no output)';
-    } catch (error) {
-      throw new Error(`Command failed: ${error.message}`);
-    }
-  },
-
-  async searchFiles(pattern) {
-    try {
-      const { stdout } = await execAsync(`find . -name "${pattern}"`, { cwd: process.cwd() });
-      return stdout || 'No files found';
-    } catch (error) {
-      throw new Error(`Search failed: ${error.message}`);
-    }
-  }
-};
-
-// Extract JSON from markdown code blocks
-function extractJsonFromMarkdown(text) {
-  // Try to find a markdown code block with JSON content
-  const codeBlockRegex = /```json\s*([\s\S]*?)\s*```/;
-  const match = text.match(codeBlockRegex);
-  
-  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;
-  }
-}
-
-// Call OpenRouter API
-async function callOpenRouter(messages) {
-  const apiKey = process.env.OPENROUTER_API_KEY;
-  
-  if (!apiKey) {
-    throw new Error('OPENROUTER_API_KEY environment variable is not set');
-  }
-
-  try {
-    const response = await fetch(API_BASE_URL + '/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'HTTP-Referer': 'https://github.com/yourusername/agi-cli'
-      },
-      body: JSON.stringify({
-        model: MODEL,
-        messages: messages
-      })
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`API error: ${error.error?.message || response.statusText}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error('API call failed:', error);
-    throw new Error(`Failed to call OpenRouter API: ${error.message}`);
-  }
-}
-
-// Process a query with action handling
-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 = 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':
-                result = await agentUtils.writeFile(action.data.path, action.data.content);
-                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
-    };
-  }
-}
-
-// Main chat loop
-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 (input) => {
-    if (input.toLowerCase() === 'exit') {
-      rl.close();
-      return;
-    }
-    
-    const result = await processQuery(input, conversation);
-    console.log(result.response);
-    
-    // Update conversation with the full context
-    conversation.length = 0; // Clear the array
-    result.conversation.forEach(msg => conversation.push(msg));
-    
-    rl.prompt();
-  }).on('close', () => {
-    console.log('Goodbye!');
-    process.exit(0);
-  });
-}
-
-// Start the chat
-chat().catch(console.error);

package/foldersnake/snake_game.py

@@ -1,218 +0,0 @@
-import pygame
-import random
-
-# Initialize pygame
-pygame.init()
-
-# Constants
-SCREEN_WIDTH = 300
-SCREEN_HEIGHT = 600
-BLOCK_SIZE = 30
-GRID_WIDTH = 10
-GRID_HEIGHT = 20
-GAME_AREA_LEFT = (SCREEN_WIDTH - GRID_WIDTH * BLOCK_SIZE) // 2
-GAME_AREA_TOP = SCREEN_HEIGHT - GRID_HEIGHT * BLOCK_SIZE
-
-# Colors
-BLACK = (0, 0, 0)
-WHITE = (255, 255, 255)
-GRAY = (128, 128, 128)
-COLORS = [
-    (0, 255, 255),  # Cyan (I)
-    (0, 0, 255),    # Blue (J)
-    (255, 165, 0),  # Orange (L)
-    (255, 255, 0),  # Yellow (O)
-    (0, 255, 0),    # Green (S)
-    (128, 0, 128),  # Purple (T)
-    (255, 0, 0)     # Red (Z)
-]
-
-# Tetrimino shapes
-SHAPES = [
-    [[1, 1, 1, 1]],  # I
-    [[1, 0, 0], [1, 1, 1]],  # J
-    [[0, 0, 1], [1, 1, 1]],  # L
-    [[1, 1], [1, 1]],  # O
-    [[0, 1, 1], [1, 1, 0]],  # S
-    [[0, 1, 0], [1, 1, 1]],  # T
-    [[1, 1, 0], [0, 1, 1]]   # Z
-]
-
-# Set up the display
-screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
-pygame.display.set_caption("Tetris")
-
-clock = pygame.time.Clock()
-
-# Game variables
-grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
-current_piece = None
-next_piece = None
-current_x = GRID_WIDTH // 2
-current_y = 0
-score = 0
-game_over = False
-fall_time = 0
-fall_speed = 0.5  # seconds
-
-def new_piece():
-    global current_piece, next_piece, current_x, current_y
-    if next_piece is None:
-        next_piece = random.randint(0, len(SHAPES) - 1)
-    current_piece = next_piece
-    next_piece = random.randint(0, len(SHAPES) - 1)
-    current_x = GRID_WIDTH // 2 - len(SHAPES[current_piece][0]) // 2
-    current_y = 0
-    if check_collision():
-        return False
-    return True
-
-def check_collision():
-    for y, row in enumerate(SHAPES[current_piece]):
-        for x, cell in enumerate(row):
-            if cell:
-                if (current_y + y >= GRID_HEIGHT or
-                        current_x + x < 0 or
-                        current_x + x >= GRID_WIDTH or
-                        grid[current_y + y][current_x + x]):
-                    return True
-    return False
-
-def merge_piece():
-    for y, row in enumerate(SHAPES[current_piece]):
-        for x, cell in enumerate(row):
-            if cell:
-                grid[current_y + y][current_x + x] = current_piece + 1
-
-def clear_lines():
-    global grid, score
-    lines_cleared = 0
-    for y in range(GRID_HEIGHT - 1, -1, -1):
-        if all(grid[y]):
-            lines_cleared += 1
-            for y2 in range(y, 0, -1):
-                grid[y2] = grid[y2 - 1][:]
-            grid[0] = [0] * GRID_WIDTH
-    score += lines_cleared ** 2 * 100
-
-def draw_grid():
-    for y in range(GRID_HEIGHT):
-        for x in range(GRID_WIDTH):
-            if grid[y][x]:
-                pygame.draw.rect(
-                    screen, COLORS[grid[y][x] - 1],
-                    (GAME_AREA_LEFT + x * BLOCK_SIZE, GAME_AREA_TOP + y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE)
-                )
-                pygame.draw.rect(
-                    screen, WHITE,
-                    (GAME_AREA_LEFT + x * BLOCK_SIZE, GAME_AREA_TOP + y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE),
-                    1
-                )
-
-def draw_piece():
-    for y, row in enumerate(SHAPES[current_piece]):
-        for x, cell in enumerate(row):
-            if cell:
-                pygame.draw.rect(
-                    screen, COLORS[current_piece],
-                    (GAME_AREA_LEFT + (current_x + x) * BLOCK_SIZE, GAME_AREA_TOP + (current_y + y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE)
-                )
-                pygame.draw.rect(
-                    screen, WHITE,
-                    (GAME_AREA_LEFT + (current_x + x) * BLOCK_SIZE, GAME_AREA_TOP + (current_y + y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE),
-                    1
-                )
-
-def draw_next_piece():
-    if next_piece is not None:
-        font = pygame.font.SysFont(None, 24)
-        text = font.render("Next:", True, WHITE)
-        screen.blit(text, (20, 20))
-        for y, row in enumerate(SHAPES[next_piece]):
-            for x, cell in enumerate(row):
-                if cell:
-                    pygame.draw.rect(
-                        screen, COLORS[next_piece],
-                        (40 + x * BLOCK_SIZE, 50 + y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE)
-                    )
-                    pygame.draw.rect(
-                        screen, WHITE,
-                        (40 + x * BLOCK_SIZE, 50 + y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE),
-                        1
-                    )
-
-def draw_score():
-    font = pygame.font.SysFont(None, 36)
-    text = font.render(f"Score: {score}", True, WHITE)
-    screen.blit(text, (20, SCREEN_HEIGHT - 50))
-
-def rotate_piece():
-    global current_piece
-    rotated = list(zip(*reversed(SHAPES[current_piece])))
-    for y in range(len(rotated)):
-        rotated[y] = list(rotated[y])
-    old_shape = SHAPES[current_piece]
-    SHAPES[current_piece] = rotated
-    if check_collision():
-        SHAPES[current_piece] = old_shape
-
-# Main game loop
-new_piece()
-running = True
-while running:
-    screen.fill(BLACK)
-    fall_time += clock.get_rawtime() / 1000  # Convert to seconds
-    clock.tick()
-
-    if fall_time >= fall_speed:
-        fall_time = 0
-        current_y += 1
-        if check_collision():
-            current_y -= 1
-            merge_piece()
-            clear_lines()
-            if not new_piece():
-                game_over = True
-
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            running = False
-        if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_LEFT:
-                current_x -= 1
-                if check_collision():
-                    current_x += 1
-            if event.key == pygame.K_RIGHT:
-                current_x += 1
-                if check_collision():
-                    current_x -= 1
-            if event.key == pygame.K_DOWN:
-                current_y += 1
-                if check_collision():
-                    current_y -= 1
-            if event.key == pygame.K_UP:
-                rotate_piece()
-            if event.key == pygame.K_SPACE:
-                while not check_collision():
-                    current_y += 1
-                current_y -= 1
-                merge_piece()
-                clear_lines()
-                if not new_piece():
-                    game_over = True
-
-    draw_grid()
-    draw_piece()
-    draw_next_piece()
-    draw_score()
-    pygame.display.update()
-
-    if game_over:
-        font = pygame.font.SysFont(None, 48)
-        text = font.render("GAME OVER", True, WHITE)
-        screen.blit(text, (SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 - 24))
-        pygame.display.update()
-        pygame.time.wait(2000)
-        running = False
-
-pygame.quit()