@stupify/cli 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,60 @@
+# @stupify/cli
+
+Local-only diagnostic CLI for checking whether AI is making you dumber.
+
+This iteration analyzes a recent net diff locally. The default engine uses
+line-sized diff batches. The sem engine uses entity-level changes, scouts
+candidate entity IDs, optionally packs selected candidate files with Repomix,
+and prints findings.
+
+```sh
+npx @stupify/cli --commit HEAD
+```
+
+```sh
+npx @stupify/cli --engine sem --commit HEAD
+```
+
+The sem engine splits findings-audit batches before local inference when the
+prompt exceeds `--max-audit-input-tokens`. Use `--audit-concurrency` to tune
+parallel local audit calls. The default sem scout uses fast deterministic
+signal counters; use `--scout llm` to compare against the older local model
+scout. Use `--audit-context none|repomix` and `--audit-prompt strict|high_bar`
+to run audit ablations without changing code.
+
+```sh
+stupify experiment experiments/bevyl-last-week.json
+stupify experiment experiments/bevyl-per-check.json
+```
+
+The experiment runner shells out to the CLI and writes local JSON plus
+manual-label markdown files under `experiments/results/`.
+
+By default, `stupify` is equivalent to `stupify --since "2 weeks ago"`.
+Commit mode analyzes `<commit>^..commit` as a net diff.
+The default registry currently runs nine concise checks for duplicated schemas,
+unnecessary complexity, fake precision, noisy metadata, mega-files,
+over-commenting, lint bypasses, inconsistent patterns, and reinvented
+utilities. `operator_style_mismatch` remains available with `--checks`, but is
+not enabled by default in the sem audit path.
+
+```sh
+npx @stupify/cli --commits 20
+```
+
+Recent-commits mode analyzes the selected range as one change. Findings are
+range-level for now, not per-commit blame.
+
+```sh
+git diff HEAD~1..HEAD | npx @stupify/cli --stdin
+```
+
+```sh
+stupify --help
+```
+
+The package is prepared for the public `@stupify` npm scope. Publishing should
+run the TypeScript build first so the executable points at `dist/stupify.js`.
+
+This iteration intentionally does not compare baselines, share data, call hosted
+LLM APIs, integrate with Ollama, or scan the whole repo.

package/dist/analysis.d.ts

@@ -0,0 +1,14 @@
+import type { LocalModel } from "./model.ts";
+import type { CandidateContext, DiffBatch, AuditPromptName, AuditReviewResult, FindingsResult, NetDiff, SemCandidate, SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
+export declare function scoutBatch(model: LocalModel, batch: DiffBatch, checks: readonly StupifyCheck[], sourceLabel: string): Promise<readonly string[]>;
+export declare function auditCandidates(model: LocalModel, diff: NetDiff, contexts: readonly CandidateContext[], checks: readonly StupifyCheck[]): Promise<FindingsResult>;
+export declare function scoutSemChanges(model: LocalModel, changeSet: SemChangeSet, checks: readonly StupifyCheck[], maxCandidates: number): Promise<readonly SemCandidate[]>;
+export declare function runFindingsAudit(model: LocalModel, changeSet: SemChangeSet, contexts: readonly SemContext[], pack: SemContextPack, checks: readonly StupifyCheck[], request?: Readonly<{
+    prompt: string;
+    schema: unknown;
+}>): Promise<AuditReviewResult>;
+export declare function findingsAuditRequest(changeSet: SemChangeSet, contexts: readonly SemContext[], pack: SemContextPack, checks: readonly StupifyCheck[], promptName?: AuditPromptName): Readonly<{
+    prompt: string;
+    schema: unknown;
+}>;
+export declare function countPromptTokens(model: LocalModel, prompt: string): Promise<number>;

package/dist/analysis.js

@@ -0,0 +1,276 @@
+import { auditPrompt, findingsAuditPrompt, scoutPrompt, semScoutPrompt } from "./prompts.js";
+import { cachedJson, fingerprint } from "./cache.js";
+export async function scoutBatch(model, batch, checks, sourceLabel) {
+    const raw = await runJsonPrompt(model, scoutPrompt(batch, checks, sourceLabel), scoutSchema(batch), 0);
+    return uncheckedCandidates(raw);
+}
+export async function auditCandidates(model, diff, contexts, checks) {
+    if (contexts.length === 0)
+        return { findings: [], summary: "No candidate regions found." };
+    const raw = await runJsonPrompt(model, auditPrompt(contexts, checks, diff.label), auditSchema(contexts), 0);
+    return uncheckedRawAuditResult(raw, diff.id);
+}
+export async function scoutSemChanges(model, changeSet, checks, maxCandidates) {
+    const raw = await runJsonPrompt(model, semScoutPrompt(changeSet, checks, maxCandidates), semScoutSchema(changeSet, checks, maxCandidates), 0);
+    return uncheckedSemCandidates(raw, changeSet.id);
+}
+export async function runFindingsAudit(model, changeSet, contexts, pack, checks, request = findingsAuditRequest(changeSet, contexts, pack, checks)) {
+    if (contexts.length === 0) {
+        return {
+            findings: [],
+            summary: "No candidate entities found.",
+            stats: { totalTargets: 0, finding: 0, clean: 0, uncertain: 0, invalid: 0 },
+        };
+    }
+    const raw = await runJsonPrompt(model, request.prompt, request.schema, 0);
+    return uncheckedFindingsAuditResult(raw, changeSet.id, contexts);
+}
+export function findingsAuditRequest(changeSet, contexts, pack, checks, promptName = "strict") {
+    return {
+        prompt: findingsAuditPrompt(contexts, pack, checks, changeSet.label, promptName),
+        schema: findingsAuditSchema(contexts),
+    };
+}
+export async function countPromptTokens(model, prompt) {
+    const cached = await cachedJson("prompt-tokens", fingerprint({
+        version: 1,
+        modelId: model.id,
+        profile: model.profile,
+        prompt,
+    }), async () => {
+        const response = await fetch(`${model.baseUrl}/tokenize`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: prompt }),
+        });
+        if (!response.ok) {
+            throw new Error(`llama-server tokenize failed: HTTP ${response.status} ${await response.text()}`);
+        }
+        const body = await response.json();
+        if (!Array.isArray(body.tokens))
+            throw new Error("llama-server tokenize returned no tokens.");
+        return { count: body.tokens.length };
+    });
+    return cached.count;
+}
+function findingsAuditSchema(contexts) {
+    const targetIds = contexts.map((context) => context.targetId);
+    const findingItem = {
+        type: "object",
+        properties: {
+            targetId: { type: "string", enum: targetIds },
+            why: { type: "string" },
+            proof: { type: "string" },
+        },
+        required: ["targetId", "why", "proof"],
+        additionalProperties: false,
+    };
+    const uncertainItem = {
+        type: "object",
+        properties: {
+            targetId: { type: "string", enum: targetIds },
+            why: { type: "string" },
+        },
+        required: ["targetId", "why"],
+        additionalProperties: false,
+    };
+    return {
+        type: "object",
+        properties: {
+            findings: {
+                type: "array",
+                items: findingItem,
+            },
+            uncertain: {
+                type: "array",
+                items: uncertainItem,
+            },
+        },
+        additionalProperties: false,
+    };
+}
+function auditSchema(contexts) {
+    return auditSchemaFromProofs(contexts.map((context) => context.pointer));
+}
+function auditSchemaFromProofs(proofs) {
+    return {
+        type: "object",
+        properties: {
+            findings: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        checkId: { type: "string" },
+                        why: { type: "string" },
+                        proof: { type: "string", enum: proofs },
+                    },
+                    required: ["checkId", "why", "proof"],
+                    additionalProperties: false,
+                },
+            },
+            summary: { type: "string" },
+        },
+        required: ["findings", "summary"],
+        additionalProperties: false,
+    };
+}
+function semScoutSchema(changeSet, checks, maxCandidates) {
+    return {
+        type: "object",
+        properties: {
+            targets: {
+                type: "array",
+                maxItems: maxCandidates,
+                items: {
+                    type: "object",
+                    properties: {
+                        entityId: { type: "string", enum: changeSet.changes.map((change) => change.entityId) },
+                        checkId: { type: "string", enum: checks.map((check) => check.id) },
+                        reason: { type: "string" },
+                    },
+                    required: ["entityId", "checkId", "reason"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ["targets"],
+        additionalProperties: false,
+    };
+}
+function scoutSchema(batch) {
+    return {
+        type: "object",
+        properties: {
+            candidates: {
+                type: "array",
+                maxItems: 3,
+                items: { type: "string", enum: batch.hunks.map((hunk) => hunk.pointer) },
+            },
+        },
+        required: ["candidates"],
+        additionalProperties: false,
+    };
+}
+function uncheckedCandidates(value) {
+    return [...(value.candidates ?? [])];
+}
+function uncheckedRawAuditResult(value, sourceId) {
+    const output = value;
+    const findings = (output.findings ?? []).map((finding) => ({
+        sourceId,
+        checkId: (finding.checkId ?? ""),
+        why: finding.why ?? "",
+        proof: finding.proof ?? "",
+    }));
+    return { findings, summary: output.summary ?? defaultSummary(findings.length) };
+}
+function uncheckedSemCandidates(value, sourceId) {
+    const output = value;
+    const rawTargets = output.targets ?? output.candidates ?? [];
+    return rawTargets.flatMap((candidate) => {
+        if (candidate.checkId) {
+            return [{
+                    sourceId,
+                    targetId: candidate.targetId ?? "",
+                    entityId: candidate.entityId ?? "",
+                    checkId: candidate.checkId,
+                    reason: candidate.reason ?? "",
+                }];
+        }
+        return (candidate.checkIds ?? []).map((checkId) => ({
+            sourceId,
+            targetId: candidate.targetId ?? "",
+            entityId: candidate.entityId ?? "",
+            checkId: checkId,
+            reason: candidate.reason ?? "",
+        }));
+    });
+}
+function uncheckedFindingsAuditResult(value, sourceId, contexts) {
+    const output = value;
+    const targetsById = new Map(contexts.map((context) => [context.targetId, context]));
+    const findings = (output.findings ?? []).map((finding) => {
+        const target = targetsById.get(finding.targetId ?? "");
+        return {
+            sourceId,
+            checkId: (target?.checkId ?? ""),
+            why: finding.why ?? "",
+            proof: finding.proof ?? "",
+        };
+    });
+    const uncertain = output.uncertain?.length ?? 0;
+    const totalTargets = contexts.length;
+    return {
+        findings,
+        summary: defaultSummary(findings.length),
+        stats: {
+            totalTargets,
+            finding: findings.length,
+            clean: Math.max(0, totalTargets - findings.length - uncertain),
+            uncertain,
+            invalid: 0,
+        },
+    };
+}
+function defaultSummary(findingCount) {
+    return findingCount === 0
+        ? "No clear judgment-offload signal found."
+        : `${findingCount} finding review${findingCount === 1 ? "" : "s"} accepted.`;
+}
+async function runJsonPrompt(model, prompt, schema, temperature) {
+    return cachedJson("model-json", fingerprint({
+        version: 1,
+        modelId: model.id,
+        profile: model.profile,
+        prompt,
+        schema,
+        temperature,
+    }), () => runJsonPromptUncached(model, prompt, schema, temperature));
+}
+async function runJsonPromptUncached(model, prompt, schema, temperature) {
+    const first = await complete(model, prompt, schema, temperature);
+    const parsed = parseJson(first);
+    if (parsed.ok)
+        return parsed.value;
+    const retry = await complete(model, `${prompt}
+
+Your previous response was not valid JSON. Return the requested JSON object only.`, schema, temperature);
+    const retryParsed = parseJson(retry);
+    if (retryParsed.ok)
+        return retryParsed.value;
+    console.error("Raw model output:");
+    console.error(retry);
+    throw new Error("Model returned invalid JSON.");
+}
+async function complete(model, prompt, schema, temperature) {
+    const response = await fetch(`${model.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            model: model.id,
+            messages: [{ role: "user", content: prompt }],
+            temperature,
+            response_format: {
+                type: "json_object",
+                schema,
+            },
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`llama-server request failed: HTTP ${response.status} ${await response.text()}`);
+    const body = await response.json();
+    const content = body.choices?.[0]?.message?.content;
+    if (typeof content !== "string")
+        throw new Error("llama-server returned no message content.");
+    return content;
+}
+function parseJson(raw) {
+    try {
+        const value = JSON.parse(raw);
+        return { ok: true, value };
+    }
+    catch {
+        return { ok: false };
+    }
+}

package/dist/batcher.d.ts

@@ -0,0 +1,3 @@
+import type { DiffBatch, DiffHunk } from "./types.ts";
+export declare function batchDiff(diff: string, linesPerBatch?: number): readonly DiffBatch[];
+export declare function allHunks(batches: readonly DiffBatch[]): readonly DiffHunk[];

package/dist/batcher.js

@@ -0,0 +1,142 @@
+const DEFAULT_BATCH_LINES = 1_000;
+export function batchDiff(diff, linesPerBatch = DEFAULT_BATCH_LINES) {
+    const hunks = parseHunks(diff).flatMap((item) => splitLargeHunk(item, linesPerBatch));
+    const initialState = {
+        batches: [],
+        current: [],
+        currentLines: 0,
+        batchNumber: 1,
+    };
+    const finalized = hunks.reduce((state, hunk) => {
+        const needsFlush = state.current.length > 0 &&
+            state.currentLines + hunk.lineCount > linesPerBatch;
+        const flushed = needsFlush ? flush(state) : state;
+        return {
+            ...flushed,
+            current: [...flushed.current, toDiffHunk(hunk, flushed.batchNumber)],
+            currentLines: flushed.currentLines + hunk.lineCount,
+        };
+    }, initialState);
+    return finalized.current.length > 0
+        ? [...finalized.batches, toBatch(finalized.batchNumber, finalized.current)]
+        : finalized.batches;
+    function flush(state) {
+        return {
+            batches: [...state.batches, toBatch(state.batchNumber, state.current)],
+            current: [],
+            currentLines: 0,
+            batchNumber: state.batchNumber + 1,
+        };
+    }
+}
+export function allHunks(batches) {
+    return batches.flatMap((batch) => batch.hunks);
+}
+function parseHunks(diff) {
+    const lines = diff.split(/\r?\n/);
+    const initialState = {
+        hunks: [],
+        filePath: "unknown",
+        fileIndex: 0,
+        hunkIndex: 0,
+        fileHeader: [],
+        hunkLines: null,
+    };
+    const finalState = lines.reduce((state, line) => {
+        const fileMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+        if (fileMatch) {
+            const flushed = flush(state);
+            return {
+                ...flushed,
+                fileIndex: flushed.fileIndex + 1,
+                hunkIndex: 0,
+                filePath: fileMatch[1],
+                fileHeader: [line],
+                hunkLines: null,
+            };
+        }
+        if (line.startsWith("@@ ")) {
+            const flushed = flush(state);
+            return {
+                ...flushed,
+                hunkIndex: flushed.hunkIndex + 1,
+                hunkLines: [...flushed.fileHeader, line],
+            };
+        }
+        if (state.hunkLines)
+            return { ...state, hunkLines: [...state.hunkLines, line] };
+        if (state.fileHeader.length > 0)
+            return { ...state, fileHeader: [...state.fileHeader, line] };
+        return state;
+    }, initialState);
+    return flush(finalState).hunks;
+    function flush(state) {
+        if (!state.hunkLines)
+            return state;
+        const fileId = `file-${pad(state.fileIndex)}`;
+        const hunkId = `hunk-${pad(state.hunkIndex)}`;
+        const text = state.hunkLines.join("\n").trimEnd();
+        const nextHunk = {
+            fileId,
+            hunkId,
+            filePath: state.filePath,
+            text,
+            lineCount: countLines(text),
+        };
+        return { ...state, hunks: [...state.hunks, nextHunk], hunkLines: null };
+    }
+}
+function splitLargeHunk(hunk, linesPerBatch) {
+    if (hunk.lineCount <= linesPerBatch)
+        return [hunk];
+    const lines = hunk.text.split(/\r?\n/);
+    const chunkCount = Math.ceil(lines.length / linesPerBatch);
+    return Array.from({ length: chunkCount }, (_, chunkIndex) => {
+        const start = chunkIndex * linesPerBatch;
+        const text = lines.slice(start, start + linesPerBatch).join("\n");
+        return {
+            ...hunk,
+            hunkId: `${hunk.hunkId}-part-${pad(chunkIndex + 1)}`,
+            text,
+            lineCount: countLines(text),
+        };
+    });
+}
+function toDiffHunk(hunk, batchNumber) {
+    const batchId = `batch-${pad(batchNumber)}`;
+    return {
+        ...hunk,
+        batchId,
+        pointer: `${batchId}:${hunk.fileId}:${hunk.hunkId}`,
+    };
+}
+function toBatch(batchNumber, hunks) {
+    const id = `batch-${pad(batchNumber)}`;
+    return {
+        id,
+        hunks,
+        text: hunks.map(formatHunkForSearch).join("\n\n"),
+    };
+}
+function formatHunkForSearch(hunk) {
+    return `POINTER ${hunk.pointer}
+FILE ${hunk.fileId}
+PATH ${hunk.filePath}
+${searchView(hunk.text)}`;
+}
+function searchView(text) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("diff --git ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("@@ ") ||
+        (line.startsWith("+") && !line.startsWith("+++")))
+        .join("\n");
+}
+function countLines(value) {
+    return value.length === 0 ? 0 : value.split(/\r?\n/).length;
+}
+function pad(value) {
+    return String(value).padStart(3, "0");
+}

package/dist/cache.d.ts

@@ -0,0 +1,2 @@
+export declare function fingerprint(value: unknown): string;
+export declare function cachedJson<T>(namespace: string, key: string, compute: () => Promise<T>): Promise<T>;

package/dist/cache.js

@@ -0,0 +1,59 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+export function fingerprint(value) {
+    const text = typeof value === "string" ? value : stableStringify(value);
+    return createHash("sha256").update(text).digest("hex");
+}
+export async function cachedJson(namespace, key, compute) {
+    const filePath = cachePath(namespace, key);
+    try {
+        const value = JSON.parse(await readFile(filePath, "utf8"));
+        console.error(`cache hit ${namespace} ${key.slice(0, 12)}`);
+        return value;
+    }
+    catch {
+        console.error(`cache miss ${namespace} ${key.slice(0, 12)}`);
+    }
+    const value = await compute();
+    await writeCache(filePath, value).catch(() => undefined);
+    return value;
+}
+function cachePath(namespace, key) {
+    return path.join(cacheRoot(), "intermediate-v1", safeNamespace(namespace), `${key}.json`);
+}
+async function writeCache(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        await writeFile(tempPath, JSON.stringify(value), "utf8");
+        await rename(tempPath, filePath);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+}
+function cacheRoot() {
+    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");
+}
+function safeNamespace(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}

package/dist/candidate-context.d.ts

@@ -0,0 +1,2 @@
+import type { CandidateContext, DiffBatch } from "./types.ts";
+export declare function candidateContexts(batches: readonly DiffBatch[], candidatePointers: readonly string[]): readonly CandidateContext[];

package/dist/candidate-context.js

@@ -0,0 +1,40 @@
+import { allHunks } from "./batcher.js";
+const MAX_CONTEXT_LINES = 80;
+export function candidateContexts(batches, candidatePointers) {
+    const hunks = allHunks(batches);
+    const byPointer = new Map(hunks.map((hunk) => [hunk.pointer, hunk]));
+    const uniquePointers = [...new Set(candidatePointers)]
+        .sort((left, right) => hunkPriority(byPointer.get(right)) - hunkPriority(byPointer.get(left)));
+    return uniquePointers.flatMap((pointer) => {
+        const hunk = byPointer.get(pointer);
+        if (!hunk)
+            return [];
+        return [{ pointer, text: formatHunk(hunk) }];
+    });
+}
+function formatHunk(hunk) {
+    return `PATH ${hunk.filePath}
+${shorten(hunk.text)}`;
+}
+function shorten(text) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length <= MAX_CONTEXT_LINES)
+        return text;
+    return `${lines.slice(0, MAX_CONTEXT_LINES).join("\n")}
+[stupify: hunk shortened after ${MAX_CONTEXT_LINES} lines]`;
+}
+function hunkPriority(hunk) {
+    if (!hunk)
+        return 0;
+    const text = hunk.text;
+    let priority = 0;
+    if (/^\+export\s+type\s|\+export\s+interface\s|\+type\s|\+interface\s/m.test(text))
+        priority += 3;
+    if (/^\+export\s+function\s|\+function\s/m.test(text))
+        priority += 2;
+    if (/\.map\(|=>\s*\(\{|=>\s*\{/m.test(text))
+        priority += 2;
+    if (/payload|schema|dto|response|result/i.test(text))
+        priority += 1;
+    return priority;
+}

package/dist/checks.d.ts

@@ -0,0 +1,3 @@
+import { type StupifyCheck } from "./types.ts";
+export declare const defaultChecks: readonly StupifyCheck[];
+export declare function enabledChecks(checkIds: readonly string[] | null): readonly StupifyCheck[];