@scira/cli 0.1.4 → 0.1.6

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}`;
-            }
-        }
-    });
-}