@stupify/cli 0.0.2 → 0.0.3

package/dist/checks.js

@@ -0,0 +1,131 @@
+import { checkId } from "./types.js";
+export const defaultChecks = [
+    {
+        id: checkId("duplicated_schema"),
+        name: "Duplicated schema",
+        question: "Did the change duplicate an existing type, schema, payload, or DTO shape?",
+        lookFor: [
+            "local shape mirrors existing fields and maps them one-for-one",
+            "new response, payload, schema, or DTO adds no filtering, renaming, validation, or versioning",
+        ],
+        ignoreWhen: [
+            "test fixture, mock, or intentional external contract",
+        ],
+    },
+    {
+        id: checkId("unnecessary_complexity"),
+        name: "Unnecessary complexity",
+        question: "Did the change add structure without buying clarity?",
+        lookFor: [
+            "helper, wrapper, service, layer, or extra file around simple logic without reuse",
+        ],
+        ignoreWhen: [
+            "isolates dependency, removes duplication, or improves testability",
+        ],
+    },
+    {
+        id: checkId("fake_precision_windowing"),
+        name: "Fake precision windowing",
+        question: "Did the change add fake precision around model context?",
+        lookFor: [
+            "precise-looking counts, budgets, ratios, reports, or batching fields without useful behavior",
+        ],
+        ignoreWhen: [
+            "simple fixed cap or chunking",
+            "external API requirement",
+        ],
+    },
+    {
+        id: checkId("coauthored_slop"),
+        name: "Coauthored slop",
+        question: "Does author metadata contain co-author text?",
+        lookFor: [
+            "author signal contains coauhtoried, coauthored, or co-authored text",
+        ],
+        ignoreWhen: [
+            "normal Co-authored-by trailer in the commit body",
+        ],
+    },
+    {
+        id: checkId("mega_file"),
+        name: "Mega file",
+        question: "Is a touched non-config file over 1000 LOC?",
+        lookFor: [
+            "touched non-config source file over 1000 LOC",
+        ],
+        ignoreWhen: [
+            "config, lock, generated, fixture, or vendored file",
+        ],
+    },
+    {
+        id: checkId("over_commenting"),
+        name: "Over commenting",
+        question: "Did the change add noisy comments?",
+        lookFor: [
+            "comments restate obvious code or narrate simple logic",
+        ],
+        ignoreWhen: [
+            "comment explains intent, constraint, workaround, or public API behavior",
+        ],
+    },
+    {
+        id: checkId("lint_bypass"),
+        name: "Lint bypass",
+        question: "Did the change bypass lint or type rules?",
+        lookFor: [
+            "adds suppressions, any, broad casts, or weakens lint/typecheck config",
+        ],
+        ignoreWhen: [
+            "narrow suppression with a reason",
+            "type-level test",
+            "generated file convention",
+        ],
+    },
+    {
+        id: checkId("inconsistent_patterns"),
+        name: "Inconsistent patterns",
+        question: "Does the change clash with nearby patterns?",
+        lookFor: [
+            "same job uses different naming, errors, state, imports, or layout than nearby files",
+        ],
+        ignoreWhen: [
+            "external API requires it",
+            "change follows a newer local convention",
+        ],
+    },
+    {
+        id: checkId("reinvented_utils"),
+        name: "Reinvented utils",
+        question: "Did the change recreate an existing utility?",
+        lookFor: [
+            "new helper duplicates local utility or standard library behavior",
+        ],
+        ignoreWhen: [
+            "existing utility has wrong contract",
+            "new helper is clearer as a tiny private expression",
+        ],
+    },
+    {
+        id: checkId("operator_style_mismatch"),
+        name: "Operator style mismatch",
+        question: "Does the change read unlike the surrounding code?",
+        lookFor: [
+            "generic or template-like names, abstractions, comments, or control flow clash with local style",
+        ],
+        ignoreWhen: [
+            "generated, vendored, framework-required, or newer established local style",
+        ],
+        enabledByDefault: false,
+    },
+];
+export function enabledChecks(checkIds) {
+    if (!checkIds)
+        return defaultChecks.filter((check) => check.enabledByDefault !== false);
+    const checksById = new Map(defaultChecks.map((check) => [check.id, check]));
+    return checkIds.map((id) => {
+        const check = checksById.get(id);
+        if (!check)
+            throw new Error(`Unknown check: ${id}`);
+        return check;
+    });
+}

package/dist/command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "./types.ts";
+export declare function parseCommand(argv: readonly string[]): Command;

package/dist/command.js

@@ -0,0 +1,183 @@
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.js";
+const DEFAULT_SINCE = "2 weeks ago";
+const DEFAULT_MAX_CANDIDATES = 10;
+const DEFAULT_SCOUT_MODE = "counter";
+const DEFAULT_AUDIT_CONTEXT = "repomix";
+const DEFAULT_AUDIT_PROMPT = "high_bar";
+const DEFAULT_AUDIT_BATCH_SIZE = 25;
+const DEFAULT_MAX_AUDIT_INPUT_TOKENS = 20_000;
+const DEFAULT_AUDIT_CONCURRENCY = 2;
+export function parseCommand(argv) {
+    if (argv.length === 1 && isHelp(argv[0]))
+        return { kind: "help" };
+    if (argv[0] === "experiment") {
+        const configPath = argv[1];
+        if (!configPath || argv.length > 2)
+            throw new Error("Usage: stupify experiment <config.json>");
+        return { kind: "experiment", configPath };
+    }
+    const initialState = {
+        inputMode: { kind: "since", since: DEFAULT_SINCE },
+        explicitInputMode: false,
+        checkIds: null,
+        json: false,
+        model: DEFAULT_MODEL_ID,
+        engine: "raw-diff",
+        scout: DEFAULT_SCOUT_MODE,
+        auditContext: DEFAULT_AUDIT_CONTEXT,
+        auditPrompt: DEFAULT_AUDIT_PROMPT,
+        debugSem: false,
+        debugTargets: false,
+        maxCandidates: DEFAULT_MAX_CANDIDATES,
+        auditBatchSize: DEFAULT_AUDIT_BATCH_SIZE,
+        maxAuditInputTokens: DEFAULT_MAX_AUDIT_INPUT_TOKENS,
+        auditConcurrency: DEFAULT_AUDIT_CONCURRENCY,
+    };
+    const finalState = parseFrom(0, initialState);
+    return {
+        ...finalState.inputMode,
+        checkIds: finalState.checkIds,
+        json: finalState.json,
+        model: finalState.model,
+        engine: finalState.engine,
+        scout: finalState.scout,
+        auditContext: finalState.auditContext,
+        auditPrompt: finalState.auditPrompt,
+        debugSem: finalState.debugSem,
+        debugTargets: finalState.debugTargets,
+        maxCandidates: finalState.maxCandidates,
+        auditBatchSize: finalState.auditBatchSize,
+        maxAuditInputTokens: finalState.maxAuditInputTokens,
+        auditConcurrency: finalState.auditConcurrency,
+    };
+    function parseFrom(index, state) {
+        if (index >= argv.length)
+            return state;
+        const arg = argv[index];
+        if (arg === "--stdin")
+            return parseFrom(index + 1, setInputMode(state, { kind: "stdin" }));
+        if (arg === "--json")
+            return parseFrom(index + 1, { ...state, json: true });
+        if (arg === "--debug-sem")
+            return parseFrom(index + 1, { ...state, debugSem: true });
+        if (arg === "--debug-targets")
+            return parseFrom(index + 1, { ...state, debugTargets: true });
+        if (arg === "--since") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-"))
+                throw new Error("--since requires a git date, such as \"2 weeks ago\".");
+            return parseFrom(index + 2, setInputMode(state, { kind: "since", since: value }));
+        }
+        if (arg === "--commit") {
+            const value = argv[index + 1];
+            if (!value || !isSafeCommitArg(value))
+                throw new Error("Invalid commit.");
+            return parseFrom(index + 2, setInputMode(state, { kind: "commit", commit: value }));
+        }
+        if (arg === "--commits") {
+            const value = argv[index + 1];
+            const count = Number(value);
+            if (!Number.isInteger(count) || count < 1)
+                throw new Error("--commits requires a positive integer.");
+            return parseFrom(index + 2, setInputMode(state, { kind: "commits", count }));
+        }
+        if (arg === "--checks") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-"))
+                throw new Error("--checks requires a comma-separated list.");
+            const checkIds = value.split(",").map((id) => id.trim()).filter(Boolean);
+            if (checkIds.length === 0)
+                throw new Error("--checks requires at least one check id.");
+            return parseFrom(index + 2, { ...state, checkIds });
+        }
+        if (arg === "--model") {
+            const value = argv[index + 1];
+            if (!value || !isModelId(value))
+                throw new Error(`--model must be one of: ${Object.keys(MODEL_REGISTRY).join(", ")}`);
+            return parseFrom(index + 2, { ...state, model: value });
+        }
+        if (arg === "--engine") {
+            const value = argv[index + 1];
+            if (!value || !isEngine(value))
+                throw new Error("--engine must be raw-diff or sem.");
+            return parseFrom(index + 2, { ...state, engine: value });
+        }
+        if (arg === "--scout") {
+            const value = argv[index + 1];
+            if (!value || !isScoutMode(value))
+                throw new Error("--scout must be counter or llm.");
+            return parseFrom(index + 2, { ...state, scout: value });
+        }
+        if (arg === "--audit-context") {
+            const value = argv[index + 1];
+            if (!value || !isAuditContextMode(value))
+                throw new Error("--audit-context must be none or repomix.");
+            return parseFrom(index + 2, { ...state, auditContext: value });
+        }
+        if (arg === "--audit-prompt") {
+            const value = argv[index + 1];
+            if (!value || !isAuditPromptName(value))
+                throw new Error("--audit-prompt must be strict or high_bar.");
+            return parseFrom(index + 2, { ...state, auditPrompt: value });
+        }
+        if (arg === "--max-candidates") {
+            const value = argv[index + 1];
+            const maxCandidates = Number(value);
+            if (!Number.isInteger(maxCandidates) || maxCandidates < 1) {
+                throw new Error("--max-candidates requires a positive integer.");
+            }
+            return parseFrom(index + 2, { ...state, maxCandidates });
+        }
+        if (arg === "--audit-batch-size") {
+            const value = argv[index + 1];
+            const auditBatchSize = Number(value);
+            if (!Number.isInteger(auditBatchSize) || auditBatchSize < 1) {
+                throw new Error("--audit-batch-size requires a positive integer.");
+            }
+            return parseFrom(index + 2, { ...state, auditBatchSize });
+        }
+        if (arg === "--max-audit-input-tokens") {
+            const value = argv[index + 1];
+            const maxAuditInputTokens = Number(value);
+            if (!Number.isInteger(maxAuditInputTokens) || maxAuditInputTokens < 1) {
+                throw new Error("--max-audit-input-tokens requires a positive integer.");
+            }
+            return parseFrom(index + 2, { ...state, maxAuditInputTokens });
+        }
+        if (arg === "--audit-concurrency") {
+            const value = argv[index + 1];
+            const auditConcurrency = Number(value);
+            if (!Number.isInteger(auditConcurrency) || auditConcurrency < 1) {
+                throw new Error("--audit-concurrency requires a positive integer.");
+            }
+            return parseFrom(index + 2, { ...state, auditConcurrency });
+        }
+        throw new Error(`Unknown option: ${arg}`);
+    }
+    function setInputMode(state, next) {
+        if (state.explicitInputMode)
+            throw new Error("Choose only one input mode: --since, --stdin, --commit, or --commits.");
+        return { ...state, inputMode: next, explicitInputMode: true };
+    }
+}
+function isSafeCommitArg(value) {
+    return value.length > 0 && !value.startsWith("-") && /^[A-Za-z0-9._/@~^:+-]+$/.test(value);
+}
+function isHelp(value) {
+    return value === "--help" || value === "-h";
+}
+function isModelId(value) {
+    return value in MODEL_REGISTRY;
+}
+function isEngine(value) {
+    return value === "raw-diff" || value === "sem";
+}
+function isScoutMode(value) {
+    return value === "counter" || value === "llm";
+}
+function isAuditContextMode(value) {
+    return value === "none" || value === "repomix";
+}
+function isAuditPromptName(value) {
+    return value === "strict" || value === "high_bar";
+}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION = "0.0.3";
+import type { ModelConfig, ModelId } from "./types.ts";
+export declare const DEFAULT_MODEL_ID: ModelId;
+export declare const MODEL_REGISTRY: Record<ModelId, ModelConfig>;

package/dist/constants.js

@@ -0,0 +1,53 @@
+export const VERSION = "0.0.3";
+export const DEFAULT_MODEL_ID = "gemma-4-e2b";
+export const MODEL_REGISTRY = {
+    "gemma-4-e2b": {
+        id: "gemma-4-e2b",
+        name: "Gemma 4 E2B Instruct Q4_K_M",
+        size: "about 3.1 GB",
+        file: "gemma-4-e2b-it-q4_k_m.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF/resolve/main/gemma-4-E2B-it-Q4_K_M.gguf?download=true",
+    },
+    "gemma-4-e4b": {
+        id: "gemma-4-e4b",
+        name: "Gemma 4 E4B Instruct Q4_K_M",
+        size: "about 5.0 GB",
+        file: "gemma-4-e4b-it-q4_k_m.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-Q4_K_M.gguf?download=true",
+    },
+    "gemma-4-26b-a4b": {
+        id: "gemma-4-26b-a4b",
+        name: "Gemma 4 26B A4B Instruct UD-IQ2_XXS",
+        size: "about 9.9 GB",
+        file: "gemma-4-26b-a4b-it-ud-iq2_xxs.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF/resolve/main/gemma-4-26B-A4B-it-UD-IQ2_XXS.gguf?download=true",
+    },
+    "qwen3-4b-magicquant": {
+        id: "qwen3-4b-magicquant",
+        name: "Qwen3-4B-Instruct-2507 MagicQuant Q4_K_M",
+        size: "about 2.4 GB",
+        file: "qwen3-4b-instruct-2507-magicquant-q4_k_m.gguf",
+        url: "https://huggingface.co/magiccodingman/Qwen3-4B-Instruct-2507-Unsloth-MagicQuant-v2-GGUF/resolve/main/Model-MQ-Q4_K_M_1.gguf?download=true",
+    },
+    "qwen2.5-coder-1.5b": {
+        id: "qwen2.5-coder-1.5b",
+        name: "Qwen2.5-Coder-1.5B-Instruct Q4_K_M",
+        size: "about 1.1 GB",
+        file: "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf?download=true",
+    },
+    "qwen2.5-coder-7b": {
+        id: "qwen2.5-coder-7b",
+        name: "Qwen2.5-Coder-7B-Instruct Q4_K_M",
+        size: "about 4.7 GB",
+        file: "qwen2.5-coder-7b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct-GGUF/resolve/main/qwen2.5-coder-7b-instruct-q4_k_m.gguf?download=true",
+    },
+    "qwen2.5-coder-32b": {
+        id: "qwen2.5-coder-32b",
+        name: "Qwen2.5-Coder-32B-Instruct Q4_K_M",
+        size: "about 19 GB",
+        file: "qwen2.5-coder-32b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct-GGUF/resolve/main/qwen2.5-coder-32b-instruct-q4_k_m.gguf?download=true",
+    },
+};

package/dist/counter-scout.d.ts

@@ -0,0 +1,14 @@
+import type { CheckId, SemCandidate, SemChangeSet, StupifyCheck } from "./types.ts";
+type Signal = Readonly<{
+    checkId: CheckId;
+    entityId: string;
+    reasonCode: string;
+}>;
+type SignalBucket = Readonly<{
+    checkId: CheckId;
+    total: number;
+    examples: readonly Signal[];
+}>;
+export declare function counterScoutTargets(changeSet: SemChangeSet, checks: readonly StupifyCheck[], maxTargets: number): readonly SemCandidate[];
+export declare function runSignalCounters(changeSet: SemChangeSet, checks: readonly StupifyCheck[]): readonly SignalBucket[];
+export {};

package/dist/counter-scout.js

@@ -0,0 +1,97 @@
+const MAX_COUNTER_EXAMPLES_PER_CHECK = 4;
+export function counterScoutTargets(changeSet, checks, maxTargets) {
+    const buckets = runSignalCounters(changeSet, checks);
+    const targets = [];
+    let cursor = 0;
+    while (targets.length < maxTargets && buckets.some((bucket) => cursor < bucket.examples.length)) {
+        for (const bucket of buckets) {
+            const signal = bucket.examples[cursor];
+            if (!signal)
+                continue;
+            targets.push({
+                sourceId: changeSet.id,
+                targetId: `t${String(targets.length + 1).padStart(3, "0")}`,
+                entityId: signal.entityId,
+                checkId: signal.checkId,
+                reason: signal.reasonCode,
+            });
+            if (targets.length >= maxTargets)
+                break;
+        }
+        cursor += 1;
+    }
+    return targets;
+}
+export function runSignalCounters(changeSet, checks) {
+    return checks
+        .map((check) => {
+        const signals = changeSet.changes.flatMap((change) => {
+            const reasonCode = reasonForCheck(check.id, change);
+            return reasonCode ? [{ checkId: check.id, entityId: change.entityId, reasonCode }] : [];
+        });
+        return {
+            checkId: check.id,
+            total: signals.length,
+            examples: signals.slice(0, MAX_COUNTER_EXAMPLES_PER_CHECK),
+        };
+    })
+        .filter((bucket) => bucket.total > 0);
+}
+function reasonForCheck(checkId, change) {
+    const haystack = `${change.entityName}\n${change.entityType}\n${change.filePath}\n${change.afterContent ?? ""}`.toLowerCase();
+    const changed = change.changeType === "added" || change.changeType === "modified";
+    if (!changed)
+        return null;
+    switch (checkId) {
+        case "duplicated_schema":
+            return isSchemaish(change, haystack) ? "schemaish_type_or_payload" : null;
+        case "unnecessary_complexity":
+            return /\b(helper|wrapper|service|provider|manager|factory|adapter|resolver|coordinator)\b/i.test(change.entityName)
+                ? "new_abstraction_name"
+                : null;
+        case "fake_precision_windowing":
+            return /\b(token|budget|window|batch|ratio|estimate|counter|count|limit)\b/i.test(haystack)
+                ? "precision_accounting_terms"
+                : null;
+        case "coauthored_slop":
+            return /\b(coauhtoried|coauthored|co-authored|co-authored-by)\b/i.test(haystack)
+                ? "coauthor_text"
+                : null;
+        case "mega_file":
+            return change.entityType === "chunk" && /lines\s+\d+-\d+/i.test(change.entityName)
+                ? "large_changed_chunk"
+                : null;
+        case "over_commenting":
+            return commentLines(change.afterContent) > commentLines(change.beforeContent) + 3
+                ? "comment_lines_increased"
+                : null;
+        case "lint_bypass":
+            return /(eslint-disable|biome-ignore|@ts-ignore|@ts-expect-error|\bas unknown as\b|\bany\b)/i.test(change.afterContent ?? "")
+                ? "lint_or_type_bypass_text"
+                : null;
+        case "inconsistent_patterns":
+            return /\b(manager|factory|provider|adapter|orchestrator|coordinator)\b/i.test(change.entityName)
+                ? "pattern_abstraction_name"
+                : null;
+        case "reinvented_utils":
+            return /^(format|parse|normalize|group|sort|filter|find|has|get|set|is|resolve|clamp|slug)/i.test(change.entityName)
+                ? "generic_utility_name"
+                : null;
+        case "operator_style_mismatch":
+            return /\b(manager|factory|provider|enterprise|orchestrator)\b/i.test(haystack)
+                ? "style_smell_terms"
+                : null;
+        default:
+            return null;
+    }
+}
+function isSchemaish(change, haystack) {
+    if (/^(interface|type|class)$/i.test(change.entityType))
+        return true;
+    return /\b(payload|dto|schema|response|request|input|output|result|context|asset|job|node|edge|generation)\b/i.test(haystack);
+}
+function commentLines(value) {
+    if (!value)
+        return 0;
+    return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
+}

package/dist/diff.d.ts

@@ -0,0 +1 @@
+export declare function readDiffFromStdin(): Promise<string>;

package/dist/diff.js

@@ -0,0 +1,10 @@
+import { stdin as input } from "node:process";
+export async function readDiffFromStdin() {
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (!text.trim())
+        throw new Error("No diff received on stdin.");
+    return text;
+}

package/dist/experiment.d.ts

@@ -0,0 +1 @@
+export declare function runExperiment(configPath: string): Promise<string>;