@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.10

package/dist/worker/console/chat/scm-routes.js

@@ -0,0 +1,217 @@
+/**
+ * Operator Chat — source control HTTP API (Console UI side).
+ *
+ * Endpoints (all under /api/operator/v1/chat):
+ *   GET  /scm/status                    branch + changes + counts
+ *   GET  /scm/diff?path=&staged=       unified diff (one path or --stat)
+ *   POST /scm/stage                     { paths: string[] } | { all: true }
+ *   POST /scm/unstage                   { paths: string[] }
+ *   POST /scm/discard                   { paths: string[] }  [dangerous]
+ *   POST /scm/commit                    { message }
+ *   GET  /scm/log?limit=                recent commits
+ *   GET  /scm/branches                  branch list + current
+ *   POST /scm/branches                  { name, create? }  switch or create
+ *   POST /scm/push                      push to upstream
+ *   POST /scm/pull                      pull from upstream
+ *
+ * Reads are open (same-origin console); every mutation passes gateMutation.
+ * The ScmService is workspace-scoped (repoRoot fixed at construction).
+ */
+function sendJson(res, status, body) {
+    res.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(JSON.stringify(body));
+}
+function mapScmError(res, error) {
+    const status = error.code === "NO_PATHS" || error.code === "EMPTY_MESSAGE" || error.code === "INVALID_NAME" || error.code === "INVALID_HASH"
+        ? 400
+        : error.code === "GIT_TIMEOUT"
+            ? 504
+            : 500;
+    sendJson(res, status, {
+        ok: false,
+        error: { code: error.code, message: error.message, ...(error.stderr ? { stderr: error.stderr } : {}) },
+    });
+}
+async function readJsonBody(req, maxBytes = 256 * 1024) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > maxBytes)
+            throw new Error("request body too large");
+        chunks.push(buf);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+function parsePaths(body) {
+    if (!Array.isArray(body.paths))
+        return [];
+    return body.paths
+        .filter((p) => typeof p === "string" && p.length > 0 && !p.includes("\0"))
+        .slice(0, 500);
+}
+/** Route dispatcher; returns true when the request was handled. */
+export async function handleScmRequest(req, res, deps, pathname) {
+    if (!pathname.startsWith("/api/operator/v1/chat/scm"))
+        return false;
+    const method = (req.method ?? "GET").toUpperCase();
+    const rest = pathname.slice("/api/operator/v1/chat/scm".length);
+    const parts = rest.split("/").filter(Boolean);
+    const sub = parts[0] ?? "";
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const gateFailed = (gate) => {
+        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+        return true;
+    };
+    try {
+        if (method === "GET" && sub === "status" && parts.length === 1) {
+            const r = await deps.scm.status();
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "GET" && sub === "diff" && parts.length === 1) {
+            const path = url.searchParams.get("path") ?? undefined;
+            const staged = url.searchParams.get("staged") === "1";
+            const r = await deps.scm.diff({ path, staged });
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "GET" && sub === "commit-diff" && parts.length === 1) {
+            const hash = url.searchParams.get("hash") ?? "";
+            if (!hash) {
+                sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: "hash is required" } });
+                return true;
+            }
+            const r = await deps.scm.commitDiff(hash);
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "GET" && sub === "untracked-diff" && parts.length === 1) {
+            const path = url.searchParams.get("path") ?? "";
+            if (!path) {
+                sendJson(res, 400, { ok: false, error: { code: "NO_PATHS", message: "path is required" } });
+                return true;
+            }
+            const r = await deps.scm.untrackedDiff(path);
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "GET" && sub === "log" && parts.length === 1) {
+            const limit = Number(url.searchParams.get("limit") ?? 30);
+            const r = await deps.scm.log(Number.isFinite(limit) ? Math.min(Math.max(limit, 1), 200) : 30);
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "GET" && sub === "branches" && parts.length === 1) {
+            const r = await deps.scm.branchList();
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        // Everything below mutates → gate first.
+        const gate = deps.gateMutation(req);
+        if (!gate.ok)
+            return gateFailed(gate);
+        if (method === "POST" && sub === "stage" && parts.length === 1) {
+            const body = await readJsonBody(req);
+            const r = body.all === true
+                ? await deps.scm.stage([], true)
+                : await deps.scm.stage(parsePaths(body));
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "unstage" && parts.length === 1) {
+            const body = await readJsonBody(req);
+            const r = await deps.scm.unstage(parsePaths(body));
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "discard" && parts.length === 1) {
+            const body = await readJsonBody(req);
+            const r = await deps.scm.discard(parsePaths(body));
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "commit" && parts.length === 1) {
+            const body = await readJsonBody(req);
+            const message = typeof body.message === "string" ? body.message : "";
+            const r = await deps.scm.commit(message);
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "POST" && sub === "branches" && parts.length === 1) {
+            const body = await readJsonBody(req);
+            const name = typeof body.name === "string" ? body.name : "";
+            if (!name) {
+                sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: "name is required" } });
+                return true;
+            }
+            const r = body.create === true
+                ? await deps.scm.branchCreate(name)
+                : await deps.scm.branchSwitch(name);
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "push" && parts.length === 1) {
+            const r = await deps.scm.push();
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        if (method === "POST" && sub === "pull" && parts.length === 1) {
+            const r = await deps.scm.pull();
+            if (!r.ok)
+                return mapScmError(res, r), true;
+            sendJson(res, 200, { ok: true, data: r });
+            return true;
+        }
+        sendJson(res, 404, { ok: false, error: { code: "NOT_FOUND", message: `unknown scm route: ${method} ${pathname}` } });
+        return true;
+    }
+    catch (error) {
+        if (!res.headersSent) {
+            sendJson(res, 500, {
+                ok: false,
+                error: {
+                    code: "SCM_INTERNAL",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        else {
+            res.end();
+        }
+        return true;
+    }
+}

package/dist/worker/console/chat/scm-service.js

@@ -0,0 +1,283 @@
+/**
+ * Operator Chat — source control service (DSH-style SCM).
+ *
+ * Workspace-scoped git operations shared by the Console UI panel and the
+ * model-facing tools:
+ *   - status: porcelain + branch + ahead/behind, parsed into typed changes
+ *   - diff:   working tree / staged, per-path or whole tree (bounded)
+ *   - stage / unstage / discard (path-scoped)
+ *   - commit (message required), log (bounded), branch list/switch/create
+ *   - push / pull (remote ops, explicit user/model intent only)
+ *
+ * All git invocations are fixed-argv execFile (no shell), bounded output and
+ * timeout, scoped to the workspace repoRoot. Failures return typed errors
+ * instead of throwing raw.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 20_000;
+const MAX_OUTPUT_CHARS = 200_000;
+function gitEnv() {
+    return {
+        ...process.env,
+        // Deterministic porcelain output regardless of user locale config.
+        GIT_PAGER: "cat",
+        LC_ALL: "C",
+    };
+}
+export class ScmService {
+    repoRoot;
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    async git(args, opts) {
+        try {
+            const { stdout } = await execFileAsync("git", args, {
+                cwd: this.repoRoot,
+                encoding: "utf8",
+                maxBuffer: 4 * 1024 * 1024,
+                timeout: opts?.timeoutMs ?? GIT_TIMEOUT_MS,
+                windowsHide: true,
+                env: gitEnv(),
+            });
+            const cap = opts?.maxOutputChars ?? MAX_OUTPUT_CHARS;
+            return { ok: true, stdout: stdout.length > cap ? stdout.slice(0, cap) : stdout };
+        }
+        catch (e) {
+            const err = e;
+            return {
+                ok: false,
+                code: err.killed ? "GIT_TIMEOUT" : "GIT_FAILED",
+                message: err.killed
+                    ? `git ${args[0]} timed out`
+                    : err.message ?? String(e),
+                stderr: typeof err.stderr === "string" ? err.stderr.slice(0, 2000) : undefined,
+                // `git diff --no-index` exits 1 when a diff exists; callers that
+                // expect that carry the partial stdout through.
+                stdout: typeof err.stdout === "string" ? err.stdout : undefined,
+            };
+        }
+    }
+    /** `git rev-parse --is-inside-work-tree` — cheap repo probe. */
+    async isRepo() {
+        const r = await this.git(["rev-parse", "--is-inside-work-tree"], { timeoutMs: 5_000 });
+        return r.ok && r.stdout.trim() === "true";
+    }
+    async status() {
+        // -uall: expand untracked directories to individual files (VS Code style);
+        // renames surface as R rows (with fromPath) only when git's rename
+        // detection is active, which is the default for status since git 2.9.
+        const porcelain = await this.git([
+            "status", "--porcelain=v1", "-z", "--branch", "-uall",
+        ]);
+        if (!porcelain.ok)
+            return porcelain;
+        const changes = [];
+        // porcelain v1 -z: NUL-separated fields. Header is
+        // "## branch...upstream [ahead N, behind M]"; status rows "XY path";
+        // rename/copy rows "XY newpath" followed by a bare "oldpath" field.
+        const fields = porcelain.stdout.split("\0").filter((s) => s !== "");
+        let branch = "";
+        let upstream;
+        let ahead;
+        let behind;
+        for (const field of fields) {
+            if (field.startsWith("## ")) {
+                const header = field.slice(3);
+                const track = header.split(/\s+/)[0] ?? "";
+                const dot = track.indexOf("...");
+                if (dot >= 0) {
+                    branch = track.slice(0, dot);
+                    upstream = track.slice(dot + 3);
+                }
+                else {
+                    branch = track;
+                }
+                const aheadM = /\[ahead (\d+)/.exec(header);
+                const behindM = /behind (\d+)\]/.exec(header);
+                if (aheadM)
+                    ahead = Number(aheadM[1]);
+                if (behindM)
+                    behind = Number(behindM[1]);
+                continue;
+            }
+            if (field.startsWith("#"))
+                continue;
+            // Bare path field: from-path of the previous rename/copy row.
+            const prev = changes[changes.length - 1];
+            if (prev && prev.xy.match(/[RC]/) && !prev.fromPath && !/^[ MADRCU?!]{1,2} /.test(field)) {
+                prev.fromPath = field;
+                continue;
+            }
+            const xy = field.slice(0, 2);
+            const path = field.slice(3);
+            changes.push({
+                path,
+                xy,
+                staged: xy[0] !== " " && xy[0] !== "?" && xy[0] !== "!",
+                unstaged: xy[1] !== " " && xy[1] !== "?",
+                untracked: xy === "??",
+            });
+        }
+        const head = await this.git(["rev-parse", "--short", "HEAD"], { timeoutMs: 5_000 });
+        return {
+            ok: true,
+            repoRoot: this.repoRoot,
+            branch,
+            head: head.ok ? head.stdout.trim() : "",
+            upstream,
+            ahead,
+            behind,
+            changes,
+            stagedCount: changes.filter((c) => c.staged).length,
+            unstagedCount: changes.filter((c) => c.unstaged).length,
+            untrackedCount: changes.filter((c) => c.untracked).length,
+        };
+    }
+    /** Unified diff for one path (or whole tree when path omitted). */
+    async diff(options) {
+        const args = ["diff"];
+        if (options.staged)
+            args.push("--cached");
+        args.push(`-U${options.contextLines ?? 3}`);
+        if (options.path) {
+            args.push("--", options.path);
+        }
+        else {
+            args.push("--stat");
+        }
+        const r = await this.git(args);
+        if (!r.ok)
+            return r;
+        return { ok: true, diff: r.stdout };
+    }
+    /** Full patch of one commit (`git show` without the commit header). */
+    async commitDiff(hash) {
+        if (!/^[0-9a-f]{4,40}$/i.test(hash)) {
+            return { ok: false, code: "INVALID_HASH", message: "invalid commit hash" };
+        }
+        const r = await this.git(["show", "--format=", "--no-color", hash]);
+        if (!r.ok)
+            return r;
+        return { ok: true, diff: r.stdout };
+    }
+    /**
+     * Untracked-file content as a full-addition diff (`git diff --no-index
+     * /dev/null <path>`): git diff never lists untracked files, and this
+     * renders them like any other change in the diff view.
+     */
+    async untrackedDiff(path) {
+        if (path.includes("\0") || path.includes("..")) {
+            return { ok: false, code: "NO_PATHS", message: "invalid path" };
+        }
+        const r = await this.git(["diff", "--no-index", "--no-color", "-U3", "--", "/dev/null", path]);
+        // `git diff --no-index` exits 1 when there IS a diff — carry stdout.
+        if (!r.ok && r.code === "GIT_FAILED")
+            return { ok: true, diff: r.stdout ?? "" };
+        if (!r.ok)
+            return r;
+        return { ok: true, diff: r.stdout };
+    }
+    /** Stage paths (`git add --` / `git add -A --` for "."). */
+    async stage(paths, all = false) {
+        if (!all && paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "stage requires paths or all=true" };
+        }
+        const args = ["add"];
+        if (all) {
+            args.push("-A");
+        }
+        else {
+            args.push("--");
+            args.push(...paths);
+        }
+        return this.git(args);
+    }
+    /** Unstage paths (`git reset HEAD --`). */
+    async unstage(paths) {
+        if (paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "unstage requires paths" };
+        }
+        return this.git(["reset", "HEAD", "--", ...paths]);
+    }
+    /** Discard worktree changes for paths (`git checkout --`). DANGEROUS. */
+    async discard(paths) {
+        if (paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "discard requires paths" };
+        }
+        return this.git(["checkout", "--", ...paths]);
+    }
+    async commit(message) {
+        const trimmed = message.trim();
+        if (!trimmed) {
+            return { ok: false, code: "EMPTY_MESSAGE", message: "commit message required" };
+        }
+        const r = await this.git(["commit", "-m", trimmed]);
+        if (!r.ok)
+            return r;
+        const sha = await this.git(["rev-parse", "--short", "HEAD"], { timeoutMs: 5_000 });
+        return { ok: true, commit: sha.ok ? sha.stdout.trim() : "" };
+    }
+    async log(limit = 30) {
+        const r = await this.git([
+            "log",
+            `--max-count=${limit}`,
+            "--pretty=format:%H\u0001%h\u0001%s\u0001%an\u0001%aI\u0001%D",
+        ]);
+        if (!r.ok)
+            return r;
+        const commits = [];
+        for (const line of r.stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [sha, short, subject, author, date, refs] = line.split("\u0001");
+            if (!sha)
+                continue;
+            commits.push({
+                sha: short ?? sha,
+                subject: subject ?? "",
+                author: author ?? "",
+                date: date ?? "",
+                refs: refs?.trim() || undefined,
+            });
+        }
+        return { ok: true, commits };
+    }
+    async branchList() {
+        const r = await this.git(["branch", "--list", "--format=%(HEAD)%02%(refname:short)"]);
+        if (!r.ok)
+            return r;
+        const branches = [];
+        for (const line of r.stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [headMark, name] = line.split("\x02");
+            if (!name)
+                continue;
+            branches.push({ name: name.trim(), current: headMark?.trim() === "*" });
+        }
+        const current = branches.find((b) => b.current)?.name ?? "";
+        return { ok: true, current, branches };
+    }
+    async branchCreate(name) {
+        if (!/^[\w.\-/]+$/.test(name)) {
+            return { ok: false, code: "INVALID_NAME", message: `invalid branch name: ${name}` };
+        }
+        return this.git(["checkout", "-b", name]);
+    }
+    async branchSwitch(name) {
+        if (!/^[\w.\-/]+$/.test(name)) {
+            return { ok: false, code: "INVALID_NAME", message: `invalid branch name: ${name}` };
+        }
+        return this.git(["checkout", name]);
+    }
+    async push() {
+        const r = await this.git(["push"], { timeoutMs: 120_000 });
+        return r.ok ? { ok: true, output: r.stdout } : r;
+    }
+    async pull() {
+        const r = await this.git(["pull", "--no-edit"], { timeoutMs: 120_000 });
+        return r.ok ? { ok: true, output: r.stdout } : r;
+    }
+}

package/dist/worker/console/chat/scm-tools.js

@@ -0,0 +1,111 @@
+/**
+ * Operator Chat — model-facing source control tool (DSH-style SCM).
+ *
+ * Registers `scm` (single tool, multi-action) so the model can inspect and
+ * drive git in the workspace repo: status / diff / stage / unstage / commit /
+ * log / branch / push / pull. Read actions are cheap and safe; write actions
+ * (commit/push) are the model's explicit intent, mirroring DSH's SCM tool.
+ *
+ * All operations go through ScmService (fixed-argv git, no shell, bounded),
+ * scoped to the workspace repoRoot.
+ */
+const TOOL_DESCRIPTION = "Inspect and drive git source control in the workspace repo. " +
+    "Actions: 'status' (branch + working-tree changes), 'diff' (one path or whole tree; staged=1 for the index), " +
+    "'stage'/'unstage' (paths array; all=true stages everything), 'discard' (DESTRUCTIVE: revert worktree changes of paths), " +
+    "'commit' (message required), 'log' (recent commits), 'branch' (list; name+create to create/switch), 'push', 'pull'. " +
+    "Use status/diff before proposing commits; prefer committing focused changesets. push/pull contact the remote — call them only when the user asks.";
+export async function buildScmTools(deps) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    function result(body) {
+        return { content: [{ type: "text", text: JSON.stringify(body) }], details: body };
+    }
+    function errText(e) {
+        return JSON.stringify({ ok: false, code: e.code, message: e.message, ...(e.stderr ? { stderr: e.stderr } : {}) });
+    }
+    const tool = defineTool({
+        name: "scm",
+        label: "SCM",
+        description: TOOL_DESCRIPTION,
+        promptSnippet: "scm: git source control (status/diff/stage/unstage/discard/commit/log/branch/push/pull) for the workspace repo.",
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal("status"),
+                Type.Literal("diff"),
+                Type.Literal("stage"),
+                Type.Literal("unstage"),
+                Type.Literal("discard"),
+                Type.Literal("commit"),
+                Type.Literal("log"),
+                Type.Literal("branch"),
+                Type.Literal("push"),
+                Type.Literal("pull"),
+            ], { description: "Which git operation to run." }),
+            path: Type.Optional(Type.String({ description: "For diff: repo-relative path (default whole tree --stat)." })),
+            staged: Type.Optional(Type.Boolean({ description: "For diff: diff the staging area (index) instead of the worktree." })),
+            paths: Type.Optional(Type.Array(Type.String(), { description: "For stage/unstage/discard: repo-relative paths." })),
+            all: Type.Optional(Type.Boolean({ description: "For stage: stage all changes (git add -A)." })),
+            message: Type.Optional(Type.String({ description: "For commit: commit message (required)." })),
+            limit: Type.Optional(Type.Number({ description: "For log: max commits (default 30)." })),
+            name: Type.Optional(Type.String({ description: "For branch: branch name to create or switch to." })),
+            create: Type.Optional(Type.Boolean({ description: "For branch: create the branch instead of switching." })),
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const paths = Array.isArray(params.paths) ? params.paths.slice(0, 500) : [];
+            switch (params.action) {
+                case "status":
+                    return result(await deps.scm.status());
+                case "diff": {
+                    const r = await deps.scm.diff({
+                        ...(params.path ? { path: params.path } : {}),
+                        ...(params.staged ? { staged: true } : {}),
+                    });
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "stage": {
+                    const r = params.all === true ? await deps.scm.stage([], true) : await deps.scm.stage(paths);
+                    return r.ok ? result({ ok: true, staged: params.all === true ? "all" : paths }) : result({ error: errText(r) });
+                }
+                case "unstage": {
+                    const r = await deps.scm.unstage(paths);
+                    return r.ok ? result({ ok: true, unstaged: paths }) : result({ error: errText(r) });
+                }
+                case "discard": {
+                    const r = await deps.scm.discard(paths);
+                    return r.ok ? result({ ok: true, discarded: paths }) : result({ error: errText(r) });
+                }
+                case "commit": {
+                    const r = await deps.scm.commit(params.message ?? "");
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "log": {
+                    const r = await deps.scm.log(params.limit ?? 30);
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "branch": {
+                    if (params.name) {
+                        const r = params.create === true
+                            ? await deps.scm.branchCreate(params.name)
+                            : await deps.scm.branchSwitch(params.name);
+                        return r.ok ? result({ ok: true, ...(params.create === true ? { created: params.name } : { switched: params.name }) }) : result({ error: errText(r) });
+                    }
+                    const r = await deps.scm.branchList();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "push": {
+                    const r = await deps.scm.push();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "pull": {
+                    const r = await deps.scm.pull();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                default:
+                    return result({ error: `unknown action: ${params.action}` });
+            }
+        },
+    });
+    return [tool];
+}