@agentbridge1/cli 0.0.1

package/dist/git-evidence.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyEvidencePath = classifyEvidencePath;
+exports.compactEvidencePayload = compactEvidencePayload;
+exports.collectGitEvidenceFromLog = collectGitEvidenceFromLog;
+exports.collectGitEvidence = collectGitEvidence;
+const node_child_process_1 = require("node:child_process");
+const PATH_LENGTH_LIMIT = 240;
+const DEFAULT_MAX_COMMITS = 50;
+const DEFAULT_MAX_PAYLOAD_BYTES = 750 * 1024;
+const BASE_CAPS = [
+    { files: 500, coChange: 50, churn: 100 },
+    { files: 300, coChange: 25, churn: 50 },
+    { files: 150, coChange: 10, churn: 25 },
+];
+const PREFERRED_PREFIXES = [
+    "src/",
+    "app/",
+    "pages/",
+    "server/",
+    "api/",
+    "routes/",
+    "db/",
+    "prisma/",
+    "supabase/",
+    "lib/",
+    "services/",
+    "modules/",
+    "components/",
+];
+const PREFERRED_EXACT_FILES = new Set([
+    "package.json",
+    "tsconfig.json",
+    "netlify.toml",
+    "vercel.json",
+    "railway.json",
+    "render.yaml",
+    "Dockerfile",
+    "README.md",
+    "CLAUDE.md",
+]);
+const NOISY_PREFIXES = [
+    "node_modules/",
+    ".git/",
+    ".agentbridge/",
+    ".cursor/",
+    ".agents/",
+    "dist/",
+    "build/",
+    ".next/",
+    "coverage/",
+    ".turbo/",
+    ".cache/",
+    "DerivedData/",
+    "logs/",
+    "log/",
+    "tmp/",
+    "temp/",
+    ".tmp/",
+];
+const NOISY_SEGMENTS = [
+    "/node_modules/",
+    "/.git/",
+    "/.agentbridge/",
+    "/.cursor/",
+    "/.agents/",
+    "/dist/",
+    "/build/",
+    "/.next/",
+    "/coverage/",
+    "/.turbo/",
+    "/.cache/",
+    "/DerivedData/",
+    "/logs/",
+    "/log/",
+    "/tmp/",
+    "/temp/",
+    "/.tmp/",
+];
+const NOISY_LOCKFILES = new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]);
+const BINARY_MEDIA_EXTENSIONS = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".mp4",
+    ".mov",
+    ".pdf",
+    ".zip",
+    ".sqlite",
+    ".db",
+];
+function runGit(args) {
+    return (0, node_child_process_1.execFileSync)("git", args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/").replace(/^\.\/+/, "").trim();
+}
+function increment(map, key) {
+    map.set(key, (map.get(key) ?? 0) + 1);
+}
+function isNoisyDirectory(path) {
+    return (NOISY_PREFIXES.some((prefix) => path.startsWith(prefix)) ||
+        NOISY_SEGMENTS.some((segment) => path.includes(segment)));
+}
+function isNoisyXcodePath(path) {
+    return (path.includes(".xcworkspace/") ||
+        path.includes(".xcodeproj/project.xcworkspace/") ||
+        path.endsWith(".xcuserstate") ||
+        path.endsWith(".pbxuser") ||
+        path.endsWith(".mode1v3") ||
+        path.endsWith(".mode2v3") ||
+        path.endsWith(".perspectivev3"));
+}
+function isNoisyBinaryMedia(path) {
+    const lower = path.toLowerCase();
+    return BINARY_MEDIA_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function classifyEvidencePath(pathRaw) {
+    const path = normalizePath(pathRaw);
+    if (!path) {
+        return { include: false, reason: "empty_path" };
+    }
+    if (path.length > PATH_LENGTH_LIMIT) {
+        return { include: false, reason: "path_too_long" };
+    }
+    if (isNoisyDirectory(path)) {
+        return { include: false, reason: "noisy_directory" };
+    }
+    if (isNoisyXcodePath(path)) {
+        return { include: false, reason: "xcode_workspace_noise" };
+    }
+    if (NOISY_LOCKFILES.has(path)) {
+        return { include: false, reason: "lockfile_noise" };
+    }
+    if (isNoisyBinaryMedia(path)) {
+        return { include: false, reason: "binary_or_media" };
+    }
+    return { include: true };
+}
+function pathScore(path) {
+    if (PREFERRED_EXACT_FILES.has(path))
+        return 1_000;
+    const preferredIndex = PREFERRED_PREFIXES.findIndex((prefix) => path.startsWith(prefix));
+    if (preferredIndex >= 0)
+        return 500 - preferredIndex * 10;
+    return 10;
+}
+function sortPathsByPriority(paths) {
+    return Array.from(paths).sort((a, b) => {
+        const scoreDiff = pathScore(b) - pathScore(a);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return a.localeCompare(b);
+    });
+}
+function sortChurn(entries) {
+    return Array.from(entries).sort((a, b) => {
+        const commitDiff = b.commits - a.commits;
+        if (commitDiff !== 0)
+            return commitDiff;
+        const scoreDiff = pathScore(b.path) - pathScore(a.path);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return a.path.localeCompare(b.path);
+    });
+}
+function sortCoChange(entries) {
+    return Array.from(entries).sort((a, b) => {
+        const weightDiff = (b.weight ?? 0) - (a.weight ?? 0);
+        if (weightDiff !== 0)
+            return weightDiff;
+        const leftDiff = a.left.localeCompare(b.left);
+        if (leftDiff !== 0)
+            return leftDiff;
+        return a.right.localeCompare(b.right);
+    });
+}
+function compactEvidencePayload(raw, skippedByReason, commitCount, maxPayloadBytes = DEFAULT_MAX_PAYLOAD_BYTES) {
+    const rawFileSet = new Set(raw.files.map((path) => normalizePath(path)));
+    const sortedRawFiles = sortPathsByPriority(rawFileSet);
+    const sortedRawChurn = sortChurn(raw.churn.map((entry) => ({ ...entry, path: normalizePath(entry.path) })));
+    const sortedRawCoChange = sortCoChange(raw.coChange.map((entry) => ({
+        left: normalizePath(entry.left),
+        right: normalizePath(entry.right),
+        weight: entry.weight ?? 0,
+    })));
+    for (let stageIndex = 0; stageIndex < BASE_CAPS.length; stageIndex += 1) {
+        const stage = BASE_CAPS[stageIndex];
+        const selectedFiles = sortedRawFiles.slice(0, stage.files);
+        const selectedFileSet = new Set(selectedFiles);
+        const churn = sortedRawChurn
+            .filter((entry) => selectedFileSet.has(entry.path))
+            .slice(0, stage.churn);
+        const coChange = sortedRawCoChange
+            .filter((entry) => selectedFileSet.has(entry.left) && selectedFileSet.has(entry.right))
+            .slice(0, stage.coChange);
+        const payload = {
+            files: selectedFiles,
+            coChange,
+            churn,
+        };
+        const payloadBytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+        if (payloadBytes <= maxPayloadBytes) {
+            return {
+                payload,
+                report: {
+                    commitCount,
+                    beforeCounts: {
+                        files: sortedRawFiles.length,
+                        coChange: sortedRawCoChange.length,
+                        churn: sortedRawChurn.length,
+                    },
+                    afterCounts: {
+                        files: payload.files.length,
+                        coChange: payload.coChange.length,
+                        churn: payload.churn.length,
+                    },
+                    payloadBytes,
+                    skippedByReason,
+                    compactionStage: (stageIndex + 1),
+                },
+            };
+        }
+    }
+    throw new Error(`Recovery evidence payload too large after compaction (budget=${maxPayloadBytes} bytes).`);
+}
+function collectGitEvidenceFromLog(log) {
+    const filesSet = new Set();
+    const churn = new Map();
+    const pairWeight = new Map();
+    const skippedByReason = new Map();
+    let commitCount = 0;
+    const chunks = log.split("__COMMIT__").map((s) => s.trim()).filter(Boolean);
+    for (const chunk of chunks) {
+        commitCount += 1;
+        const files = chunk
+            .split("\n")
+            .map((line) => normalizePath(line))
+            .filter((line) => line.length > 0);
+        const commitFiles = new Set();
+        for (const file of files) {
+            const classification = classifyEvidencePath(file);
+            if (!classification.include) {
+                increment(skippedByReason, classification.reason ?? "filtered");
+                continue;
+            }
+            commitFiles.add(file);
+        }
+        const prioritized = sortPathsByPriority(commitFiles).slice(0, 30);
+        if (commitFiles.size > prioritized.length) {
+            increment(skippedByReason, "commit_file_cap");
+        }
+        const unique = Array.from(new Set(prioritized));
+        for (const file of unique) {
+            filesSet.add(file);
+            churn.set(file, (churn.get(file) ?? 0) + 1);
+        }
+        for (let i = 0; i < unique.length; i += 1) {
+            for (let j = i + 1; j < unique.length; j += 1) {
+                const left = unique[i];
+                const right = unique[j];
+                const key = left < right ? `${left}::${right}` : `${right}::${left}`;
+                pairWeight.set(key, (pairWeight.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    const coChange = Array.from(pairWeight.entries()).map(([key, weight]) => {
+        const [left, right] = key.split("::");
+        return { left: left, right: right, weight };
+    });
+    return compactEvidencePayload({
+        files: Array.from(filesSet),
+        coChange,
+        churn: Array.from(churn.entries()).map(([path, commits]) => ({ path, commits })),
+    }, Object.fromEntries(Array.from(skippedByReason.entries()).sort((a, b) => b[1] - a[1])), commitCount);
+}
+function collectGitEvidence(maxCommits = DEFAULT_MAX_COMMITS) {
+    const log = runGit(["log", `-${maxCommits}`, "--name-only", "--pretty=format:__COMMIT__"]);
+    return collectGitEvidenceFromLog(log);
+}

package/dist/git-status.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAgentbridgeLocalPath = isAgentbridgeLocalPath;
+exports.parseGitStatusPorcelainZ = parseGitStatusPorcelainZ;
+exports.collectChangedFilesFromStatusEntries = collectChangedFilesFromStatusEntries;
+exports.repoDirtySnapshotFromGitStatus = repoDirtySnapshotFromGitStatus;
+exports.getBranchName = getBranchName;
+exports.getDirtyWorkingTreeFiles = getDirtyWorkingTreeFiles;
+const node_child_process_1 = require("node:child_process");
+function normalizePath(path) {
+    return path.trim().replaceAll("\\", "/");
+}
+function isAgentbridgeLocalPath(path) {
+    const normalized = normalizePath(path);
+    return normalized === ".agentbridge" || normalized.startsWith(".agentbridge/");
+}
+function isRenameOrCopy(xy) {
+    return xy.includes("R") || xy.includes("C");
+}
+function parseGitStatusPorcelainZ(raw) {
+    const tokens = raw.split("\0");
+    const entries = [];
+    for (let idx = 0; idx < tokens.length; idx += 1) {
+        const token = tokens[idx];
+        if (!token || token.length < 4)
+            continue;
+        const xy = token.slice(0, 2);
+        const payload = token.slice(3);
+        if (!payload)
+            continue;
+        if (isRenameOrCopy(xy)) {
+            const originalPath = normalizePath(payload);
+            const renamedTo = normalizePath(tokens[idx + 1] ?? "");
+            if (renamedTo.length > 0) {
+                entries.push({ xy, path: renamedTo, originalPath });
+            }
+            idx += 1;
+            continue;
+        }
+        entries.push({ xy, path: normalizePath(payload) });
+    }
+    return entries;
+}
+function collectChangedFilesFromStatusEntries(entries) {
+    const files = new Set();
+    for (const entry of entries) {
+        if (entry.path && !isAgentbridgeLocalPath(entry.path)) {
+            files.add(entry.path);
+        }
+        if (entry.originalPath && !isAgentbridgeLocalPath(entry.originalPath)) {
+            files.add(entry.originalPath);
+        }
+    }
+    return [...files].sort();
+}
+function repoDirtySnapshotFromGitStatus() {
+    try {
+        const raw = (0, node_child_process_1.execSync)("git status --porcelain=v1 -z --untracked-files=all", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return collectChangedFilesFromStatusEntries(parseGitStatusPorcelainZ(raw));
+    }
+    catch {
+        return [];
+    }
+}
+function getBranchName() {
+    try {
+        return (0, node_child_process_1.execSync)("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function getDirtyWorkingTreeFiles() {
+    return repoDirtySnapshotFromGitStatus();
+}

package/dist/http.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliMissingConfigError = exports.CliHttpError = void 0;
+exports.isCliHttpError = isCliHttpError;
+exports.parseCliHttpErrorBody = parseCliHttpErrorBody;
+exports.postJson = postJson;
+exports.putJson = putJson;
+exports.getJson = getJson;
+class CliHttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "CliHttpError";
+    }
+}
+exports.CliHttpError = CliHttpError;
+function isCliHttpError(err) {
+    return err instanceof CliHttpError;
+}
+/** Safely parse the JSON body of a CliHttpError. Returns null on parse failure. */
+function parseCliHttpErrorBody(err) {
+    try {
+        const parsed = JSON.parse(err.body);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // non-JSON body
+    }
+    return null;
+}
+class CliMissingConfigError extends Error {
+    code = "CONFIG_INCOMPLETE";
+    constructor(message) {
+        super(message);
+        this.name = "CliMissingConfigError";
+    }
+}
+exports.CliMissingConfigError = CliMissingConfigError;
+function requireApiKey(ctx) {
+    if (!ctx.apiKey || ctx.apiKey.trim().length === 0) {
+        throw new CliMissingConfigError("Missing AGENTBRIDGE_API_KEY. Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.");
+    }
+}
+async function postJson(ctx, path, body) {
+    requireApiKey(ctx);
+    const url = new URL(path, ctx.apiBaseUrl).toString();
+    const debugHttp = process.env.AGENTBRIDGE_DEBUG_HTTP === "1";
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] request POST ${url}\n`);
+    }
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${ctx.apiKey}`,
+            "x-api-key": ctx.apiKey,
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        if (debugHttp) {
+            const headers = Object.fromEntries(res.headers.entries());
+            process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+            process.stderr.write(`[agentbridge:http] response headers ${JSON.stringify(headers)}\n`);
+            process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+        }
+        throw new CliHttpError(`POST ${path} failed (${res.status}): ${text || "<empty>"}`, res.status, text);
+    }
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+        process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+    }
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+async function putJson(ctx, path, body) {
+    requireApiKey(ctx);
+    const url = new URL(path, ctx.apiBaseUrl).toString();
+    const debugHttp = process.env.AGENTBRIDGE_DEBUG_HTTP === "1";
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] request PUT ${url}\n`);
+    }
+    const res = await fetch(url, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${ctx.apiKey}`,
+            "x-api-key": ctx.apiKey,
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        if (debugHttp) {
+            const headers = Object.fromEntries(res.headers.entries());
+            process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+            process.stderr.write(`[agentbridge:http] response headers ${JSON.stringify(headers)}\n`);
+            process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+        }
+        throw new CliHttpError(`PUT ${path} failed (${res.status}): ${text || "<empty>"}`, res.status, text);
+    }
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+        process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+    }
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+async function getJson(ctx, path) {
+    requireApiKey(ctx);
+    const url = new URL(path, ctx.apiBaseUrl).toString();
+    const debugHttp = process.env.AGENTBRIDGE_DEBUG_HTTP === "1";
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] request GET ${url}\n`);
+    }
+    const res = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${ctx.apiKey}`,
+            "x-api-key": ctx.apiKey,
+        },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        if (debugHttp) {
+            const headers = Object.fromEntries(res.headers.entries());
+            process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+            process.stderr.write(`[agentbridge:http] response headers ${JSON.stringify(headers)}\n`);
+            process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+        }
+        throw new CliHttpError(`GET ${path} failed (${res.status}): ${text || "<empty>"}`, res.status, text);
+    }
+    if (debugHttp) {
+        process.stderr.write(`[agentbridge:http] response status ${res.status}\n`);
+        process.stderr.write(`[agentbridge:http] response body ${text || "<empty>"}\n`);
+    }
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}