diffact 0.1.0 → 0.2.0

package/dist/list-directories.d.ts

@@ -1,8 +0,0 @@
-export declare function listDirectories(inputPath?: string | null): Promise<{
-    path: string;
-    parent: string | null;
-    entries: Array<{
-        name: string;
-        path: string;
-    }>;
-}>;

package/dist/list-directories.js

@@ -1,32 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-export async function listDirectories(inputPath) {
-    const resolved = inputPath ? path.resolve(inputPath) : os.homedir();
-    let stat;
-    try {
-        stat = await fs.stat(resolved);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                throw new Error("invalid_path");
-            }
-        }
-        throw error;
-    }
-    if (!stat.isDirectory()) {
-        throw new Error("invalid_path");
-    }
-    const dirents = await fs.readdir(resolved, { withFileTypes: true });
-    const entries = dirents
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => ({
-        name: entry.name,
-        path: path.join(resolved, entry.name),
-    }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const root = path.parse(resolved).root;
-    const parent = resolved === root ? null : path.dirname(resolved);
-    return { path: resolved, parent, entries };
-}

package/dist/log.d.ts

@@ -1,2 +0,0 @@
-import pino from "pino";
-export declare const log: pino.Logger<never, boolean>;

package/dist/log.js

@@ -1,2 +0,0 @@
-import pino from "pino";
-export const log = pino({ level: process.env.LOG_LEVEL || "info" });

package/dist/open-browser.d.ts

@@ -1,5 +0,0 @@
-/**
- * Cross-platform browser opener.
- * Works on macOS, Linux, and Windows.
- */
-export declare function openBrowser(url: string): void;

package/dist/open-browser.js

@@ -1,23 +0,0 @@
-/**
- * Cross-platform browser opener.
- * Works on macOS, Linux, and Windows.
- */
-import { runtime } from "./runtime.js";
-export function openBrowser(url) {
-    const platform = process.platform;
-    let cmd;
-    switch (platform) {
-        case "darwin":
-            cmd = ["open", url];
-            break;
-        case "win32":
-            cmd = ["cmd", "/c", "start", "", url];
-            break;
-        default:
-            // Linux and others - try xdg-open
-            cmd = ["xdg-open", url];
-            break;
-    }
-    // Fire and forget - don't wait for browser to close
-    runtime.spawn(cmd);
-}

package/dist/project-commands.d.ts

@@ -1,17 +0,0 @@
-export type CommandSource = "package.json" | "makefile" | "custom";
-export type ProjectCommand = {
-    id: string;
-    name: string;
-    label: string;
-    source: CommandSource;
-    detail?: string;
-};
-export type CommandExecutionPlan = {
-    command: string;
-    args: string[];
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    commandLine?: string;
-};
-export declare const listProjectCommands: (rootPath: string) => Promise<ProjectCommand[]>;
-export declare const resolveCommandPlan: (rootPath: string, source: CommandSource, name: string) => CommandExecutionPlan | null;

package/dist/project-commands.js

@@ -1,152 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { runtime } from "./runtime.js";
-const createCommandId = (source, name) => `${source}:${name}`;
-const readTextFile = async (filePath) => {
-    try {
-        return await fs.readFile(filePath, "utf8");
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return null;
-            }
-        }
-        throw error;
-    }
-};
-const parseMakefileTargets = (contents) => {
-    const targets = [];
-    const seen = new Set();
-    const lines = contents.split(/\r?\n/);
-    for (const line of lines) {
-        if (!line || line.startsWith("\t")) {
-            continue;
-        }
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#")) {
-            continue;
-        }
-        const match = /^([^:=]+)\s*:(?!\s*=)/.exec(trimmed);
-        if (!match) {
-            continue;
-        }
-        const names = match[1]?.trim().split(/\s+/) ?? [];
-        for (const name of names) {
-            if (!name || name.startsWith(".") || name.includes("%")) {
-                continue;
-            }
-            if (seen.has(name)) {
-                continue;
-            }
-            seen.add(name);
-            targets.push(name);
-        }
-    }
-    return targets;
-};
-const packageJsonProvider = {
-    type: "package.json",
-    listCommands: async (rootPath) => {
-        const filePath = path.join(rootPath, "package.json");
-        const contents = await readTextFile(filePath);
-        if (!contents) {
-            return [];
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(contents);
-        }
-        catch {
-            return [];
-        }
-        if (!parsed || typeof parsed !== "object") {
-            return [];
-        }
-        const scripts = parsed.scripts;
-        if (!scripts || typeof scripts !== "object") {
-            return [];
-        }
-        const commands = [];
-        for (const [name, value] of Object.entries(scripts)) {
-            const trimmedName = name.trim();
-            if (!trimmedName || typeof value !== "string") {
-                continue;
-            }
-            commands.push({
-                id: createCommandId("package.json", trimmedName),
-                name: trimmedName,
-                label: trimmedName,
-                source: "package.json",
-                detail: value.trim(),
-            });
-        }
-        return commands;
-    },
-    buildExecution: (rootPath, name) => {
-        const bunPath = runtime.which("bun");
-        if (!bunPath) {
-            return null;
-        }
-        return {
-            command: bunPath,
-            args: ["run", name],
-            cwd: rootPath,
-        };
-    },
-};
-const makefileProvider = {
-    type: "makefile",
-    listCommands: async (rootPath) => {
-        const makefileNames = ["Makefile", "makefile", "GNUmakefile"];
-        const commands = [];
-        const seen = new Set();
-        for (const name of makefileNames) {
-            const filePath = path.join(rootPath, name);
-            const contents = await readTextFile(filePath);
-            if (!contents) {
-                continue;
-            }
-            const targets = parseMakefileTargets(contents);
-            for (const target of targets) {
-                if (seen.has(target)) {
-                    continue;
-                }
-                seen.add(target);
-                commands.push({
-                    id: createCommandId("makefile", target),
-                    name: target,
-                    label: target,
-                    source: "makefile",
-                });
-            }
-        }
-        return commands;
-    },
-    buildExecution: (rootPath, name) => {
-        const makePath = runtime.which("make");
-        if (!makePath) {
-            return null;
-        }
-        return {
-            command: makePath,
-            args: [name],
-            cwd: rootPath,
-        };
-    },
-};
-const COMMAND_PROVIDERS = [
-    packageJsonProvider,
-    makefileProvider,
-];
-export const listProjectCommands = async (rootPath) => {
-    const results = await Promise.all(COMMAND_PROVIDERS.map((provider) => provider.listCommands(rootPath)));
-    return results.flat();
-};
-export const resolveCommandPlan = (rootPath, source, name) => {
-    const provider = COMMAND_PROVIDERS.find((item) => item.type === source);
-    if (!provider) {
-        return null;
-    }
-    return provider.buildExecution(rootPath, name);
-};

package/dist/project-path.d.ts

@@ -1,5 +0,0 @@
-export type ProjectRoot = {
-    rootPath: string;
-    isGit: boolean;
-};
-export declare function resolveProjectRoot(projectPath: string): Promise<ProjectRoot>;

package/dist/project-path.js

@@ -1,33 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export async function resolveProjectRoot(projectPath) {
-    const resolved = path.resolve(projectPath);
-    let stat;
-    try {
-        stat = await fs.stat(resolved);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                throw new Error("invalid_path");
-            }
-        }
-        throw error;
-    }
-    if (!stat.isDirectory()) {
-        throw new Error("not_a_directory");
-    }
-    const gitPath = path.join(resolved, ".git");
-    const isGit = await fs
-        .stat(gitPath)
-        .then(() => true)
-        .catch((error) => {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return false;
-            }
-        }
-        throw error;
-    });
-    return { rootPath: resolved, isGit };
-}

package/dist/runtime.d.ts

@@ -1,65 +0,0 @@
-/**
- * Runtime abstraction layer for Bun/Node.js compatibility.
- * Wraps Bun-specific APIs with cross-runtime implementations.
- *
- * Usage:
- *   import { runtime } from "./runtime.js";
- *   runtime.which("gh");
- *   runtime.spawn(["ls", "-la"]);
- *   runtime.file("/path/to/file");
- *   runtime.createTerminal({ cols: 80, rows: 24, data: ... });
- */
-export type RuntimeFile = {
-    stream(): ReadableStream<Uint8Array>;
-    size: number;
-    type: string;
-};
-export type TerminalOptions = {
-    cols: number;
-    rows: number;
-    data: (terminal: RuntimeTerminal, data: Uint8Array) => void;
-};
-export interface RuntimeTerminal {
-    resize(cols: number, rows: number): void;
-    write(data: string | Uint8Array): void;
-}
-export type SpawnOptions = {
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    terminal?: RuntimeTerminal;
-    onExit?: (subprocess: unknown, exitCode: number | null, signalCode: string | null, error?: Error) => void;
-};
-export type SpawnedProcess = {
-    exited: Promise<number>;
-    exitCode: number | null;
-    signalCode: NodeJS.Signals | null;
-    stdout: ReadableStream<Uint8Array> | null | undefined;
-    stderr: ReadableStream<Uint8Array> | null | undefined;
-    kill: (signal?: number | NodeJS.Signals) => void;
-};
-export declare const runtime: {
-    /** Runtime name: "bun" or "node" */
-    readonly name: "bun" | "node";
-    /** Runtime version */
-    readonly version: string;
-    /** True if running on Bun */
-    readonly isBun: boolean;
-    /** True if running on Node.js */
-    readonly isNode: boolean;
-    /**
-     * Find executable path (like `which` command)
-     */
-    readonly which: (command: string) => string | null;
-    /**
-     * Create file handle for streaming responses
-     */
-    readonly file: (filePath: string) => RuntimeFile;
-    /**
-     * Create PTY terminal
-     */
-    readonly createTerminal: (options: TerminalOptions) => RuntimeTerminal;
-    /**
-     * Spawn a process with optional terminal support
-     */
-    readonly spawn: (cmd: string[], options?: SpawnOptions) => SpawnedProcess;
-};

package/dist/runtime.js

@@ -1,235 +0,0 @@
-/**
- * Runtime abstraction layer for Bun/Node.js compatibility.
- * Wraps Bun-specific APIs with cross-runtime implementations.
- *
- * Usage:
- *   import { runtime } from "./runtime.js";
- *   runtime.which("gh");
- *   runtime.spawn(["ls", "-la"]);
- *   runtime.file("/path/to/file");
- *   runtime.createTerminal({ cols: 80, rows: 24, data: ... });
- */
-import { execSync, spawn as nodeSpawn, } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-// -----------------------------------------------------------------------------
-// Runtime detection
-// -----------------------------------------------------------------------------
-const isBun = typeof globalThis.Bun !== "undefined";
-const isNode = !isBun;
-let nodePty = null;
-function getNodePty() {
-    if (!nodePty) {
-        try {
-            nodePty = require("node-pty");
-        }
-        catch {
-            throw new Error("node-pty is required for terminal support in Node.js. Install it with: npm install node-pty");
-        }
-    }
-    return nodePty;
-}
-// -----------------------------------------------------------------------------
-// Node Terminal implementation
-// -----------------------------------------------------------------------------
-class NodeTerminal {
-    pty = null;
-    cols;
-    rows;
-    dataCallback;
-    encoder = new TextEncoder();
-    constructor(options) {
-        this.cols = options.cols;
-        this.rows = options.rows;
-        this.dataCallback = options.data;
-    }
-    ensurePty() {
-        if (this.pty)
-            return this.pty;
-        const pty = getNodePty();
-        const shell = process.env.SHELL || "/bin/sh";
-        this.pty = pty.spawn(shell, [], {
-            name: "xterm-256color",
-            cols: this.cols,
-            rows: this.rows,
-            cwd: process.cwd(),
-            env: process.env,
-        });
-        this.pty.onData((data) => {
-            this.dataCallback(this, this.encoder.encode(data));
-        });
-        return this.pty;
-    }
-    resize(cols, rows) {
-        this.cols = cols;
-        this.rows = rows;
-        this.pty?.resize(cols, rows);
-    }
-    write(data) {
-        const pty = this.ensurePty();
-        if (typeof data === "string") {
-            pty.write(data);
-        }
-        else {
-            pty.write(new TextDecoder().decode(data));
-        }
-    }
-}
-// -----------------------------------------------------------------------------
-// Runtime object - unified API
-// -----------------------------------------------------------------------------
-export const runtime = {
-    /** Runtime name: "bun" or "node" */
-    name: isBun ? "bun" : "node",
-    /** Runtime version */
-    version: isBun ? Bun.version : process.version,
-    /** True if running on Bun */
-    isBun,
-    /** True if running on Node.js */
-    isNode,
-    /**
-     * Find executable path (like `which` command)
-     */
-    which(command) {
-        if (isBun) {
-            return Bun.which(command);
-        }
-        try {
-            const result = execSync(`which ${command}`, {
-                encoding: "utf8",
-                stdio: ["pipe", "pipe", "ignore"],
-            });
-            return result.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    },
-    /**
-     * Create file handle for streaming responses
-     */
-    file(filePath) {
-        if (isBun) {
-            return Bun.file(filePath);
-        }
-        const stat = fs.statSync(filePath);
-        const ext = path.extname(filePath).toLowerCase();
-        const mimeTypes = {
-            ".html": "text/html",
-            ".css": "text/css",
-            ".js": "application/javascript",
-            ".json": "application/json",
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".gif": "image/gif",
-            ".svg": "image/svg+xml",
-            ".txt": "text/plain",
-        };
-        return {
-            stream() {
-                const nodeStream = fs.createReadStream(filePath);
-                return new ReadableStream({
-                    start(controller) {
-                        nodeStream.on("data", (chunk) => {
-                            controller.enqueue(new Uint8Array(chunk));
-                        });
-                        nodeStream.on("end", () => {
-                            controller.close();
-                        });
-                        nodeStream.on("error", (err) => {
-                            controller.error(err);
-                        });
-                    },
-                    cancel() {
-                        nodeStream.destroy();
-                    },
-                });
-            },
-            size: stat.size,
-            type: mimeTypes[ext] || "application/octet-stream",
-        };
-    },
-    /**
-     * Create PTY terminal
-     */
-    createTerminal(options) {
-        if (isBun) {
-            return new Bun.Terminal({
-                cols: options.cols,
-                rows: options.rows,
-                data: options.data,
-            });
-        }
-        return new NodeTerminal(options);
-    },
-    /**
-     * Spawn a process with optional terminal support
-     */
-    spawn(cmd, options = {}) {
-        if (isBun) {
-            const bunOnExit = options.onExit
-                ? (subprocess, exitCode, signalCode, error) => {
-                    options.onExit?.(subprocess, exitCode, signalCode !== null ? String(signalCode) : null, error);
-                }
-                : undefined;
-            const bunOptions = {
-                cwd: options.cwd,
-                env: options.env,
-                onExit: bunOnExit,
-            };
-            if (options.terminal) {
-                bunOptions.terminal = options.terminal;
-            }
-            return Bun.spawn(cmd, bunOptions);
-        }
-        const command = cmd[0];
-        if (!command) {
-            throw new Error("Command array must not be empty");
-        }
-        const child = nodeSpawn(command, cmd.slice(1), {
-            cwd: options.cwd,
-            env: options.env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let exitCode = null;
-        let signalCode = null;
-        const exited = new Promise((resolve) => {
-            child.on("exit", (code, signal) => {
-                exitCode = code;
-                signalCode = signal;
-                options.onExit?.(child, code, signal, undefined);
-                resolve(code ?? 1);
-            });
-            child.on("error", (error) => {
-                options.onExit?.(child, null, null, error);
-                resolve(1);
-            });
-        });
-        const toReadableStream = (nodeStream) => {
-            if (!nodeStream)
-                return null;
-            return new ReadableStream({
-                start(controller) {
-                    nodeStream.on("data", (chunk) => {
-                        controller.enqueue(new Uint8Array(chunk));
-                    });
-                    nodeStream.on("end", () => controller.close());
-                    nodeStream.on("error", (err) => controller.error(err));
-                },
-            });
-        };
-        return {
-            exited,
-            get exitCode() {
-                return exitCode;
-            },
-            get signalCode() {
-                return signalCode;
-            },
-            stdout: toReadableStream(child.stdout),
-            stderr: toReadableStream(child.stderr),
-            kill: (signal) => child.kill(signal),
-        };
-    },
-};

package/dist/static.d.ts

@@ -1,10 +0,0 @@
-/**
- * Static file serving for bundled frontend assets.
- * Resolves web/dist relative to the package root or source location.
- */
-export declare function isStaticEnabled(): boolean;
-export declare function getStaticDir(): string | null;
-/**
- * Serve a static file. Returns null if file not found or static serving disabled.
- */
-export declare function serveStatic(reqPath: string): Promise<Response | null>;