@stupify/cli 0.0.15 → 0.1.0

package/dist/stupify.js

@@ -1,474 +0,0 @@
-#!/usr/bin/env node
-import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { countPromptTokens, runSearch, searchRequest } from "./analysis.js";
-import { searchChecks } from "./checks.js";
-import { parseCommand } from "./command.js";
-import { counterScoutPlan } from "./counter-scout.js";
-import { runDoctor } from "./doctor.js";
-import { runHookCommand } from "./hooks.js";
-import { firstRunModelBootstrap, loadLocalModel } from "./model.js";
-import { entityContextsFromChanges, emptyContextPack, repomixContextPack, repomixSearchConfig } from "./repomix-provider.js";
-import { helpText, renderSearchRun } from "./render.js";
-import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
-import { semChangeSetForCommand } from "./sem-provider.js";
-import { createTracer } from "./trace.js";
-import { createCliUi } from "./ui.js";
-export async function main(argv = process.argv.slice(2)) {
-    const startedAt = Date.now();
-    let ui = createCliUi();
-    try {
-        const command = parseCommand(argv);
-        if (command.kind === "help") {
-            ui.writeStdout(helpText());
-            return 0;
-        }
-        if (command.kind === "hook") {
-            ui.writeStdout(await runHookCommand(command.action));
-            return 0;
-        }
-        if (command.kind === "doctor") {
-            const result = await runDoctor();
-            ui.writeStdout(result.text);
-            return result.exitCode;
-        }
-        if (command.kind === "bench-search") {
-            const { runSearchBench } = await import("./search-bench.js");
-            ui.writeStdout(await runSearchBench(command.configPath));
-            return 0;
-        }
-        ui = createCliUi({ quiet: command.json });
-        const run = await runSearchCommand(command, startedAt, ui);
-        ui.writeStdout(renderSearchRun(run, command));
-        return 0;
-    }
-    catch (error) {
-        ui.error(error instanceof Error ? error.message : String(error), { force: true });
-        return 1;
-    }
-}
-export async function runSearchCommand(command, startedAt, ui = createCliUi({ quiet: command.json })) {
-    const activeSpans = new Map();
-    const t = createTracer({
-        writeLine: () => undefined,
-        onEvent: (event) => {
-            if (command.json)
-                return;
-            if (event.phase === "start") {
-                activeSpans.set(event.name, ui.spinner(formatStartStep(event.name, event.detail)));
-                return;
-            }
-            const active = activeSpans.get(event.name);
-            activeSpans.delete(event.name);
-            const message = event.phase === "error"
-                ? formatErrorStep(event.name, event.ms)
-                : formatStep(event.name, event.ms, event.count, event.detail);
-            if (!active) {
-                if (event.phase === "error")
-                    ui.error(message);
-                else
-                    ui.step(message);
-                return;
-            }
-            if (event.phase === "error")
-                active.error(message);
-            else
-                active.stop(message);
-        },
-    });
-    const profile = await loadSearchProfile(command.searchProfilePath);
-    const checks = profile ? effectiveSearchChecks(command.checkIds, profile) : searchChecks(command.checkIds);
-    const patternIds = checks.map((check) => check.id);
-    const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
-    const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
-    printRunPlan(command, patternIds, ui);
-    const { value: changeSet } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
-        count: (v) => v.summary.total,
-        detail: (v) => `${v.summary.fileCount} files`,
-    });
-    try {
-        const scoutPlan = counterScoutPlan(changeSet, checks, maxCandidates);
-        if (!command.json)
-            ui.step(scoutPlanLine(scoutPlan, changeSet.summary.total));
-        const candidates = scoutPlan.targets;
-        const contexts = entityContextsFromChanges(candidates, changeSet.changes);
-        const targetsByPattern = countTargetsByPattern(contexts);
-        const targetsPreview = previewTargets(contexts);
-        if (contexts.length === 0) {
-            return {
-                schemaVersion: "search.v1",
-                mode: "search",
-                source: command.source,
-                model: { id: command.model },
-                patterns: patternIds,
-                stats: {
-                    elapsedMs: Date.now() - startedAt,
-                    modelCalls: 0,
-                    committers: changeSet.committers,
-                    skipped: true,
-                    skipReason: "no_candidates",
-                    filesChanged: changeSet.summary.fileCount,
-                    entitiesScanned: changeSet.summary.total,
-                    candidates: 0,
-                    searchTargets: 0,
-                    repomixFiles: 0,
-                    repomixTokens: 0,
-                    profileId: profile?.id,
-                    targetsByPattern,
-                    targetsPreview,
-                },
-                matches: [],
-            };
-        }
-        const baseRepomixConfig = effectiveRepomixConfig(repomixSearchConfig(), profile);
-        const initialPack = profile?.context === "sem"
-            ? emptyContextPack()
-            : await t.trace("context.pack", () => repomixContextPack(changeSet.contextCwd, contexts, changeSet.changes, baseRepomixConfig), {
-                count: (v) => v.filePaths.length,
-                detail: (v) => `${v.totalTokens} tokens`,
-            }).then((result) => result.value);
-        const packedFiles = new Set(initialPack.filePaths);
-        const searchContexts = profile?.context === "sem"
-            ? contexts
-            : contexts.filter((context) => context.filePath && packedFiles.has(context.filePath));
-        if (!command.json)
-            ui.step(targetPlanLine(searchContexts, contexts.length, countTargetsByPattern(searchContexts)));
-        if (searchContexts.length === 0) {
-            return {
-                schemaVersion: "search.v1",
-                mode: "search",
-                source: command.source,
-                model: { id: command.model },
-                patterns: patternIds,
-                stats: {
-                    elapsedMs: Date.now() - startedAt,
-                    modelCalls: 0,
-                    committers: changeSet.committers,
-                    skipped: true,
-                    skipReason: "no_candidates",
-                    filesChanged: changeSet.summary.fileCount,
-                    entitiesScanned: changeSet.summary.total,
-                    candidates: contexts.length,
-                    searchTargets: 0,
-                    repomixFiles: initialPack.filePaths.length,
-                    repomixTokens: initialPack.totalTokens,
-                    repomixConfig: initialPack.config,
-                    profileId: profile?.id,
-                    targetsByPattern,
-                    targetsPreview,
-                },
-                matches: [],
-            };
-        }
-        const pack = profile?.context === "sem" || searchContexts.length === contexts.length
-            ? initialPack
-            : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-        const { value: batches } = await t.trace("search.batches", () => buildSearchBatches({
-            command,
-            changeSet,
-            contexts: searchContexts,
-            initialPack: pack,
-            checks,
-            profile,
-            includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
-            maxSearchInputTokens,
-            baseRepomixConfig,
-        }), {
-            startDetail: `${searchContexts.length} targets`,
-            count: (result) => result.batches.length,
-            detail: (result) => result.wasSplit
-                ? `${result.skippedTargets} oversized targets skipped`
-                : `${result.estimatedInputTokens} estimated tokens`,
-        });
-        if (batches.batches.length === 0) {
-            return {
-                schemaVersion: "search.v1",
-                mode: "search",
-                source: command.source,
-                model: { id: command.model },
-                patterns: patternIds,
-                stats: {
-                    elapsedMs: Date.now() - startedAt,
-                    modelCalls: 0,
-                    inputTokens: batches.estimatedInputTokens,
-                    inputTokenCap: maxSearchInputTokens,
-                    committers: changeSet.committers,
-                    skipped: true,
-                    skipReason: "input_too_large",
-                    filesChanged: changeSet.summary.fileCount,
-                    entitiesScanned: changeSet.summary.total,
-                    candidates: contexts.length,
-                    searchTargets: searchContexts.length,
-                    repomixFiles: pack.filePaths.length,
-                    repomixTokens: pack.totalTokens,
-                    repomixConfig: pack.config,
-                    searchBatches: 0,
-                    skippedTargets: batches.skippedTargets,
-                    profileId: profile?.id,
-                    targetsByPattern: countTargetsByPattern(searchContexts),
-                    targetsPreview: previewTargets(searchContexts),
-                },
-                matches: [],
-            };
-        }
-        if (batches.wasSplit && !command.json) {
-            ui.warn(`Search input is large; queued ${batches.batches.length} smaller batches for ${searchContexts.length} targets (${maxSearchInputTokens} token cap).`);
-            if (batches.skippedTargets > 0) {
-                ui.warn(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
-            }
-        }
-        else if (!command.json) {
-            ui.step(`Search: ${searchContexts.length} targets in ${batches.batches.length} model batch (${maxSearchInputTokens} token cap)`);
-        }
-        const modelPath = await firstRunModelBootstrap(command.model, ui);
-        const model = await loadLocalModel(modelPath, command.model, "scout", ui);
-        const matches = [];
-        let modelCalls = 0;
-        let inputTokens = 0;
-        let exactSkippedTargets = batches.skippedTargets;
-        for (const batch of batches.batches) {
-            const { value: batchInputTokens } = await t.trace("prompt.tokens", () => countPromptTokens(model, batch.request.prompt), {
-                startDetail: `${batch.contexts.length} targets`,
-                count: (tokens) => tokens,
-            });
-            inputTokens += batchInputTokens;
-            if (batchInputTokens > maxSearchInputTokens) {
-                exactSkippedTargets += batch.contexts.length;
-                if (!command.json) {
-                    ui.warn(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
-                }
-                continue;
-            }
-            const { value } = await t.trace("search.model", () => runSearch(model, batch.request), {
-                startDetail: `${batch.contexts.length} targets`,
-                count: (v) => v.length,
-            });
-            modelCalls += 1;
-            matches.push(...withCheckWhy(value, checks));
-        }
-        const uniqueMatches = dedupeMatches(matches);
-        return {
-            schemaVersion: "search.v1",
-            mode: "search",
-            source: command.source,
-            model: { id: command.model },
-            patterns: patternIds,
-            stats: {
-                elapsedMs: Date.now() - startedAt,
-                modelCalls,
-                inputTokens,
-                inputTokenCap: maxSearchInputTokens,
-                committers: changeSet.committers,
-                filesChanged: changeSet.summary.fileCount,
-                entitiesScanned: changeSet.summary.total,
-                candidates: contexts.length,
-                searchTargets: searchContexts.length,
-                repomixFiles: pack.filePaths.length,
-                repomixTokens: pack.totalTokens,
-                repomixConfig: pack.config,
-                searchBatches: batches.batches.length,
-                skippedTargets: exactSkippedTargets,
-                profileId: profile?.id,
-                targetsByPattern: countTargetsByPattern(searchContexts),
-                targetsPreview: previewTargets(searchContexts),
-            },
-            matches: uniqueMatches,
-        };
-    }
-    finally {
-        await changeSet.cleanup();
-    }
-}
-function dedupeMatches(matches) {
-    const seen = new Set();
-    return matches.filter((match) => {
-        const key = `${match.patternId}\n${match.proof.trim()}`;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    });
-}
-function withCheckWhy(matches, checks) {
-    const checksById = new Map(checks.map((check) => [check.id, check]));
-    return matches.map((match) => ({
-        ...match,
-        checkWhy: checksById.get(match.patternId)?.why,
-    }));
-}
-async function buildSearchBatches(input) {
-    const first = makeSearchBatch(input, input.contexts, input.initialPack);
-    if (first.estimatedInputTokens <= input.maxSearchInputTokens) {
-        return {
-            batches: [first],
-            estimatedInputTokens: first.estimatedInputTokens,
-            skippedTargets: 0,
-            wasSplit: false,
-        };
-    }
-    const batches = [];
-    let skippedTargets = 0;
-    let currentContexts = [];
-    let currentBatch = null;
-    for (const context of input.contexts) {
-        const candidateContexts = [...currentContexts, context];
-        const candidateBatch = await makeSearchBatchWithPack(input, candidateContexts);
-        if (candidateBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
-            currentContexts = candidateContexts;
-            currentBatch = candidateBatch;
-            continue;
-        }
-        if (currentBatch) {
-            batches.push(currentBatch);
-            currentContexts = [];
-            currentBatch = null;
-        }
-        const singleBatch = candidateContexts.length === 1
-            ? candidateBatch
-            : await makeSearchBatchWithPack(input, [context]);
-        if (singleBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
-            currentContexts = [context];
-            currentBatch = singleBatch;
-        }
-        else {
-            skippedTargets += 1;
-        }
-    }
-    if (currentBatch)
-        batches.push(currentBatch);
-    return {
-        batches,
-        estimatedInputTokens: first.estimatedInputTokens,
-        skippedTargets,
-        wasSplit: true,
-    };
-}
-function makeSearchBatch(input, contexts, pack) {
-    const request = buildSearchRequest(input.changeSet, contexts, pack, input.checks, input.profile, input.includeCounterReasonInPrompt);
-    return {
-        contexts,
-        pack,
-        request,
-        estimatedInputTokens: estimatePromptTokens(request.prompt),
-    };
-}
-async function makeSearchBatchWithPack(input, contexts) {
-    const pack = input.profile?.context === "sem"
-        ? emptyContextPack()
-        : await repomixContextPack(input.changeSet.contextCwd, contexts, input.changeSet.changes, input.baseRepomixConfig);
-    return makeSearchBatch(input, contexts, pack);
-}
-function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includeCounterReasonInPrompt) {
-    return searchRequest({
-        changeSet,
-        contexts,
-        pack,
-        patterns,
-        includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
-    });
-}
-function printRunPlan(command, patternIds, ui) {
-    if (command.json)
-        return;
-    ui.intro("stupify");
-    ui.note([
-        `Search: ${sourceLabel(command)}`,
-        `Patterns: ${patternIds.join(", ")}`,
-    ].join("\n"), "Run");
-}
-function formatStartStep(name, detail) {
-    if (name === "entity.diff")
-        return "Diff: running sem over the selected git range";
-    if (name === "context.pack")
-        return "Context: packing selected target files with Repomix";
-    if (name === "search.batches")
-        return `Search: preparing token-bounded model batches${detail ? ` for ${detail}` : ""}`;
-    if (name === "prompt.tokens")
-        return `Tokens: counting search prompt${detail ? ` for ${detail}` : ""}`;
-    if (name === "search.model")
-        return `Model: searching selected target/check pairs${detail ? ` (${detail})` : ""}`;
-    return `${name}: working`;
-}
-function formatStep(name, ms, count, detail) {
-    if (name === "entity.diff")
-        return `Diff: ${detail ?? "changed files"}, ${count ?? 0} changed entities (${ms}ms)`;
-    if (name === "context.pack")
-        return `Context: ${count ?? 0} files, ${detail ?? "0 tokens"} (${ms}ms)`;
-    if (name === "search.batches")
-        return `Search: ${count ?? 0} model batches, ${detail ?? "0 estimated tokens"} (${ms}ms)`;
-    if (name === "prompt.tokens")
-        return `Tokens: ${count ?? 0} prompt tokens (${ms}ms)`;
-    if (name === "search.model")
-        return `Model: ${count ?? 0} matches (${ms}ms)`;
-    return `${name}: ${ms}ms`;
-}
-function formatErrorStep(name, ms) {
-    if (name === "entity.diff")
-        return `Diff failed after ${ms}ms`;
-    if (name === "context.pack")
-        return `Context packing failed after ${ms}ms`;
-    if (name === "search.batches")
-        return `Search batch preparation failed after ${ms}ms`;
-    if (name === "prompt.tokens")
-        return `Token counting failed after ${ms}ms`;
-    if (name === "search.model")
-        return `Model search failed after ${ms}ms`;
-    return `${name} failed after ${ms}ms`;
-}
-function scoutPlanLine(plan, entitiesScanned) {
-    if (plan.targets.length === 0) {
-        return `Scout: deterministic counters scanned ${entitiesScanned} entities; no target/check pairs selected`;
-    }
-    return [
-        `Scout: deterministic counters scanned ${entitiesScanned} entities`,
-        `${plan.totalSignals} counter signals`,
-        `selected ${plan.targets.length}/${plan.totalSignals} target/check pairs (cap ${plan.maxTargets}, not exhaustive)`,
-    ].join("; ");
-}
-function targetPlanLine(searchContexts, selectedTargets, targetsByPattern) {
-    const retained = searchContexts.length === selectedTargets
-        ? `${searchContexts.length} selected targets`
-        : `${searchContexts.length}/${selectedTargets} selected targets retained after context packing`;
-    return `Targets: model will inspect ${retained}; ${formatCounts(targetsByPattern)}`;
-}
-function formatCounts(counts) {
-    const entries = Object.entries(counts).filter(([, count]) => count > 0);
-    if (entries.length === 0)
-        return "no target/check pairs";
-    return entries.map(([id, count]) => `${id}=${count}`).join(", ");
-}
-function sourceLabel(command) {
-    if (command.kind === "since")
-        return `since ${command.since}`;
-    if (command.kind === "commit")
-        return `commit ${command.commit}`;
-    if (command.kind === "commits")
-        return `last ${command.count} commits`;
-    if (command.kind === "staged")
-        return "staged changes";
-    return "stdin diff";
-}
-function estimatePromptTokens(prompt) {
-    return Math.ceil(prompt.length / 3);
-}
-function countTargetsByPattern(contexts) {
-    const counts = {};
-    for (const context of contexts)
-        counts[context.checkId] = (counts[context.checkId] ?? 0) + 1;
-    return counts;
-}
-function previewTargets(contexts) {
-    return contexts.map((context) => ({
-        targetId: context.targetId,
-        patternId: context.checkId,
-        entityKind: context.entityKind || undefined,
-        sourceKind: context.filePath ? pathKind(context.filePath) : undefined,
-    }));
-}
-function pathKind(filePath) {
-    const ext = filePath.split(".").pop();
-    return ext && ext !== filePath ? ext : "unknown";
-}
-if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
-    process.exitCode = await main();
-}

package/dist/trace.d.ts

@@ -1,31 +0,0 @@
-export type TraceFields = Record<string, string | number | boolean | null | undefined>;
-export type Tracer = {
-    trace<T>(span: string, fn: () => Promise<T>, options?: SpanTraceOptions<T>): Promise<{
-        value: T;
-        ms: number;
-    }>;
-    trace<T>(span: string, fn: () => T, options?: SpanTraceOptions<T>): {
-        value: T;
-        ms: number;
-    };
-};
-export type SpanTraceEvent = Readonly<{
-    name: string;
-    phase: "start" | "end" | "error";
-    ms: number;
-    count?: number;
-    detail?: string;
-}>;
-export type SpanTraceOptions<T> = Readonly<{
-    fields?: TraceFields;
-    startDetail?: string | (() => string);
-    count?: (value: T) => number;
-    detail?: (value: T) => string;
-}>;
-export type CreateTracerOptions = {
-    enabled?: boolean;
-    writeLine?: (line: string) => void;
-    onEvent?: (event: SpanTraceEvent) => void;
-};
-export declare function createTracer(options?: CreateTracerOptions): Tracer;
-export declare const trace: Tracer;

package/dist/trace.js

@@ -1,86 +0,0 @@
-import { performance } from "node:perf_hooks";
-export function createTracer(options) {
-    const enabled = options?.enabled ?? true;
-    const writeLine = options?.writeLine ?? ((line) => process.stderr.write(line + "\n"));
-    const onEvent = options?.onEvent;
-    const nowMs = () => performance.now();
-    function emit(span, durationMs, fields) {
-        if (!enabled)
-            return;
-        const payload = { span, ms: Math.round(durationMs) };
-        for (const [k, v] of Object.entries(fields ?? {})) {
-            if (v !== undefined)
-                payload[k] = v;
-        }
-        writeLine(`trace ${JSON.stringify(payload)}`);
-    }
-    function trace(span, fn, options) {
-        const startedAtMs = nowMs();
-        onEvent?.({
-            name: span,
-            phase: "start",
-            ms: 0,
-            detail: typeof options?.startDetail === "function" ? options.startDetail() : options?.startDetail,
-        });
-        try {
-            const out = fn();
-            if (isPromiseLike(out)) {
-                return (async () => {
-                    let durationMs;
-                    try {
-                        const value = await out;
-                        durationMs = nowMs() - startedAtMs;
-                        const event = {
-                            name: span,
-                            phase: "end",
-                            ms: Math.round(durationMs),
-                            count: options?.count?.(value),
-                            detail: options?.detail?.(value),
-                        };
-                        onEvent?.(event);
-                        return { value, ms: event.ms };
-                    }
-                    catch (error) {
-                        durationMs = nowMs() - startedAtMs;
-                        onEvent?.({
-                            name: span,
-                            phase: "error",
-                            ms: Math.round(durationMs),
-                        });
-                        throw error;
-                    }
-                    finally {
-                        durationMs ??= nowMs() - startedAtMs;
-                        emit(span, durationMs, options?.fields);
-                    }
-                })();
-            }
-            const durationMs = nowMs() - startedAtMs;
-            emit(span, durationMs, options?.fields);
-            const event = {
-                name: span,
-                phase: "end",
-                ms: Math.round(durationMs),
-                count: options?.count?.(out),
-                detail: options?.detail?.(out),
-            };
-            onEvent?.(event);
-            return { value: out, ms: event.ms };
-        }
-        catch (error) {
-            const durationMs = nowMs() - startedAtMs;
-            onEvent?.({
-                name: span,
-                phase: "error",
-                ms: Math.round(durationMs),
-            });
-            emit(span, durationMs, options?.fields);
-            throw error;
-        }
-    }
-    return { trace };
-}
-export const trace = createTracer();
-function isPromiseLike(value) {
-    return typeof value === "object" && value !== null && "then" in value;
-}