codeshark-cli 0.1.5 → 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;
     }
@@ -250,7 +262,10 @@ async function main() {
             if (status === "available") {
                 console.log(`    ${hex("#4ade80", "✓ Available")}  ${model.label}`);
             }
-            else {
+            else if (status === "busy") {
+                console.log(`    ${hex("#fbbf24", "~ Lane busy")}  ${model.label}${reason ? dim(` — ${reason}`) : ""}`);
+            }
+            else if (status === "unavailable") {
                 console.log(`    ${hex("#f87171", "✗ Unavailable")}  ${model.label}${reason ? dim(` — ${reason}`) : ""}`);
             }
         }

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/modelAvailability.js

@@ -2,7 +2,9 @@ import { DEFAULT_GATEWAY_URL, envApiKey } from "./config.js";
 import { MODELS } from "./models.js";
 const statuses = new Map();
 const reasons = new Map();
-const TIMEOUT_MS = 8_000;
+const TIMEOUT_MS = 15_000;
+/** Match the gateway's per-IP inflight cap so probes never queue behind themselves. */
+const MAX_CONCURRENT_CHECKS = 2;
 export function modelAvailability(modelId) {
     return statuses.get(modelId) ?? "checking";
 }
@@ -16,6 +18,25 @@ export function modelAvailabilitySnapshot() {
         reason: modelAvailabilityReason(model.id),
     }));
 }
+/**
+ * Classify a failed probe. "busy" covers transient lane problems (rate
+ * limits, upstream hiccups, timeouts) where the model is likely fine but
+ * the shared free lane is momentarily overloaded — those must NOT read as
+ * "model removed". Only explicit client errors mean the model itself is
+ * not servable right now.
+ */
+export function classifyProbeFailure(statusOrError) {
+    if (statusOrError instanceof Error) {
+        if (statusOrError.name === "AbortError")
+            return { status: "busy", reason: "lane busy — timed out" };
+        return { status: "busy", reason: statusOrError.message || "network error" };
+    }
+    if (statusOrError === 429)
+        return { status: "busy", reason: "rate limited — try again shortly" };
+    if (statusOrError >= 500)
+        return { status: "busy", reason: `lane busy — HTTP ${statusOrError}` };
+    return { status: "unavailable", reason: `HTTP ${statusOrError}` };
+}
 function endpointFor(model, cfg) {
     if (model.provider === "gemini") {
         return {
@@ -53,8 +74,12 @@ async function checkOne(model, cfg) {
                 body: JSON.stringify({ contents: [{ role: "user", parts: [{ text: "Reply with OK." }] }] }),
                 signal: controller.signal,
             });
-            if (!response.ok)
-                throw new Error(`HTTP ${response.status}`);
+            if (!response.ok) {
+                const { status, reason } = classifyProbeFailure(response.status);
+                statuses.set(model.id, status);
+                reasons.set(model.id, reason);
+                return;
+            }
         }
         else {
             const response = await fetch(target.url, {
@@ -63,15 +88,20 @@ async function checkOne(model, cfg) {
                 body: JSON.stringify({ model: model.model, messages: [{ role: "user", content: "Reply with OK." }], stream: false, max_tokens: 4 }),
                 signal: controller.signal,
             });
-            if (!response.ok)
-                throw new Error(`HTTP ${response.status}`);
+            if (!response.ok) {
+                const { status, reason } = classifyProbeFailure(response.status);
+                statuses.set(model.id, status);
+                reasons.set(model.id, reason);
+                return;
+            }
         }
         statuses.set(model.id, "available");
         reasons.delete(model.id);
     }
     catch (error) {
-        statuses.set(model.id, "unavailable");
-        reasons.set(model.id, error instanceof Error && error.name === "AbortError" ? "check timed out" : error instanceof Error ? error.message : String(error));
+        const { status, reason } = classifyProbeFailure(error instanceof Error ? error : new Error(String(error)));
+        statuses.set(model.id, status);
+        reasons.set(model.id, reason);
     }
     finally {
         clearTimeout(timer);
@@ -82,5 +112,13 @@ export async function checkModelAvailability(cfg) {
         statuses.set(model.id, "checking");
         reasons.delete(model.id);
     }
-    await Promise.all(MODELS.map((model) => checkOne(model, cfg)));
+    // Throttle to the gateway's per-IP inflight limit: firing all probes at
+    // once makes them queue behind each other and time out spuriously.
+    const queue = [...MODELS];
+    const workers = Array.from({ length: Math.min(MAX_CONCURRENT_CHECKS, queue.length) }, async () => {
+        for (let model = queue.shift(); model; model = queue.shift()) {
+            await checkOne(model, cfg);
+        }
+    });
+    await Promise.all(workers);
 }

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) {
@@ -48,9 +49,14 @@ export function printModelInfo() {
     for (const m of MODELS) {
         const active = m.id === (findModel(cfg.model ?? "")?.id ?? DEFAULT_MODEL_ID);
         const status = modelAvailability(m.id);
-        const marker = status === "available" ? hex("#4ade80", "●") : status === "unavailable" ? hex("#f87171", "✗") : dim("○");
-        const note = status === "unavailable" ? `Unavailable${modelAvailabilityReason(m.id) ? ` — ${modelAvailabilityReason(m.id)}` : ""}` : m.notes;
-        console.log(`    ${marker} ${m.label.padEnd(28)} ${dim(m.context.padEnd(5))} ${status === "unavailable" ? hex("#f87171", note) : note}`);
+        const marker = status === "available" ? hex("#4ade80", "●") : status === "unavailable" ? hex("#f87171", "✗") : status === "busy" ? hex("#fbbf24", "◐") : dim("○");
+        const note = status === "unavailable"
+            ? `Unavailable${modelAvailabilityReason(m.id) ? ` — ${modelAvailabilityReason(m.id)}` : ""}`
+            : status === "busy"
+                ? `Lane busy${modelAvailabilityReason(m.id) ? ` — ${modelAvailabilityReason(m.id)}` : ""} — should still work`
+                : m.notes;
+        const styled = status === "unavailable" ? hex("#f87171", note) : status === "busy" ? hex("#fbbf24", note) : note;
+        console.log(`    ${marker} ${m.label.padEnd(28)} ${dim(m.context.padEnd(5))} ${styled}`);
     }
     console.log("");
     console.log(dim("  Switch with: /model <name>"));
@@ -81,6 +87,9 @@ export function switchModel(query) {
         console.log(dim(`  ${modelAvailabilityReason(entry.id) ?? "The boot health check failed."}`));
         return;
     }
+    if (modelAvailability(entry.id) === "busy") {
+        console.log(hex("#fbbf24", `  ⚠ ${entry.label}'s shared lane is busy right now — switching anyway. Requests may wait or retry.`));
+    }
     cfg.model = entry.id;
     saveConfig(cfg);
     console.log(`  ${hex("#4ade80", "✓")} Switched to ${bold(entry.label)} ${dim(`(${entry.context} context)`)}`);
@@ -204,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)),
         };
@@ -220,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"))
@@ -235,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.5",
+  "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": {