@armanckeser/downstream 0.0.0-stage → 0.1.0

package/dist/server/agent-host.js

@@ -0,0 +1,230 @@
+// Claude Code sessions that Downstream runs itself, through the Agent SDK. You
+// press a pull request; a session starts in its repository with a first
+// message; what it says and does streams to the browser, and anything that
+// isn't read-only waits for your approval there. You can move a session to
+// your terminal at any time: Downstream lets go and `claude --resume` picks it up.
+import { EventEmitter } from "node:events";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { autoApprove, reachesOthers } from "../domain/approval.js";
+import { ghEnv } from "./gh.js";
+import { packageRoot } from "./install.js";
+import { newId, now } from "./store.js";
+const skillDir = packageRoot;
+const ACTIVITY_LIMIT = 200;
+class AgentSession {
+    view;
+    queue = [];
+    wake = null;
+    closed = false;
+    pending = new Map();
+    q = null;
+    changed;
+    constructor(input, changed) {
+        this.changed = changed;
+        this.view = { key: input.key, repo: input.repo, pr: input.pr, root: input.root, sessionId: input.resumeId ?? null, status: "starting", activity: [], approvals: [], error: null, resume: null };
+    }
+    start(input) {
+        this.send(input.prompt, false);
+        this.q = query({
+            prompt: this.input(),
+            options: {
+                cwd: input.root,
+                // 'user' carries the user's model gateway and their own CLAUDE.md; 'project' the repo's.
+                settingSources: ["user", "project", "local"],
+                // Auto mode: a classifier approves ordinary work, so you're asked only when it can't tell.
+                permissionMode: "auto",
+                // Runs before the classifier: anything that reaches other people comes to you, whatever it would decide.
+                hooks: { PreToolUse: [{ hooks: [async (hook) => outwardHook(hook)] }] },
+                canUseTool: (tool, toolInput, { signal, title }) => this.approve(tool, toolInput, signal, title),
+                // DOWNSTREAM_HOSTED: the browser is already on its way to the review; `open` shouldn't open another tab.
+                env: { ...ghEnv(input.account), DOWNSTREAM_HOSTED: "1" },
+                ...(input.resumeId ? { resume: input.resumeId } : {}),
+            },
+        });
+        void this.pump(this.q);
+    }
+    /** Queue a message for the agent. It reads it when its current turn ends. */
+    send(text, record = true) {
+        if (this.closed)
+            throw new Error("This session has ended.");
+        this.queue.push({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null });
+        if (record)
+            this.log({ kind: "user", text });
+        this.wake?.();
+    }
+    decide(approvalId, allow) {
+        const resolve = this.pending.get(approvalId);
+        if (!resolve)
+            return;
+        this.pending.delete(approvalId);
+        this.view.approvals = this.view.approvals.filter((a) => a.id !== approvalId);
+        resolve(allow ? { behavior: "allow" } : { behavior: "deny", message: "The user declined this in Downstream." });
+        this.setStatus(this.view.approvals.length ? "asking" : "running");
+    }
+    /** Let go of the session so a terminal can resume it; two live writers would interleave the transcript. */
+    async handOff() {
+        const id = this.view.sessionId;
+        if (!id)
+            throw new Error("The session hasn't started yet.");
+        for (const id of [...this.pending.keys()])
+            this.decide(id, false);
+        this.stop();
+        await this.q?.interrupt().catch(() => undefined);
+        this.q?.close();
+        this.view.resume = `cd ${JSON.stringify(this.view.root)} && claude --resume ${id}`;
+        this.setStatus("handed-off");
+        return this.view.resume;
+    }
+    stop() {
+        this.closed = true;
+        this.wake?.();
+    }
+    get live() {
+        return !this.closed;
+    }
+    async *input() {
+        while (!this.closed) {
+            if (!this.queue.length)
+                await new Promise((r) => (this.wake = r));
+            while (this.queue.length)
+                yield this.queue.shift();
+        }
+    }
+    async approve(tool, input, signal, title) {
+        if (autoApprove(tool, input, skillDir).allow)
+            return { behavior: "allow", updatedInput: input };
+        const approval = { id: newId("ap"), tool, title: title ?? `Claude wants to use ${tool}`, detail: describeInput(tool, input), at: now() };
+        // Register the answer before announcing the question: a listener may answer the moment it hears.
+        const answer = new Promise((resolve) => {
+            this.pending.set(approval.id, (r) => resolve(r.behavior === "allow" ? { ...r, updatedInput: input } : r));
+        });
+        signal.addEventListener("abort", () => this.decide(approval.id, false), { once: true });
+        this.view.approvals = [...this.view.approvals, approval];
+        this.setStatus("asking");
+        return answer;
+    }
+    async pump(q) {
+        try {
+            for await (const m of q)
+                this.onMessage(m);
+            if (this.view.status !== "handed-off")
+                this.setStatus("ended");
+        }
+        catch (e) {
+            if (this.view.status === "handed-off")
+                return;
+            this.view.error = e.message;
+            this.log({ kind: "error", text: this.view.error });
+            this.setStatus("failed");
+        }
+        finally {
+            this.closed = true;
+        }
+    }
+    onMessage(m) {
+        if (m.type === "system" && m.subtype === "init") {
+            this.view.sessionId = m.session_id;
+            this.setStatus("running");
+            return;
+        }
+        if (m.type === "system" && m.subtype === "session_state_changed") {
+            // "requires_action" is our own approval prompt, already reflected; only idle/running come from here.
+            if (this.view.approvals.length === 0 && m.state !== "requires_action")
+                this.setStatus(m.state === "idle" ? "idle" : "running");
+            return;
+        }
+        if (m.type === "assistant" && m.parent_tool_use_id === null) {
+            for (const block of m.message.content) {
+                if (block.type === "text" && block.text.trim())
+                    this.log({ kind: "text", text: block.text });
+                if (block.type === "tool_use")
+                    this.log({ kind: "tool", tool: block.name, summary: describeInput(block.name, block.input) });
+            }
+            return;
+        }
+        if (m.type === "result") {
+            if (m.subtype !== "success")
+                this.log({ kind: "error", text: `The turn ended early (${m.subtype}).` });
+            if (this.view.approvals.length === 0)
+                this.setStatus("idle");
+        }
+    }
+    log(entry) {
+        this.view.activity = [...this.view.activity, { ...entry, id: newId("ac"), at: now() }].slice(-ACTIVITY_LIMIT);
+        this.changed();
+    }
+    setStatus(status) {
+        if (this.view.status === status)
+            return;
+        this.view.status = status;
+        this.changed();
+    }
+}
+/** One line a person can read: the command, the file, the pattern. */
+function describeInput(tool, input) {
+    const pick = (k) => (typeof input[k] === "string" ? input[k] : null);
+    const text = pick("command") ?? pick("file_path") ?? pick("pattern") ?? pick("url") ?? pick("query") ?? pick("description") ?? pick("prompt") ?? "";
+    return (text || tool).replace(new RegExp(`node "?${skillDir}/bin/downstream.mjs"?`, "g"), "downstream").slice(0, 400);
+}
+export class AgentHost {
+    sessions = new Map();
+    /** "changed" with the session key. */
+    bus = new EventEmitter();
+    constructor() {
+        this.bus.setMaxListeners(100);
+    }
+    start(input) {
+        const existing = this.sessions.get(input.key);
+        if (existing?.live)
+            return existing.view;
+        const session = new AgentSession(input, () => this.bus.emit("changed", input.key));
+        this.sessions.set(input.key, session);
+        session.start(input);
+        this.bus.emit("changed", input.key);
+        return session.view;
+    }
+    view(key) {
+        return this.sessions.get(key)?.view ?? null;
+    }
+    views() {
+        return [...this.sessions.values()].map((s) => s.view);
+    }
+    live(key) {
+        return this.sessions.get(key)?.live ?? false;
+    }
+    send(key, text) {
+        this.require(key).send(text);
+    }
+    decide(key, approvalId, allow) {
+        this.require(key).decide(approvalId, allow);
+    }
+    handOff(key) {
+        return this.require(key).handOff();
+    }
+    /**
+     * The user wrote in Downstream while the agent sat idle (its turn over, not in
+     * `downstream wait`): tell it, so a message never waits on an agent that
+     * stopped listening.
+     */
+    nudge(key) {
+        const s = this.sessions.get(key);
+        if (s?.live && s.view.status === "idle")
+            s.send("The user wrote to you in Downstream. Run `downstream wait` to read it and answer there.", false);
+    }
+    stopAll() {
+        for (const s of this.sessions.values())
+            s.stop();
+    }
+    require(key) {
+        const s = this.sessions.get(key);
+        if (!s)
+            throw new Error(`No agent session for ${key}.`);
+        return s;
+    }
+}
+function outwardHook(hook) {
+    if (hook.hook_event_name !== "PreToolUse")
+        return {};
+    const reason = reachesOthers(hook.tool_name, (hook.tool_input ?? {}));
+    return reason ? { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "ask", permissionDecisionReason: `This is ${reason}, which you approve yourself.` } } : {};
+}

package/dist/server/analyze/git.js

@@ -0,0 +1,161 @@
+// Git plumbing: which files changed, which lines changed, and file contents on
+// either side. "head" is either a ref or the working tree (uncommitted work
+// counts, untracked files included) so an agent can review what it just wrote.
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+export const WORKTREE = "WORKTREE";
+export function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
+}
+export function tryGit(cwd, args) {
+    try {
+        return git(cwd, args);
+    }
+    catch {
+        return null;
+    }
+}
+export function repoRoot(cwd) {
+    return git(cwd, ["rev-parse", "--show-toplevel"]).trim();
+}
+export function worktreeSource(root) {
+    return {
+        label: WORKTREE,
+        read(file) {
+            const abs = path.join(root, file);
+            return existsSync(abs) ? readFileSync(abs, "utf8") : null;
+        },
+        exists: (file) => existsSync(path.join(root, file)),
+        files: () => [
+            ...new Set([
+                ...git(root, ["ls-files"]).split("\n"),
+                ...git(root, ["ls-files", "--others", "--exclude-standard"]).split("\n"),
+            ]),
+        ].filter(Boolean),
+    };
+}
+const PRELOAD = /\.(m|c)?(t|j)sx?$|\.json$|\.pyi?$/;
+/**
+ * Files at a commit. A type checker reads hundreds of files, and one `git show`
+ * each costs seconds, so source files are read up front in one `cat-file --batch`.
+ */
+export function refSource(root, ref) {
+    const cache = new Map();
+    let blobs = null;
+    const tree = () => {
+        if (blobs)
+            return blobs;
+        blobs = new Map();
+        for (const line of git(root, ["ls-tree", "-r", "-l", ref]).split("\n")) {
+            const m = line.match(/^\d+ blob ([0-9a-f]+)\s+(\d+|-)\t(.+)$/);
+            if (m)
+                blobs.set(m[3], m[1]);
+        }
+        const wanted = [...blobs].filter(([p]) => PRELOAD.test(p) && !p.includes("node_modules/"));
+        if (wanted.length) {
+            const out = execFileSync("git", ["cat-file", "--batch"], { cwd: root, input: wanted.map(([, sha]) => sha).join("\n") + "\n", maxBuffer: 1024 * 1024 * 1024 });
+            let at = 0;
+            for (const [p] of wanted) {
+                const nl = out.indexOf(10, at);
+                const size = Number(out.subarray(at, nl).toString("utf8").split(" ")[2]);
+                cache.set(p, out.subarray(nl + 1, nl + 1 + size).toString("utf8"));
+                at = nl + 1 + size + 1;
+            }
+        }
+        return blobs;
+    };
+    return {
+        label: ref,
+        read(file) {
+            const files = tree();
+            if (!cache.has(file))
+                cache.set(file, files.has(file) ? tryGit(root, ["show", `${ref}:${file}`]) : null);
+            return cache.get(file) ?? null;
+        },
+        exists: (file) => tree().has(file),
+        files: () => [...tree().keys()],
+    };
+}
+function parseHunks(patch) {
+    const added = [];
+    const deleted = [];
+    for (const m of patch.matchAll(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/gm)) {
+        const oldStart = Number(m[1]);
+        const oldLen = m[2] === undefined ? 1 : Number(m[2]);
+        const newStart = Number(m[3]);
+        const newLen = m[4] === undefined ? 1 : Number(m[4]);
+        if (oldLen > 0)
+            deleted.push({ start: oldStart, end: oldStart + oldLen - 1 });
+        if (newLen > 0)
+            added.push({ start: newStart, end: newStart + newLen - 1 });
+    }
+    return { added, deleted };
+}
+const IGNORED = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|\.downstream\/)/;
+export function diff(root, base, head) {
+    const headRef = head === WORKTREE ? "HEAD" : head;
+    const mergeBase = (tryGit(root, ["merge-base", base, headRef]) ?? git(root, ["rev-parse", base])).trim();
+    const range = head === WORKTREE ? [mergeBase] : [mergeBase, head];
+    const files = [];
+    const hunks = new Map();
+    const numstat = git(root, ["diff", "--numstat", "-M", ...range]);
+    const nameStatus = git(root, ["diff", "--name-status", "-M", ...range]);
+    const counts = new Map();
+    for (const line of numstat.split("\n").filter(Boolean)) {
+        const [a, d, ...rest] = line.split("\t");
+        const p = rest.at(-1);
+        counts.set(p, [Number(a) || 0, Number(d) || 0]);
+    }
+    for (const line of nameStatus.split("\n").filter(Boolean)) {
+        const parts = line.split("\t");
+        const code = parts[0][0];
+        const p = parts.at(-1);
+        if (IGNORED.test(p))
+            continue;
+        const oldPath = code === "R" ? parts[1] : code === "A" ? null : p;
+        const status = code === "A" ? "added" : code === "D" ? "deleted" : code === "R" ? "renamed" : "modified";
+        const [additions, deletions] = counts.get(p) ?? counts.get(`${parts[1]} => ${p}`) ?? [0, 0];
+        files.push({ path: p, oldPath, status, additions, deletions });
+        const patch = git(root, ["diff", "-U0", "-M", ...range, "--", ...(oldPath && oldPath !== p ? [oldPath, p] : [p])]);
+        hunks.set(p, parseHunks(patch));
+    }
+    if (head === WORKTREE) {
+        const untracked = git(root, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+        for (const p of untracked) {
+            if (IGNORED.test(p) || files.some((f) => f.path === p))
+                continue;
+            const text = tryReadText(path.join(root, p));
+            if (text === null)
+                continue;
+            const lines = text.split("\n").length;
+            files.push({ path: p, oldPath: null, status: "added", additions: lines, deletions: 0 });
+            hunks.set(p, { added: [{ start: 1, end: lines }], deleted: [] });
+        }
+    }
+    return { mergeBase, files, hunks };
+}
+function tryReadText(abs) {
+    try {
+        const buf = readFileSync(abs);
+        if (buf.length > 2_000_000 || buf.includes(0))
+            return null;
+        return buf.toString("utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function inRanges(line, ranges) {
+    return ranges.some((r) => line >= r.start && line <= r.end);
+}
+export function countInRange(range, ranges) {
+    let n = 0;
+    for (const r of ranges) {
+        const s = Math.max(r.start, range.start);
+        const e = Math.min(r.end, range.end);
+        if (e >= s)
+            n += e - s + 1;
+    }
+    return n;
+}