@scira/cli 0.1.5 → 0.1.7

package/dist/utils/update-check.js

@@ -0,0 +1,63 @@
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const PKG = "@scira/cli";
+const CACHE_FILE = join(homedir(), ".scira", "update-check.json");
+const THROTTLE_MS = 24 * 60 * 60 * 1000; // check npm at most once a day
+/** `true` when `latest` is a higher semver than `current` (pre-release suffixes ignored). */
+function isNewer(latest, current) {
+    const parse = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+    const a = parse(latest), b = parse(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] ?? 0, y = b[i] ?? 0;
+        if (x !== y)
+            return x > y;
+    }
+    return false;
+}
+async function fetchLatest() {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${PKG}/latest`, {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns the available update (or null), checking npm at most once per day.
+ * Network/parse failures resolve to null and are swallowed — this never throws
+ * and never blocks for more than ~3s (and only that once a day).
+ */
+export async function checkForUpdate(current) {
+    let cache = null;
+    try {
+        cache = (await Bun.file(CACHE_FILE).json());
+    }
+    catch { /* no/invalid cache */ }
+    const now = Date.now();
+    let latest = cache?.latest ?? null;
+    if (!cache || now - cache.checkedAt > THROTTLE_MS) {
+        // Keep the previously-known version on a failed fetch — a transient network
+        // error shouldn't discard an update we already knew about (and then suppress
+        // it for the rest of the throttle window).
+        latest = (await fetchLatest()) ?? latest;
+        // Persist (even on failure) so we don't re-check on every command today.
+        try {
+            await mkdir(join(homedir(), ".scira"), { recursive: true });
+            await Bun.write(CACHE_FILE, JSON.stringify({ checkedAt: now, latest }));
+        }
+        catch { /* best-effort */ }
+    }
+    return latest && isNewer(latest, current) ? { current, latest } : null;
+}
+/** One-line, human-facing update message. */
+export function formatUpdateNotice(u) {
+    return `Update available: ${u.current} → ${u.latest} · run "bun add -g ${PKG}"`;
+}

package/dist/watch/runner.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { diffLines } from "diff";
 import { createRun, listRuns, getRunPaths } from "../storage/run-store.js";
-import { runResearchAgent } from "../agent/research-agent.js";
+import { runResearchAgent } from "../agent/main-agent.js";
 /** Compare two report.md texts and return a human-readable diff summary. */
 export function diffReports(prev, next) {
     const changes = diffLines(prev, next);
@@ -47,7 +47,7 @@ export async function watchLoop(opts, signal) {
         opts.onRunStart?.(runPath, tick);
         try {
             await runResearchAgent(runPath, goal, config);
-            const nextReport = await readFile(getRunPaths(runPath).report, "utf8").catch(() => "");
+            const nextReport = await Bun.file(getRunPaths(runPath).report).text().catch(() => "");
             const diffText = diffReports(prevReport, nextReport);
             opts.onRunComplete?.(runPath, diffText, tick);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scira/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Scira — terminal-native AI research agent with grounded sources, verified claims, and local run storage.",
   "license": "MIT",
   "type": "module",
@@ -35,22 +35,26 @@
     "dev": "bun src/cli/index.ts",
     "docs:dev": "bun run --cwd docs dev",
     "docs:build": "NODE_ENV=production bun run --cwd docs build",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "bun test src",
+    "test:watch": "bun test --watch src"
   },
   "dependencies": {
-    "@ai-sdk/mcp": "^1.0.49",
+    "@ai-sdk/harness": "^1.0.0-canary.9",
+    "@ai-sdk/harness-claude-code": "^1.0.0-canary.5",
+    "@ai-sdk/harness-codex": "^1.0.0-canary.5",
+    "@ai-sdk/mcp": "^1.0.50",
     "@ai-sdk/openai-compatible": "^2.0.50",
     "@ai-sdk/xai": "^3.0.95",
     "@clack/prompts": "^1.5.1",
-    "@mendable/firecrawl-js": "^4.25.3",
+    "@mendable/firecrawl-js": "^4.25.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
-    "ai": "^6.0.203",
+    "ai": "^6.0.204",
+    "bun": "^1.3.14",
     "diff": "^9.0.0",
     "exa-js": "^2.13.0",
     "files-sdk": "^1.8.0",
-    "ink": "^7.0.5",
+    "ink": "^7.0.6",
     "ink-link": "^5.0.0",
     "jsdom": "^29.1.1",
     "parallel-web": "^1.1.0",
@@ -62,14 +66,12 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "bun-types": "^1.3.14",
+    "@types/bun": "^1.3.14",
     "@types/jsdom": "^28.0.3",
     "@types/node": "^25.9.3",
     "@types/react": "^19.2.17",
-    "@vitest/coverage-v8": "^4.1.8",
     "tsx": "^4.22.4",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "bun": ">=1.2.0"

package/dist/agent/background-tasks.js

@@ -1,173 +0,0 @@
-import { spawn } from "node:child_process";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-const MAX_OUTPUT_LINES = 500;
-const MAX_TAIL_CHARS = 4000;
-function nextTaskId(existing) {
-    const nums = existing
-        .map((t) => /^task_(\d+)$/u.exec(t.id)?.[1])
-        .filter((n) => Boolean(n))
-        .map((n) => Number.parseInt(n, 10));
-    const next = nums.length > 0 ? Math.max(...nums) + 1 : 1;
-    return `task_${String(next).padStart(3, "0")}`;
-}
-function tailText(lines, maxChars = MAX_TAIL_CHARS) {
-    const joined = lines.join("\n");
-    if (joined.length <= maxChars)
-        return joined;
-    return `…[truncated]\n${joined.slice(-maxChars)}`;
-}
-export class BackgroundTaskManager {
-    persistPath;
-    defaultCwd;
-    runtime = new Map();
-    records = [];
-    loaded = false;
-    constructor(persistPath, defaultCwd) {
-        this.persistPath = persistPath;
-        this.defaultCwd = defaultCwd;
-    }
-    async ensureLoaded() {
-        if (this.loaded)
-            return;
-        this.loaded = true;
-        try {
-            const raw = await readFile(this.persistPath, "utf8");
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                this.records = parsed.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string");
-            }
-        }
-        catch {
-            this.records = [];
-        }
-    }
-    async persist() {
-        await mkdir(dirname(this.persistPath), { recursive: true });
-        await writeFile(this.persistPath, JSON.stringify(this.records, null, 2) + "\n");
-    }
-    syncRecord(task) {
-        const idx = this.records.findIndex((r) => r.id === task.record.id);
-        task.record.outputTail = tailText(task.output);
-        if (idx === -1)
-            this.records.push({ ...task.record });
-        else
-            this.records[idx] = { ...task.record };
-    }
-    async spawn(command, cwd) {
-        await this.ensureLoaded();
-        const id = nextTaskId(this.records);
-        const workDir = cwd ?? this.defaultCwd;
-        const proc = spawn(command, {
-            cwd: workDir,
-            shell: "/bin/bash",
-            env: process.env,
-            detached: false,
-            stdio: ["ignore", "pipe", "pipe"]
-        });
-        const record = {
-            id,
-            command,
-            cwd: workDir,
-            pid: proc.pid ?? 0,
-            startedAt: new Date().toISOString(),
-            status: "running",
-            exitCode: null,
-            outputTail: ""
-        };
-        const output = [];
-        const append = (chunk) => {
-            const text = chunk.toString();
-            for (const line of text.split("\n")) {
-                if (line.length > 0)
-                    output.push(line);
-            }
-            while (output.length > MAX_OUTPUT_LINES)
-                output.shift();
-            const rt = this.runtime.get(id);
-            if (rt) {
-                rt.output = output;
-                rt.record.outputTail = tailText(output);
-            }
-        };
-        proc.stdout?.on("data", append);
-        proc.stderr?.on("data", append);
-        const runtime = { record, proc, output };
-        this.runtime.set(id, runtime);
-        this.records.push({ ...record });
-        await this.persist();
-        proc.on("close", (code) => {
-            record.status = "exited";
-            record.exitCode = code;
-            record.outputTail = tailText(output);
-            this.syncRecord(runtime);
-            void this.persist();
-            this.runtime.delete(id);
-        });
-        proc.on("error", (err) => {
-            output.push(`[spawn error] ${err.message}`);
-            record.status = "exited";
-            record.exitCode = 1;
-            record.outputTail = tailText(output);
-            this.syncRecord(runtime);
-            void this.persist();
-            this.runtime.delete(id);
-        });
-        return { ...record };
-    }
-    async list() {
-        await this.ensureLoaded();
-        for (const rt of this.runtime.values()) {
-            rt.record.outputTail = tailText(rt.output);
-            this.syncRecord(rt);
-        }
-        return this.records.map((r) => {
-            const live = this.runtime.get(r.id);
-            return live ? { ...live.record } : { ...r };
-        });
-    }
-    async getOutput(taskId, tailLines = 50) {
-        await this.ensureLoaded();
-        const live = this.runtime.get(taskId);
-        if (live) {
-            const lines = live.output.slice(-tailLines);
-            return lines.length > 0 ? lines.join("\n") : "(no output yet)";
-        }
-        const rec = this.records.find((r) => r.id === taskId);
-        if (!rec)
-            return `Task "${taskId}" not found.`;
-        const lines = rec.outputTail.split("\n").slice(-tailLines);
-        return lines.length > 0 ? lines.join("\n") : "(no output)";
-    }
-    async kill(taskId) {
-        await this.ensureLoaded();
-        const live = this.runtime.get(taskId);
-        if (live) {
-            live.proc.kill("SIGTERM");
-            live.record.status = "killed";
-            live.record.exitCode = live.record.exitCode ?? 143;
-            this.syncRecord(live);
-            await this.persist();
-            return `Killed ${taskId} (pid ${live.record.pid}).`;
-        }
-        const rec = this.records.find((r) => r.id === taskId);
-        if (!rec)
-            return `Task "${taskId}" not found.`;
-        if (rec.status !== "running")
-            return `${taskId} is already ${rec.status}.`;
-        rec.status = "killed";
-        await this.persist();
-        return `Marked ${taskId} as killed (process not tracked in this session).`;
-    }
-    async formatContextForAgent() {
-        const tasks = await this.list();
-        const active = tasks.filter((t) => t.status === "running");
-        if (active.length === 0)
-            return "";
-        const lines = active.map((t) => `  - ${t.id}: [running pid ${t.pid}] ${t.command} (cwd: ${t.cwd})`);
-        return `\nActive background tasks:\n${lines.join("\n")}\nUse bash with action "output" and taskId to read logs, or action "kill" to stop a task.\n`;
-    }
-}
-export function createBackgroundTaskManager(runPath, workspacePath) {
-    return new BackgroundTaskManager(join(runPath, "background-tasks.json"), workspacePath);
-}

package/dist/agent/todos.js

@@ -1,140 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { tool } from "ai";
-import { z } from "zod";
-import { logEvent } from "../storage/run-store.js";
-const TodoStatusSchema = z.enum(["pending", "in_progress", "completed", "cancelled"]);
-function nextTodoId(existing) {
-    const nums = existing
-        .map((t) => /^todo_(\d+)$/u.exec(t.id)?.[1])
-        .filter((n) => Boolean(n))
-        .map((n) => Number.parseInt(n, 10));
-    const next = nums.length > 0 ? Math.max(...nums) + 1 : 1;
-    return `todo_${String(next).padStart(3, "0")}`;
-}
-async function loadTodos(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string");
-    }
-    catch {
-        return [];
-    }
-}
-async function saveTodos(path, items) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(items, null, 2) + "\n");
-}
-function formatTodoList(items) {
-    if (items.length === 0)
-        return "No todos.";
-    const icon = {
-        pending: "[ ]",
-        in_progress: "[~]",
-        completed: "[x]",
-        cancelled: "[-]"
-    };
-    return items
-        .map((t) => `${icon[t.status]} ${t.id}: ${t.content} (${t.status})`)
-        .join("\n");
-}
-export function createTodoTool(runPath) {
-    const todosPath = join(runPath, "todos.json");
-    return tool({
-        description: "Manage structured task todos for the current session. " +
-            "Actions: create (add items), edit (change content), mark (set status), remove (delete one), rewrite (replace entire list), list (show all). " +
-            "Statuses: pending, in_progress, completed, cancelled.",
-        inputSchema: z.object({
-            action: z.enum(["create", "edit", "mark", "remove", "rewrite", "list"]),
-            id: z.string().optional().describe("Todo id for edit, mark, or remove."),
-            content: z.string().optional().describe("Todo text for create, edit, or rewrite items."),
-            status: TodoStatusSchema.optional().describe("Status for mark action or rewrite items."),
-            items: z
-                .array(z.object({
-                id: z.string().optional(),
-                content: z.string(),
-                status: TodoStatusSchema.optional()
-            }))
-                .optional()
-                .describe("Items for create or rewrite.")
-        }),
-        execute: async ({ action, id, content, status, items }) => {
-            const now = new Date().toISOString();
-            let todos = await loadTodos(todosPath);
-            switch (action) {
-                case "list":
-                    return formatTodoList(todos);
-                case "create": {
-                    const toAdd = items ?? (content ? [{ content, status: status ?? "pending" }] : []);
-                    if (toAdd.length === 0)
-                        return "create requires content or items.";
-                    for (const item of toAdd) {
-                        const todoId = item.id ?? nextTodoId(todos);
-                        todos.push({
-                            id: todoId,
-                            content: item.content,
-                            status: item.status ?? "pending",
-                            createdAt: now,
-                            updatedAt: now
-                        });
-                    }
-                    await saveTodos(todosPath, todos);
-                    await logEvent(runPath, "todo.created", { count: toAdd.length });
-                    return `Created ${toAdd.length} todo(s).\n\n${formatTodoList(todos)}`;
-                }
-                case "edit": {
-                    if (!id || !content)
-                        return "edit requires id and content.";
-                    const idx = todos.findIndex((t) => t.id === id);
-                    if (idx === -1)
-                        return `Todo "${id}" not found.`;
-                    todos[idx] = { ...todos[idx], content, updatedAt: now };
-                    await saveTodos(todosPath, todos);
-                    await logEvent(runPath, "todo.edited", { id });
-                    return `Updated ${id}.\n\n${formatTodoList(todos)}`;
-                }
-                case "mark": {
-                    if (!id || !status)
-                        return "mark requires id and status.";
-                    const idx = todos.findIndex((t) => t.id === id);
-                    if (idx === -1)
-                        return `Todo "${id}" not found.`;
-                    todos[idx] = { ...todos[idx], status, updatedAt: now };
-                    await saveTodos(todosPath, todos);
-                    await logEvent(runPath, "todo.marked", { id, status });
-                    return `Marked ${id} as ${status}.\n\n${formatTodoList(todos)}`;
-                }
-                case "remove": {
-                    if (!id)
-                        return "remove requires id.";
-                    const before = todos.length;
-                    todos = todos.filter((t) => t.id !== id);
-                    if (todos.length === before)
-                        return `Todo "${id}" not found.`;
-                    await saveTodos(todosPath, todos);
-                    await logEvent(runPath, "todo.removed", { id });
-                    return `Removed ${id}.\n\n${formatTodoList(todos)}`;
-                }
-                case "rewrite": {
-                    if (!items || items.length === 0)
-                        return "rewrite requires a non-empty items array.";
-                    todos = items.map((item, i) => ({
-                        id: item.id ?? `todo_${String(i + 1).padStart(3, "0")}`,
-                        content: item.content,
-                        status: item.status ?? "pending",
-                        createdAt: now,
-                        updatedAt: now
-                    }));
-                    await saveTodos(todosPath, todos);
-                    await logEvent(runPath, "todo.rewritten", { count: todos.length });
-                    return `Rewrote todo list (${todos.length} items).\n\n${formatTodoList(todos)}`;
-                }
-                default:
-                    return `Unknown action: ${action}`;
-            }
-        }
-    });
-}