sam-coder-cli 1.0.58 → 1.0.60

package/bin/agi-animation.js

@@ -168,19 +168,30 @@ function clearScreen() {
 }
 
 function getTerminalSize() {
+  // Ensure we always have valid numeric values
+  const width = Number(process.stdout.columns) || 80;
+  const height = Number(process.stdout.rows) || 24;
+  
   return {
-    width: process.stdout.columns || 80,
-    height: process.stdout.rows || 24
+    width: Math.max(width, 40),  // Minimum width of 40
+    height: Math.max(height, 10) // Minimum height of 10
   };
 }
 
 function centerText(text, width = getTerminalSize().width) {
-  if (!text) return '';
+  if (!text || typeof text !== 'string') return '';
+  
+  // Ensure width is a valid number
+  const safeWidth = Number(width) || 80;
+  
   const lines = text.split('\n');
   return lines.map(line => {
+    if (!line) return line; // Handle empty lines
+    
     // Strip ANSI codes to calculate actual text length
     const cleanLine = line.replace(/\x1b\[[0-9;]*m/g, '');
-    const padding = Math.max(0, Math.floor((width - cleanLine.length) / 2));
+    const lineLength = cleanLine.length || 0;
+    const padding = Math.max(0, Math.floor((safeWidth - lineLength) / 2));
     return ' '.repeat(padding) + line;
   }).join('\n');
 }
@@ -194,6 +205,12 @@ function safeWrite(content) {
   }
 }
 
+function safeRepeat(str, count) {
+  // Ensure count is a valid positive integer
+  const safeCount = Math.max(0, Math.floor(Number(count) || 0));
+  return str.repeat(safeCount);
+}
+
 // Frame interpolation system
 class FrameInterpolator {
   constructor() {
@@ -329,9 +346,9 @@ async function runAGIAnimation() {
     for (let i = 0; i < 30; i++) {
       const dotCount = (i % 4) + 1;
       const dots = '•'.repeat(dotCount) + ' '.repeat(4 - dotCount);
-      const frame = '\n'.repeat(Math.floor(height / 2) - 2) + 
+      const frame = safeRepeat('\n', Math.floor(height / 2) - 2) + 
                    centerText(dots) + 
-                   '\n'.repeat(Math.floor(height / 2) - 2);
+                   safeRepeat('\n', Math.floor(height / 2) - 2);
       voidFrames.push(frame);
     }
 
@@ -358,9 +375,9 @@ async function runAGIAnimation() {
         sparkPattern = ` · · ·\n· ·${core}· ·\n · · ·`;
       }
       
-      const frame = '\n'.repeat(Math.floor(height / 2) - 3) + 
+      const frame = safeRepeat('\n', Math.floor(height / 2) - 3) + 
                    centerText(sparkPattern) + 
-                   '\n'.repeat(Math.floor(height / 2) - 3);
+                   safeRepeat('\n', Math.floor(height / 2) - 3);
       sparkFrames.push(frame);
     }
     
@@ -390,7 +407,7 @@ async function runAGIAnimation() {
       const baseSize = 2 + progress * 4;
       const pulseSize = baseSize + Math.sin(phase * 2) * 1.5;
       
-      let frame = '\n'.repeat(Math.floor(height / 2) - Math.floor(pulseSize) - 2);
+      let frame = safeRepeat('\n', Math.floor(height / 2) - Math.floor(pulseSize) - 2);
       
       for (let y = -Math.floor(pulseSize); y <= Math.floor(pulseSize); y++) {
         let line = '';
@@ -447,7 +464,7 @@ async function runAGIAnimation() {
 
     for (let i = 0; i < 45; i++) {
       const progress = i / 44;
-      let frame = '\n'.repeat(Math.floor(height / 2) - layers * 2);
+      let frame = safeRepeat('\n', Math.floor(height / 2) - layers * 2);
       
       for (let layer = 0; layer < layers; layer++) {
         let line = '';
@@ -525,7 +542,7 @@ async function runAGIAnimation() {
     const streamWidth = Math.min(60, Math.floor(width * 0.7));
     
     for (let i = 0; i < 30; i++) {
-      let frame = '\n'.repeat(Math.floor((height - streamHeight) / 2));
+      let frame = safeRepeat('\n', Math.floor((height - streamHeight) / 2));
       
       for (let y = 0; y < streamHeight; y++) {
         let line = '';
@@ -689,7 +706,7 @@ async function runAGIAnimation() {
     // Transition from Matrix Rain to DNA
     clearScreen();
     const matrixToDNAText = centerText('[ DECODING GENETIC ALGORITHMS ]');
-    safeWrite(chalk.greenBright('\n'.repeat(Math.floor(height / 2)) + matrixToDNAText));
+          safeWrite(chalk.greenBright(safeRepeat('\n', Math.floor(height / 2)) + matrixToDNAText));
     await sleep(500);
     
     // Fade out transition
@@ -697,9 +714,9 @@ async function runAGIAnimation() {
       clearScreen();
       const opacity = 1 - (i / 10);
       if (opacity > 0.5) {
-        safeWrite(chalk.green('\n'.repeat(Math.floor(height / 2)) + matrixToDNAText));
+        safeWrite(chalk.green(safeRepeat('\n', Math.floor(height / 2)) + matrixToDNAText));
       } else if (opacity > 0.2) {
-        safeWrite(chalk.green.dim('\n'.repeat(Math.floor(height / 2)) + matrixToDNAText));
+        safeWrite(chalk.green.dim(safeRepeat('\n', Math.floor(height / 2)) + matrixToDNAText));
       }
       await sleep(frameTime);
       frameCount++;
@@ -715,7 +732,7 @@ async function runAGIAnimation() {
       const helixHeight = Math.min(20, Math.floor(height * 0.6));
       const phase = progress * Math.PI * 4; // Two full rotations
       
-      let dnaFrame = '\n'.repeat(Math.floor((height - helixHeight) / 2));
+      let dnaFrame = safeRepeat('\n', Math.floor((height - helixHeight) / 2));
       
       for (let y = 0; y < helixHeight; y++) {
         const yProgress = y / helixHeight;
@@ -792,7 +809,7 @@ async function runAGIAnimation() {
     
     for (let frame = 0; frame < 60; frame++) {
       const progress = frame / 59;
-      let circuitFrame = '\n'.repeat(Math.floor((height - circuitHeight) / 2));
+      let circuitFrame = safeRepeat('\n', Math.floor((height - circuitHeight) / 2));
       
       // Build circuit board progressively
       for (let y = 0; y < circuitHeight; y++) {
@@ -872,7 +889,7 @@ async function runAGIAnimation() {
       const progress = frame / 59;
       const wavePhase = frame * 0.1;
       
-      let consciousnessFrame = '\n'.repeat(Math.floor((height - brainHeight) / 2));
+      let consciousnessFrame = safeRepeat('\n', Math.floor((height - brainHeight) / 2));
       
       // Create brain outline with neural activity
       const brainArt = [
@@ -981,7 +998,7 @@ async function runAGIAnimation() {
       const progress = frame / 59;
       const rotation = progress * Math.PI * 2;
       
-      let galaxyFrame = '\n'.repeat(Math.floor((height - galaxySize) / 2));
+      let galaxyFrame = safeRepeat('\n', Math.floor((height - galaxySize) / 2));
       
       // Create spiral galaxy
       for (let y = 0; y < galaxySize; y++) {
@@ -1051,7 +1068,7 @@ async function runAGIAnimation() {
     const galaxyToCodeFrames = [];
     for (let i = 0; i < 15; i++) {
       const progress = i / 14;
-      let transitionFrame = '\n'.repeat(Math.floor(height / 2) - 2);
+      let transitionFrame = safeRepeat('\n', Math.floor(height / 2) - 2);
       
       // Stars morphing into code characters
       const morphChars = ['*', '/', '{', '}', '(', ')', ';', '='];
@@ -1117,7 +1134,7 @@ async function runAGIAnimation() {
     
     for (let frame = 0; frame < 60; frame++) {
       const progress = frame / 59;
-      let compilationFrame = '\n'.repeat(Math.floor((height - codeHeight) / 2));
+      let compilationFrame = safeRepeat('\n', Math.floor((height - codeHeight) / 2));
       
       // Terminal header
       compilationFrame += centerText(chalk.gray('┌' + '─'.repeat(codeWidth - 2) + '┐')) + '\n';
@@ -1405,7 +1422,7 @@ async function runAGIAnimation() {
 
     // Final hold with status
     clearScreen();
-    let finalDisplay = '\n'.repeat(Math.max(0, centerY));
+    let finalDisplay = safeRepeat('\n', Math.max(0, centerY));
     for (const line of lines) {
       finalDisplay += centerText(line) + '\n';
     }

package/bin/agi-cli.js

@@ -17,6 +17,7 @@ const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
 let MODEL = 'deepseek/deepseek-chat-v3-0324:free';
 let API_BASE_URL = 'https://openrouter.ai/api/v1';
+let SHOW_THOUGHTS = false; // Optional: reveal <think> content in console
 
 // Tool/Function definitions for the AI
 const tools = [
@@ -619,6 +620,143 @@ function extractJsonFromMarkdown(text) {
   return null;
 }
 
+// Extract and strip <think>...</think> blocks from model output
+function splitThinking(text) {
+  if (!text || typeof text !== 'string') {
+    return { thought: '', content: text || '' };
+  }
+  const thinkRegex = /<think>[\s\S]*?<\/think>/gi;
+  let combinedThoughts = [];
+  let match;
+  // Collect all thoughts
+  const singleThinkRegex = /<think>([\s\S]*?)<\/think>/i;
+  let remaining = text;
+  while ((match = remaining.match(singleThinkRegex))) {
+    combinedThoughts.push((match[1] || '').trim());
+    remaining = remaining.replace(singleThinkRegex, '');
+  }
+  const visible = remaining.replace(thinkRegex, '').trim();
+  return { thought: combinedThoughts.join('\n\n').trim(), content: visible };
+}
+
+// Try to recover tool/function calls embedded in assistant text for thinking models
+function parseInlineToolCalls(text) {
+  if (!text || typeof text !== 'string') return null;
+
+  const candidates = [];
+
+  // 1) JSON code blocks
+  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/gi;
+  let m;
+  while ((m = codeBlockRegex.exec(text)) !== null) {
+    const block = (m[1] || '').trim();
+    if (block) candidates.push(block);
+  }
+
+  // 2) <tool_call>...</tool_call>
+  const toolTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  while ((m = toolTagRegex.exec(text)) !== null) {
+    const inner = (m[1] || '').trim();
+    if (inner) candidates.push(inner);
+  }
+  // 2b) <function_call>...</function_call>
+  const fnTagRegex = /<function_call>([\s\S]*?)<\/function_call>/gi;
+  while ((m = fnTagRegex.exec(text)) !== null) {
+    const inner = (m[1] || '').trim();
+    if (inner) candidates.push(inner);
+  }
+
+  // 3) General JSON-looking substrings as last resort
+  const braceRegex = /\{[\s\S]*?\}/g;
+  const braceMatches = text.match(braceRegex) || [];
+  braceMatches.forEach(snippet => candidates.push(snippet));
+
+  const toolCalls = [];
+
+  for (const candidate of candidates) {
+    try {
+      const obj = JSON.parse(candidate);
+      // OpenAI-style single function_call
+      if (obj && obj.function_call && obj.function_call.name) {
+        const args = obj.function_call.arguments ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.function_call.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+      // Anthropic-like tool_use
+      if (obj && obj.tool_call && obj.tool_call.name) {
+        const args = obj.tool_call.arguments ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.tool_call.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+      // Array of tool_calls
+      if (Array.isArray(obj?.tool_calls)) {
+        obj.tool_calls.forEach((tc) => {
+          if (tc?.function?.name) {
+            const args = tc.function.arguments ?? {};
+            toolCalls.push({
+              id: tc.id || `inline-${toolCalls.length + 1}`,
+              type: 'function',
+              function: {
+                name: tc.function.name,
+                arguments: typeof args === 'string' ? args : JSON.stringify(args)
+              }
+            });
+          }
+        });
+        if (toolCalls.length) continue;
+      }
+      // Direct function structure
+      if (obj?.name && (obj.arguments !== undefined || obj.args !== undefined)) {
+        const args = obj.arguments ?? obj.args ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+    } catch (_) {
+      // ignore parse failures
+    }
+  }
+
+  return toolCalls.length ? toolCalls : null;
+}
+
+// Normalize single function_call to tool_calls array if present
+function normalizeToolCallsFromMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  if (!message.tool_calls && message.function_call && message.function_call.name) {
+    const args = message.function_call.arguments ?? {};
+    message.tool_calls = [{
+      id: 'fc-1',
+      type: 'function',
+      function: {
+        name: message.function_call.name,
+        arguments: typeof args === 'string' ? args : JSON.stringify(args)
+      }
+    }];
+  }
+  return message;
+}
+
 // Call OpenRouter API with tool calling
 async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
@@ -675,8 +813,24 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
   try {
     const response = await callOpenRouter(messages, currentModel);
     const assistantMessage = response.choices[0].message;
+    // Handle thinking tags and optionally display them
+    if (assistantMessage && typeof assistantMessage.content === 'string') {
+      const { thought, content } = splitThinking(assistantMessage.content);
+      if (thought && SHOW_THOUGHTS) {
+        ui.showInfo(`Thinking:\n${thought}`);
+      }
+      assistantMessage.content = content;
+    }
+    normalizeToolCallsFromMessage(assistantMessage);
     messages.push(assistantMessage);
 
+    // Try inline recovery for thinking models that embed tool calls inside content
+    if (!assistantMessage.tool_calls && assistantMessage.content) {
+      const recovered = parseInlineToolCalls(assistantMessage.content);
+      if (recovered && recovered.length) {
+        assistantMessage.tool_calls = recovered;
+      }
+    }
     if (assistantMessage.tool_calls) {
       const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
       messages.push(...toolResults);
@@ -684,6 +838,14 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
       ui.startThinking();
       const finalResponseObj = await callOpenRouter(messages, currentModel);
       const finalAssistantMessage = finalResponseObj.choices[0].message;
+      if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(finalAssistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        finalAssistantMessage.content = content;
+      }
+      normalizeToolCallsFromMessage(finalAssistantMessage);
       messages.push(finalAssistantMessage);
       ui.stopThinking();
 
@@ -692,6 +854,31 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
         conversation: messages
       };
     } else {
+      // Fallback: if no tool_calls were returned, try to parse a JSON action from content (thinking models may embed later)
+      const fallbackAction = extractJsonFromMarkdown(assistantMessage.content);
+      if (fallbackAction && fallbackAction.type) {
+        try {
+          const result = await executeAction(fallbackAction);
+          messages.push({ role: 'user', content: `Action result (${fallbackAction.type}): ${result}` });
+          ui.startThinking();
+          const finalResponseObj = await callOpenRouter(messages, currentModel);
+          const finalAssistantMessage = finalResponseObj.choices[0].message;
+          if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+            const { thought, content } = splitThinking(finalAssistantMessage.content);
+            if (thought && SHOW_THOUGHTS) {
+              ui.showInfo(`Thinking:\n${thought}`);
+            }
+            finalAssistantMessage.content = content;
+          }
+          normalizeToolCallsFromMessage(finalAssistantMessage);
+          messages.push(finalAssistantMessage);
+          ui.stopThinking();
+          return { response: finalAssistantMessage.content, conversation: messages };
+        } catch (e) {
+          ui.stopThinking();
+          // If fallback execution fails, just return original assistant content
+        }
+      }
       ui.stopThinking();
       return {
         response: assistantMessage.content,
@@ -818,6 +1005,14 @@ async function processQuery(query, conversation = [], currentModel) {
     while (actionCount < MAX_ACTIONS) {
       const responseObj = await callOpenRouter(messages, currentModel, true);
       const assistantMessage = responseObj.choices[0].message;
+      if (assistantMessage && typeof assistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(assistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        assistantMessage.content = content;
+      }
+      normalizeToolCallsFromMessage(assistantMessage);
       messages.push(assistantMessage);
       
       const actionData = extractJsonFromMarkdown(assistantMessage.content);
@@ -869,8 +1064,17 @@ async function processQuery(query, conversation = [], currentModel) {
       messages.push(finalMsg);
       
       const finalResponseObj = await callOpenRouter(messages, currentModel, true);
-      finalResponse = finalResponseObj.choices[0].message.content;
-      messages.push(finalResponseObj.choices[0].message);
+      const finalAssistantMessage = finalResponseObj.choices[0].message;
+      if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(finalAssistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        finalResponse = content;
+      } else {
+        finalResponse = finalResponseObj.choices[0].message.content;
+      }
+      messages.push(finalAssistantMessage);
     }
 
     ui.stopThinking();
@@ -920,6 +1124,25 @@ async function chat(rl, useToolCalling, initialModel) {
       return;
     }
 
+    if (input.toLowerCase().startsWith('/thoughts')) {
+      const parts = input.trim().split(/\s+/);
+      const arg = parts[1] ? parts[1].toLowerCase() : '';
+      if (arg !== 'on' && arg !== 'off') {
+        const state = SHOW_THOUGHTS ? 'on' : 'off';
+        ui.showInfo(`Usage: /thoughts on|off (currently ${state})`);
+        rl.prompt();
+        return;
+      }
+      const enable = arg === 'on';
+      SHOW_THOUGHTS = enable;
+      let config = await readConfig() || {};
+      config.showThoughts = enable;
+      await writeConfig(config);
+      ui.showResponse(`Hidden thoughts ${enable ? 'enabled' : 'disabled'}.`);
+      rl.prompt();
+      return;
+    }
+
     if (input.toLowerCase() === '/default-model') {
       currentModel = 'deepseek/deepseek-chat-v3-0324:free';
       let config = await readConfig() || {};
@@ -1039,6 +1262,9 @@ async function start() {
       console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
     }
 
+    // Optional: reveal <think> thoughts if enabled in config or env
+    SHOW_THOUGHTS = (typeof config.showThoughts === 'boolean') ? config.showThoughts : (process.env.SHOW_THOUGHTS === '1');
+
     // Check if animation should be shown (can be disabled via config)
     const showAnimation = config.showAnimation !== false; // Default to true
     

package/package.json

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