codeshark-cli 0.1.6 → 0.1.7

package/dist/agent.js

@@ -93,6 +93,7 @@ export async function runAgent(input, opts, events) {
                 continue;
             }
             const result = await opts.registry.execute(call.name, call.args, ctx);
+            events?.onToolResult?.(call.name);
             messages.push({
                 role: "tool",
                 content: result.content,

package/dist/index.js

@@ -4,7 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { bold, dim, hex } from "./ansi.js";
 import { printBanner } from "./banner.js";
-import { showLoading, startThinkingSpinner } from "./loading.js";
+import { showLoading, startActivityIndicator, toolPhase } from "./loading.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { readTerms } from "./terms.js";
 import { resolveClients } from "./provider/index.js";
@@ -77,35 +77,48 @@ async function runOneShot(prompt) {
     const cwd = process.cwd();
     const registry = createRegistry();
     const clients = resolveClients(cfg, (m) => console.error(dim(m)));
-    // Show a "thinking" spinner until the first token arrives, then stream.
-    const stopThinking = startThinkingSpinner("Thinking");
-    let thinking = true;
+    // A live indicator shows what the agent is doing (Thinking, Reading
+    // files, Running commands, …) until the first token arrives, then the
+    // answer streams over it.
+    let activityActive = true;
+    const stopActivity = () => {
+        if (activityActive) {
+            activityActive = false;
+            activity.stop();
+        }
+    };
+    const activity = startActivityIndicator("Thinking");
     const events = {
         onText: (d) => {
-            if (thinking) {
-                thinking = false;
-                stopThinking();
-            }
+            stopActivity();
             process.stdout.write(d);
         },
+        onToolCall: (call) => {
+            activity.setPhase(toolPhase(call.name));
+        },
+        onToolResult: () => {
+            activity.setPhase("Thinking");
+        },
     };
     const approvalRl = process.stdin.isTTY ? createInterface({ input, output }) : undefined;
     try {
         const result = await runAgent(prompt, {
             clients,
             registry,
-            cwd,
-            approveToolCall: approvalRl
+            cwd, approveToolCall: approvalRl
                 ? async (call) => {
-                    const answer = await approvalRl.question(`\nApprove ${call.name}? [y/N]: `);
-                    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+                    activity.pause();
+                    try {
+                        const answer = await approvalRl.question(`\nApprove ${call.name}? [y/N]: `);
+                        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+                    }
+                    finally {
+                        activity.resume(toolPhase(call.name));
+                    }
                 }
                 : async () => false,
         }, events);
-        if (thinking) {
-            thinking = false;
-            stopThinking();
-        }
+        stopActivity();
         if (result.streamedText) {
             if (!result.streamedText.endsWith("\n"))
                 process.stdout.write("\n");
@@ -115,8 +128,7 @@ async function runOneShot(prompt) {
         }
     }
     catch (e) {
-        if (thinking)
-            stopThinking();
+        stopActivity();
         console.error(hex("#f87171", `✗ ${errorMessage(e)}`));
         process.exitCode = 1;
     }

package/dist/loading.js

@@ -61,3 +61,72 @@ export function startThinkingSpinner(label) {
         process.stdout.write("\r\u001b[2K");
     };
 }
+/** Human phase label for a tool call — shown by activity indicators. */
+export function toolPhase(name) {
+    switch (name) {
+        case "run_command":
+            return "Running command";
+        case "read_file":
+            return "Reading files";
+        case "write_file":
+            return "Writing files";
+        case "edit_file":
+            return "Editing files";
+        case "glob":
+            return "Finding files";
+        case "list_directory":
+            return "Listing directory";
+        case "code_search":
+            return "Searching code";
+        case "finish":
+            return "Wrapping up";
+        default:
+            return `Running ${name}`;
+    }
+}
+export function startActivityIndicator(initialPhase = "Thinking") {
+    if (!canAnimate()) {
+        return { setPhase: () => { }, pause: () => { }, resume: () => { }, stop: () => { } };
+    }
+    let phase = initialPhase;
+    let frame = 0;
+    let paused = false;
+    let pausedLine = "";
+    const startedAt = Date.now();
+    const render = (pausedText) => {
+        const seconds = Math.floor((Date.now() - startedAt) / 1000);
+        const suffix = pausedText ?? `${phase} · ${seconds}s`;
+        process.stdout.write(`\r\u001b[2K  ${hex(ACCENT, FRAMES[frame % FRAMES.length])} ${suffix}`);
+    };
+    render();
+    const timer = setInterval(() => {
+        frame++;
+        if (!paused)
+            render();
+    }, 90);
+    const clearLine = () => process.stdout.write("\r\u001b[2K");
+    return {
+        setPhase(next) {
+            phase = next;
+            if (!paused)
+                render();
+        },
+        pause() {
+            if (paused)
+                return;
+            paused = true;
+            const seconds = Math.floor((Date.now() - startedAt) / 1000);
+            pausedLine = `${phase} · ${seconds}s — waiting for your approval`;
+            render(hex("#fbbf24", `⏸ ${pausedLine}`));
+        },
+        resume(next) {
+            phase = next;
+            paused = false;
+            render();
+        },
+        stop() {
+            clearInterval(timer);
+            clearLine();
+        },
+    };
+}

package/dist/repl.js

@@ -8,6 +8,7 @@ import { loadConfig, modelLabel, saveConfig } from "./config.js";
 import { DEFAULT_MODEL_ID, MODELS, findModel } from "./models.js";
 import { launchKeysPage } from "./keysPage.js";
 import { defaultSystemPrompt } from "./system.js";
+import { startActivityIndicator, toolPhase } from "./loading.js";
 import { modelAvailability, modelAvailabilityReason } from "./modelAvailability.js";
 const PROMPT = "> ";
 function replClosed(rl) {
@@ -212,10 +213,25 @@ export async function startRepl(opts) {
         // Keep input active so Ctrl+C can cancel while the model is working.
         rl.resume();
         console.log("");
+        const activity = startActivityIndicator("Thinking");
+        let activityActive = true;
+        const stopActivity = () => {
+            if (activityActive) {
+                activityActive = false;
+                activity.stop();
+            }
+        };
         const events = {
-            onText: (delta) => process.stdout.write(delta),
+            onText: (delta) => {
+                stopActivity();
+                process.stdout.write(delta);
+            },
             onToolCall: (call) => {
                 console.log(dim(`  ⚙ ${call.name}(${briefArgs(call.args)})`));
+                activity.setPhase(toolPhase(call.name));
+            },
+            onToolResult: (toolName) => {
+                activity.setPhase(toolName === "finish" ? "Wrapping up" : "Thinking");
             },
             onDebug: (msg) => console.log(dim(msg)),
         };
@@ -228,11 +244,20 @@ export async function startRepl(opts) {
                 systemPrompt: cfg.systemPrompt ?? defaultSystemPrompt(opts.cwd, mode),
                 readOnly: mode === "plan",
                 maxIterations: cfg.maxIterations,
-                approveToolCall: (call) => approveToolCall(rl, call, controller?.signal),
+                approveToolCall: async (call) => {
+                    activity.pause();
+                    try {
+                        return await approveToolCall(rl, call, controller?.signal);
+                    }
+                    finally {
+                        activity.resume(toolPhase(call.name));
+                    }
+                },
                 signal: controller.signal,
                 debug: opts.debug,
                 initialMessages: history,
             }, events);
+            stopActivity();
             history = result.history;
             if (result.streamedText) {
                 if (!result.streamedText.endsWith("\n"))
@@ -243,6 +268,7 @@ export async function startRepl(opts) {
             }
         }
         catch (e) {
+            stopActivity();
             console.log("");
             if (e instanceof ProviderError) {
                 console.log(hex("#f87171", `  ✗ ${e.message}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeshark-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "An open-source terminal coding agent. Eight model choices, project tools, and approval before every tool action.",
   "type": "module",
   "bin": {