diffact 0.1.0

package/dist/git.js

@@ -0,0 +1,482 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const MAX_BUFFER = 1024 * 1024 * 20;
+const execGit = (cwd, args) => execFileAsync("git", args, { cwd, maxBuffer: MAX_BUFFER });
+const execGitAllowNonZero = async (cwd, args) => {
+    try {
+        return await execGit(cwd, args);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "stdout" in error) {
+            const record = error;
+            const toText = (value) => typeof value === "string"
+                ? value
+                : value instanceof Buffer
+                    ? value.toString("utf8")
+                    : "";
+            return {
+                stdout: toText(record.stdout),
+                stderr: toText(record.stderr),
+            };
+        }
+        throw error;
+    }
+};
+export async function gitDiff(cwd, args = [], paths = []) {
+    const diffArgs = ["diff", "--no-color", ...args];
+    if (paths.length) {
+        diffArgs.push("--", ...paths);
+    }
+    const { stdout } = await execGit(cwd, diffArgs);
+    const includeUntracked = !args.some((arg) => ["--cached", "--staged", "--index"].includes(arg));
+    if (!includeUntracked) {
+        return stdout;
+    }
+    const { stdout: untrackedRaw } = await execGit(cwd, [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "-z",
+    ]);
+    const untracked = untrackedRaw
+        .split("\0")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const filteredUntracked = paths.length
+        ? untracked.filter((file) => paths.some((path) => file === path || file.startsWith(`${path}/`)))
+        : untracked;
+    if (!filteredUntracked.length) {
+        return stdout;
+    }
+    const untrackedDiffs = [];
+    for (const file of filteredUntracked) {
+        const { stdout: fileDiff } = await execGitAllowNonZero(cwd, [
+            "diff",
+            "--no-color",
+            "--no-index",
+            "--",
+            "/dev/null",
+            file,
+        ]);
+        if (fileDiff) {
+            untrackedDiffs.push(fileDiff.trimEnd());
+        }
+    }
+    if (!untrackedDiffs.length) {
+        return stdout;
+    }
+    const base = stdout.trimEnd();
+    const combined = [base, ...untrackedDiffs].filter(Boolean).join("\n\n");
+    return combined ? `${combined}\n` : combined;
+}
+export async function gitListStagedFiles(cwd) {
+    const { stdout } = await execGit(cwd, [
+        "diff",
+        "--name-only",
+        "--cached",
+        "-z",
+    ]);
+    return stdout
+        .split("\0")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+export async function gitStagePaths(cwd, paths) {
+    if (!paths.length) {
+        return;
+    }
+    await execGit(cwd, ["add", "-A", "--", ...paths]);
+}
+const isMissingHeadError = (error) => {
+    if (!error || typeof error !== "object" || !("stderr" in error)) {
+        return false;
+    }
+    const record = error;
+    const message = typeof record.stderr === "string"
+        ? record.stderr
+        : record.stderr instanceof Buffer
+            ? record.stderr.toString("utf8")
+            : "";
+    return (message.includes("ambiguous argument 'HEAD'") ||
+        message.includes("bad revision 'HEAD'") ||
+        message.includes("unknown revision or path"));
+};
+export async function gitUnstagePaths(cwd, paths) {
+    if (!paths.length) {
+        return;
+    }
+    try {
+        await execGit(cwd, ["reset", "-q", "HEAD", "--", ...paths]);
+    }
+    catch (error) {
+        if (!isMissingHeadError(error)) {
+            throw error;
+        }
+        await execGit(cwd, ["rm", "-r", "--cached", "--", ...paths]);
+    }
+}
+export async function gitShowFile(cwd, ref, filePath) {
+    if (!ref) {
+        throw new Error("invalid_ref");
+    }
+    if (!filePath) {
+        throw new Error("invalid_path");
+    }
+    const { stdout } = await execGit(cwd, ["show", `${ref}:${filePath}`]);
+    return stdout;
+}
+export async function gitLog(cwd, skip = 0, limit = 50) {
+    const safeSkip = Number.isFinite(skip) && skip > 0 ? Math.floor(skip) : 0;
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 50;
+    const format = "%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%b%x1e";
+    const { stdout } = await execGit(cwd, [
+        "log",
+        `--skip=${safeSkip}`,
+        "-n",
+        `${safeLimit + 1}`,
+        `--format=${format}`,
+    ]);
+    const records = stdout
+        .split("\x1e")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const parsed = records
+        .map((line) => {
+        const [sha, shortSha, authorName, authoredAt, subject, description] = line.split("\x1f");
+        if (!sha) {
+            return null;
+        }
+        return {
+            sha,
+            shortSha: shortSha || sha.slice(0, 7),
+            authorName: authorName || "",
+            authoredAt: authoredAt || "",
+            subject: subject || "",
+            description: description || "",
+        };
+    })
+        .filter((entry) => Boolean(entry));
+    const hasMore = parsed.length > safeLimit;
+    const items = parsed.slice(0, safeLimit);
+    return {
+        items,
+        hasMore,
+        nextSkip: safeSkip + items.length,
+    };
+}
+export async function gitCommitDiff(cwd, sha) {
+    if (!sha) {
+        throw new Error("invalid_commit");
+    }
+    const { stdout } = await execGit(cwd, [
+        "show",
+        "--no-color",
+        "--no-ext-diff",
+        "--format=",
+        sha,
+    ]);
+    return stdout;
+}
+export function gitCommitDiffStream(cwd, sha) {
+    if (!sha) {
+        throw new Error("invalid_commit");
+    }
+    const child = spawn("git", ["show", "--no-color", "--no-ext-diff", "--format=", sha], { cwd });
+    return new ReadableStream({
+        start(controller) {
+            const onData = (chunk) => {
+                controller.enqueue(chunk);
+            };
+            const onError = (error) => {
+                controller.error(error);
+            };
+            const onClose = (code) => {
+                if (code && code !== 0) {
+                    controller.error(new Error("git_failed"));
+                    return;
+                }
+                controller.close();
+            };
+            child.stdout.on("data", onData);
+            child.stdout.on("error", onError);
+            child.on("error", onError);
+            child.on("close", onClose);
+        },
+        cancel() {
+            child.kill();
+        },
+    });
+}
+export async function gitCommitFiles(cwd, sha) {
+    if (!sha) {
+        throw new Error("invalid_commit");
+    }
+    const { stdout } = await execGit(cwd, [
+        "show",
+        "--name-status",
+        "--no-ext-diff",
+        "--format=",
+        sha,
+    ]);
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [rawStatus = "", ...paths] = line.split("\t");
+        const statusCode = rawStatus[0] || "";
+        const pickPath = statusCode === "R" || statusCode === "C"
+            ? paths[1] || paths[0] || ""
+            : paths[0] || "";
+        const previousPath = statusCode === "R" ? paths[0] || "" : "";
+        const status = statusCode === "A"
+            ? "added"
+            : statusCode === "D"
+                ? "deleted"
+                : statusCode === "R"
+                    ? "renamed"
+                    : statusCode === "C"
+                        ? "added"
+                        : "modified";
+        const entry = {
+            path: pickPath,
+            status,
+        };
+        if (previousPath && previousPath !== pickPath) {
+            entry.previousPath = previousPath;
+        }
+        return entry;
+    })
+        .filter((entry) => entry.path);
+}
+export async function gitCommitDiffLineEstimate(cwd, sha) {
+    if (!sha) {
+        throw new Error("invalid_commit");
+    }
+    const { stdout } = await execGit(cwd, [
+        "show",
+        "--numstat",
+        "--no-ext-diff",
+        "--format=",
+        sha,
+    ]);
+    let total = 0;
+    for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const [addRaw, delRaw] = trimmed.split("\t");
+        if (addRaw === "-" || delRaw === "-") {
+            return null;
+        }
+        const additions = Number.parseInt(addRaw || "0", 10);
+        const deletions = Number.parseInt(delRaw || "0", 10);
+        const safeAdditions = Number.isFinite(additions) ? additions : 0;
+        const safeDeletions = Number.isFinite(deletions) ? deletions : 0;
+        total += safeAdditions + safeDeletions;
+    }
+    return total;
+}
+const parseGitFileList = (value) => value.split("\0").filter((entry) => entry);
+const buildFileTree = (files) => {
+    const root = {
+        name: "",
+        path: "",
+        type: "folder",
+        children: new Map(),
+    };
+    for (const filePath of files) {
+        const normalized = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+        if (!normalized) {
+            continue;
+        }
+        const parts = normalized.split("/").filter((part) => part);
+        let current = root;
+        let currentPath = "";
+        for (const [index, part] of parts.entries()) {
+            const nextPath = currentPath ? `${currentPath}/${part}` : part;
+            const isFile = index === parts.length - 1;
+            const type = isFile ? "file" : "folder";
+            let child = current.children.get(part);
+            if (!child) {
+                child = {
+                    name: part,
+                    path: nextPath,
+                    type,
+                    children: new Map(),
+                };
+                current.children.set(part, child);
+            }
+            current = child;
+            currentPath = nextPath;
+        }
+    }
+    const toEntry = (node) => {
+        if (node.type === "file") {
+            return {
+                name: node.name,
+                path: node.path,
+                type: node.type,
+            };
+        }
+        const children = Array.from(node.children.values()).map(toEntry);
+        children.sort((a, b) => {
+            if (a.type !== b.type) {
+                return a.type === "folder" ? -1 : 1;
+            }
+            return a.name.localeCompare(b.name);
+        });
+        return {
+            name: node.name,
+            path: node.path,
+            type: node.type,
+            children,
+        };
+    };
+    return Array.from(root.children.values())
+        .map(toEntry)
+        .sort((a, b) => {
+        if (a.type !== b.type) {
+            return a.type === "folder" ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+};
+export async function gitListFileTree(cwd) {
+    const [tracked, untracked] = await Promise.all([
+        execGit(cwd, ["ls-files", "-z"]),
+        execGit(cwd, ["ls-files", "-z", "--others", "--exclude-standard"]),
+    ]);
+    const files = new Set([
+        ...parseGitFileList(tracked.stdout),
+        ...parseGitFileList(untracked.stdout),
+    ]);
+    return buildFileTree(Array.from(files));
+}
+const DEFAULT_BRANCH_PAGE_SIZE = 30;
+export async function gitListBranches(cwd, options = {}) {
+    const { stdout } = await execGit(cwd, [
+        "for-each-ref",
+        "--sort=-committerdate",
+        "--format=%(refname:short)\t%(committerdate:iso8601)",
+        "refs/heads",
+    ]);
+    let branches = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [name = "", updatedAtRaw] = line.split("\t");
+        return {
+            name,
+            updatedAt: updatedAtRaw || null,
+        };
+    });
+    // Apply filter if provided
+    if (options.filter) {
+        const filterLower = options.filter.toLowerCase();
+        branches = branches.filter((b) => b.name.toLowerCase().includes(filterLower));
+    }
+    // Apply cursor-based pagination
+    if (options.cursor) {
+        const cursorIndex = branches.findIndex((b) => b.name === options.cursor);
+        if (cursorIndex >= 0) {
+            branches = branches.slice(cursorIndex + 1);
+        }
+    }
+    // Apply limit
+    const limit = options.limit ?? DEFAULT_BRANCH_PAGE_SIZE;
+    return branches.slice(0, limit + 1); // Return one extra to detect hasMore
+}
+export async function gitListBranchesPaginated(cwd, options = {}) {
+    const limit = options.limit ?? DEFAULT_BRANCH_PAGE_SIZE;
+    const allBranches = await gitListBranches(cwd, options);
+    const hasMore = allBranches.length > limit;
+    const branches = hasMore ? allBranches.slice(0, limit) : allBranches;
+    const nextCursor = hasMore
+        ? (branches[branches.length - 1]?.name ?? null)
+        : null;
+    const currentBranch = await gitCurrentBranch(cwd);
+    const fullBranchList = await gitListBranches(cwd, {}); // Full list for default branch detection
+    const defaultBranch = await gitDefaultBranch(cwd, fullBranchList, currentBranch);
+    return {
+        current: currentBranch,
+        defaultBranch,
+        branches,
+        hasMore,
+        nextCursor,
+    };
+}
+export async function gitCurrentBranch(cwd) {
+    const { stdout } = await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    return stdout.trim();
+}
+export async function gitDefaultBranch(cwd, branches, currentBranch) {
+    try {
+        const { stdout } = await execGit(cwd, [
+            "symbolic-ref",
+            "--short",
+            "refs/remotes/origin/HEAD",
+        ]);
+        const raw = stdout.trim();
+        const parsed = raw.split("/").pop();
+        if (parsed) {
+            return parsed;
+        }
+    }
+    catch { }
+    const names = new Set(branches.map((branch) => branch.name));
+    if (names.has("main")) {
+        return "main";
+    }
+    if (names.has("master")) {
+        return "master";
+    }
+    if (currentBranch && currentBranch !== "HEAD") {
+        return currentBranch;
+    }
+    return branches[0]?.name || "";
+}
+const assertValidBranchName = async (cwd, name) => {
+    if (!name) {
+        throw new Error("invalid_branch");
+    }
+    try {
+        await execGit(cwd, ["check-ref-format", "--branch", name]);
+    }
+    catch {
+        throw new Error("invalid_branch");
+    }
+};
+const branchExists = async (cwd, name) => {
+    try {
+        await execGit(cwd, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/heads/${name}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export async function gitCheckoutBranch(cwd, name) {
+    await assertValidBranchName(cwd, name);
+    const exists = await branchExists(cwd, name);
+    if (!exists) {
+        throw new Error("branch_not_found");
+    }
+    await execGit(cwd, ["checkout", name]);
+}
+export async function gitCreateBranch(cwd, name) {
+    await assertValidBranchName(cwd, name);
+    const exists = await branchExists(cwd, name);
+    if (exists) {
+        throw new Error("branch_exists");
+    }
+    await execGit(cwd, ["checkout", "-b", name]);
+}

package/dist/http.d.ts

@@ -0,0 +1,7 @@
+export declare function withCors(response: Response): Response;
+export declare function jsonResponse(status: number, payload: unknown): Response;
+export declare function textResponse(status: number, message: string): Response;
+export declare function streamResponse(status: number, stream: ReadableStream<Uint8Array>): Response;
+export declare function optionsResponse(): Response;
+export declare function readJson(req: Request): Promise<unknown>;
+export declare function mapErrorResponse(error: unknown): Response;

package/dist/http.js

@@ -0,0 +1,98 @@
+import { log } from "./log.js";
+const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,PATCH,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+};
+export function withCors(response) {
+    const headers = new Headers(response.headers);
+    for (const [key, value] of Object.entries(CORS_HEADERS)) {
+        headers.set(key, value);
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+export function jsonResponse(status, payload) {
+    const response = new Response(JSON.stringify(payload), {
+        status,
+        headers: {
+            "Content-Type": "application/json; charset=utf-8",
+        },
+    });
+    return withCors(response);
+}
+export function textResponse(status, message) {
+    const response = new Response(message, {
+        status,
+        headers: {
+            "Content-Type": "text/plain; charset=utf-8",
+        },
+    });
+    return withCors(response);
+}
+export function streamResponse(status, stream) {
+    const response = new Response(stream, {
+        status,
+        headers: {
+            "Content-Type": "text/plain; charset=utf-8",
+        },
+    });
+    return withCors(response);
+}
+export function optionsResponse() {
+    return withCors(new Response(null, { status: 204 }));
+}
+export async function readJson(req) {
+    const text = await req.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error("invalid_json");
+    }
+}
+export function mapErrorResponse(error) {
+    if (error instanceof Error && error.message === "invalid_json") {
+        return jsonResponse(400, { error: "invalid_json" });
+    }
+    if (error instanceof Error && error.message === "not_a_directory") {
+        return jsonResponse(400, { error: "not_a_directory" });
+    }
+    if (error instanceof Error && error.message === "project_not_found") {
+        return jsonResponse(404, { error: "project_not_found" });
+    }
+    if (error instanceof Error && error.message === "project_required") {
+        return jsonResponse(400, { error: "project_required" });
+    }
+    if (error instanceof Error && error.message === "project_not_git") {
+        return jsonResponse(400, { error: "project_not_git" });
+    }
+    if (error instanceof Error && error.message === "invalid_branch") {
+        return jsonResponse(400, { error: "invalid_branch" });
+    }
+    if (error instanceof Error && error.message === "branch_exists") {
+        return jsonResponse(409, { error: "branch_exists" });
+    }
+    if (error instanceof Error && error.message === "branch_not_found") {
+        return jsonResponse(404, { error: "branch_not_found" });
+    }
+    if (error instanceof Error && error.message === "invalid_path") {
+        return jsonResponse(400, { error: "invalid_path" });
+    }
+    if (error instanceof Error && error.message === "app_server_spawn_failed") {
+        return jsonResponse(500, { error: "app_server_spawn_failed" });
+    }
+    if (error && typeof error === "object" && "code" in error) {
+        if (error.code === "ENOENT") {
+            return jsonResponse(400, { error: "invalid_path" });
+        }
+    }
+    log.error(error, "Unhandled server error");
+    return jsonResponse(500, { error: "server_error" });
+}

package/dist/index-node.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Node.js entry point for the diffact server.
+ * Uses @hono/node-server for HTTP and ws for WebSocket.
+ */
+export {};

package/dist/index-node.js

@@ -0,0 +1,51 @@
+/**
+ * Node.js entry point for the diffact server.
+ * Uses @hono/node-server for HTTP and ws for WebSocket.
+ */
+import { serve } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+import { app, hub, PORT } from "./index.js";
+import { log } from "./log.js";
+import { openBrowser } from "./open-browser.js";
+import { getStaticDir, isStaticEnabled } from "./static.js";
+// CLI flags
+const NO_OPEN = process.argv.includes("--no-open");
+// Start HTTP server
+const server = serve({
+    fetch: app.fetch,
+    port: PORT,
+});
+// Attach WebSocket server
+const wss = new WebSocketServer({ server });
+wss.on("connection", (ws) => {
+    log.info("ws open (node)");
+    const handlers = hub.open();
+    // Adapter: convert ws events to Hono-compatible events
+    const wsContext = {
+        send: (data) => ws.send(data),
+        close: () => ws.close(),
+        binaryType: "arraybuffer",
+        readyState: 1,
+        url: "",
+        protocol: "",
+    };
+    ws.on("message", (data) => {
+        const message = typeof data === "string" ? data : data.toString("utf8");
+        handlers.onMessage?.({ data: message }, wsContext);
+    });
+    ws.on("close", (code, reason) => {
+        handlers.onClose?.({ code, reason: reason.toString("utf8") }, wsContext);
+    });
+    ws.on("error", (error) => {
+        log.error({ err: error }, "ws error (node)");
+    });
+    handlers.onOpen?.({}, wsContext);
+});
+const url = `http://localhost:${PORT}`;
+log.info(`diffact server (node) listening on ${url}`);
+if (isStaticEnabled()) {
+    log.info(`serving static files from ${getStaticDir()}`);
+}
+if (!NO_OPEN && isStaticEnabled()) {
+    openBrowser(url);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Hono } from "hono";
+import { WsHub } from "./ws-hub.js";
+declare const PORT: number;
+declare const hub: WsHub;
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { app, hub, PORT };