sam-coder-cli 1.0.4 → 1.0.6

package/bin/agi-cli.js

@@ -13,7 +13,7 @@ const execAsync = util.promisify(exec);
 const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
 const MODEL = 'deepseek/deepseek-chat-v3-0324:free';
-const API_BASE_URL = 'https://openrouter.ai/api/v1';
+let API_BASE_URL = 'https://openrouter.ai/api/v1';
 
 // Tool/Function definitions for the AI
 const tools = [
@@ -508,12 +508,10 @@ async function handleToolCalls(toolCalls, messages) {
 }
 
 // Process a query with tool calling
-async function processQueryWithTools(query, conversation = [], maxIterations = 5) {
+async function processQueryWithTools(query, conversation = []) {
   // Add user message to conversation
   const userMessage = { role: 'user', content: query };
-  let messages = [...conversation, userMessage];
-  let iteration = 0;
-  let finalResponse = null;
+  const messages = [...conversation, userMessage];
 
   // Add system message if this is the first message
   if (conversation.length === 0) {
@@ -526,54 +524,50 @@ If a tool fails, you can try again with different parameters or a different appr
     });
   }
 
-  // Process in a loop to handle multiple tool calls
-  while (iteration < maxIterations) {
-    ui.startThinking();
-    
-    try {
-      const response = await callOpenRouterWithTools(messages);
-      const assistantMessage = response.choices[0].message;
-      messages.push(assistantMessage);
-      
-      // If there are no tool calls, we're done
-      if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
-        ui.stopThinking();
-        finalResponse = assistantMessage.content || 'No content in response';
-        break;
-      }
-      
-      // Process tool calls
-      console.log(`🛠️  Executing ${assistantMessage.tool_calls.length} tools...`);
-      const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
-      
-      // Add tool results to messages
-      messages = [...messages, ...toolResults];
-      
-      // If we've reached max iterations, get a final response
-      if (iteration === maxIterations - 1) {
-        console.log('ℹ️  Reached maximum number of iterations. Getting final response...');
-        const finalResponseObj = await callOpenRouterWithTools(messages);
-        finalResponse = finalResponseObj.choices[0].message.content || 'No content in final response';
-      }
-      
-      iteration++;
-    } catch (error) {
+  ui.startThinking();
+
+  try {
+    const response = await callOpenRouterWithTools(messages);
+    const assistantMessage = response.choices[0].message;
+    messages.push(assistantMessage);
+
+    // If there are no tool calls, we're done
+    if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
       ui.stopThinking();
-      console.error('❌ Error during processing:', error);
-      finalResponse = `An error occurred: ${error.message}`;
-      break;
+      return {
+        response: assistantMessage.content || 'No content in response',
+        conversation: messages
+      };
     }
+
+    // Process tool calls
+    ui.stopThinking(); // Stop thinking while tools execute
+    console.log(`🛠️  Executing ${assistantMessage.tool_calls.length} tools...`);
+    const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
+
+    // Add tool results to messages
+    messages.push(...toolResults);
+
+    // Now, get the AI's response to the tool results
+    ui.startThinking();
+    const finalResponseObj = await callOpenRouterWithTools(messages);
+    const finalAssistantMessage = finalResponseObj.choices[0].message;
+    messages.push(finalAssistantMessage);
+    ui.stopThinking();
+
+    return {
+      response: finalAssistantMessage.content || 'Actions executed. What is the next step?',
+      conversation: messages
+    };
+
+  } catch (error) {
+    ui.stopThinking();
+    console.error('❌ Error during processing:', error);
+    return {
+      response: `An error occurred: ${error.message}`,
+      conversation: messages
+    };
   }
-  
-  // If we don't have a final response yet (shouldn't happen, but just in case)
-  if (!finalResponse) {
-    finalResponse = 'No response generated. The operation may have timed out or encountered an error.';
-  }
-  
-  return {
-    response: finalResponse,
-    conversation: messages
-  };
 }
 
 // Execute a single action from the action system
@@ -781,8 +775,19 @@ async function runSetup(isReconfig = false) {
   }
 
   const apiKey = await askQuestion('Enter OpenRouter API Key: ');
+  const proCode = await askQuestion('Enter Pro Plan activation code (or press Enter to skip): ');
+
+  let config = { OPENROUTER_API_KEY: apiKey, isPro: false };
+
+  if (proCode === '1234') {
+    console.log('✅ Pro Plan activated!');
+    const customEndpoint = await askQuestion('Enter custom OpenAI-compatible API endpoint: ');
+    config.isPro = true;
+    config.customApiBase = customEndpoint;
+  } else if (proCode) {
+    console.log('⚠️ Invalid activation code. Continuing with standard setup.');
+  }
 
-  const config = { OPENROUTER_API_KEY: apiKey };
   await writeConfig(config);
 
   console.log('✅ Configuration saved successfully!');
@@ -799,6 +804,10 @@ async function start() {
     }
 
     OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
+    if (config.isPro && config.customApiBase) {
+      API_BASE_URL = config.customApiBase;
+      console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
+    }
 
     ui.showHeader();
     console.log('Select Mode:');

package/foldersnake/snake_game.py

@@ -1,125 +1,218 @@
 import pygame
-import time
 import random
 
 # Initialize pygame
 pygame.init()
 
-# Screen dimensions
-WIDTH, HEIGHT = 800, 600
+# 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
-WHITE = (255, 255, 255)
 BLACK = (0, 0, 0)
-RED = (213, 50, 80)
-GREEN = (0, 255, 0)
-BLUE = (50, 153, 213)
-
-# Snake block size
-BLOCK_SIZE = 20
+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 for controlling the speed of the snake
 clock = pygame.time.Clock()
 
-# Font for score
-font_style = pygame.font.SysFont("bahnschrift", 25)
-score_font = pygame.font.SysFont("comicsansms", 35)
-
-def message(msg, color):
-    mesg = font_style.render(msg, True, color)
-    screen.blit(mesg, [WIDTH / 6, HEIGHT / 3])
-
-def your_score(score):
-    value = score_font.render("Your Score: " + str(score), True, GREEN)
-    screen.blit(value, [0, 0])
-
-def our_snake(block_size, snake_list):
-    for pos in snake_list:
-        pygame.draw.rect(screen, BLUE, [pos[0], pos[1], block_size, block_size])
-
-def gameLoop():
-    game_over = False
-    game_close = False
-
-    x1 = WIDTH / 2
-    y1 = HEIGHT / 2
-
-    x1_change = 0
-    y1_change = 0
-
-    snake_list = []
-    length_of_snake = 1
-
-    foodx = round(random.randrange(0, WIDTH - BLOCK_SIZE) / 20.0) * 20.0
-    foody = round(random.randrange(0, HEIGHT - BLOCK_SIZE) / 20.0) * 20.0
-
-    while not game_over:
-
-        while game_close:
-            screen.fill(BLACK)
-            message("You Lost! Press Q-Quit or C-Play Again", RED)
-            your_score(length_of_snake - 1)
-            pygame.display.update()
-
-            for event in pygame.event.get():
-                if event.type == pygame.KEYDOWN:
-                    if event.key == pygame.K_q:
-                        game_over = True
-                        game_close = False
-                    if event.key == pygame.K_c:
-                        gameLoop()
-
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
+# 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
-            if event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_LEFT:
-                    x1_change = -BLOCK_SIZE
-                    y1_change = 0
-                elif event.key == pygame.K_RIGHT:
-                    x1_change = BLOCK_SIZE
-                    y1_change = 0
-                elif event.key == pygame.K_UP:
-                    y1_change = -BLOCK_SIZE
-                    x1_change = 0
-                elif event.key == pygame.K_DOWN:
-                    y1_change = BLOCK_SIZE
-                    x1_change = 0
-
-        if x1 >= WIDTH or x1 < 0 or y1 >= HEIGHT or y1 < 0:
-            game_close = True
-        x1 += x1_change
-        y1 += y1_change
-        screen.fill(BLACK)
-        pygame.draw.rect(screen, GREEN, [foodx, foody, BLOCK_SIZE, BLOCK_SIZE])
-        snake_head = []
-        snake_head.append(x1)
-        snake_head.append(y1)
-        snake_list.append(snake_head)
-        if len(snake_list) > length_of_snake:
-            del snake_list[0]
-
-        for pos in snake_list[:-1]:
-            if pos == snake_head:
-                game_close = True
-
-        our_snake(BLOCK_SIZE, snake_list)
-        your_score(length_of_snake - 1)
 
+    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
 
-        if x1 == foodx and y1 == foody:
-            foodx = round(random.randrange(0, WIDTH - BLOCK_SIZE) / 20.0) * 20.0
-            foody = round(random.randrange(0, HEIGHT - BLOCK_SIZE) / 20.0) * 20.0
-            length_of_snake += 1
-
-        clock.tick(15)
-
-    pygame.quit()
-    quit()
-
-# Create the screen
-screen = pygame.display.set_mode((WIDTH, HEIGHT))
-pygame.display.set_caption('Snake Game')
-
-gameLoop()
+pygame.quit()

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {
-    "sam-coder": "./bin/agi-cli.js"
+    "sam-coder": "bin/agi-cli.js"
   },
   "scripts": {
     "start": "node ./bin/agi-cli.js"