diffact 0.1.0 → 0.2.0

package/dist/command-runner.js

@@ -1,427 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { log } from "./log.js";
-import { runtime, } from "./runtime.js";
-const DEFAULT_TERMINAL_COLS = 120;
-const DEFAULT_TERMINAL_ROWS = 30;
-const MIN_TERMINAL_COLS = 2;
-const MIN_TERMINAL_ROWS = 1;
-const RUN_STOP_TIMEOUT_MS = 2000;
-const RUN_CLEANUP_DELAY_MS = 5 * 60 * 1000;
-const RUNS = new Map();
-const OUTPUT_DIR = path.join(os.tmpdir(), "diffact-command-output");
-const TERMINAL_POOL = new Map();
-let outputDirPromise = null;
-const deriveStatus = (exitCode, signal) => {
-    if (signal) {
-        return "stopped";
-    }
-    if (exitCode === 0) {
-        return "completed";
-    }
-    return "failed";
-};
-const resolveShellPath = (value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return "";
-    }
-    if (trimmed.includes("/")) {
-        return trimmed;
-    }
-    return runtime.which(trimmed) ?? trimmed;
-};
-const getDefaultShellPath = () => {
-    if (process.env.SHELL) {
-        return resolveShellPath(process.env.SHELL);
-    }
-    try {
-        const info = os.userInfo();
-        if (info.shell) {
-            return resolveShellPath(info.shell);
-        }
-    }
-    catch {
-        return "";
-    }
-    return "";
-};
-const shellSupportsProcessSubstitution = (shellPath) => {
-    const name = path.basename(shellPath);
-    return name === "bash" || name === "zsh";
-};
-const buildInteractiveShellArgs = (shellPath, commandLine) => {
-    const name = path.basename(shellPath);
-    if (name === "bash" || name === "zsh" || name === "fish" || name === "sh") {
-        return ["-ilc", commandLine];
-    }
-    return ["-ic", commandLine];
-};
-const toPtyEnv = (env) => {
-    const next = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (typeof value === "string") {
-            next[key] = value;
-        }
-    }
-    return next;
-};
-const ensureOutputDir = async () => {
-    if (!outputDirPromise) {
-        outputDirPromise = fs
-            .mkdir(OUTPUT_DIR, { recursive: true })
-            .then(() => undefined);
-    }
-    await outputDirPromise;
-};
-const quoteShellArg = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const buildCommandLine = (plan) => plan.commandLine ?? [plan.command, ...plan.args].map(quoteShellArg).join(" ");
-const acquireTerminal = (projectRoot, cols, rows, onData) => {
-    const pool = TERMINAL_POOL.get(projectRoot) ?? [];
-    const existing = pool.find((entry) => !entry.busy);
-    if (existing) {
-        existing.busy = true;
-        existing.onData = onData;
-        if (existing.cols !== cols || existing.rows !== rows) {
-            existing.cols = cols;
-            existing.rows = rows;
-            existing.terminal.resize(cols, rows);
-        }
-        return existing;
-    }
-    const entry = {
-        id: randomUUID(),
-        terminal: null,
-        busy: true,
-        cols,
-        rows,
-        onData,
-    };
-    entry.terminal = runtime.createTerminal({
-        cols,
-        rows,
-        data: (_terminal, data) => {
-            entry.onData?.(data);
-        },
-    });
-    pool.push(entry);
-    TERMINAL_POOL.set(projectRoot, pool);
-    return entry;
-};
-const releaseTerminal = (projectRoot, entry) => {
-    const pool = TERMINAL_POOL.get(projectRoot);
-    if (!pool) {
-        return;
-    }
-    entry.busy = false;
-    entry.onData = undefined;
-};
-const readFileSafe = async (filePath) => {
-    if (!filePath) {
-        return null;
-    }
-    try {
-        return await fs.readFile(filePath, "utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const createExitTracker = () => {
-    let resolved = false;
-    let resolveExit = null;
-    const exitPromise = new Promise((resolve) => {
-        resolveExit = resolve;
-    });
-    const resolveOnce = (value) => {
-        if (resolved) {
-            return;
-        }
-        resolved = true;
-        resolveExit?.(value);
-    };
-    const onExit = (_proc, exitCode, signalCode, error) => {
-        if (error) {
-            log.error({ err: error }, "command run exit error");
-        }
-        resolveOnce({
-            exitCode: exitCode ?? null,
-            signal: signalCode ?? null,
-        });
-    };
-    return { exitPromise, onExit, resolveOnce };
-};
-const scheduleCleanup = (runId) => {
-    setTimeout(() => {
-        const record = RUNS.get(runId);
-        if (record?.stdoutPath) {
-            fs.unlink(record.stdoutPath).catch(() => undefined);
-        }
-        if (record?.stderrPath) {
-            fs.unlink(record.stderrPath).catch(() => undefined);
-        }
-        RUNS.delete(runId);
-    }, RUN_CLEANUP_DELAY_MS);
-};
-export const startCommandRun = async (params) => {
-    const runId = randomUUID();
-    let proc;
-    let spawnFile = "";
-    let spawnCwd = "";
-    let terminalLease = null;
-    let terminalId = "";
-    try {
-        const startedAt = Date.now();
-        const output = {
-            stdout: "",
-            stderr: "",
-            combined: "",
-        };
-        const terminalDecoder = new TextDecoder();
-        const pushOutput = (stream, data) => {
-            if (!data) {
-                return;
-            }
-            if (stream === "stdout") {
-                output.stdout += data;
-            }
-            else {
-                output.stderr += data;
-            }
-            output.combined += data;
-            params.listener?.onOutput?.({
-                runId,
-                stream,
-                data,
-            });
-        };
-        const defaultShell = getDefaultShellPath();
-        const shellPath = defaultShell || "/bin/sh";
-        const commandLine = buildCommandLine(params.plan);
-        const env = toPtyEnv({
-            ...process.env,
-            ...(params.plan.env || {}),
-            SHELL: shellPath,
-            TERM: "xterm-256color",
-            FORCE_COLOR: "1",
-            CLICOLOR_FORCE: "1",
-        });
-        const cwd = params.plan.cwd || params.projectRoot;
-        spawnCwd = cwd;
-        try {
-            const stat = await fs.stat(cwd);
-            if (!stat.isDirectory()) {
-                throw new Error(`invalid_cwd:${cwd}`);
-            }
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : `invalid_cwd:${cwd}`;
-            throw new Error(detail);
-        }
-        let file = shellPath;
-        let args = buildInteractiveShellArgs(shellPath, commandLine);
-        let stdoutPath;
-        let stderrPath;
-        let wrapperShell = shellSupportsProcessSubstitution(shellPath)
-            ? shellPath
-            : "";
-        if (wrapperShell) {
-            await ensureOutputDir();
-            stdoutPath = path.join(OUTPUT_DIR, `${runId}.out`);
-            stderrPath = path.join(OUTPUT_DIR, `${runId}.err`);
-            const wrapped = `set -o pipefail; ${commandLine} > >(tee -a ${quoteShellArg(stdoutPath)}) 2> >(tee -a ${quoteShellArg(stderrPath)} >&2)`;
-            file = wrapperShell;
-            args = buildInteractiveShellArgs(wrapperShell, wrapped);
-        }
-        const spawnProcess = async () => {
-            const { exitPromise, onExit, resolveOnce } = createExitTracker();
-            spawnFile = file;
-            log.info({
-                runId,
-                commandId: params.command.id,
-                commandName: params.command.name,
-                commandSource: params.command.source,
-                projectRoot: params.projectRoot,
-                cwd,
-                file,
-                args,
-                defaultShell,
-                shellPath,
-                wrapperShell,
-            }, "command run spawn");
-            if (file.includes("/")) {
-                await fs.access(file);
-            }
-            const cmd = [file, ...args];
-            const terminalCols = Math.max(MIN_TERMINAL_COLS, Math.floor(params.terminal?.cols ?? DEFAULT_TERMINAL_COLS));
-            const terminalRows = Math.max(MIN_TERMINAL_ROWS, Math.floor(params.terminal?.rows ?? DEFAULT_TERMINAL_ROWS));
-            terminalLease = acquireTerminal(params.projectRoot, terminalCols, terminalRows, (data) => {
-                const text = terminalDecoder.decode(data, { stream: true });
-                if (text) {
-                    pushOutput("stdout", text);
-                }
-            });
-            terminalId = terminalLease.id;
-            const process = runtime.spawn(cmd, {
-                cwd,
-                env,
-                terminal: terminalLease.terminal,
-                onExit,
-            });
-            process.exited
-                .then((exitCode) => {
-                resolveOnce({
-                    exitCode: exitCode ?? null,
-                    signal: process.signalCode ? String(process.signalCode) : null,
-                });
-            })
-                .catch((error) => {
-                log.error({ err: error, runId, file: spawnFile }, "command run exit failed");
-                resolveOnce({ exitCode: null, signal: null });
-            });
-            return { process, exitPromise };
-        };
-        let exitPromise;
-        try {
-            const result = await spawnProcess();
-            proc = result.process;
-            exitPromise = result.exitPromise;
-        }
-        catch (error) {
-            if (terminalLease) {
-                releaseTerminal(params.projectRoot, terminalLease);
-                terminalLease = null;
-                terminalId = "";
-            }
-            if (!wrapperShell) {
-                throw error;
-            }
-            log.warn({ err: error, runId, wrapperShell }, "command run wrapper failed, retrying without wrapper");
-            wrapperShell = "";
-            file = shellPath;
-            args = buildInteractiveShellArgs(shellPath, commandLine);
-            stdoutPath = undefined;
-            stderrPath = undefined;
-            const result = await spawnProcess();
-            proc = result.process;
-            exitPromise = result.exitPromise;
-        }
-        const record = {
-            id: runId,
-            command: params.command,
-            projectRoot: params.projectRoot,
-            terminalId,
-            status: "running",
-            exitCode: null,
-            signal: null,
-            startedAt: new Date(startedAt).toISOString(),
-            output,
-            process: proc,
-            stdoutPath,
-            stderrPath,
-        };
-        RUNS.set(runId, record);
-        params.listener?.onStatus?.(record);
-        const finalize = async (exitCode, signal) => {
-            const tail = terminalDecoder.decode();
-            if (tail) {
-                pushOutput("stdout", tail);
-            }
-            record.exitCode = exitCode;
-            record.signal = signal ? String(signal) : null;
-            record.status = deriveStatus(exitCode, record.signal);
-            record.completedAt = new Date().toISOString();
-            const [stdout, stderr] = await Promise.all([
-                readFileSafe(stdoutPath),
-                readFileSafe(stderrPath),
-            ]);
-            if (stdout !== null) {
-                record.output.stdout = stdout;
-            }
-            if (stderr !== null) {
-                record.output.stderr = stderr;
-            }
-            if (!stdoutPath && !stderrPath) {
-                if (!record.output.stdout && !record.output.stderr) {
-                    record.output.stdout = record.output.combined;
-                    record.output.stderr = "";
-                }
-            }
-            else if (!stdoutPath && !record.output.stdout) {
-                record.output.stdout = record.output.combined;
-            }
-            scheduleCleanup(runId);
-            params.listener?.onStatus?.(record);
-            if (terminalLease) {
-                releaseTerminal(params.projectRoot, terminalLease);
-                terminalLease = null;
-            }
-            log.info({
-                runId,
-                status: record.status,
-                exitCode: record.exitCode,
-                signal: record.signal,
-            }, "command run exit");
-        };
-        // Always return immediately with running status; completion is notified via onStatus callback
-        exitPromise.then(({ exitCode, signal }) => {
-            void finalize(exitCode, signal);
-        });
-        return {
-            status: "running",
-            runId,
-            exitCode: null,
-            signal: null,
-        };
-    }
-    catch (error) {
-        if (terminalLease) {
-            releaseTerminal(params.projectRoot, terminalLease);
-            terminalLease = null;
-        }
-        const detail = error instanceof Error ? error.message : "spawn_failed";
-        const record = error;
-        const extra = typeof record?.code === "string" || typeof record?.errno === "number"
-            ? `:code=${String(record.code ?? "")}:errno=${String(record.errno ?? "")}`
-            : "";
-        log.error({ err: error, runId, file: spawnFile, cwd: spawnCwd }, "command run failed");
-        return {
-            status: "failed",
-            runId: null,
-            exitCode: null,
-            signal: null,
-            error: `command_spawn_failed:${detail}${extra}:file=${spawnFile}:cwd=${spawnCwd}`,
-        };
-    }
-};
-export const getCommandRun = (runId) => RUNS.get(runId) ?? null;
-export const listCommandRuns = (projectRoot) => [...RUNS.values()].filter((record) => record.projectRoot === projectRoot);
-export const getCommandRunOutput = (runId) => {
-    const record = RUNS.get(runId);
-    if (!record) {
-        return null;
-    }
-    return {
-        stdout: record.output.stdout,
-        stderr: record.output.stderr,
-        combined: record.output.combined,
-    };
-};
-export const stopCommandRun = (runId) => {
-    const record = RUNS.get(runId);
-    if (!record) {
-        return null;
-    }
-    if (record.status !== "running") {
-        return record;
-    }
-    record.process.kill("SIGTERM");
-    setTimeout(() => {
-        if (record.status === "running") {
-            record.process.kill("SIGKILL");
-        }
-    }, RUN_STOP_TIMEOUT_MS);
-    return record;
-};

package/dist/editors.d.ts

@@ -1,26 +0,0 @@
-export type EditorId = "vscode" | "cursor" | "zed";
-export type EditorInfo = {
-    id: EditorId;
-    name: string;
-    command: string;
-    available: boolean;
-};
-export declare const listAvailableEditors: () => Promise<EditorInfo[]>;
-export declare const getEditor: (id: EditorId) => Promise<EditorInfo | null>;
-export type OpenTarget = {
-    type: "project";
-} | {
-    type: "file";
-    filePath: string;
-    line?: number;
-} | {
-    type: "diff";
-    filePath: string;
-} | {
-    type: "commit";
-    sha: string;
-};
-export declare const openInEditor: (editorId: EditorId, projectPath: string, target?: OpenTarget) => Promise<{
-    success: boolean;
-    error?: string;
-}>;

package/dist/editors.js

@@ -1,144 +0,0 @@
-import { access, constants } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { runtime } from "./runtime.js";
-const EDITORS = [
-    {
-        id: "vscode",
-        name: "VS Code",
-        commands: {
-            darwin: [
-                "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
-                "/usr/local/bin/code",
-                "/opt/homebrew/bin/code",
-            ],
-            linux: ["/usr/bin/code", "/usr/local/bin/code", "/snap/bin/code"],
-            win32: [
-                "C:\\Program Files\\Microsoft VS Code\\bin\\code.cmd",
-                "C:\\Users\\%USERNAME%\\AppData\\Local\\Programs\\Microsoft VS Code\\bin\\code.cmd",
-            ],
-        },
-    },
-    {
-        id: "cursor",
-        name: "Cursor",
-        commands: {
-            darwin: [
-                "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
-                "/usr/local/bin/cursor",
-            ],
-            linux: ["/usr/bin/cursor", "/usr/local/bin/cursor", "/opt/cursor/cursor"],
-            win32: [
-                "C:\\Program Files\\Cursor\\cursor.exe",
-                "C:\\Users\\%USERNAME%\\AppData\\Local\\Programs\\Cursor\\cursor.exe",
-            ],
-        },
-    },
-    {
-        id: "zed",
-        name: "Zed",
-        commands: {
-            darwin: [
-                "/Applications/Zed.app/Contents/MacOS/cli",
-                "/usr/local/bin/zed",
-            ],
-            linux: ["/usr/bin/zed", "/usr/local/bin/zed", "~/.local/bin/zed"],
-            win32: [],
-        },
-    },
-];
-const expandPath = (p) => {
-    if (p.startsWith("~")) {
-        return path.join(os.homedir(), p.slice(1));
-    }
-    if (process.platform === "win32" && p.includes("%USERNAME%")) {
-        return p.replace("%USERNAME%", os.userInfo().username);
-    }
-    return p;
-};
-const fileExists = async (filePath) => {
-    try {
-        await access(filePath, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const findCommand = async (commands) => {
-    for (const cmd of commands) {
-        const expanded = expandPath(cmd);
-        if (await fileExists(expanded)) {
-            return expanded;
-        }
-    }
-    return null;
-};
-export const listAvailableEditors = async () => {
-    const platform = os.platform();
-    const results = [];
-    for (const editor of EDITORS) {
-        const commands = editor.commands[platform] ?? [];
-        const command = await findCommand(commands);
-        results.push({
-            id: editor.id,
-            name: editor.name,
-            command: command ?? "",
-            available: Boolean(command),
-        });
-    }
-    return results;
-};
-export const getEditor = async (id) => {
-    const editors = await listAvailableEditors();
-    return editors.find((e) => e.id === id) ?? null;
-};
-const buildEditorArgs = (editorId, projectPath, target) => {
-    // All editors: code/cursor/zed support `editor <folder>` and `editor <file>:<line>`
-    // For diff: VSCode/Cursor support `-d file1 file2`, Zed doesn't have built-in diff
-    // For git diff: open the file, editors have built-in git integration
-    if (target.type === "project") {
-        return [projectPath];
-    }
-    if (target.type === "file") {
-        const fullPath = path.join(projectPath, target.filePath);
-        if (target.line && target.line > 0) {
-            // VSCode/Cursor: --goto file:line or file:line:column
-            // Zed: file:line
-            if (editorId === "vscode" || editorId === "cursor") {
-                return [projectPath, "--goto", `${fullPath}:${target.line}`];
-            }
-            return [projectPath, `${fullPath}:${target.line}`];
-        }
-        return [projectPath, fullPath];
-    }
-    if (target.type === "diff") {
-        // Open the file - editors will show git changes via their built-in git integration
-        const fullPath = path.join(projectPath, target.filePath);
-        return [projectPath, fullPath];
-    }
-    if (target.type === "commit") {
-        // Can't directly open a commit view, just open the project
-        // User can use editor's git history panel
-        return [projectPath];
-    }
-    return [projectPath];
-};
-export const openInEditor = async (editorId, projectPath, target = { type: "project" }) => {
-    const editor = await getEditor(editorId);
-    if (!editor) {
-        return { success: false, error: "editor_not_found" };
-    }
-    if (!editor.available) {
-        return { success: false, error: "editor_not_installed" };
-    }
-    const args = buildEditorArgs(editorId, projectPath, target);
-    try {
-        runtime.spawn([editor.command, ...args]);
-        return { success: true };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : "spawn_failed";
-        return { success: false, error: message };
-    }
-};

package/dist/gh.d.ts

@@ -1,61 +0,0 @@
-export type PullRequestInfo = {
-    number: number;
-    title: string;
-    headRefName: string;
-    updatedAt: string;
-    author?: string;
-    url?: string;
-};
-export type PullRequestListing = {
-    available: boolean;
-    items: PullRequestInfo[];
-    hasMore: boolean;
-    nextCursor: string | null;
-    error?: string;
-};
-export type IssueLabel = {
-    name: string;
-    color: string;
-};
-export type IssueInfo = {
-    number: number;
-    title: string;
-    state: "open" | "closed";
-    updatedAt: string;
-    author?: string;
-    url?: string;
-    labels: IssueLabel[];
-};
-export type IssueListing = {
-    available: boolean;
-    items: IssueInfo[];
-    hasMore: boolean;
-    nextCursor: string | null;
-    error?: string;
-};
-export type IssueDetail = {
-    number: number;
-    title: string;
-    body: string;
-    state: "open" | "closed";
-    author?: string;
-    url?: string;
-    labels: IssueLabel[];
-    createdAt: string;
-    updatedAt: string;
-    commentsCount: number;
-};
-export type ListPullRequestsOptions = {
-    limit?: number;
-    cursor?: string | null;
-    search?: string | null;
-};
-export declare function ghListPullRequests(cwd: string, options?: ListPullRequestsOptions): Promise<PullRequestListing>;
-export type ListIssuesOptions = {
-    limit?: number;
-    cursor?: string | null;
-    search?: string | null;
-    state?: "open" | "closed" | "all";
-};
-export declare function ghListIssues(cwd: string, options?: ListIssuesOptions): Promise<IssueListing>;
-export declare function ghGetIssueDetail(cwd: string, issueNumber: number): Promise<IssueDetail | null>;