knodin 0.7.6 → 0.8.2

package/dist/src/progressive-evidence.js

@@ -0,0 +1,477 @@
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { compareBytes } from "./compare.js";
+import { resolveStateDir } from "./engine/state-paths.js";
+const LEVELS = new Set(["locate", "outline", "evidence", "expand"]);
+const DEFAULT_BYTES = 65_536;
+const DEFAULT_TOKENS = 16_384;
+const DEFAULT_ITEMS = 100;
+const MIN_PROGRESSIVE_BYTES = 1_600;
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function normalizeFile(repo, file) {
+    if (!file || path.isAbsolute(file))
+        throw new Error("file must be a repository-relative path");
+    const root = fs.realpathSync(repo);
+    const lexical = path.resolve(root, file);
+    const relative = path.relative(root, lexical).split(path.sep).join("/");
+    if (!relative || relative === ".." || relative.startsWith("../"))
+        throw new Error("file must be a repository-relative path");
+    if (relative === ".knodin" || relative.startsWith(".knodin/"))
+        throw new Error("progressive evidence refuses internal knodin state");
+    let cursor = root;
+    for (const segment of relative.split("/")) {
+        cursor = path.join(cursor, segment);
+        if (fs.lstatSync(cursor).isSymbolicLink())
+            throw new Error("progressive evidence refuses symlinked paths");
+    }
+    const absolute = fs.realpathSync(lexical);
+    const realRelative = path.relative(root, absolute);
+    if (realRelative === ".." ||
+        realRelative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(realRelative))
+        throw new Error("file must remain within the repository");
+    const stat = fs.lstatSync(absolute);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error("progressive evidence requires a regular repository file");
+    return { absolute, relative, root };
+}
+function handleSecret(root) {
+    const stateDirectory = resolveStateDir(root);
+    if (fs.existsSync(stateDirectory) && fs.lstatSync(stateDirectory).isSymbolicLink())
+        throw new Error("progressive evidence refuses a symlinked .knodin directory");
+    fs.mkdirSync(stateDirectory, { recursive: true, mode: 0o700 });
+    const secretPath = path.join(stateDirectory, "progressive-evidence.key");
+    if (!fs.existsSync(secretPath)) {
+        try {
+            fs.writeFileSync(secretPath, randomBytes(32).toString("hex"), { flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    if (fs.lstatSync(secretPath).isSymbolicLink())
+        throw new Error("progressive evidence refuses a symlinked handle key");
+    const secret = fs.readFileSync(secretPath, "utf8");
+    if (!/^[a-f0-9]{64}$/.test(secret))
+        throw new Error("invalid progressive evidence handle key");
+    return { secret: Buffer.from(secret, "hex"), path: secretPath };
+}
+function encodeHandle(payload, secret) {
+    const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
+    const signature = createHmac("sha256", secret).update(body).digest("hex");
+    return `pev1.${body}.${signature}`;
+}
+function decodeHandle(value, secret) {
+    if (value.length > 2_048)
+        throw new Error("invalid continuation handle");
+    const [prefix, body, signature, extra] = value.split(".");
+    if (prefix !== "pev1" || !body || !signature || extra !== undefined)
+        throw new Error("invalid continuation handle");
+    const expected = createHmac("sha256", secret).update(body).digest("hex");
+    const actualBuffer = Buffer.from(signature);
+    const expectedBuffer = Buffer.from(expected);
+    if (actualBuffer.length !== expectedBuffer.length ||
+        !timingSafeEqual(actualBuffer, expectedBuffer))
+        throw new Error("invalid continuation handle");
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("invalid continuation handle");
+    }
+    if (!parsed || typeof parsed !== "object")
+        throw new Error("invalid continuation handle");
+    const candidate = parsed;
+    if (candidate.v !== 1 ||
+        typeof candidate.path !== "string" ||
+        !/^[a-f0-9]{64}$/.test(candidate.hash ?? "") ||
+        !Number.isSafeInteger(candidate.bytes) ||
+        (candidate.bytes ?? -1) < 0 ||
+        !Number.isSafeInteger(candidate.nextLine) ||
+        (candidate.nextLine ?? 0) < 1 ||
+        !Number.isSafeInteger(candidate.relatedOffset) ||
+        (candidate.relatedOffset ?? -1) < 0 ||
+        !Number.isSafeInteger(candidate.outlineOffset) ||
+        (candidate.outlineOffset ?? -1) < 0 ||
+        !LEVELS.has(candidate.nextLevel))
+        throw new Error("invalid continuation handle");
+    return candidate;
+}
+function positiveLimit(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1)
+        throw new Error(`${name} must be positive`);
+    return resolved;
+}
+function outlineSource(lines) {
+    const entries = [];
+    const declaration = /^(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|enum|const|let|var)\s+[A-Za-z_$][\w$]*/;
+    for (let index = 0; index < lines.length; index++) {
+        if (!declaration.test(lines[index] ?? ""))
+            continue;
+        let depth = 0;
+        let sawBrace = false;
+        let end = index;
+        for (let cursor = index; cursor < lines.length; cursor++) {
+            for (const char of lines[cursor] ?? "") {
+                if (char === "{") {
+                    depth++;
+                    sawBrace = true;
+                }
+                else if (char === "}")
+                    depth--;
+            }
+            end = cursor;
+            if (!sawBrace || depth <= 0)
+                break;
+        }
+        entries.push({ signature: (lines[index] ?? "").trim(), line: index + 1, endLine: end + 1 });
+    }
+    return entries;
+}
+function findRelated(root, target, lines) {
+    const names = outlineSource(lines)
+        .map(({ signature }) => /\b(?:function|class|interface|type|enum|const|let|var)\s+([\w$]+)/.exec(signature)?.[1])
+        .filter((name) => Boolean(name));
+    if (names.length === 0)
+        return [];
+    const results = [];
+    const visit = (directory) => {
+        for (const entry of fs
+            .readdirSync(directory, { withFileTypes: true })
+            // Byte order: this walk order fixes the related-evidence sequence that
+            // the integrity-checked paging handle indexes into across calls.
+            .sort((a, b) => compareBytes(a.name, b.name))) {
+            if ([".git", ".knodin", "node_modules"].includes(entry.name) || entry.isSymbolicLink())
+                continue;
+            const absolute = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                visit(absolute);
+                continue;
+            }
+            const file = path.relative(root, absolute).split(path.sep).join("/");
+            if (!entry.isFile() || file === target || !/\.(?:[cm]?[jt]sx?|py|java|cs|go|rs)$/.test(file))
+                continue;
+            for (const [index, evidence] of fs.readFileSync(absolute, "utf8").split("\n").entries()) {
+                if (!names.some((name) => new RegExp(String.raw `\b${name}\b`).test(evidence)))
+                    continue;
+                results.push({
+                    file,
+                    line: index + 1,
+                    kind: /(?:^|\/)(?:test|tests|__tests__)(?:\/|$)|\.(?:test|spec)\./.test(file)
+                        ? "test-reference"
+                        : "source-reference",
+                    evidence,
+                    confidence: "heuristic",
+                });
+            }
+        }
+    };
+    visit(root);
+    return results;
+}
+function omissionPath(request, handle, currentHash, contentBytes, relative) {
+    if (handle && handle.path !== relative)
+        return "full-renamed-baseline";
+    if (handle && (handle.hash !== currentHash || handle.bytes !== contentBytes))
+        return "full-stale-baseline";
+    if (!request.baselineHash && request.baselineBytes === undefined)
+        return "full-missing-baseline";
+    if (!request.baselineHash || request.baselineBytes === undefined)
+        return "full-incomplete-baseline";
+    if (!/^[a-f0-9]{64}$/.test(request.baselineHash))
+        return "full-hash-mismatch";
+    if (!handle)
+        return "full-unverified-baseline";
+    if (request.baselineHash !== currentHash || request.baselineBytes !== contentBytes)
+        return "full-hash-mismatch";
+    return "hash-match-omission";
+}
+/**
+ * Produce a deterministic, source-preserving view of one exact repository file.
+ * Handles are integrity checked and bind path, content hash, byte length, level,
+ * and the next source line; hash omission is allowed only against current disk
+ * content and a complete byte-length assertion.
+ */
+export function deliverProgressiveEvidence(request) {
+    if (!LEVELS.has(request.level))
+        throw new Error("invalid progressive evidence level");
+    const { absolute, relative, root } = normalizeFile(request.repo, request.file);
+    const handleKey = handleSecret(root);
+    const fileStat = fs.statSync(absolute);
+    const keyStat = fs.statSync(handleKey.path);
+    if (fileStat.dev === keyStat.dev && fileStat.ino === keyStat.ino)
+        throw new Error("progressive evidence refuses an alias of internal knodin state");
+    const content = fs.readFileSync(absolute, "utf8");
+    const contentHash = sha256(content);
+    const contentBytes = Buffer.byteLength(content);
+    const lines = content.split("\n");
+    const secret = handleKey.secret;
+    const handle = request.continuation ? decodeHandle(request.continuation, secret) : undefined;
+    const handleMatchesCurrentFile = !handle ||
+        (handle.path === relative && handle.hash === contentHash && handle.bytes === contentBytes);
+    const continuationMismatch = Boolean(handle && !handleMatchesCurrentFile);
+    const pagingHandle = handleMatchesCurrentFile ? handle : undefined;
+    if (handle && handle.nextLevel !== request.level)
+        throw new Error(`continuation requires ${handle.nextLevel}, not ${request.level}`);
+    if (pagingHandle &&
+        (request.level === "evidence" || request.level === "expand") &&
+        request.startLine !== undefined &&
+        request.startLine !== pagingHandle.nextLine)
+        throw new Error("continuation source range does not match its next line");
+    if (handle &&
+        (request.level === "locate" || request.level === "outline") &&
+        (handle.path !== relative || handle.hash !== contentHash || handle.bytes !== contentBytes))
+        throw new Error("stale or renamed continuation");
+    const byteLimit = Math.min(positiveLimit(request.byteLimit, DEFAULT_BYTES, "byteLimit"), positiveLimit(request.tokenLimit, DEFAULT_TOKENS, "tokenLimit") * 4);
+    const tokenLimit = positiveLimit(request.tokenLimit, DEFAULT_TOKENS, "tokenLimit");
+    const itemLimit = positiveLimit(request.itemLimit, DEFAULT_ITEMS, "itemLimit");
+    if (byteLimit < MIN_PROGRESSIVE_BYTES)
+        throw new Error(`progressive evidence byte/token budget must allow at least ${MIN_PROGRESSIVE_BYTES} bytes`);
+    let returned = ["identity", "location"];
+    let omitted = ["outline", "source", "related"];
+    let reason = "requested-level";
+    let more = request.level !== "expand";
+    let outline;
+    let related;
+    let source;
+    let sourceRange;
+    let nextLine = 1;
+    let totalItems = 1;
+    let pathTaken = "full";
+    let confidence = "exact";
+    const outlineOffset = pagingHandle?.outlineOffset ?? 0;
+    let outlineTotal = 0;
+    if (request.level === "outline") {
+        const fullOutline = outlineSource(lines);
+        outlineTotal = fullOutline.length;
+        outline = fullOutline.slice(outlineOffset, outlineOffset + itemLimit);
+        returned = [...returned, "outline"];
+        omitted = [
+            ...(outlineOffset + outline.length < fullOutline.length ? ["outline-tail"] : []),
+            "source",
+            "related",
+        ];
+        totalItems = fullOutline.length;
+        more = true;
+    }
+    else if (request.level === "evidence" || request.level === "expand") {
+        pathTaken = omissionPath(request, handle, contentHash, contentBytes, relative);
+        const omitForHash = request.level === "evidence" && pathTaken === "hash-match-omission";
+        if (omitForHash) {
+            returned = [...returned, "hash-verification"];
+            omitted = ["source", "related"];
+            reason = "verified-baseline-current";
+            more = true;
+        }
+        else {
+            const requestedStart = continuationMismatch
+                ? 1
+                : (request.startLine ?? pagingHandle?.nextLine ?? 1);
+            if (!Number.isSafeInteger(requestedStart) ||
+                requestedStart < 1 ||
+                requestedStart > lines.length + 1)
+                throw new Error("invalid source range");
+            if (requestedStart === lines.length + 1 && request.level === "expand") {
+                nextLine = requestedStart;
+                omitted = [];
+                more = false;
+            }
+            else {
+                const requestedEnd = continuationMismatch
+                    ? lines.length
+                    : (request.endLine ?? lines.length);
+                if (!Number.isSafeInteger(requestedEnd) || requestedEnd < requestedStart)
+                    throw new Error("invalid source range");
+                const last = Math.min(requestedEnd, lines.length, requestedStart + itemLimit - 1);
+                sourceRange = { startLine: requestedStart, endLine: last };
+                source = lines.slice(requestedStart - 1, last).join("\n");
+                returned = [...returned, "source"];
+                nextLine = last + 1;
+                more = last < lines.length || request.level !== "expand";
+                if (last < lines.length)
+                    omitted = ["source-tail", "related"];
+                else if (request.level === "expand")
+                    omitted = [];
+                else
+                    omitted = ["related"];
+                reason = last < lines.length ? "hard-item-budget" : "requested-level";
+            }
+            totalItems = lines.length;
+        }
+        if (request.level === "expand") {
+            const allRelated = findRelated(root, relative, lines);
+            const offset = pagingHandle?.relatedOffset ?? 0;
+            const sourceItems = sourceRange ? sourceRange.endLine - sourceRange.startLine + 1 : 0;
+            const remainingItems = Math.max(0, itemLimit - sourceItems);
+            related = nextLine > lines.length ? allRelated.slice(offset, offset + remainingItems) : [];
+            if (related.length > 0) {
+                returned = [...returned, "related"];
+                confidence = "heuristic";
+            }
+            if (offset + related.length < allRelated.length) {
+                omitted = [...omitted, "related-tail"];
+                more = true;
+                reason = "hard-item-budget";
+            }
+            totalItems = lines.length + allRelated.length;
+        }
+    }
+    let nextLevel;
+    if (request.level === "locate")
+        nextLevel = "outline";
+    else if (request.level === "outline")
+        nextLevel = outlineOffset + (outline?.length ?? 0) < outlineTotal ? "outline" : "evidence";
+    else
+        nextLevel = more && nextLine <= lines.length ? request.level : "expand";
+    const evidenceHandle = encodeHandle({
+        v: 1,
+        path: relative,
+        hash: contentHash,
+        bytes: contentBytes,
+        nextLine: 1,
+        nextLevel: "evidence",
+        outlineOffset: 0,
+        relatedOffset: 0,
+    }, secret);
+    const continuation = more
+        ? encodeHandle({
+            v: 1,
+            path: relative,
+            hash: contentHash,
+            bytes: contentBytes,
+            nextLine,
+            nextLevel,
+            outlineOffset: outlineOffset + (outline?.length ?? 0),
+            relatedOffset: (pagingHandle?.relatedOffset ?? 0) + (related?.length ?? 0),
+        }, secret)
+        : null;
+    const response = {
+        protocol: "knodin-progressive-evidence-v1",
+        level: request.level,
+        file: relative,
+        identity: `file_${sha256(relative).slice(0, 24)}`,
+        contentHash,
+        contentBytes,
+        returned,
+        omitted,
+        reason,
+        more,
+        continuation,
+        evidenceHandle,
+        freshness: "fresh",
+        confidence,
+        pathTaken,
+        location: { path: relative, lines: lines.length },
+        ...(outline ? { outline } : {}),
+        ...(related ? { related } : {}),
+        ...(source !== undefined ? { source, sourceRange } : {}),
+        budget: {
+            byteLimit,
+            tokenLimit,
+            itemLimit,
+            serializedBytes: 0,
+            estimatedTokens: 0,
+            returnedItems: (outline?.length ?? (sourceRange ? sourceRange.endLine - sourceRange.startLine + 1 : 1)) +
+                (related?.length ?? 0),
+            totalItems,
+            truncated: omitted.length > 0,
+        },
+    };
+    const refreshBudget = () => {
+        for (let iteration = 0; iteration < 4; iteration++) {
+            response.budget.serializedBytes = Buffer.byteLength(JSON.stringify(response));
+            response.budget.estimatedTokens = Math.ceil(response.budget.serializedBytes / 4);
+        }
+    };
+    refreshBudget();
+    while (response.budget.serializedBytes > byteLimit && response.related?.length) {
+        response.related.pop();
+        response.more = true;
+        response.reason = "hard-byte-budget";
+        if (!response.omitted.includes("related-tail"))
+            response.omitted.push("related-tail");
+        if (response.related.length === 0)
+            response.returned = response.returned.filter((v) => v !== "related");
+        response.continuation = encodeHandle({
+            v: 1,
+            path: relative,
+            hash: contentHash,
+            bytes: contentBytes,
+            nextLine,
+            nextLevel: "expand",
+            outlineOffset: 0,
+            relatedOffset: (pagingHandle?.relatedOffset ?? 0) + response.related.length,
+        }, secret);
+        response.budget.returnedItems--;
+        response.budget.truncated = true;
+        refreshBudget();
+    }
+    while (response.budget.serializedBytes > byteLimit && response.outline?.length) {
+        response.outline.pop();
+        response.more = true;
+        response.reason = "hard-byte-budget";
+        if (!response.omitted.includes("outline-tail"))
+            response.omitted.unshift("outline-tail");
+        response.continuation = encodeHandle({
+            v: 1,
+            path: relative,
+            hash: contentHash,
+            bytes: contentBytes,
+            nextLine: 1,
+            nextLevel: "outline",
+            outlineOffset: outlineOffset + response.outline.length,
+            relatedOffset: 0,
+        }, secret);
+        response.budget.returnedItems--;
+        response.budget.truncated = true;
+        refreshBudget();
+    }
+    while (response.budget.serializedBytes > byteLimit &&
+        response.sourceRange &&
+        response.sourceRange.endLine >= response.sourceRange.startLine) {
+        response.sourceRange.endLine--;
+        if (response.sourceRange.endLine < response.sourceRange.startLine) {
+            delete response.source;
+            delete response.sourceRange;
+            response.returned = response.returned.filter((value) => value !== "source");
+        }
+        else {
+            response.source = lines
+                .slice(response.sourceRange.startLine - 1, response.sourceRange.endLine)
+                .join("\n");
+        }
+        response.more = true;
+        response.reason = "hard-byte-budget";
+        if (!response.omitted.includes("source-tail"))
+            response.omitted.unshift("source-tail");
+        let resumeLine;
+        if (response.sourceRange?.endLine)
+            resumeLine = response.sourceRange.endLine + 1;
+        else if (continuationMismatch)
+            resumeLine = 1;
+        else
+            resumeLine = request.startLine ?? pagingHandle?.nextLine ?? 1;
+        response.continuation = encodeHandle({
+            v: 1,
+            path: relative,
+            hash: contentHash,
+            bytes: contentBytes,
+            nextLine: resumeLine,
+            nextLevel: request.level,
+            outlineOffset: 0,
+            relatedOffset: pagingHandle?.relatedOffset ?? 0,
+        }, secret);
+        response.budget.returnedItems = Math.max(0, response.budget.returnedItems - 1);
+        response.budget.truncated = true;
+        refreshBudget();
+    }
+    if (response.budget.serializedBytes > byteLimit)
+        throw new RangeError("progressive evidence response exceeds the hard byte/token budget");
+    return response;
+}

package/dist/src/pure-compression-cli.js

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import path from "node:path";
+import { compressOutput, compressOutputFile, } from "./output-compression.js";
+function valueAfter(argv, flag) {
+    const index = argv.indexOf(flag);
+    return index >= 0
+        ? argv[index + 1]
+        : argv.find((value) => value.startsWith(`${flag}=`))?.slice(flag.length + 1);
+}
+function boundedInteger(argv, flag, fallback, minimum, maximum) {
+    const raw = valueAfter(argv, flag);
+    const value = raw === undefined ? fallback : Number(raw);
+    if (!Number.isInteger(value) || value < minimum || value > maximum)
+        throw new Error(`knodin compress: ${flag} must be an integer from ${minimum} to ${maximum}`);
+    return value;
+}
+async function readBoundedStdin(maxBytes) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        bytes += buffer.byteLength;
+        if (bytes > maxBytes)
+            throw new Error(`knodin compress: input exceeded bounded retention limit of ${maxBytes} bytes`);
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function human(result) {
+    const omitted = result.omittedRanges.reduce((total, range) => total + range.lineCount, 0);
+    let fidelity = `Compressed output; ${omitted} line(s) omitted.`;
+    if (result.status === "insufficient-budget")
+        fidelity = `INSUFFICIENT BUDGET: ${result.fidelity.unpreservedSignals.length} detected signal line(s) are available only through retained drill-down.`;
+    else if (result.complete)
+        fidelity = "Complete output; nothing omitted.";
+    const artifact = result.artifact.retained
+        ? ` Retained artifact: ${result.artifact.id} (${result.artifact.path}).`
+        : " Raw retention disabled; omitted regions cannot be retrieved.";
+    const body = result.content ? `${result.content}\n` : "";
+    return `${body}---\n${fidelity} ${result.output.lines}/${result.input.lines} lines, ${result.output.bytes}/${result.input.bytes} bytes; exit=${result.exit.code ?? "unknown"}, signal=${result.exit.signal ?? "none"}.${artifact}\n`;
+}
+/** Handle only pure compression creation. Artifact reads/diagnosis retain the full CLI contract. */
+export async function tryPureCompressionFastPath(argv, cwd) {
+    if (argv[0] !== "compress")
+        return false;
+    const valueFlags = new Set([
+        "--strategy",
+        "--adapter",
+        "--lines",
+        "--max-output-bytes",
+        "--context",
+        "--exit-code",
+        "--signal",
+        "--max-input-bytes",
+        "--repo",
+    ]);
+    const rest = argv.slice(1);
+    const positionals = rest.filter((argument, index) => !argument.startsWith("--") && !valueFlags.has(rest[index - 1]));
+    if (["read", "diagnose", "delete"].includes(positionals[0] ?? ""))
+        return false;
+    const strategy = valueAfter(argv, "--strategy") ?? "smart";
+    if (!["smart", "head-tail", "errors-only"].includes(strategy))
+        return false;
+    const adapter = valueAfter(argv, "--adapter") ?? "auto";
+    if (![
+        "auto",
+        "generic",
+        "vitest",
+        "jest",
+        "pytest",
+        "go-test",
+        "maven",
+        "gradle",
+        "dotnet",
+        "cargo",
+    ].includes(adapter))
+        return false;
+    const repo = path.resolve(valueAfter(argv, "--repo") ?? cwd ?? process.cwd());
+    const maxInputBytes = boundedInteger(argv, "--max-input-bytes", 16 * 1024 * 1024, 1, 64 * 1024 * 1024);
+    const request = {
+        exitCode: valueAfter(argv, "--exit-code")
+            ? boundedInteger(argv, "--exit-code", 0, 0, 255)
+            : undefined,
+        signal: valueAfter(argv, "--signal"),
+        strategy: strategy,
+        adapter: adapter,
+        lineBudget: boundedInteger(argv, "--lines", 200, 1, 10_000),
+        byteBudget: boundedInteger(argv, "--max-output-bytes", 16_384, 256, 4 * 1024 * 1024),
+        contextLines: boundedInteger(argv, "--context", 1, 0, 10),
+        maxInputBytes,
+        retain: !argv.includes("--no-retain"),
+        redactSecrets: !argv.includes("--no-redact"),
+    };
+    const input = positionals[0] === "create" ? (positionals[1] ?? "-") : (positionals[0] ?? "-");
+    if (input !== "-" && !fs.existsSync(path.resolve(repo, input)))
+        return false;
+    const result = input === "-"
+        ? compressOutput(repo, { ...request, text: await readBoundedStdin(maxInputBytes) })
+        : compressOutputFile(repo, input, request);
+    process.stdout.write(argv.includes("--json") ? `${JSON.stringify(result)}\n` : human(result));
+    return true;
+}