diffact 0.1.0

package/dist/app-server-client.js

@@ -0,0 +1,249 @@
+import { spawn } from "node:child_process";
+import { log } from "./log.js";
+const APP_SERVER_LOG_PREFIX = "[app-server]";
+const logAppServer = (event, detail) => {
+    if (detail) {
+        log.info({ detail }, `${APP_SERVER_LOG_PREFIX} ${event}`);
+        return;
+    }
+    log.info(`${APP_SERVER_LOG_PREFIX} ${event}`);
+};
+export class AppServerClient {
+    #command;
+    #args;
+    #process = null;
+    #pending = new Map();
+    #nextId = 1;
+    #connectPromise = null;
+    #initializePromise = null;
+    #onNotification;
+    #onRequest;
+    #onClose;
+    #initialized = false;
+    #stdoutBuffer = "";
+    constructor(options) {
+        this.#command = options.command ?? "codex";
+        this.#args = options.args ?? ["app-server"];
+        this.#onNotification = options.onNotification;
+        this.#onRequest = options.onRequest;
+        this.#onClose = options.onClose;
+    }
+    async connect() {
+        if (this.#connectPromise) {
+            return this.#connectPromise;
+        }
+        this.#connectPromise = new Promise((resolve, reject) => {
+            logAppServer("connect:start", { command: this.#command });
+            const child = spawn(this.#command, this.#args, {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            this.#process = child;
+            let settled = false;
+            const cleanup = () => {
+                child.removeListener("spawn", onSpawn);
+                child.removeListener("error", onError);
+            };
+            const onSpawn = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                logAppServer("connect:ready");
+                resolve();
+            };
+            const onError = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                const error = new Error("app_server_spawn_failed");
+                this.#connectPromise = null;
+                this.#process = null;
+                logAppServer("connect:error", { error: error.message });
+                reject(error);
+                if (this.#onClose) {
+                    this.#onClose(error);
+                }
+            };
+            child.on("spawn", onSpawn);
+            child.on("error", onError);
+            child.stdout.on("data", (chunk) => {
+                this.#handleStdout(chunk);
+            });
+            child.stderr.on("data", () => { });
+            child.on("exit", (code, signal) => {
+                const error = new Error("app_server_closed");
+                for (const pending of this.#pending.values()) {
+                    pending.reject(error);
+                }
+                this.#pending.clear();
+                this.#connectPromise = null;
+                this.#initializePromise = null;
+                this.#initialized = false;
+                this.#stdoutBuffer = "";
+                this.#process = null;
+                logAppServer("connect:closed", { code, signal });
+                if (this.#onClose) {
+                    this.#onClose(error);
+                }
+            });
+        });
+        return this.#connectPromise;
+    }
+    async initialize(params) {
+        if (this.#initialized) {
+            return;
+        }
+        if (this.#initializePromise) {
+            return this.#initializePromise;
+        }
+        this.#initializePromise = (async () => {
+            await this.connect();
+            logAppServer("initialize:start");
+            await this.request("initialize", {
+                clientInfo: {
+                    name: params.name,
+                    title: params.title ?? null,
+                    version: params.version,
+                },
+            });
+            this.notify("initialized");
+            this.#initialized = true;
+            logAppServer("initialize:done");
+        })();
+        try {
+            await this.#initializePromise;
+        }
+        finally {
+            this.#initializePromise = null;
+        }
+    }
+    async request(method, params) {
+        await this.connect();
+        const id = this.#nextId++;
+        const payload = { id, method, params };
+        const stdin = this.#process?.stdin;
+        if (!stdin || !stdin.writable) {
+            throw new Error("app_server_not_connected");
+        }
+        const result = new Promise((resolve, reject) => {
+            this.#pending.set(id, { method, resolve, reject });
+            logAppServer("request:out", { id, method });
+            stdin.write(`${JSON.stringify(payload)}\n`);
+        });
+        return result;
+    }
+    notify(method, params) {
+        const stdin = this.#process?.stdin;
+        if (!stdin || !stdin.writable) {
+            return;
+        }
+        const payload = { method, params };
+        logAppServer("notify:out", { method });
+        stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    close() {
+        if (this.#process) {
+            this.#process.kill();
+        }
+    }
+    async #handleMessage(message) {
+        if (message.method) {
+            if (message.id !== undefined) {
+                logAppServer("request:in", {
+                    id: message.id,
+                    method: message.method,
+                });
+                const request = {
+                    id: message.id,
+                    method: message.method,
+                    params: message.params,
+                };
+                let result = null;
+                if (this.#onRequest) {
+                    result = await this.#onRequest(request);
+                }
+                logAppServer("response:out", {
+                    id: request.id,
+                    method: request.method,
+                });
+                this.#sendResponse(request.id, result);
+                return;
+            }
+            if (this.#onNotification) {
+                logAppServer("notification:in", { message });
+                this.#onNotification({
+                    method: message.method,
+                    params: message.params,
+                });
+            }
+            return;
+        }
+        if (message.id === undefined) {
+            return;
+        }
+        const pending = this.#pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.#pending.delete(message.id);
+        if (message.error) {
+            logAppServer("response:error", {
+                id: message.id,
+                method: pending.method,
+            });
+            const messageError = message.error &&
+                typeof message.error === "object" &&
+                "message" in message.error
+                ? message.error.message
+                : null;
+            pending.reject(new Error(typeof messageError === "string" ? messageError : "app_server_error"));
+            return;
+        }
+        if (message.result !== undefined) {
+            logAppServer("response:in", {
+                id: message.id,
+                method: pending.method,
+            });
+            pending.resolve(message.result);
+            return;
+        }
+        logAppServer("response:in", { id: message.id, method: pending.method });
+        pending.resolve(message);
+    }
+    #sendResponse(id, result) {
+        const stdin = this.#process?.stdin;
+        if (!stdin || !stdin.writable) {
+            return;
+        }
+        stdin.write(`${JSON.stringify({ id, result })}\n`);
+    }
+    #handleStdout(chunk) {
+        this.#stdoutBuffer += chunk.toString("utf8");
+        let newlineIndex = this.#stdoutBuffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            const line = this.#stdoutBuffer.slice(0, newlineIndex).trim();
+            this.#stdoutBuffer = this.#stdoutBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                newlineIndex = this.#stdoutBuffer.indexOf("\n");
+                continue;
+            }
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                newlineIndex = this.#stdoutBuffer.indexOf("\n");
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object") {
+                newlineIndex = this.#stdoutBuffer.indexOf("\n");
+                continue;
+            }
+            void this.#handleMessage(parsed);
+            newlineIndex = this.#stdoutBuffer.indexOf("\n");
+        }
+    }
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { CapabilityInfo } from "./types.js";
+export declare function computeCapabilities(projectPath?: string | null): Promise<CapabilityInfo>;

package/dist/capabilities.js

@@ -0,0 +1,27 @@
+import { resolveProjectRoot } from "./project-path.js";
+import { runtime } from "./runtime.js";
+async function detectGithubAuth() {
+    const ghPath = runtime.which("gh");
+    if (!ghPath) {
+        return false;
+    }
+    try {
+        const proc = runtime.spawn([ghPath, "auth", "status", "--hostname", "github.com"], {});
+        const exitCode = await proc.exited;
+        return exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function computeCapabilities(projectPath) {
+    const project = projectPath
+        ? await resolveProjectRoot(projectPath).catch(() => null)
+        : null;
+    const github = await detectGithubAuth();
+    return {
+        diffReview: true,
+        git: project ? project.isGit : false,
+        github,
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for diffact.
+ * Auto-detects runtime (Bun/Node) and starts the appropriate server.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for diffact.
+ * Auto-detects runtime (Bun/Node) and starts the appropriate server.
+ */
+const isBun = typeof globalThis.Bun !== "undefined";
+if (isBun) {
+    await import("./index.js");
+}
+else {
+    await import("./index-node.js");
+}
+export {};

package/dist/command-runner.d.ts

@@ -0,0 +1,83 @@
+import type { CommandExecutionPlan, CommandSource } from "./project-commands.js";
+import { type RuntimeTerminal, type SpawnedProcess } from "./runtime.js";
+export type CommandRunStatus = "running" | "completed" | "failed" | "stopped";
+export type CommandRunStream = "stdout" | "stderr";
+export type CommandDescriptor = {
+    id: string;
+    name: string;
+    label: string;
+    source: CommandSource;
+};
+export type CommandRunOutput = {
+    stdout: string;
+    stderr: string;
+    combined: string;
+};
+export type CommandRunRecord = {
+    id: string;
+    command: CommandDescriptor;
+    projectRoot: string;
+    terminalId: string;
+    status: CommandRunStatus;
+    exitCode: number | null;
+    signal: string | null;
+    startedAt: string;
+    completedAt?: string;
+    output: CommandRunOutput;
+    process: CommandRunProcess;
+    stdoutPath?: string;
+    stderrPath?: string;
+};
+export type CommandRunResult = {
+    status: CommandRunStatus;
+    runId: string | null;
+    exitCode: number | null;
+    signal: string | null;
+    error?: string;
+};
+export type CommandRunSummary = {
+    runId: string;
+    projectPath: string;
+    terminalId: string;
+    commandId: string;
+    commandName: string;
+    commandLabel: string;
+    commandSource: CommandSource;
+    status: CommandRunStatus;
+    exitCode: number | null;
+    signal: string | null;
+    startedAt: string;
+    completedAt: string | null;
+    stdout?: string;
+    stderr?: string;
+};
+export type CommandRunListener = {
+    onStatus?: (record: CommandRunRecord) => void;
+    onOutput?: (event: {
+        runId: string;
+        stream: CommandRunStream;
+        data: string;
+    }) => void;
+};
+type CommandRunProcess = SpawnedProcess & {
+    terminal?: RuntimeTerminal;
+};
+export declare const startCommandRun: (params: {
+    command: CommandDescriptor;
+    projectRoot: string;
+    plan: CommandExecutionPlan;
+    terminal?: {
+        cols: number;
+        rows: number;
+    };
+    listener?: CommandRunListener;
+}) => Promise<CommandRunResult>;
+export declare const getCommandRun: (runId: string) => CommandRunRecord | null;
+export declare const listCommandRuns: (projectRoot: string) => CommandRunRecord[];
+export declare const getCommandRunOutput: (runId: string) => {
+    stdout: string;
+    stderr: string;
+    combined: string;
+} | null;
+export declare const stopCommandRun: (runId: string) => CommandRunRecord | null;
+export {};