diffact 0.1.0 → 0.2.0

package/dist/app-server-client.js

@@ -1,249 +0,0 @@
-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

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

package/dist/capabilities.js

@@ -1,27 +0,0 @@
-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

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

package/dist/cli.js

@@ -1,13 +0,0 @@
-#!/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

@@ -1,83 +0,0 @@
-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 {};