@stupify/cli 0.0.16 → 0.2.0

package/dist/model.js

@@ -1,296 +0,0 @@
-import { execFile, spawn } from "node:child_process";
-import { mkdir, open, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
-import { homedir, platform } from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-import { MODEL_REGISTRY } from "./constants.js";
-const execFileAsync = promisify(execFile);
-const LLAMA_SERVER_HOST = "127.0.0.1";
-export async function firstRunModelBootstrap(modelId, ui) {
-    const selectedModel = MODEL_REGISTRY[modelId];
-    const modelDir = path.join(cacheDir(), "models");
-    const modelPath = path.join(modelDir, selectedModel.file);
-    if (await exists(modelPath))
-        return modelPath;
-    ui.note(`No local Stupify model found.
-Stupify runs locally.
-Download this model now?
-Model: ${selectedModel.name}
-Size: ${selectedModel.size}`, "Setup", { force: true });
-    if (!(await ui.confirm("Continue?")))
-        throw new Error("Setup cancelled.");
-    await mkdir(modelDir, { recursive: true });
-    await downloadModel(modelPath, selectedModel.url, ui);
-    if (!(await exists(modelPath)))
-        throw new Error("Model download failed: file was not created.");
-    return modelPath;
-}
-export async function loadLocalModel(modelPath, modelId, profile, ui) {
-    const selectedModel = MODEL_REGISTRY[modelId];
-    const runtime = modelRuntime(profile);
-    const runningModel = await runningServerModel(runtime.baseUrl);
-    if (runningModel) {
-        if (runningModel !== modelId)
-            await stopManagedServer(runtime, ui);
-        if (runningModel === modelId) {
-            ui.info(`Using local model: ${selectedModel.name}`);
-            return {
-                id: modelId,
-                name: selectedModel.name,
-                baseUrl: runtime.baseUrl,
-                profile,
-            };
-        }
-    }
-    await ensureLlamaServerBinary();
-    await startLlamaServer(modelPath, modelId, selectedModel.name, runtime, ui);
-    const ready = ui.spinner(`Waiting for local ${profile} model`);
-    try {
-        await waitForServer(runtime.baseUrl, modelId);
-        ready.stop(`Local ${profile} model ready`);
-    }
-    catch (error) {
-        ready.error(`Local ${profile} model failed to start`);
-        throw error;
-    }
-    return {
-        id: modelId,
-        name: selectedModel.name,
-        baseUrl: runtime.baseUrl,
-        profile,
-    };
-}
-function modelRuntime(profile) {
-    const baseUrl = process.env.STUPIFY_SCOUT_LLAMA_SERVER_URL ??
-        process.env.STUPIFY_LLAMA_SERVER_URL ??
-        "http://127.0.0.1:8091";
-    return {
-        profile,
-        baseUrl,
-        port: new URL(baseUrl).port || "8091",
-        contextSize: envInteger("STUPIFY_LLAMA_CONTEXT") ?? 65_536,
-        reasoning: "off",
-        gpuLayers: envInteger("STUPIFY_LLAMA_GPU_LAYERS") ?? 999,
-        batchSize: envInteger("STUPIFY_LLAMA_BATCH") ?? 2_048,
-        ubatchSize: envInteger("STUPIFY_LLAMA_UBATCH") ?? 512,
-        parallel: envInteger("STUPIFY_LLAMA_PARALLEL") ?? 2,
-        threads: envInteger("STUPIFY_LLAMA_THREADS"),
-        threadsBatch: envInteger("STUPIFY_LLAMA_THREADS_BATCH"),
-        flashAttention: envBoolean("STUPIFY_LLAMA_FLASH_ATTN"),
-    };
-}
-async function runningServerModel(baseUrl) {
-    try {
-        const response = await fetch(`${baseUrl}/v1/models`, {
-            signal: AbortSignal.timeout(500),
-        });
-        if (!response.ok)
-            return null;
-        const body = (await response.json());
-        const id = body.data?.[0]?.id;
-        return typeof id === "string" ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function ensureLlamaServerBinary() {
-    try {
-        await execFileAsync("llama-server", ["--version"], {
-            maxBuffer: 1024 * 1024,
-        });
-    }
-    catch {
-        throw new Error(`Stupify needs llama-server for local inference.
-Install llama.cpp first:
-  brew install llama.cpp`);
-    }
-}
-async function startLlamaServer(modelPath, modelId, modelName, runtime, ui) {
-    const logDir = path.join(cacheDir(), "logs");
-    await mkdir(logDir, { recursive: true });
-    const logPath = path.join(logDir, "llama-server.log");
-    const out = await open(logPath, "a");
-    const err = await open(logPath, "a");
-    ui.step(`Starting local model server: ${modelName}`);
-    ui.info(`llama-server log: ${logPath}`);
-    const args = [
-        "-m",
-        modelPath,
-        "-a",
-        modelId,
-        "--host",
-        LLAMA_SERVER_HOST,
-        "--port",
-        runtime.port,
-        "-c",
-        String(runtime.contextSize),
-        "--reasoning",
-        runtime.reasoning,
-        "--no-warmup",
-    ];
-    if (runtime.gpuLayers !== undefined)
-        args.push("-ngl", String(runtime.gpuLayers));
-    if (runtime.batchSize !== undefined)
-        args.push("-b", String(runtime.batchSize));
-    if (runtime.ubatchSize !== undefined)
-        args.push("-ub", String(runtime.ubatchSize));
-    if (runtime.parallel !== undefined)
-        args.push("-np", String(runtime.parallel));
-    if (runtime.threads !== undefined)
-        args.push("-t", String(runtime.threads));
-    if (runtime.threadsBatch !== undefined)
-        args.push("-tb", String(runtime.threadsBatch));
-    if (runtime.flashAttention !== undefined)
-        args.push("-fa", runtime.flashAttention ? "on" : "off");
-    if (runtime.reasoningBudget !== undefined) {
-        args.push("--reasoning-budget", String(runtime.reasoningBudget));
-    }
-    const child = spawn("llama-server", args, {
-        detached: true,
-        stdio: ["ignore", out.fd, err.fd],
-    });
-    child.unref();
-    if (child.pid)
-        await writeFile(pidPath(runtime), String(child.pid));
-    await out.close();
-    await err.close();
-}
-async function stopManagedServer(runtime, ui) {
-    const pid = await managedServerPid(runtime);
-    if (!pid) {
-        const runningModel = await runningServerModel(runtime.baseUrl);
-        throw new Error(`A llama-server is already running with ${runningModel ?? "another model"}.
-Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server.`);
-    }
-    ui.step("Restarting local model server for selected model.");
-    try {
-        process.kill(pid, "SIGTERM");
-    }
-    catch {
-        await rm(pidPath(runtime), { force: true });
-        return;
-    }
-    const deadline = Date.now() + 15_000;
-    while (Date.now() < deadline) {
-        if (!(await runningServerModel(runtime.baseUrl))) {
-            await rm(pidPath(runtime), { force: true });
-            return;
-        }
-        await sleep(250);
-    }
-    throw new Error("Timed out while stopping existing llama-server.");
-}
-async function managedServerPid(runtime) {
-    try {
-        const value = Number((await readFile(pidPath(runtime), "utf8")).trim());
-        return Number.isInteger(value) && value > 0 ? value : null;
-    }
-    catch {
-        return null;
-    }
-}
-function pidPath(_runtime) {
-    return path.join(cacheDir(), "llama-server.pid");
-}
-function envInteger(name, fallback) {
-    const raw = process.env[name];
-    if (raw === undefined || raw === "")
-        return fallback;
-    const value = Number(raw);
-    return Number.isInteger(value) && value > 0 ? value : fallback;
-}
-function envBoolean(name) {
-    const raw = process.env[name];
-    if (raw === undefined || raw === "")
-        return undefined;
-    return /^(1|true|yes|on)$/i.test(raw);
-}
-async function waitForServer(baseUrl, modelId) {
-    const deadline = Date.now() + 120_000;
-    while (Date.now() < deadline) {
-        const runningModel = await runningServerModel(baseUrl);
-        if (runningModel === modelId)
-            return;
-        await sleep(500);
-    }
-    throw new Error(`llama-server did not become ready for ${modelId}.`);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function downloadModel(modelPath, modelUrl, ui) {
-    const tempPath = `${modelPath}.download`;
-    await rm(tempPath, { force: true });
-    const downloadSpinner = ui.spinner("Downloading model");
-    let downloadProgress = null;
-    try {
-        const response = await fetch(modelUrl);
-        if (!response.ok || !response.body)
-            throw new Error(`Model download failed: HTTP ${response.status}`);
-        const total = Number(response.headers.get("content-length") ?? 0);
-        let received = 0;
-        let lastPrint = 0;
-        let lastProgressBytes = 0;
-        const reader = response.body.getReader();
-        const file = await open(tempPath, "wx");
-        if (total > 0) {
-            downloadSpinner.clear();
-            downloadProgress = ui.progress("Downloading model", total);
-        }
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                received += value.byteLength;
-                await file.write(value);
-                const now = Date.now();
-                if (total > 0 && now - lastPrint > 500) {
-                    lastPrint = now;
-                    downloadProgress?.advance(received - lastProgressBytes, `${formatBytes(received)} / ${formatBytes(total)}`);
-                    lastProgressBytes = received;
-                }
-            }
-        }
-        finally {
-            await file.close();
-        }
-        if (downloadProgress && received > lastProgressBytes) {
-            downloadProgress.advance(received - lastProgressBytes, `${formatBytes(received)} / ${formatBytes(total)}`);
-        }
-        const activeProgress = downloadProgress ?? downloadSpinner;
-        activeProgress.stop(total > 0
-            ? `Downloaded ${formatBytes(received)} / ${formatBytes(total)}`
-            : "Downloaded model");
-        await rename(tempPath, modelPath);
-    }
-    catch (error) {
-        const activeProgress = downloadProgress ?? downloadSpinner;
-        activeProgress.error("Model download failed");
-        await rm(tempPath, { force: true });
-        throw error;
-    }
-}
-function cacheDir() {
-    if (process.env.STUPIFY_CACHE_DIR)
-        return process.env.STUPIFY_CACHE_DIR;
-    if (process.env.XDG_CACHE_HOME)
-        return path.join(process.env.XDG_CACHE_HOME, "stupify");
-    if (platform() === "darwin")
-        return path.join(homedir(), "Library", "Caches", "stupify");
-    if (platform() === "win32" && process.env.LOCALAPPDATA)
-        return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
-    return path.join(homedir(), ".cache", "stupify");
-}
-async function exists(filePath) {
-    try {
-        return (await stat(filePath)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function formatBytes(bytes) {
-    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-}

package/dist/prompts.d.ts

@@ -1,8 +0,0 @@
-import type { SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
-export declare function searchPrompt(input: Readonly<{
-    changeSet: SemChangeSet;
-    contexts: readonly SemContext[];
-    pack: SemContextPack;
-    patterns: readonly StupifyCheck[];
-    includeCounterReason: boolean;
-}>): string;

package/dist/prompts.js

@@ -1,89 +0,0 @@
-export function searchPrompt(input) {
-    return `You are Stupify's local search model.
-Stupify checks whether AI-assisted coding may be replacing developer judgment.
-You will receive:
-1. Semantic changed entities selected by a fast local counter.
-2. Compressed local file context from Repomix.
-3. A list of search targets. Each target has exactly one assigned pattern.
-
-Your job:
-Evaluate each target only against its assigned pattern.
-False positives are expensive.
-Only emit a match if the assigned pattern clearly applies to that exact target.
-Do not perform general code review.
-Do not suggest improvements.
-Do not choose a pattern.
-Do not apply other patterns.
-Do not report issues for unlisted targets.
-Do not emit clean results.
-Omitted target = clean.
-Return JSON only:
-{
-  "matches": [
-    {
-      "targetId": "t001",
-      "reason": "one sentence",
-      "proof": "short pointer"
-    }
-  ]
-}
-
-Rules:
-- Use only targetIds from the input.
-- Emit at most 5 matches.
-- Prefer omission over a weak match.
-- Do not quote source code.
-- Do not write generic feedback.
-- Do not emit "no evidence" or "does not apply."
-- Proof must point to concrete changed product code that implements the pattern.
-- Proof must not be a file header or start with "diff --git".
-- Do not use pattern registry text, prompt text, docs, tests, or examples as proof.
-- Do not treat pattern or prompt wording as the code being evaluated.
-- Do not treat plain conditionals, guard clauses, skip paths, or error handling as indirection.
-- For unnecessary_complexity, identify the exact new named abstraction in proof.
-- If unnecessary_complexity proof would only be a file, hunk, or conditional block, omit it.
-- If nothing clearly matches, return { "matches": [] }.
-
-SOURCE:
-${input.changeSet.label}
-
-SEARCH TARGETS:
-${input.contexts.map((context) => formatSearchTarget(context, patternForContext(context, input.patterns), input.includeCounterReason)).join("\n\n") || "(none)"}
-
-REPOMIX CONTEXT (${input.pack.filePaths.length} files, ${input.pack.totalTokens} tokens):
-${input.pack.text || "(none)"}`;
-}
-function formatSearchPattern(check) {
-    return `Pattern: ${check.id} (${check.name})
-Why this matters: ${check.why}
-Question: ${check.searchPrompt ?? check.question}
-Look for:
-${check.lookFor.map((signal) => `- ${signal}`).join("\n")}
-Ignore when:
-${check.ignoreWhen.map((signal) => `- ${signal}`).join("\n")}
-Match examples:
-${(check.searchExamples?.match ?? check.examples?.match ?? []).map((example) => `- ${example}`).join("\n")}
-Non-match examples:
-${(check.searchExamples?.nonMatch ?? check.examples?.noMatch ?? []).map((example) => `- ${example}`).join("\n")}`;
-}
-function formatSearchTarget(context, pattern, includeCounterReason) {
-    return `TARGET ${context.targetId}
-ASSIGNED ${formatSearchPattern(pattern)}
-SEM TARGET:
-ENTITY ${context.entityId}
-NAME ${context.entityName}
-KIND ${context.entityKind}
-CHANGE ${context.changeKind}
-FILE ${context.filePath ?? "(unknown)"}
-${includeCounterReason ? `COUNTER_REASON ${context.reason}` : ""}`.trim();
-}
-function patternForContext(context, patterns) {
-    return patterns.find((pattern) => pattern.id === context.checkId) ?? {
-        id: context.checkId,
-        name: context.checkId,
-        question: `Does this target match ${context.checkId}?`,
-        why: "This pattern may indicate judgment-offload.",
-        lookFor: [],
-        ignoreWhen: [],
-    };
-}

package/dist/render.d.ts

@@ -1,6 +0,0 @@
-import type { SearchCommand, SearchRunJson } from "./types.ts";
-import { type CliUi } from "./ui.ts";
-export declare function renderSearchRun(run: SearchRunJson, command: SearchCommand): string;
-export declare function renderSearchRunToUi(run: SearchRunJson, command: SearchCommand, ui: CliUi): void;
-export declare function renderSearchHumanText(run: SearchRunJson, command: SearchCommand): string;
-export declare function helpText(): string;

package/dist/render.js

@@ -1,295 +0,0 @@
-import { VERSION } from "./constants.js";
-import { format } from "./ui.js";
-export function renderSearchRun(run, command) {
-    if (command.json)
-        return JSON.stringify(run, null, 2);
-    return renderSearchHumanText(run, command);
-}
-export function renderSearchRunToUi(run, command, ui) {
-    if (command.json) {
-        ui.writeStdout(renderSearchRun(run, command));
-        return;
-    }
-    if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
-        ui.warn("Search skipped: input is too large for precise local search.");
-        ui.note(oversizedText(run, command), "Skipped");
-        ui.outro("Warn-only. Nothing blocked.");
-        return;
-    }
-    if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
-        ui.success("Search complete: no search targets found.");
-        ui.note(cleanSummaryText(run), "Summary");
-        ui.outro("No judgment-offload signals found.");
-        return;
-    }
-    if (run.matches.length === 0) {
-        ui.success("Search complete: no judgment-offload signals found.");
-        ui.note(cleanSummaryText(run), "Summary");
-        ui.outro("Warn-only. Nothing blocked.");
-        return;
-    }
-    ui.warn(format.warn(format.heading("AI SLOP DETECTED")));
-    ui.note(matchSummaryText(run, command), "Summary");
-    for (const group of groupMatchesByFile(run.matches)) {
-        ui.note(renderMatchGroup(group, run), group.filePath);
-    }
-    ui.outro(summaryLine(run));
-}
-export function renderSearchHumanText(run, command) {
-    if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
-        return `${format.heading("Search skipped")}
-${oversizedText(run, command)}
-Warn-only. Nothing blocked.`;
-    }
-    if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
-        return `${format.heading("Search complete.")}
-${format.label("Patterns:")} ${run.patterns.join(", ")}
-${format.success("No search targets found.")}`;
-    }
-    if (run.matches.length === 0) {
-        return `${format.heading("Search complete.")}
-${format.label("Patterns:")} ${run.patterns.join(", ")}
-${format.success("No judgment-offload signals found.")}`;
-    }
-    const groups = groupMatchesByFile(run.matches);
-    return `${slopHeading()}
-${matchSummaryText(run, command)}
-
-${groups.map((group) => `${format.heading(group.filePath)}
-${renderMatchGroup(group, run)}`).join("\n\n")}
-${format.muted(summaryLine(run))}`;
-}
-export function helpText() {
-    return `Stupify ${VERSION}
-
-Usage:
-  stupify
-  stupify --since "2 weeks ago"
-  stupify --commit <commit>
-  stupify --commits <count>
-  stupify --staged
-  stupify --mode search --staged
-  stupify hook install|uninstall|status
-  stupify doctor
-  stupify bench search experiments/search-bench.json
-  git diff HEAD~1..HEAD | stupify --stdin
-
-Options:
-  --staged             Search staged changes.
-  --mode <mode>        search. Search is the only analysis mode.
-  --since <date>       Search the net diff from the first commit before this git date to HEAD.
-  --commit <commit>    Search one commit as a net diff.
-  --commits <count>    Search the net diff across the last N non-merge commits.
-  --stdin              Read a git diff from stdin.
-  --debug-sem          Print sem commands and stderr.
-  --max-candidates <n> Max semantic search targets. Default: 50.
-  --max-search-input-tokens <n>
-                        Max search input tokens before skipping. Default: 12000.
-  --checks <ids>       Comma-separated pattern ids.
-  --model <id>         gemma-4-e2b, gemma-4-e4b, gemma-4-26b-a4b, qwen3-4b-magicquant, qwen2.5-coder-1.5b, qwen2.5-coder-7b, or qwen2.5-coder-32b.
-  --search-profile <path>
-                       Dev/bench-only search profile override.
-  --include-counter-reason-in-prompt
-                       Debug/bench-only: include counter reason in the model prompt.
-  --json               Print JSON only.
-
-Diagnostics:
-  stupify doctor       Check local setup, hook status, and privacy boundary.
-
-Default:
-  stupify is equivalent to stupify --since "2 weeks ago".
-
-Pipeline:
-  sem diff -> counter scout -> Repomix context -> local search model.
-
-Not included:
-  Findings audit, validators, judges, baselines, sharing, hosted server calls, GitHub, dashboards, or repo-wide crawling.
-`;
-}
-function oversizedText(run, command) {
-    const targetLimit = Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2);
-    return [
-        `Size: ~${run.stats.inputTokens ?? "unknown"} tokens`,
-        `Limit: ${run.stats.inputTokenCap ?? "unknown"} tokens`,
-        "Stupify skipped the search rather than review truncated context.",
-        `Try: ${sourceHint(command)} --max-search-input-tokens ${targetLimit}`,
-    ].join("\n");
-}
-function cleanSummaryText(run) {
-    return [
-        `Patterns: ${run.patterns.join(", ")}`,
-        run.stats.filesChanged === undefined ? null : `Diff: ${run.stats.filesChanged} files, ${run.stats.entitiesScanned ?? 0} changed entities`,
-    ].filter(Boolean).join("\n");
-}
-function matchSummaryText(run, command) {
-    const fileCount = groupMatchesByFile(run.matches).length;
-    const fileNoun = fileCount === 1 ? "file" : "files";
-    return [
-        `${run.matches.length} ${signalNoun(run.matches.length)} across ${fileCount} ${fileNoun}`,
-        `${committerLabel(run)} · ${sourceLabel(command)}`,
-        "Warn-only. Nothing blocked.",
-        "",
-        patternSummaryLine(run),
-    ].filter((line) => line !== null).join("\n");
-}
-function patternSummaryLine(run) {
-    const counts = new Map();
-    for (const match of run.matches)
-        counts.set(patternLabel(match), (counts.get(patternLabel(match)) ?? 0) + 1);
-    return [...counts.entries()].map(([patternName, count]) => `${patternName} ${count}`).join(" · ");
-}
-function groupMatchesByFile(matches) {
-    const groups = new Map();
-    for (const match of matches) {
-        const filePath = proofFilePath(match.proof);
-        const group = groups.get(filePath) ?? [];
-        group.push(match);
-        groups.set(filePath, group);
-    }
-    return [...groups.entries()].map(([filePath, groupedMatches]) => ({
-        filePath,
-        matches: groupedMatches,
-    }));
-}
-function renderMatchGroup(group, run) {
-    return group.matches.map((match, index) => {
-        const lines = [
-            matchHeadline(match, run, index),
-            match.reason,
-            match.snapshot ? `\n\`\`\`\n${match.snapshot}\n\`\`\`` : null,
-            format.muted(`${proofDetail(match.proof)}${commitSubjectSuffix(run)}`),
-            match.checkWhy ?? "This pattern may indicate judgment-offload.",
-        ];
-        return lines.filter(Boolean).join("\n");
-    }).join("\n\n");
-}
-function matchHeadline(match, run, index) {
-    return `${index + 1}. ${format.label(patternLabel(match))}: ${headlineArgs(match)} -- ${matchBlameLabel(match, run)}`;
-}
-function patternLabel(match) {
-    return titleCase(match.patternName ?? match.patternId.replace(/_/g, " "));
-}
-function headlineArgs(match) {
-    const destination = entityNameFromProof(match.proof);
-    const source = firstBacktickedToken(match.reason) ?? firstLikelySource(match.reason, destination);
-    if (source && destination && source !== destination)
-        return `${codeLabel(source)} -> ${codeLabel(destination)}`;
-    if (destination)
-        return codeLabel(destination);
-    return codeLabel(match.targetId);
-}
-function matchBlameLabel(match, run) {
-    return match.blame ? blameSummaryLabel(match.blame) : runLevelBlameLabel(run);
-}
-function blameSummaryLabel(blame) {
-    return `${blame.author} (${blame.subject})`;
-}
-function runLevelBlameLabel(run) {
-    const author = committerLabel(run);
-    const subject = firstHumanSubject(run.stats.commitSubjects ?? []);
-    return subject ? `${author} (${subject})` : author;
-}
-function commitSubjectSuffix(run) {
-    const subject = firstHumanSubject(run.stats.commitSubjects ?? []);
-    return subject ? ` · commit: ${subject}` : "";
-}
-function firstHumanSubject(subjects) {
-    return subjects.map((subject) => subject.trim()).find(Boolean);
-}
-function codeLabel(value) {
-    return `\`${value}\``;
-}
-function titleCase(value) {
-    return value.replace(/\b[a-z]/g, (letter) => letter.toUpperCase());
-}
-function entityNameFromProof(proof) {
-    const parts = proof.split("::");
-    return parts[2] || parts[1] || undefined;
-}
-function firstBacktickedToken(value) {
-    const match = /`([^`]+)`/.exec(value);
-    return cleanToken(match?.[1]);
-}
-function firstLikelySource(value, destination) {
-    const tokens = [...value.matchAll(/\b[A-Z][A-Za-z0-9_]*(?:\[[^\]]+\])?\b/g)]
-        .map((match) => cleanToken(match[0]))
-        .filter((token) => Boolean(token));
-    return tokens.find((token) => token !== destination && token !== "The");
-}
-function cleanToken(value) {
-    const token = value?.trim().replace(/[.,;:]+$/, "");
-    return token || undefined;
-}
-function proofFilePath(proof) {
-    return proof.split("::")[0] || proof;
-}
-function proofDetail(proof) {
-    const [, ...rest] = proof.split("::");
-    return rest.length > 0 ? `::${rest.join("::")}` : proof;
-}
-function sourceHint(command) {
-    if (command.kind === "staged")
-        return "--staged";
-    if (command.kind === "since")
-        return `--since "${command.since}"`;
-    if (command.kind === "commit")
-        return `--commit ${command.commit}`;
-    if (command.kind === "commits")
-        return `--commits ${command.count}`;
-    return "--stdin";
-}
-function sourceLabel(command) {
-    if (command.kind === "staged")
-        return "staged";
-    if (command.kind === "since")
-        return sinceLabel(command.since);
-    if (command.kind === "commit")
-        return `commit ${command.commit}`;
-    if (command.kind === "commits")
-        return `last ${command.count} commits`;
-    return "stdin";
-}
-function committerLabel(run) {
-    const committers = humanCommitters(run.stats.committers ?? []).map(committerDisplayName);
-    if (committers.length === 0)
-        return "unknown committer";
-    if (committers.length <= 3)
-        return committers.join(", ");
-    return `${committers.slice(0, 3).join(", ")} +${committers.length - 3} more`;
-}
-function humanCommitters(committers) {
-    const nonEmpty = committers.filter(Boolean);
-    const humans = nonEmpty.filter((committer) => !isBotCommitter(committer));
-    return humans.length > 0 ? humans : nonEmpty;
-}
-function isBotCommitter(value) {
-    return /(?:^|<)(?:github|dependabot|renovate)(?:\s|@|>)/i.test(value) ||
-        /(?:noreply@github\.com|bot@)/i.test(value);
-}
-function committerDisplayName(value) {
-    return value.replace(/\s*<[^>]+>\s*$/, "").trim() || value;
-}
-function slopHeading() {
-    const heading = "AI SLOP DETECTED";
-    return `${format.warn(format.heading(heading))}
-${format.warn("=".repeat(heading.length))}`;
-}
-function sinceLabel(since) {
-    const value = since.trim().toLowerCase();
-    if (value === "yesterday" || value === "1 day ago")
-        return "yesterday";
-    const match = /^(\d+)\s+(day|week|month|year)s?\s+ago$/.exec(value);
-    if (!match)
-        return `since ${since}`;
-    const count = Number(match[1]);
-    const unit = match[2];
-    if (count === 1)
-        return `last ${unit}`;
-    return `last ${count} ${unit}s`;
-}
-function summaryLine(run) {
-    return `${run.matches.length} ${signalNoun(run.matches.length)}. Warn-only. Nothing blocked.`;
-}
-function signalNoun(count) {
-    return count === 1 ? "signal" : "signals";
-}