closed-loop-cli 1.0.0

package/src/tools/shell-tools.ts

@@ -0,0 +1,90 @@
+import { spawn } from 'child_process';
+
+export interface CommandResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  error?: string;
+}
+
+/**
+ * Executes a terminal command within a specified working directory.
+ * Supports interactive stdin input streams and streams output in real-time.
+ * Safely caps execution time using a timeout.
+ */
+export function runCommand(
+  command: string, 
+  cwd: string = process.cwd(), 
+  timeoutMs: number = 120000 // 2 minutes timeout
+): Promise<CommandResult> {
+  return new Promise((resolve) => {
+    const isWindows = process.platform === 'win32';
+    const shell = isWindows ? 'cmd.exe' : '/bin/sh';
+    const args = isWindows ? ['/d', '/s', '/c', command] : ['-c', command];
+
+    let stdoutData = '';
+    let stderrData = '';
+    let isFinished = false;
+
+    // Spawn child with stdin inherited so standard keyboard input goes through
+    const child = spawn(shell, args, {
+      cwd,
+      windowsVerbatimArguments: isWindows,
+      stdio: ['inherit', 'pipe', 'pipe']
+    });
+
+    const timeout = setTimeout(() => {
+      if (!isFinished) {
+        isFinished = true;
+        try {
+          child.kill('SIGKILL');
+        } catch (e) {}
+        resolve({
+          stdout: stdoutData,
+          stderr: stderrData,
+          exitCode: 1,
+          error: `Command timed out after ${timeoutMs}ms.`
+        });
+      }
+    }, timeoutMs);
+
+    child.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdoutData += chunk;
+      process.stdout.write(chunk);
+    });
+
+    child.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      stderrData += chunk;
+      process.stderr.write(chunk);
+    });
+
+    child.on('error', (err) => {
+      if (!isFinished) {
+        isFinished = true;
+        clearTimeout(timeout);
+        resolve({
+          stdout: stdoutData,
+          stderr: stderrData,
+          exitCode: 1,
+          error: err.message
+        });
+      }
+    });
+
+    child.on('close', (code) => {
+      if (!isFinished) {
+        isFinished = true;
+        clearTimeout(timeout);
+        resolve({
+          stdout: stdoutData,
+          stderr: stderrData,
+          exitCode: code,
+          error: code !== 0 ? `Command exited with code ${code}` : undefined
+        });
+      }
+    });
+  });
+}
+

package/src/tools/skills.ts

@@ -0,0 +1,101 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
+const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
+const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
+
+export interface SkillRecipe {
+  id: string;
+  title: string;
+  description: string;
+  filesModified: string[];
+  recipe: string;
+}
+
+/**
+ * Summarizes the recent successful evolution step and saves it to docs/skills/
+ */
+export async function extractAndSaveSkill(task: string, diffText: string): Promise<void> {
+  const workspaceRoot = process.cwd();
+  const skillsDir = path.join(workspaceRoot, 'docs', 'skills');
+  
+  if (!fs.existsSync(skillsDir)) {
+    fs.mkdirSync(skillsDir, { recursive: true });
+  }
+
+  const anthropic = new Anthropic({
+    apiKey: apiKey,
+    baseURL: baseURL,
+  });
+
+  const prompt = `You are a technical documenter. Your task is to analyze the user's refactoring/coding task and the successful git diff, then extract a general reusable development recipe/skill.
+
+Task: "${task}"
+
+Git Diff:
+"""
+${diffText}
+"""
+
+Output your response strictly as a JSON object of a reusable playbook. Do not write any markdown wrappers (like \`\`\`json or \`\`\`), greetings, or conversational headers/footers. Output ONLY the raw JSON.
+
+Format:
+{
+  "id": "hyphenated-lowercase-slug-id",
+  "title": "Clear Action-Oriented Title",
+  "description": "Concise summary of what this recipe achieves",
+  "filesModified": ["src/relative/path/to/file.ts"],
+  "recipe": "Step-by-step general instructions of the technique used, focusing on design patterns, APIs, and syntax."
+}`;
+
+  try {
+    const response = await anthropic.messages.create({
+      model: defaultModel,
+      max_tokens: 1500,
+      messages: [{ role: 'user', content: prompt }]
+    });
+
+    const block = response.content.find(b => b.type === 'text') as Anthropic.TextBlock | undefined;
+    if (block && block.text) {
+      const text = block.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
+      const recipe: SkillRecipe = JSON.parse(text);
+      
+      const fileName = `${recipe.id}.json`;
+      fs.writeFileSync(path.join(skillsDir, fileName), JSON.stringify(recipe, null, 2), 'utf-8');
+      console.log(`\n\x1b[32m[Skill Registry] Reusable skill saved successfully to docs/skills/${fileName}\x1b[0m`);
+    }
+  } catch (err: any) {
+    console.error(`\x1b[31m[Skill Registry] Failed to extract skill: ${err.message}\x1b[0m`);
+  }
+}
+
+/**
+ * Returns a concatenated summary of all available skills for prompt context.
+ */
+export function getSkillsSummary(): string {
+  const workspaceRoot = process.cwd();
+  const skillsDir = path.join(workspaceRoot, 'docs', 'skills');
+  if (!fs.existsSync(skillsDir)) {
+    return 'No custom development skills recorded yet.';
+  }
+
+  const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.json'));
+  if (files.length === 0) {
+    return 'No custom development skills recorded yet.';
+  }
+
+  const summaries: string[] = [];
+  for (const file of files) {
+    try {
+      const recipe: SkillRecipe = JSON.parse(fs.readFileSync(path.join(skillsDir, file), 'utf-8'));
+      summaries.push(`- **${recipe.title}** (${recipe.id}): ${recipe.description}\n  Recipe: ${recipe.recipe}`);
+    } catch (e) {}
+  }
+
+  return summaries.join('\n\n');
+}

package/src/tools/tui-tools.ts

@@ -0,0 +1,87 @@
+export class Spinner {
+  private timer: NodeJS.Timeout | null = null;
+  private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  private currentFrame = 0;
+  private message: string;
+  private isStarted = false;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+
+  /**
+   * Starts the spinner animation in the terminal.
+   * Hides the terminal cursor for a cleaner look.
+   */
+  start() {
+    if (this.isStarted) return;
+    this.isStarted = true;
+    
+    // Hide cursor
+    process.stdout.write('\x1b[?25l');
+    
+    this.timer = setInterval(() => {
+      const frame = this.frames[this.currentFrame];
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+      // Clear line and write spinner frame with cyan color
+      process.stdout.write(`\r\x1b[36m${frame}\x1b[0m ${this.message}`);
+    }, 80);
+  }
+
+  /**
+   * Updates the message text displayed alongside the spinner.
+   */
+  update(newMessage: string) {
+    this.message = newMessage;
+  }
+
+  /**
+   * Stops the spinner and shows the terminal cursor again.
+   * Prints the final status indicator (green checkmark or red X).
+   */
+  stop(success: boolean = true, finalMessage?: string) {
+    if (!this.isStarted) return;
+    this.isStarted = false;
+
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    const msg = finalMessage || this.message;
+    const symbol = success ? '\x1b[32m✔\x1b[0m' : '\x1b[31m✖\x1b[0m';
+    
+    // Clear spinner line, write final result, and restore cursor
+    process.stdout.write(`\r${symbol} ${msg}\n\x1b[?25h`);
+  }
+}
+
+/**
+ * Prints a beautiful styled header block for the currently active agent.
+ */
+export function printAgentHeader(agentRole: string) {
+  const roles: Record<string, { title: string; color: string; emoji: string }> = {
+    architect: { title: 'ARCHITECT / PLANNER', color: '\x1b[35;1m', emoji: '📐' }, // bold magenta
+    coder: { title: 'CODER / IMPLEMENTOR', color: '\x1b[32;1m', emoji: '💻' }, // bold green
+    debugger: { title: 'DIAGNOSTICS & DEBUGGER', color: '\x1b[33;1m', emoji: '🔧' }, // bold yellow
+    gatekeeper: { title: 'GATEKEEPER & REVIEWER', color: '\x1b[36;1m', emoji: '🛡️' } // bold cyan
+  };
+
+  const details = roles[agentRole.toLowerCase()] || { title: agentRole.toUpperCase(), color: '\x1b[37;1m', emoji: '🤖' };
+  const border = '='.repeat(60);
+  console.log(`\n${details.color}${border}\x1b[0m`);
+  console.log(`${details.color}  ${details.emoji}  ${details.title}\x1b[0m`);
+  console.log(`${details.color}${border}\x1b[0m\n`);
+}
+
+/**
+ * Renders block contents inside a beautiful box layout with color accents.
+ */
+export function printCollapsibleBlock(title: string, content: string, color: string = '\x1b[34m') {
+  console.log(`${color}┌── ${title} ───────────────────────────────────────────────────────────────┐\x1b[0m`);
+  content.split('\n').forEach(line => {
+    console.log(`${color}│\x1b[0m ${line}`);
+  });
+  console.log(`${color}└───────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n`);
+}
+