diffact 0.1.0 → 0.2.0

package/dist/git.js

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

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

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

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

package/dist/index-node.js

@@ -1,51 +0,0 @@
-/**
- * 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

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