sam-coder-cli 1.0.45 → 1.0.47

package/bin/agi-cli.js

@@ -15,42 +15,8 @@ let OPENROUTER_API_KEY;
 let MODEL = 'deepseek/deepseek-chat-v3-0324:free';
 let API_BASE_URL = 'https://openrouter.ai/api/v1';
 
-// Tool/Function definitions for the AI
-// Knowledge management functions
-const KNOWLEDGE_FILE = path.join(os.homedir(), '.sam-coder-knowledge.json');
-
-async function loadKnowledge() {
-  try {
-    const data = await fs.readFile(KNOWLEDGE_FILE, 'utf8');
-    return JSON.parse(data);
-  } catch (error) {
-    // If file doesn't exist, return empty knowledge
-    return {};
-  }
-}
-
-async function saveKnowledge(knowledge) {
-  await fs.writeFile(KNOWLEDGE_FILE, JSON.stringify(knowledge, null, 2), 'utf8');
-}
-
 // Tool/Function definitions for the AI
 const tools = [
-  {
-    type: 'function',
-    function: {
-      name: 'addKnowledge',
-      description: 'Add or update knowledge in the knowledge base',
-      parameters: {
-        type: 'object',
-        properties: {
-          key: { type: 'string', description: 'Key/identifier for the knowledge' },
-          value: { type: 'string', description: 'The knowledge content' },
-          description: { type: 'string', description: 'Description of what this knowledge is about' }
-        },
-        required: ['key', 'value', 'description']
-      }
-    }
-  },
   {
     type: 'function',
     function: {
@@ -224,19 +190,12 @@ const tools = [
 // System prompt for the AI Assistant when using tool calling
 const TOOL_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system using the provided tools.
 
-KNOWLEDGE MANAGEMENT:
-- You can store and retrieve knowledge using the 'addKnowledge' tool.
-- Use this to remember user preferences, project details, or any other important information.
-- The knowledge will persist across sessions.
-- Example: If the user mentions they prefer Python for all projects, store this preference.
-
 TOOLS AVAILABLE:
-1. addKnowledge - Add or update knowledge in the knowledge base
-2. readFile - Read the contents of a file
-3. writeFile - Write content to a file
-4. editFile - Edit specific parts of a file
-5. runCommand - Execute a shell command
-6. searchFiles - Search for files using a glob pattern
+1. readFile - Read the contents of a file
+2. writeFile - Write content to a file
+3. editFile - Edit specific parts of a file
+4. runCommand - Execute a shell command
+5. searchFiles - Search for files using a glob pattern
 
 ENVIRONMENT:
 - OS: ${process.platform}
@@ -252,11 +211,130 @@ INSTRUCTIONS:
 Always think step by step and explain your reasoning before taking actions that could affect the system.`;
 
 // System prompt for the AI Assistant when using legacy function calling (JSON actions)
-const FUNCTION_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system.
+const FUNCTION_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system using JSON-formatted actions.
+
+AVAILABLE ACTIONS:
+1. read - Read the contents of a file
+2. write - Write content to a file  
+3. edit - Edit specific parts of a file
+4. command - Execute a shell command
+5. search - Search for files using patterns
+6. execute - Execute code (bash or node.js)
+7. analyze - Analyze code and answer questions
+8. stop - Stop taking actions and provide final response
+
+ACTION FORMAT:
+You must respond with a JSON object wrapped in markdown code blocks with the 'json' language specifier.
+The JSON should have the following structure:
+{
+  "type": "action_name",
+  "data": { /* action-specific parameters */ },
+  "reasoning": "Brief explanation of why you're taking this action"
+}
 
-   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.`;
+EXAMPLES:
+
+To read a file:
+\`\`\`json
+{
+  "type": "read",
+  "data": {
+    "path": "path/to/file.txt"
+  },
+  "reasoning": "Reading the file to understand its current contents"
+}
+\`\`\`
+
+To write a file:
+\`\`\`json
+{
+  "type": "write",
+  "data": {
+    "path": "path/to/file.txt",
+    "content": "File content here"
+  },
+  "reasoning": "Creating a new file with the specified content"
+}
+\`\`\`
+
+To edit a file:
+\`\`\`json
+{
+  "type": "edit",
+  "data": {
+    "path": "path/to/file.txt",
+    "edits": {
+      "operations": [
+        {
+          "type": "replace",
+          "startLine": 5,
+          "endLine": 7,
+          "newText": "New content for lines 5-7"
+        }
+      ]
+    }
+  },
+  "reasoning": "Modifying specific lines in the file"
+}
+\`\`\`
+
+To run a command:
+\`\`\`json
+{
+  "type": "command",
+  "data": {
+    "command": "ls -la"
+  },
+  "reasoning": "Listing directory contents to see what files are available"
+}
+\`\`\`
+
+To search for files:
+\`\`\`json
+{
+  "type": "search",
+  "data": {
+    "type": "files",
+    "pattern": "*.js"
+  },
+  "reasoning": "Finding all JavaScript files in the current directory"
+}
+\`\`\`
+
+To execute code:
+\`\`\`json
+{
+  "type": "execute",
+  "data": {
+    "language": "bash",
+    "code": "echo 'Hello World'"
+  },
+  "reasoning": "Running a simple bash command"
+}
+\`\`\`
+
+To stop and provide final response:
+\`\`\`json
+{
+  "type": "stop",
+  "data": {},
+  "reasoning": "Task completed successfully"
+}
+\`\`\`
+
+IMPORTANT RULES:
+- Always wrap your JSON in markdown code blocks with 'json' language specifier
+- Include a "reasoning" field explaining why you're taking the action
+- You will continue taking actions in a loop until you use the 'stop' action
+- Be careful with destructive operations - explain what you're doing
+- If an action fails, analyze the error and try a different approach
+- Always think step by step before taking actions
+
+ENVIRONMENT:
+- OS: ${process.platform}
+- Current directory: ${process.cwd()}
+
+Start by understanding the user's request, then take appropriate actions to fulfill it.`;
 
 // Agent utilities
 const agentUtils = {
@@ -396,50 +474,70 @@ const agentUtils = {
   }
 };
 
-const toolHandlers = {
-  addKnowledge: async ({ key, value, description }) => {
-    try {
-      const knowledge = await loadKnowledge();
-      knowledge[key] = { 
-        value, 
-        description,
-        timestamp: new Date().toISOString()
-      };
-      await saveKnowledge(knowledge);
-      return { success: true, message: `Knowledge '${key}' added successfully` };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
-  },
-  readFile,
-  writeFile,
-  editFile,
-  runCommand,
-  searchFiles
-};
-
 // 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*```/;
+  if (!text || typeof text !== 'string') {
+    console.error('Invalid input to extractJsonFromMarkdown:', typeof text);
+    return null;
+  }
+
+  // Try to find a markdown code block with JSON content (case insensitive)
+  const codeBlockRegex = /```(?:json|JSON)\s*([\s\S]*?)\s*```/i;
   const match = text.match(codeBlockRegex);
   
-  if (match) {
+  if (match && match[1]) {
     try {
-      return JSON.parse(match[1]);
+      const jsonStr = match[1].trim();
+      if (!jsonStr) {
+        console.error('Empty JSON content in markdown block');
+        return null;
+      }
+      return JSON.parse(jsonStr);
     } catch (error) {
-      console.error('Error parsing JSON from markdown:', error);
+      console.error('Error parsing JSON from markdown block:', error.message);
+      console.error('JSON content was:', match[1]);
     }
   }
   
-  // If no code block, try to parse the entire text as JSON
+  // If no code block found, look for JSON-like patterns in the text
+  const jsonPatterns = [
+    // Look for objects that start with { and end with }
+    /\{[\s\S]*?\}/g,
+    // Look for arrays that start with [ and end with ]
+    /\[[\s\S]*?\]/g
+  ];
+  
+  for (const pattern of jsonPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        try {
+          const parsed = JSON.parse(match.trim());
+          // Validate that it looks like an action object
+          if (parsed && typeof parsed === 'object' && parsed.type) {
+            return parsed;
+          }
+        } catch (error) {
+          // Continue to next match
+          continue;
+        }
+      }
+    }
+  }
+  
+  // If still no valid JSON found, try to parse the entire text as JSON
   try {
-    return JSON.parse(text);
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+      return JSON.parse(trimmed);
+    }
   } catch (error) {
-    console.error('Error parsing JSON:', error);
-    ui.stopThinking();
-    return null;
+    // Last resort failed
   }
+  
+  console.error('Failed to extract valid JSON from response');
+  console.error('Response text was:', text);
+  return null;
 }
 
 // Call OpenRouter API with tool calling
@@ -491,29 +589,7 @@ async function callOpenRouter(messages, currentModel, useJson = false) {
 // Process a query with tool calling
 async function processQueryWithTools(query, conversation = [], currentModel) {
   const userMessage = { role: 'user', content: query };
-  let messages = [...conversation, userMessage];
-
-  // Add system message with knowledge if this is the first message
-  if (conversation.length === 0) {
-    // Load knowledge and include it in the system prompt
-    const knowledge = await loadKnowledge();
-    let systemPrompt = TOOL_CALLING_PROMPT;
-    
-    // Add knowledge to the system prompt if any exists
-    const knowledgeEntries = Object.entries(knowledge);
-    if (knowledgeEntries.length > 0) {
-      systemPrompt += '\n\nCURRENT KNOWLEDGE BASE:\n';
-      systemPrompt += knowledgeEntries.map(([key, { value, description }]) => 
-        `- ${key}: ${value} (${description})`
-      ).join('\n');
-    }
-    
-    // Add system message at the beginning
-    messages = [
-      { role: 'system', content: systemPrompt },
-      ...messages
-    ];
-  }
+  const messages = [...conversation, userMessage];
 
   ui.startThinking();
 
@@ -556,20 +632,12 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
 async function handleToolCalls(toolCalls, messages) {
   const results = [];
   
-  // Load knowledge at the start of processing tool calls
-  const knowledge = await loadKnowledge();
-  
   for (const toolCall of toolCalls) {
     const functionName = toolCall.function.name;
     let args;
     
     try {
       args = JSON.parse(toolCall.function.arguments);
-      
-      // If we have knowledge that might be relevant, include it in the context
-      if (knowledge.defaultLanguage && !args.language) {
-        args.language = knowledge.defaultLanguage.value;
-      }
     } catch (error) {
       console.error('❌ Failed to parse tool arguments:', error);
       results.push({
@@ -635,10 +703,15 @@ async function executeAction(action) {
       }
       throw new Error('Text search is not implemented yet');
     case 'execute':
-      const cmd = data.language === 'bash' 
-        ? data.code 
-        : `node -e "${data.code.replace(/"/g, '\"')}"`;
-      return await agentUtils.runCommand(cmd);
+      if (data.language === 'bash' || data.language === 'sh') {
+        return await agentUtils.runCommand(data.code);
+      } else if (data.language === 'node' || data.language === 'javascript' || data.language === 'js') {
+        // For node.js code, escape quotes properly and handle multiline code
+        const escapedCode = data.code.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return await agentUtils.runCommand(`node -e "${escapedCode}"`);
+      } else {
+        throw new Error(`Unsupported execution language: ${data.language}`);
+      }
     case 'browse':
       throw new Error('Web browsing is not implemented yet');
     case 'analyze':
@@ -653,44 +726,77 @@ async function executeAction(action) {
 async function processQuery(query, conversation = [], currentModel) {
   try {
     const userMessage = { role: 'user', content: query };
+    
+    // Use existing conversation (which should already have system prompt from chat function)
     let messages = [...conversation, userMessage];
+    
     let actionCount = 0;
     const MAX_ACTIONS = 10;
+    let finalResponse = '';
 
     ui.startThinking();
     
-    const responseText = await callOpenRouter(messages, currentModel, true);
-    const assistantMessage = responseText.choices[0].message;
-    messages.push(assistantMessage);
-    
-    const actionData = extractJsonFromMarkdown(assistantMessage.content);
-    
-    if (!actionData || actionData.type === 'stop') {
-      ui.stopThinking();
-      return {
-        response: assistantMessage.content,
-        conversation: messages
-      };
-    }
-
-    let currentAction = actionData;
-    while (currentAction && currentAction.type !== 'stop' && actionCount < MAX_ACTIONS) {
-      actionCount++;
-      const result = await executeAction(currentAction);
+    while (actionCount < MAX_ACTIONS) {
+      const responseObj = await callOpenRouter(messages, currentModel, true);
+      const assistantMessage = responseObj.choices[0].message;
+      messages.push(assistantMessage);
       
-      messages.push({ role: 'assistant', content: `Action result: ${result}` });
+      const actionData = extractJsonFromMarkdown(assistantMessage.content);
       
-      ui.startThinking();
-      const nextResponse = await callOpenRouter(messages, currentModel, true);
-      const nextAssistantMessage = nextResponse.choices[0].message;
-      messages.push(nextAssistantMessage);
+      // If no valid action found, treat as final response
+      if (!actionData || !actionData.type) {
+        finalResponse = assistantMessage.content;
+        break;
+      }
+      
+      // If stop action, break with the reasoning or content
+      if (actionData.type === 'stop') {
+        finalResponse = actionData.reasoning || assistantMessage.content;
+        break;
+      }
+      
+      actionCount++;
+      console.log(`🔧 Executing action ${actionCount}: ${actionData.type}`);
+      if (actionData.reasoning) {
+        console.log(`📝 Reasoning: ${actionData.reasoning}`);
+      }
       
-      currentAction = extractJsonFromMarkdown(nextAssistantMessage.content);
+      try {
+        const result = await executeAction(actionData);
+        console.log('✅ Action executed successfully');
+        
+        // Add action result to conversation
+        const resultMessage = {
+          role: 'user', 
+          content: `Action result (${actionData.type}): ${result}`
+        };
+        messages.push(resultMessage);
+        
+      } catch (error) {
+        console.error('❌ Action execution failed:', error.message);
+        
+        // Add error result to conversation
+        const errorMessage = {
+          role: 'user', 
+          content: `Action failed (${actionData.type}): ${error.message}`
+        };
+        messages.push(errorMessage);
+      }
+    }
+    
+    // If we hit max actions, get a final response
+    if (actionCount >= MAX_ACTIONS && !finalResponse) {
+      const finalMsg = { role: 'user', content: 'Please provide a final summary of what was accomplished.' };
+      messages.push(finalMsg);
+      
+      const finalResponseObj = await callOpenRouter(messages, currentModel, true);
+      finalResponse = finalResponseObj.choices[0].message.content;
+      messages.push(finalResponseObj.choices[0].message);
     }
 
     ui.stopThinking();
     return {
-      response: messages[messages.length - 1].content,
+      response: finalResponse || 'Task completed.',
       conversation: messages
     };
   } catch (error) {
@@ -706,6 +812,14 @@ async function processQuery(query, conversation = [], currentModel) {
 async function chat(rl, useToolCalling, initialModel) {
   let currentModel = initialModel;
   const conversation = [];
+  
+  // Initialize conversation with appropriate system prompt
+  if (useToolCalling) {
+    conversation.push({ role: 'system', content: TOOL_CALLING_PROMPT });
+  } else {
+    conversation.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
+  }
+  
   console.log('Type your message, or "exit" to quit.');
   
   rl.setPrompt('> ');
@@ -740,28 +854,18 @@ async function chat(rl, useToolCalling, initialModel) {
     if (input.toLowerCase() === '/setup') {
       await runSetup(rl, true);
       console.log('\nSetup complete. Please restart the application to apply changes.');
-      rl.prompt();
+      rl.close();
       return;
     }
-    
-    if (input.toLowerCase() === '/eraseknowledge') {
-      try {
-        await fs.unlink(KNOWLEDGE_FILE);
-        console.log('✅ All knowledge has been erased.');
-      } catch (error) {
-        if (error.code === 'ENOENT') {
-          console.log('ℹ️ No knowledge to erase.');
-        } else {
-          console.error('❌ Failed to erase knowledge:', error.message);
-        }
-      }
-      rl.prompt();
+
+    if (input.toLowerCase() === 'exit') {
+      rl.close();
       return;
     }
     
     const result = useToolCalling 
-      ? await processQueryWithTools(query, conversation, currentModel)
-      : await processQuery(query, conversation, currentModel);
+      ? await processQueryWithTools(input, conversation, currentModel)
+      : await processQuery(input, conversation, currentModel);
     ui.stopThinking();
     ui.showResponse(result.response);
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {

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()