@stupify/cli 0.0.3 → 0.0.4

package/src/types.ts

@@ -13,40 +13,39 @@ export function checkId(value: string): CheckId {
   return value as CheckId;
 }
 
-export type Engine = "raw-diff" | "sem";
-export type ScoutMode = "llm" | "counter";
-export type AuditContextMode = "none" | "repomix";
-export type AuditPromptName = "strict" | "high_bar";
+export type SearchMode = "warn" | "off";
+export type HookAction = "install" | "uninstall" | "status";
+export type SearchSource = "since" | "stdin" | "commit" | "commits" | "staged";
 
-type AnalyzeOptions = Readonly<{
+type SearchOptions = Readonly<{
   checkIds: readonly string[] | null;
   json: boolean;
   model: ModelId;
-  engine: Engine;
-  scout: ScoutMode;
-  auditContext: AuditContextMode;
-  auditPrompt: AuditPromptName;
   debugSem: boolean;
-  debugTargets: boolean;
   maxCandidates: number;
-  auditBatchSize: number;
-  maxAuditInputTokens: number;
-  auditConcurrency: number;
+  maxSearchInputTokens: number;
+  searchProfilePath: string | null;
+  includeCounterReasonInPrompt: boolean;
 }>;
 
 export type Command =
   | Readonly<{ kind: "help" }>
-  | Readonly<{ kind: "experiment"; configPath: string }>
-  | (Readonly<{ kind: "since"; since: string }> & AnalyzeOptions)
-  | (Readonly<{ kind: "stdin" }> & AnalyzeOptions)
-  | (Readonly<{ kind: "commit"; commit: string }> & AnalyzeOptions)
-  | (Readonly<{ kind: "commits"; count: number }> & AnalyzeOptions);
-
-type ControlCommand =
+  | Readonly<{ kind: "hook"; action: HookAction }>
+  | Readonly<{ kind: "doctor" }>
+  | Readonly<{ kind: "bench-search"; configPath: string }>
+  | (Readonly<{ kind: "since"; since: string; mode: "search"; source: "since" }> & SearchOptions)
+  | (Readonly<{ kind: "stdin"; mode: "search"; source: "stdin" }> & SearchOptions)
+  | (Readonly<{ kind: "commit"; commit: string; mode: "search"; source: "commit" }> & SearchOptions)
+  | (Readonly<{ kind: "commits"; count: number; mode: "search"; source: "commits" }> & SearchOptions)
+  | (Readonly<{ kind: "staged"; mode: "search"; source: "staged" }> & SearchOptions);
+
+export type SearchCommand = Exclude<
+  Command,
   | Readonly<{ kind: "help" }>
-  | Readonly<{ kind: "experiment"; configPath: string }>;
-
-export type AnalyzeCommand = Exclude<Command, ControlCommand>;
+  | Readonly<{ kind: "hook"; action: HookAction }>
+  | Readonly<{ kind: "doctor" }>
+  | Readonly<{ kind: "bench-search"; configPath: string }>
+>;
 
 export type StupifyCheck = Readonly<{
   id: CheckId;
@@ -55,48 +54,29 @@ export type StupifyCheck = Readonly<{
   lookFor: readonly string[];
   ignoreWhen: readonly string[];
   enabledByDefault?: boolean;
+  hookMode?: SearchMode;
+  searchPrompt?: string;
+  searchExamples?: Readonly<{
+    match: readonly string[];
+    nonMatch: readonly string[];
+  }>;
   examples?: Readonly<{
     match?: readonly string[];
     noMatch?: readonly string[];
   }>;
 }>;
 
-export type FindingCandidate = Readonly<{
-  checkId: string;
-  why: string;
-  proof: string;
-}>;
-
-export type Finding = Readonly<{
-  sourceId: SourceId;
-  checkId: CheckId;
-  why: string;
-  proof: string;
-}>;
-
-export type FindingsResult = Readonly<{
-  findings: readonly Finding[];
-  summary?: string;
-}>;
-
-export type AuditReviewStats = Readonly<{
-  totalTargets: number;
-  finding: number;
-  clean: number;
-  uncertain: number;
-  invalid: number;
-}>;
-
-export type AuditReviewResult = FindingsResult & Readonly<{
-  stats: AuditReviewStats;
-}>;
-
 export type NetDiffStats = Readonly<{
   filesChanged: number;
   additions: number;
   deletions: number;
 }>;
 
+export type StagedDiff = Readonly<{
+  text: string;
+  stats: NetDiffStats;
+}>;
+
 export type NetDiff = Readonly<{
   id: SourceId;
   label: string;
@@ -114,27 +94,6 @@ export type SourceRange = Readonly<{
   stats: NetDiffStats;
 }>;
 
-export type DiffHunk = Readonly<{
-  pointer: string;
-  batchId: string;
-  fileId: string;
-  hunkId: string;
-  filePath: string;
-  lineCount: number;
-  text: string;
-}>;
-
-export type DiffBatch = Readonly<{
-  id: string;
-  hunks: readonly DiffHunk[];
-  text: string;
-}>;
-
-export type CandidateContext = Readonly<{
-  pointer: string;
-  text: string;
-}>;
-
 export type SemChange = Readonly<{
   entityId: string;
   entityName: string;
@@ -186,66 +145,176 @@ export type SemContext = Readonly<{
   text: string;
 }>;
 
-export type DebugTarget = Readonly<{
-  targetId: string;
-  checkId: CheckId;
-  entityId: string;
-  entityKind?: string;
-  changeKind?: string;
-  scoutReason?: string;
-  sourceLabel?: string;
-}>;
-
 export type SemContextPack = Readonly<{
   provider: "repomix";
   filePaths: readonly string[];
   totalCharacters: number;
   totalTokens: number;
   text: string;
+  config: RepomixSearchConfig;
 }>;
 
-export type AnalysisRun = Readonly<{
-  engine: Engine;
-  auditContext: AuditContextMode;
-  auditPrompt: AuditPromptName;
-  mode: AnalyzeCommand["kind"];
-  modelId: ModelId;
-  checkIds: readonly CheckId[];
-  sourceId: SourceId;
-  label: string;
-  stats: NetDiffStats;
-  batchesScanned: number;
-  candidateCount: number;
-  targetsByCheck?: Readonly<Record<string, number>>;
-  entitiesScanned: number;
-  auditedCandidateCount: number;
-  scoutModelCalls: number;
-  auditModelCalls: number;
-  timingsMs: Readonly<{
-    diff: number;
-    modelLoad: number;
-    search: number;
-    audit: number;
-    total: number;
+export type RepomixSearchConfig = Readonly<{
+  compress: boolean;
+  showLineNumbers: boolean;
+  removeEmptyLines: boolean;
+  maxFileSizeBytes: number;
+  maxTotalSizeBytes: number;
+  ignorePatterns: readonly string[];
+}>;
+
+export type SearchProfileRepomixConfig = Readonly<{
+  compress?: boolean;
+  showLineNumbers?: boolean;
+  removeEmptyLines?: boolean;
+  maxFileBytes?: number;
+  maxTotalBytes?: number;
+  ignorePatterns?: readonly string[];
+}>;
+
+export type SearchProfilePattern = Readonly<{
+  enabled?: boolean;
+  searchPrompt?: string;
+  matchExamples?: readonly string[];
+  nonMatchExamples?: readonly string[];
+}>;
+
+export type SearchProfile = Readonly<{
+  id: string;
+  context?: "repomix" | "sem";
+  maxCandidates?: number;
+  maxSearchInputTokens?: number;
+  includeCounterReasonInPrompt?: boolean;
+  repomix?: SearchProfileRepomixConfig;
+  patterns?: Readonly<Record<string, SearchProfilePattern>>;
+}>;
+
+export type SearchMatch = Readonly<{
+  targetId: string;
+  patternId: CheckId;
+  reason: string;
+  proof: string;
+}>;
+
+export type SearchRunJson = Readonly<{
+  schemaVersion: "search.v1";
+  mode: "search";
+  source: SearchSource;
+  model: Readonly<{ id: ModelId }>;
+  patterns: readonly CheckId[];
+  stats: Readonly<{
+    elapsedMs: number;
+    modelCalls: number;
+    inputTokens?: number;
+    inputTokenCap?: number;
+    skipped?: boolean;
+    skipReason?: "input_too_large" | "no_candidates";
+    filesChanged?: number;
+    entitiesScanned?: number;
+    candidates?: number;
+    repomixFiles?: number;
+    repomixTokens?: number;
+    repomixConfig?: RepomixSearchConfig;
+    searchTargets?: number;
+    profileId?: string;
+    targetsByPattern?: Readonly<Record<string, number>>;
+    targetsPreview?: readonly SearchTargetPreview[];
   }>;
-  warnings: readonly string[];
-  auditStats?: AuditReviewStats;
-  debugTargets?: readonly DebugTarget[];
-  traceEvents?: readonly TraceEvent[];
+  matches: readonly SearchMatch[];
 }>;
 
-export type TraceEvent = Readonly<{
+export type SearchTargetPreview = Readonly<{
+  targetId: string;
+  patternId: CheckId;
+  entityKind?: string;
+  sourceKind?: string;
+}>;
+
+export type SearchBenchConfig = Readonly<{
   name: string;
-  ms: number;
-  count?: number;
-  detail?: string;
+  profiles: readonly string[];
+  fixtures: string;
+  realSmokeRuns?: readonly SearchBenchSmokeRun[];
+  realCommitReplay?: readonly SearchBenchCommitReplay[];
 }>;
 
-export type AnalysisReport = Readonly<{
-  run: AnalysisRun;
-  result: FindingsResult;
+export type SearchBenchSmokeRun = Readonly<{
+  id: string;
+  cwd?: string;
+  args: readonly string[];
 }>;
 
+export type SearchBenchCommitReplay = Readonly<{
+  id: string;
+  repoEnv?: string;
+  cwd?: string;
+  limit: number;
+  since?: string;
+  nonMerge?: boolean;
+  profiles: readonly string[];
+}>;
+
+export type SearchFixture = Readonly<{
+  id: string;
+  description: string;
+  stagedPatch: string;
+  checks: readonly string[];
+  expected: readonly SearchFixtureExpectation[];
+}>;
+
+export type SearchFixtureExpectation = Readonly<{
+  patternId: string;
+  shouldMatch: boolean;
+}>;
+
+export type SearchBenchRun = Readonly<{
+  profileId: string;
+  fixtureId?: string;
+  smokeId?: string;
+  elapsedMs: number;
+  modelCalls: number;
+  patterns: readonly CheckId[];
+  targets: number;
+  targetsByPattern: Readonly<Record<string, number>>;
+  inputTokens: number;
+  repomixPackedTokens?: number;
+  skipped: boolean;
+  skipReason?: string;
+  matches: readonly SearchMatch[];
+  expected?: readonly SearchFixtureExpectation[];
+  score?: number;
+  targetsPreview: readonly SearchTargetPreview[];
+  matchesUsingCounterReasonAsProof: number;
+  error?: string;
+}>;
+
+export type SearchBenchReplayRun = Readonly<{
+  profileId: string;
+  replayId: string;
+  commitId: string;
+  outcome: SearchReplayOutcome;
+  changedFiles: number;
+  addedLines: number;
+  deletedLines: number;
+  elapsedMs: number;
+  skipped: boolean;
+  skipReason?: string;
+  targets: number;
+  inputTokens: number;
+  repomixPackedTokens?: number;
+  modelCalls: number;
+  matches: readonly SearchMatch[];
+  matchesByPattern: Readonly<Record<string, number>>;
+  error?: string;
+}>;
+
+export type SearchReplayOutcome =
+  | "no_candidates"
+  | "ran_no_matches"
+  | "ran_with_matches"
+  | "skipped_input_too_large"
+  | "error";
+
 export type ModelId =
   | "gemma-4-e2b"
   | "gemma-4-e4b"
@@ -258,7 +327,14 @@ export type ModelId =
 export type ModelConfig = Readonly<{
   id: ModelId;
   name: string;
-  size: string;
   file: string;
   url: string;
+  size: string;
+}>;
+
+export type TraceEvent = Readonly<{
+  name: string;
+  ms: number;
+  count?: number;
+  detail?: string;
 }>;

package/dist/batcher.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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/candidate-context.d.ts

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

package/dist/candidate-context.js

@@ -1,40 +0,0 @@
-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/experiment.d.ts

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