@corbat-tech/coco 1.4.0 → 1.6.0

package/dist/cli/index.js

@@ -12,13 +12,14 @@ import { z } from 'zod';
 import chalk42 from 'chalk';
 import * as p9 from '@clack/prompts';
 import { execa } from 'execa';
+import * as crypto from 'crypto';
+import { randomUUID } from 'crypto';
 import { Command } from 'commander';
 import { fileURLToPath, URL as URL$1 } from 'url';
 import JSON5 from 'json5';
-import * as crypto from 'crypto';
-import { randomUUID } from 'crypto';
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
+import { jsonrepair } from 'jsonrepair';
 import * as http from 'http';
 import { execFile, exec, execSync, execFileSync, spawn } from 'child_process';
 import { promisify } from 'util';
@@ -448,8 +449,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path43) {
-  await mkdir(dirname(path43), { recursive: true });
+async function ensureDir(path44) {
+  await mkdir(dirname(path44), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -527,8 +528,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path43) {
-  return join(path43);
+function normalizePath(path44) {
+  return join(path44);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -981,6 +982,71 @@ var init_allow_path_prompt = __esm({
     init_allowed_paths();
   }
 });
+
+// src/tools/utils/heartbeat.ts
+var heartbeat_exports = {};
+__export(heartbeat_exports, {
+  CommandHeartbeat: () => CommandHeartbeat
+});
+var CommandHeartbeat;
+var init_heartbeat = __esm({
+  "src/tools/utils/heartbeat.ts"() {
+    CommandHeartbeat = class {
+      startTime = 0;
+      lastActivityTime = 0;
+      updateInterval = null;
+      warnThreshold = 30;
+      // seconds
+      updateIntervalSeconds = 10;
+      // seconds
+      callbacks;
+      constructor(callbacks = {}) {
+        this.callbacks = callbacks;
+      }
+      /**
+       * Start monitoring - begins periodic updates and silence warnings
+       */
+      start() {
+        this.startTime = Date.now();
+        this.lastActivityTime = Date.now();
+        this.updateInterval = setInterval(() => {
+          const stats = this.getStats();
+          this.callbacks.onUpdate?.(stats);
+          if (stats.silentSeconds >= this.warnThreshold) {
+            this.callbacks.onWarn?.(`\u26A0\uFE0F  Command silent for ${stats.silentSeconds}s`);
+          }
+        }, this.updateIntervalSeconds * 1e3);
+      }
+      /**
+       * Register activity - call this when command produces output
+       * Resets the silence timer
+       */
+      activity() {
+        this.lastActivityTime = Date.now();
+      }
+      /**
+       * Stop monitoring - clears periodic interval
+       * Should be called in finally{} block to ensure cleanup
+       */
+      stop() {
+        if (this.updateInterval) {
+          clearInterval(this.updateInterval);
+          this.updateInterval = null;
+        }
+      }
+      /**
+       * Get current heartbeat statistics
+       */
+      getStats() {
+        const now = Date.now();
+        return {
+          elapsedSeconds: Math.floor((now - this.startTime) / 1e3),
+          silentSeconds: Math.floor((now - this.lastActivityTime) / 1e3)
+        };
+      }
+    };
+  }
+});
 function isEnvVarSafe(name) {
   if (SAFE_ENV_VARS.has(name)) {
     return true;
@@ -1117,23 +1183,50 @@ Examples:
         }
         const startTime = performance.now();
         const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS;
+        const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+        const heartbeat = new CommandHeartbeat2({
+          onUpdate: (stats) => {
+            if (stats.elapsedSeconds > 10) {
+              process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+            }
+          },
+          onWarn: (message) => {
+            process.stderr.write(`
+${message}
+`);
+          }
+        });
         try {
+          heartbeat.start();
           const options = {
             cwd: cwd ?? process.cwd(),
             timeout: timeoutMs,
             env: { ...process.env, ...env2 },
             shell: true,
             reject: false,
+            buffer: false,
+            // Enable streaming
             maxBuffer: MAX_OUTPUT_SIZE
           };
-          const result = await execa(command, options);
+          const subprocess = execa(command, options);
+          let stdoutBuffer = "";
+          let stderrBuffer = "";
+          subprocess.stdout?.on("data", (chunk) => {
+            const text11 = chunk.toString();
+            stdoutBuffer += text11;
+            process.stdout.write(text11);
+            heartbeat.activity();
+          });
+          subprocess.stderr?.on("data", (chunk) => {
+            const text11 = chunk.toString();
+            stderrBuffer += text11;
+            process.stderr.write(text11);
+            heartbeat.activity();
+          });
+          const result = await subprocess;
           return {
-            stdout: truncateOutput(
-              typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "")
-            ),
-            stderr: truncateOutput(
-              typeof result.stderr === "string" ? result.stderr : String(result.stderr ?? "")
-            ),
+            stdout: truncateOutput(stdoutBuffer),
+            stderr: truncateOutput(stderrBuffer),
             exitCode: result.exitCode ?? 0,
             duration: performance.now() - startTime
           };
@@ -1148,6 +1241,9 @@ Examples:
             `Command execution failed: ${error instanceof Error ? error.message : String(error)}`,
             { tool: "bash_exec", cause: error instanceof Error ? error : void 0 }
           );
+        } finally {
+          heartbeat.stop();
+          process.stderr.write("\r                                        \r");
         }
       }
     });
@@ -1260,6 +1356,224 @@ Examples:
     bashTools = [bashExecTool, bashBackgroundTool, commandExistsTool, getEnvTool];
   }
 });
+async function fileExists(filePath) {
+  try {
+    await fs23__default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_files = __esm({
+  "src/utils/files.ts"() {
+    init_errors();
+  }
+});
+
+// src/cli/repl/context/stack-detector.ts
+var stack_detector_exports = {};
+__export(stack_detector_exports, {
+  detectProjectStack: () => detectProjectStack
+});
+async function detectStack(cwd) {
+  if (await fileExists(path20__default.join(cwd, "package.json"))) return "node";
+  if (await fileExists(path20__default.join(cwd, "Cargo.toml"))) return "rust";
+  if (await fileExists(path20__default.join(cwd, "pyproject.toml"))) return "python";
+  if (await fileExists(path20__default.join(cwd, "go.mod"))) return "go";
+  if (await fileExists(path20__default.join(cwd, "pom.xml"))) return "java";
+  if (await fileExists(path20__default.join(cwd, "build.gradle"))) return "java";
+  if (await fileExists(path20__default.join(cwd, "build.gradle.kts"))) return "java";
+  return "unknown";
+}
+async function detectPackageManager2(cwd, stack) {
+  if (stack === "rust") return "cargo";
+  if (stack === "python") return "pip";
+  if (stack === "go") return "go";
+  if (stack === "java") {
+    if (await fileExists(path20__default.join(cwd, "build.gradle")) || await fileExists(path20__default.join(cwd, "build.gradle.kts"))) {
+      return "gradle";
+    }
+    if (await fileExists(path20__default.join(cwd, "pom.xml"))) {
+      return "maven";
+    }
+  }
+  if (stack === "node") {
+    if (await fileExists(path20__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists(path20__default.join(cwd, "yarn.lock"))) return "yarn";
+    if (await fileExists(path20__default.join(cwd, "bun.lockb"))) return "bun";
+    return "npm";
+  }
+  return null;
+}
+async function parsePackageJson(cwd) {
+  const packageJsonPath = path20__default.join(cwd, "package.json");
+  try {
+    const content = await fs23__default.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    const frameworks = [];
+    if (allDeps.react) frameworks.push("React");
+    if (allDeps.vue) frameworks.push("Vue");
+    if (allDeps["@angular/core"]) frameworks.push("Angular");
+    if (allDeps.next) frameworks.push("Next.js");
+    if (allDeps.nuxt) frameworks.push("Nuxt");
+    if (allDeps.express) frameworks.push("Express");
+    if (allDeps.fastify) frameworks.push("Fastify");
+    if (allDeps.nestjs || allDeps["@nestjs/core"]) frameworks.push("NestJS");
+    const buildTools2 = [];
+    if (allDeps.webpack) buildTools2.push("webpack");
+    if (allDeps.vite) buildTools2.push("vite");
+    if (allDeps.rollup) buildTools2.push("rollup");
+    if (allDeps.tsup) buildTools2.push("tsup");
+    if (allDeps.esbuild) buildTools2.push("esbuild");
+    if (pkg.scripts?.build) buildTools2.push("build");
+    const testingFrameworks = [];
+    if (allDeps.vitest) testingFrameworks.push("vitest");
+    if (allDeps.jest) testingFrameworks.push("jest");
+    if (allDeps.mocha) testingFrameworks.push("mocha");
+    if (allDeps.chai) testingFrameworks.push("chai");
+    if (allDeps["@playwright/test"]) testingFrameworks.push("playwright");
+    if (allDeps.cypress) testingFrameworks.push("cypress");
+    const languages = ["JavaScript"];
+    if (allDeps.typescript || await fileExists(path20__default.join(cwd, "tsconfig.json"))) {
+      languages.push("TypeScript");
+    }
+    return {
+      dependencies: allDeps,
+      frameworks,
+      buildTools: buildTools2,
+      testingFrameworks,
+      languages
+    };
+  } catch {
+    return {
+      dependencies: {},
+      frameworks: [],
+      buildTools: [],
+      testingFrameworks: [],
+      languages: []
+    };
+  }
+}
+async function parsePomXml(cwd) {
+  const pomPath = path20__default.join(cwd, "pom.xml");
+  try {
+    const content = await fs23__default.readFile(pomPath, "utf-8");
+    const dependencies = {};
+    const frameworks = [];
+    const buildTools2 = ["maven"];
+    const testingFrameworks = [];
+    const depRegex = /<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>/g;
+    let match;
+    while ((match = depRegex.exec(content)) !== null) {
+      const groupId = match[1];
+      const artifactId = match[2];
+      if (!groupId || !artifactId) continue;
+      const fullName = `${groupId}:${artifactId}`;
+      dependencies[fullName] = "unknown";
+      if (artifactId.includes("spring-boot")) {
+        if (!frameworks.includes("Spring Boot")) frameworks.push("Spring Boot");
+      }
+      if (artifactId.includes("spring-webmvc") || artifactId.includes("spring-web")) {
+        if (!frameworks.includes("Spring MVC")) frameworks.push("Spring MVC");
+      }
+      if (artifactId.includes("hibernate")) {
+        if (!frameworks.includes("Hibernate")) frameworks.push("Hibernate");
+      }
+      if (artifactId === "junit-jupiter" || artifactId === "junit") {
+        if (!testingFrameworks.includes("JUnit")) testingFrameworks.push("JUnit");
+      }
+      if (artifactId === "mockito-core") {
+        if (!testingFrameworks.includes("Mockito")) testingFrameworks.push("Mockito");
+      }
+    }
+    return { dependencies, frameworks, buildTools: buildTools2, testingFrameworks };
+  } catch {
+    return { dependencies: {}, frameworks: [], buildTools: ["maven"], testingFrameworks: [] };
+  }
+}
+async function parsePyprojectToml(cwd) {
+  const pyprojectPath = path20__default.join(cwd, "pyproject.toml");
+  try {
+    const content = await fs23__default.readFile(pyprojectPath, "utf-8");
+    const dependencies = {};
+    const frameworks = [];
+    const buildTools2 = ["pip"];
+    const testingFrameworks = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.match(/^["']?[\w-]+["']?\s*=\s*["'][\^~>=<]+[\d.]+["']/)) {
+        const depMatch = trimmed.match(/^["']?([\w-]+)["']?\s*=\s*["']([\^~>=<]+[\d.]+)["']/);
+        if (depMatch && depMatch[1] && depMatch[2]) {
+          dependencies[depMatch[1]] = depMatch[2];
+        }
+      }
+      if (trimmed.includes("fastapi")) frameworks.push("FastAPI");
+      if (trimmed.includes("django")) frameworks.push("Django");
+      if (trimmed.includes("flask")) frameworks.push("Flask");
+      if (trimmed.includes("pytest")) testingFrameworks.push("pytest");
+      if (trimmed.includes("unittest")) testingFrameworks.push("unittest");
+    }
+    return { dependencies, frameworks, buildTools: buildTools2, testingFrameworks };
+  } catch {
+    return { dependencies: {}, frameworks: [], buildTools: ["pip"], testingFrameworks: [] };
+  }
+}
+async function detectProjectStack(cwd) {
+  const stack = await detectStack(cwd);
+  const packageManager = await detectPackageManager2(cwd, stack);
+  let dependencies = {};
+  let frameworks = [];
+  let buildTools2 = [];
+  let testingFrameworks = [];
+  let languages = [];
+  if (stack === "node") {
+    const parsed = await parsePackageJson(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = parsed.languages;
+  } else if (stack === "java") {
+    const parsed = await parsePomXml(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = ["Java"];
+  } else if (stack === "python") {
+    const parsed = await parsePyprojectToml(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = ["Python"];
+  } else if (stack === "go") {
+    languages = ["Go"];
+    buildTools2 = ["go"];
+  } else if (stack === "rust") {
+    languages = ["Rust"];
+    buildTools2 = ["cargo"];
+  }
+  return {
+    stack,
+    packageManager,
+    dependencies,
+    frameworks,
+    buildTools: buildTools2,
+    testingFrameworks,
+    languages
+  };
+}
+var init_stack_detector = __esm({
+  "src/cli/repl/context/stack-detector.ts"() {
+    init_files();
+  }
+});
 function findPackageJson() {
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 10; i++) {
@@ -1418,8 +1732,8 @@ Generated by Corbat-Coco v0.1.0
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path43, options) => {
-    await runInit(path43, options);
+  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path44, options) => {
+    await runInit(path44, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -1498,18 +1812,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path43) {
-  const name = path43 === "." ? "my-project" : path43.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path44) {
+  const name = path44 === "." ? "my-project" : path44.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path43) {
+async function checkExistingProject(path44) {
   try {
-    const fs43 = await import('fs/promises');
-    await fs43.access(`${path43}/.coco`);
+    const fs44 = await import('fs/promises');
+    await fs44.access(`${path44}/.coco`);
     return true;
   } catch {
     return false;
@@ -5973,8 +6287,10 @@ var OpenAIProvider = class {
       const timeoutInterval = setInterval(checkTimeout, 5e3);
       try {
         for await (const chunk of stream) {
-          lastActivityTime = Date.now();
           const delta = chunk.choices[0]?.delta;
+          if (delta?.content || delta?.tool_calls) {
+            lastActivityTime = Date.now();
+          }
           if (delta?.content) {
             yield { type: "text", text: delta.content };
           }
@@ -6020,10 +6336,20 @@ var OpenAIProvider = class {
           let input = {};
           try {
             input = builder.arguments ? JSON.parse(builder.arguments) : {};
-          } catch {
+          } catch (error) {
             console.warn(
-              `[OpenAI] Failed to parse tool call arguments: ${builder.arguments?.slice(0, 100)}`
+              `[OpenAI] Failed to parse tool call arguments for ${builder.name}: ${builder.arguments?.slice(0, 100)}`
             );
+            try {
+              if (builder.arguments) {
+                const repaired = jsonrepair(builder.arguments);
+                input = JSON.parse(repaired);
+                console.log(`[OpenAI] \u2713 Successfully repaired JSON for ${builder.name}`);
+              }
+            } catch (repairError) {
+              console.error(`[OpenAI] Cannot repair JSON for ${builder.name}, using empty object`);
+              console.error(`[OpenAI] Original error:`, error);
+            }
           }
           yield {
             type: "tool_use_end",
@@ -8368,20 +8694,20 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path43) {
-          const fs43 = await import('fs/promises');
-          return fs43.readFile(path43, "utf-8");
+        async read(path44) {
+          const fs44 = await import('fs/promises');
+          return fs44.readFile(path44, "utf-8");
         },
-        async write(path43, content) {
-          const fs43 = await import('fs/promises');
+        async write(path44, content) {
+          const fs44 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs43.mkdir(nodePath.dirname(path43), { recursive: true });
-          await fs43.writeFile(path43, content, "utf-8");
+          await fs44.mkdir(nodePath.dirname(path44), { recursive: true });
+          await fs44.writeFile(path44, content, "utf-8");
         },
-        async exists(path43) {
-          const fs43 = await import('fs/promises');
+        async exists(path44) {
+          const fs44 = await import('fs/promises');
           try {
-            await fs43.access(path43);
+            await fs44.access(path44);
             return true;
           } catch {
             return false;
@@ -8620,16 +8946,16 @@ async function loadTasks(_options) {
   ];
 }
 async function checkProjectState() {
-  const fs43 = await import('fs/promises');
+  const fs44 = await import('fs/promises');
   let hasProject = false;
   let hasPlan = false;
   try {
-    await fs43.access(".coco");
+    await fs44.access(".coco");
     hasProject = true;
   } catch {
   }
   try {
-    await fs43.access(".coco/planning/backlog.json");
+    await fs44.access(".coco/planning/backlog.json");
     hasPlan = true;
   } catch {
   }
@@ -8733,24 +9059,24 @@ function getPhaseStatusForPhase(phase) {
   return "in_progress";
 }
 async function loadProjectState(cwd, config) {
-  const fs43 = await import('fs/promises');
-  const path43 = await import('path');
-  const statePath = path43.join(cwd, ".coco", "state.json");
-  const backlogPath = path43.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path43.join(cwd, ".coco", "checkpoints");
+  const fs44 = await import('fs/promises');
+  const path44 = await import('path');
+  const statePath = path44.join(cwd, ".coco", "state.json");
+  const backlogPath = path44.join(cwd, ".coco", "planning", "backlog.json");
+  const checkpointDir = path44.join(cwd, ".coco", "checkpoints");
   let currentPhase = "idle";
   let metrics;
   let sprint;
   let checkpoints = [];
   try {
-    const stateContent = await fs43.readFile(statePath, "utf-8");
+    const stateContent = await fs44.readFile(statePath, "utf-8");
     const stateData = JSON.parse(stateContent);
     currentPhase = stateData.currentPhase || "idle";
     metrics = stateData.metrics;
   } catch {
   }
   try {
-    const backlogContent = await fs43.readFile(backlogPath, "utf-8");
+    const backlogContent = await fs44.readFile(backlogPath, "utf-8");
     const backlogData = JSON.parse(backlogContent);
     if (backlogData.currentSprint) {
       const tasks = backlogData.tasks || [];
@@ -8772,7 +9098,7 @@ async function loadProjectState(cwd, config) {
   } catch {
   }
   try {
-    const files = await fs43.readdir(checkpointDir);
+    const files = await fs44.readdir(checkpointDir);
     checkpoints = files.filter((f) => f.endsWith(".json")).sort().reverse();
   } catch {
   }
@@ -8908,8 +9234,8 @@ async function restoreFromCheckpoint(_checkpoint) {
 }
 async function checkProjectExists() {
   try {
-    const fs43 = await import('fs/promises');
-    await fs43.access(".coco");
+    const fs44 = await import('fs/promises');
+    await fs44.access(".coco");
     return true;
   } catch {
     return false;
@@ -9570,12 +9896,12 @@ async function loadConfig2() {
   };
 }
 async function saveConfig(config) {
-  const fs43 = await import('fs/promises');
-  await fs43.mkdir(".coco", { recursive: true });
-  await fs43.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
+  const fs44 = await import('fs/promises');
+  await fs44.mkdir(".coco", { recursive: true });
+  await fs44.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path43) {
-  const keys = path43.split(".");
+function getNestedValue(obj, path44) {
+  const keys = path44.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -9585,8 +9911,8 @@ function getNestedValue(obj, path43) {
   }
   return current;
 }
-function setNestedValue(obj, path43, value) {
-  const keys = path43.split(".");
+function setNestedValue(obj, path44, value) {
+  const keys = path44.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -9807,8 +10133,8 @@ var MCPRegistryImpl = class {
   /**
    * Ensure directory exists
    */
-  async ensureDir(path43) {
-    await mkdir(dirname(path43), { recursive: true });
+  async ensureDir(path44) {
+    await mkdir(dirname(path44), { recursive: true });
   }
 };
 function createMCPRegistry(registryPath) {
@@ -10327,9 +10653,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path43, level) {
+function createMissingMemoryFile(path44, level) {
   return {
-    path: path43,
+    path: path44,
     level,
     content: "",
     sections: [],
@@ -10383,14 +10709,42 @@ function generateToolCatalog(registry) {
 }
 var COCO_SYSTEM_PROMPT = `You are Corbat-Coco, an autonomous coding assistant with an extensive toolkit.
 
-## Your Approach: Tool-Aware Problem Solving
+## YOUR PRIMARY DIRECTIVE: EXECUTE, DON'T TALK ABOUT EXECUTING
+
+\u{1F6A8} **CRITICAL - READ THIS FIRST** \u{1F6A8}
+YOU ARE AN EXECUTION AGENT, NOT A CONVERSATIONAL ASSISTANT.
+
+**WRONG BEHAVIOR (Never do this):**
+\u274C "I'll create a file called hello.js with a function..."
+\u274C "I created hello.js with the following code..."
+\u274C "Here's what the file would look like..."
+\u274C Showing code blocks without calling write_file tool
+
+**CORRECT BEHAVIOR (Always do this):**
+\u2705 Immediately call write_file tool with the code
+\u2705 Then say "Created hello.js with greeting function"
+\u2705 TOOLS FIRST, then brief confirmation
+
+**Core Principle: USE TOOLS, DON'T DESCRIBE**
+\u26A0\uFE0F CRITICAL: You MUST use your tools to perform actions. NEVER just describe what you would do or claim you did something without actually calling a tool.
+
+**Tool Calling is MANDATORY:**
+- User says "create a file" \u2192 CALL write_file tool FIRST (don't show code, don't explain, just CALL THE TOOL)
+- User says "search the web" \u2192 CALL web_search tool FIRST (don't describe what you would search for)
+- User says "run tests" \u2192 CALL bash_exec tool FIRST (don't say you ran them, actually run them)
+- EVERY action requires a TOOL CALL. Text responses are ONLY for brief confirmations AFTER tools execute.
+
+**Execution Process:**
+1. **Analyze**: Understand what the user wants (in your head, don't output this)
+2. **Execute**: IMMEDIATELY CALL THE APPROPRIATE TOOLS (this is mandatory, not optional)
+3. **Respond**: Brief confirmation of what was done (AFTER tools executed)
 
-When the user asks you to do something, follow this process:
-1. **Analyze the request**: Understand what the user needs
-2. **Scan your tools**: Review which of your available tools can help accomplish the task
-3. **Plan your approach**: Decide which tools to use and in what order
-4. **Execute**: Use the appropriate tools, combining multiple when needed
-5. **Verify**: Check your work (read files after editing, run tests after changes)
+**Critical Rules:**
+- User says "create X with Y" \u2192 Immediately call write_file/edit_file tool, no discussion
+- If a task needs data you don't have, fetch it with web_search/web_fetch FIRST, THEN complete the task with other tools
+- Never ask "should I do this?" or "do you want me to...?" - JUST DO IT (with tools)
+- If you don't call tools, you didn't do the task - showing code is NOT the same as creating files
+- NEVER show code blocks as examples - ALWAYS write them to files with tools
 
 **IMPORTANT**: You have many tools beyond basic file/bash/git. Before answering "I can't do that", check if any of your tools can help. For example:
 - Need information from the internet? Use **web_search** and **web_fetch**
@@ -10408,13 +10762,19 @@ When the user asks you to do something, follow this process:
 {TOOL_CATALOG}
 
 ## Guidelines
-- Be helpful and direct
-- If a task requires multiple steps, execute them one by one
-- Always verify your work by reading files after editing or running tests after changes
-- You can use multiple tools together for complex tasks
-- When uncertain which tool to use, check the full list above
+- **Be action-oriented**: Execute tasks immediately without asking for confirmation
+- **Multi-step tasks**: Chain tools together to complete the full request
+- **Always verify**: Read files after editing, run tests after changes
+- **Don't present options**: If the user says "create X", create it with reasonable defaults
+- **Don't ask "should I..."**: The user already told you what to do by making the request
+- **Combine tools**: Use web_search + write_file, bash + read_file, etc. to complete tasks fully
 - **Never** add "Co-Authored-By", "Generated by", or any AI attribution to commits, code comments, documentation, or PR descriptions. All output must read as if written by the developer.
 
+**Example Flows:**
+- "Create an HTML with weather data" \u2192 web_search for weather \u2192 write_file with HTML \u2192 DONE
+- "Add tests for function X" \u2192 read_file to see X \u2192 write_file with tests \u2192 bash to run tests \u2192 DONE
+- "Fix the bug in Y" \u2192 read_file to understand \u2192 edit_file to fix \u2192 bash to test \u2192 DONE
+
 ## File Access
 File operations are restricted to the project directory by default.
 When you need to access a path outside the project, use the **authorize_path** tool first \u2014 it will ask the user for permission interactively. Once authorized, proceed with the file operation.
@@ -10506,9 +10866,45 @@ function getConversationContext(session, toolRegistry) {
 # Project Instructions (from COCO.md/CLAUDE.md)
 
 ${session.memoryContext.combinedContent}`;
+  }
+  if (session.projectContext) {
+    const stackInfo = formatStackContext(session.projectContext);
+    systemPrompt = `${systemPrompt}
+
+${stackInfo}`;
   }
   return [{ role: "system", content: systemPrompt }, ...session.messages];
 }
+function formatStackContext(ctx) {
+  const parts = [];
+  parts.push("# Project Technology Stack");
+  parts.push("");
+  parts.push(`**Language/Runtime:** ${ctx.stack}`);
+  if (ctx.packageManager) {
+    parts.push(`**Package Manager:** ${ctx.packageManager}`);
+  }
+  if (ctx.frameworks.length > 0) {
+    parts.push(`**Frameworks:** ${ctx.frameworks.join(", ")}`);
+  }
+  if (ctx.languages.length > 0) {
+    parts.push(`**Languages:** ${ctx.languages.join(", ")}`);
+  }
+  if (ctx.testingFrameworks.length > 0) {
+    parts.push(`**Testing Frameworks:** ${ctx.testingFrameworks.join(", ")}`);
+  }
+  if (ctx.buildTools.length > 0) {
+    parts.push(`**Build Tools:** ${ctx.buildTools.join(", ")}`);
+  }
+  const keyDeps = Object.entries(ctx.dependencies).slice(0, 10).map(([name, version]) => `${name}@${version}`).join(", ");
+  if (keyDeps) {
+    parts.push(`**Key Dependencies:** ${keyDeps}`);
+  }
+  parts.push("");
+  parts.push(
+    "**IMPORTANT:** When suggesting libraries, frameworks, or dependencies, ONLY recommend technologies compatible with the stack above. Do not suggest installing Node.js packages in a Java project, or Java libraries in a Python project."
+  );
+  return parts.join("\n");
+}
 function clearSession(session) {
   session.messages = [];
 }
@@ -13259,8 +13655,8 @@ async function listTrustedProjects2(trustStore) {
   p9.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path43 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p9.log.message(`  [${level}] ${path43}`);
+    const path44 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p9.log.message(`  [${level}] ${path44}`);
     p9.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p9.log.message("");
@@ -14430,7 +14826,7 @@ async function getCheckpoint(session, checkpointId) {
   return store.checkpoints.find((cp) => cp.id === checkpointId) ?? null;
 }
 async function restoreFiles(checkpoint, excludeFiles) {
-  const fs43 = await import('fs/promises');
+  const fs44 = await import('fs/promises');
   const restored = [];
   const failed = [];
   for (const fileCheckpoint of checkpoint.files) {
@@ -14438,7 +14834,7 @@ async function restoreFiles(checkpoint, excludeFiles) {
       continue;
     }
     try {
-      await fs43.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
+      await fs44.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
       restored.push(fileCheckpoint.filePath);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -14520,8 +14916,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk42.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path43, error } of result.filesFailed) {
-    const fileName = path43.split("/").pop() ?? path43;
+  for (const { path: path44, error } of result.filesFailed) {
+    const fileName = path44.split("/").pop() ?? path44;
     console.log(`${chalk42.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -15954,8 +16350,8 @@ function formatToolSummary(toolName, input) {
       return String(input.path || ".");
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path43 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path43}`;
+      const path44 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path44}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -20989,10 +21385,10 @@ var CoverageAnalyzer = class {
       join(this.projectPath, ".coverage", "coverage-summary.json"),
       join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
     ];
-    for (const path43 of possiblePaths) {
+    for (const path44 of possiblePaths) {
       try {
-        await access(path43, constants.R_OK);
-        const content = await readFile(path43, "utf-8");
+        await access(path44, constants.R_OK);
+        const content = await readFile(path44, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -24071,7 +24467,21 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
     const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10) {
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+        }
+      },
+      onWarn: (message) => {
+        process.stderr.write(`
+${message}
+`);
+      }
+    });
     try {
+      heartbeat.start();
       const pm = packageManager ?? await detectPackageManager(projectDir);
       const cmdArgs = ["run", script];
       if (args && args.length > 0) {
@@ -24082,13 +24492,30 @@ Examples:
         timeout: timeoutMs,
         env: { ...process.env, ...env2 },
         reject: false,
+        buffer: false,
+        // Enable streaming
         maxBuffer: MAX_OUTPUT_SIZE2
       };
-      const result = await execa(pm, cmdArgs, options);
+      const subprocess = execa(pm, cmdArgs, options);
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stdoutBuffer += text11;
+        process.stdout.write(text11);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stderrBuffer += text11;
+        process.stderr.write(text11);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
       return {
         success: result.exitCode === 0,
-        stdout: truncateOutput2(String(result.stdout ?? "")),
-        stderr: truncateOutput2(String(result.stderr ?? "")),
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
         exitCode: result.exitCode ?? 0,
         duration: performance.now() - startTime,
         packageManager: pm
@@ -24104,6 +24531,9 @@ Examples:
         `Failed to run script '${script}': ${error instanceof Error ? error.message : String(error)}`,
         { tool: "run_script", cause: error instanceof Error ? error : void 0 }
       );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
     }
   }
 });
@@ -24129,7 +24559,21 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
     const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10) {
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+        }
+      },
+      onWarn: (message) => {
+        process.stderr.write(`
+${message}
+`);
+      }
+    });
     try {
+      heartbeat.start();
       const pm = packageManager ?? await detectPackageManager(projectDir);
       let cmdArgs;
       if (packages && packages.length > 0) {
@@ -24169,13 +24613,30 @@ Examples:
         cwd: projectDir,
         timeout: timeoutMs,
         reject: false,
+        buffer: false,
+        // Enable streaming
         maxBuffer: MAX_OUTPUT_SIZE2
       };
-      const result = await execa(pm, cmdArgs, options);
+      const subprocess = execa(pm, cmdArgs, options);
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stdoutBuffer += text11;
+        process.stdout.write(text11);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stderrBuffer += text11;
+        process.stderr.write(text11);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
       return {
         success: result.exitCode === 0,
-        stdout: truncateOutput2(String(result.stdout ?? "")),
-        stderr: truncateOutput2(String(result.stderr ?? "")),
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
         exitCode: result.exitCode ?? 0,
         duration: performance.now() - startTime,
         packageManager: pm
@@ -24191,6 +24652,9 @@ Examples:
         `Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`,
         { tool: "install_deps", cause: error instanceof Error ? error : void 0 }
       );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
     }
   }
 });
@@ -24215,12 +24679,26 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
     const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10) {
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+        }
+      },
+      onWarn: (message) => {
+        process.stderr.write(`
+${message}
+`);
+      }
+    });
     try {
       try {
         await fs23__default.access(path20__default.join(projectDir, "Makefile"));
       } catch {
         throw new ToolError("No Makefile found in directory", { tool: "make" });
       }
+      heartbeat.start();
       const cmdArgs = [];
       if (target) {
         cmdArgs.push(...target.split(/\s+/));
@@ -24233,13 +24711,30 @@ Examples:
         timeout: timeoutMs,
         env: { ...process.env, ...env2 },
         reject: false,
+        buffer: false,
+        // Enable streaming
         maxBuffer: MAX_OUTPUT_SIZE2
       };
-      const result = await execa("make", cmdArgs, options);
+      const subprocess = execa("make", cmdArgs, options);
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stdoutBuffer += text11;
+        process.stdout.write(text11);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stderrBuffer += text11;
+        process.stderr.write(text11);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
       return {
         success: result.exitCode === 0,
-        stdout: truncateOutput2(String(result.stdout ?? "")),
-        stderr: truncateOutput2(String(result.stderr ?? "")),
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
         exitCode: result.exitCode ?? 0,
         duration: performance.now() - startTime
       };
@@ -24255,6 +24750,9 @@ Examples:
         `Make failed: ${error instanceof Error ? error.message : String(error)}`,
         { tool: "make", cause: error instanceof Error ? error : void 0 }
       );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
     }
   }
 });
@@ -24280,7 +24778,21 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
     const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10) {
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+        }
+      },
+      onWarn: (message) => {
+        process.stderr.write(`
+${message}
+`);
+      }
+    });
     try {
+      heartbeat.start();
       const cmdArgs = [];
       if (project) {
         cmdArgs.push("--project", project);
@@ -24298,13 +24810,30 @@ Examples:
         cwd: projectDir,
         timeout: timeoutMs,
         reject: false,
+        buffer: false,
+        // Enable streaming
         maxBuffer: MAX_OUTPUT_SIZE2
       };
-      const result = await execa("npx", ["tsc", ...cmdArgs], options);
+      const subprocess = execa("npx", ["tsc", ...cmdArgs], options);
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stdoutBuffer += text11;
+        process.stdout.write(text11);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text11 = chunk.toString();
+        stderrBuffer += text11;
+        process.stderr.write(text11);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
       return {
         success: result.exitCode === 0,
-        stdout: truncateOutput2(String(result.stdout ?? "")),
-        stderr: truncateOutput2(String(result.stderr ?? "")),
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
         exitCode: result.exitCode ?? 0,
         duration: performance.now() - startTime
       };
@@ -24319,6 +24848,9 @@ Examples:
         `TypeScript compile failed: ${error instanceof Error ? error.message : String(error)}`,
         { tool: "tsc", cause: error instanceof Error ? error : void 0 }
       );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
     }
   }
 });
@@ -25202,20 +25734,10 @@ var diffTools = [showDiffTool];
 // src/tools/review.ts
 init_registry();
 init_errors();
-
-// src/utils/files.ts
-init_errors();
-async function fileExists(filePath) {
-  try {
-    await fs23__default.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function fileExists2(path43) {
+init_files();
+async function fileExists2(path44) {
   try {
-    await access(path43);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -25305,7 +25827,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs43) => fs43.readFile(join(cwd, "package.json"), "utf-8")
+        (fs44) => fs44.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -29964,6 +30486,13 @@ var terminalOptions = {
 var marked = new Marked();
 marked.use(markedTerminal(terminalOptions));
 init_bash();
+init_files();
+
+// src/cli/repl/skills/builtin/ship/version-detector.ts
+init_files();
+
+// src/cli/repl/skills/builtin/ship/changelog.ts
+init_files();
 
 // src/cli/repl/skills/builtin/ship/steps/test-coverage.ts
 init_bash();
@@ -30038,6 +30567,8 @@ async function startRepl(options = {}) {
     process.exit(1);
   }
   initializeContextManager(session, provider);
+  const { detectProjectStack: detectProjectStack2 } = await Promise.resolve().then(() => (init_stack_detector(), stack_detector_exports));
+  session.projectContext = await detectProjectStack2(projectPath);
   await loadAllowedPaths(projectPath);
   if (await shouldShowPermissionSuggestion()) {
     await showPermissionSuggestion();
@@ -30189,7 +30720,11 @@ async function startRepl(options = {}) {
           clearSpinner();
           renderToolStart(result2.name, result2.input);
           renderToolEnd(result2);
-          setSpinner("Processing...");
+          if (isCocoMode()) {
+            setSpinner("Processing results & checking quality...");
+          } else {
+            setSpinner("Processing...");
+          }
         },
         onToolSkipped: (tc, reason) => {
           clearSpinner();
@@ -30202,10 +30737,18 @@ async function startRepl(options = {}) {
             if (!thinkingStartTime) return;
             const elapsed = Math.floor((Date.now() - thinkingStartTime) / 1e3);
             if (elapsed < 4) return;
-            if (elapsed < 8) setSpinner("Analyzing request...");
-            else if (elapsed < 12) setSpinner("Planning approach...");
-            else if (elapsed < 16) setSpinner("Preparing tools...");
-            else setSpinner(`Still working... (${elapsed}s)`);
+            if (isCocoMode()) {
+              if (elapsed < 8) setSpinner("Analyzing request...");
+              else if (elapsed < 15) setSpinner("Running quality checks...");
+              else if (elapsed < 25) setSpinner("Iterating for quality...");
+              else if (elapsed < 40) setSpinner("Verifying implementation...");
+              else setSpinner(`Quality iteration in progress... (${elapsed}s)`);
+            } else {
+              if (elapsed < 8) setSpinner("Analyzing request...");
+              else if (elapsed < 12) setSpinner("Planning approach...");
+              else if (elapsed < 16) setSpinner("Preparing tools...");
+              else setSpinner(`Still working... (${elapsed}s)`);
+            }
           }, 2e3);
         },
         onThinkingEnd: () => {