@stupify/cli 0.0.2 → 0.0.3

package/src/batcher.ts

@@ -0,0 +1,198 @@
+import type { DiffBatch, DiffHunk } from "./types.ts";
+
+const DEFAULT_BATCH_LINES = 1_000;
+
+type ParsedHunk = Readonly<{
+  fileId: string;
+  hunkId: string;
+  filePath: string;
+  text: string;
+  lineCount: number;
+}>;
+
+export function batchDiff(
+  diff: string,
+  linesPerBatch = DEFAULT_BATCH_LINES,
+): readonly DiffBatch[] {
+  const hunks = parseHunks(diff).flatMap((item) =>
+    splitLargeHunk(item, linesPerBatch),
+  );
+
+  type BatchState = Readonly<{
+    batches: readonly DiffBatch[];
+    current: readonly DiffHunk[];
+    currentLines: number;
+    batchNumber: number;
+  }>;
+
+  const initialState: BatchState = {
+    batches: [],
+    current: [],
+    currentLines: 0,
+    batchNumber: 1,
+  };
+
+  const finalized = hunks.reduce<BatchState>((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: BatchState): BatchState {
+    return {
+      batches: [...state.batches, toBatch(state.batchNumber, state.current)],
+      current: [],
+      currentLines: 0,
+      batchNumber: state.batchNumber + 1,
+    };
+  }
+}
+
+export function allHunks(batches: readonly DiffBatch[]): readonly DiffHunk[] {
+  return batches.flatMap((batch) => batch.hunks);
+}
+
+function parseHunks(diff: string): readonly ParsedHunk[] {
+  type ParseState = Readonly<{
+    hunks: readonly ParsedHunk[];
+    filePath: string;
+    fileIndex: number;
+    hunkIndex: number;
+    fileHeader: readonly string[];
+    hunkLines: readonly string[] | null;
+  }>;
+
+  const lines = diff.split(/\r?\n/);
+
+  const initialState: ParseState = {
+    hunks: [],
+    filePath: "unknown",
+    fileIndex: 0,
+    hunkIndex: 0,
+    fileHeader: [],
+    hunkLines: null,
+  };
+
+  const finalState = lines.reduce<ParseState>((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: ParseState): ParseState {
+    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: ParsedHunk = {
+      fileId,
+      hunkId,
+      filePath: state.filePath,
+      text,
+      lineCount: countLines(text),
+    };
+
+    return { ...state, hunks: [...state.hunks, nextHunk], hunkLines: null };
+  }
+}
+
+function splitLargeHunk(
+  hunk: ParsedHunk,
+  linesPerBatch: number,
+): readonly ParsedHunk[] {
+  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: ParsedHunk, batchNumber: number): DiffHunk {
+  const batchId = `batch-${pad(batchNumber)}`;
+  return {
+    ...hunk,
+    batchId,
+    pointer: `${batchId}:${hunk.fileId}:${hunk.hunkId}`,
+  };
+}
+
+function toBatch(batchNumber: number, hunks: readonly DiffHunk[]): DiffBatch {
+  const id = `batch-${pad(batchNumber)}`;
+  return {
+    id,
+    hunks,
+    text: hunks.map(formatHunkForSearch).join("\n\n"),
+  };
+}
+
+function formatHunkForSearch(hunk: DiffHunk): string {
+  return `POINTER ${hunk.pointer}
+FILE ${hunk.fileId}
+PATH ${hunk.filePath}
+${searchView(hunk.text)}`;
+}
+
+function searchView(text: string): string {
+  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: string): number {
+  return value.length === 0 ? 0 : value.split(/\r?\n/).length;
+}
+
+function pad(value: number): string {
+  return String(value).padStart(3, "0");
+}

package/src/cache.ts

@@ -0,0 +1,65 @@
+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: unknown): string {
+  const text = typeof value === "string" ? value : stableStringify(value);
+  return createHash("sha256").update(text).digest("hex");
+}
+
+export async function cachedJson<T>(
+  namespace: string,
+  key: string,
+  compute: () => Promise<T>,
+): Promise<T> {
+  const filePath = cachePath(namespace, key);
+  try {
+    const value = JSON.parse(await readFile(filePath, "utf8")) as T;
+    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: string, key: string): string {
+  return path.join(cacheRoot(), "intermediate-v1", safeNamespace(namespace), `${key}.json`);
+}
+
+async function writeCache(filePath: string, value: unknown): Promise<void> {
+  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(): string {
+  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: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const record = value as Record<string, unknown>;
+  return `{${Object.keys(record).sort().map((key) =>
+    `${JSON.stringify(key)}:${stableStringify(record[key])}`
+  ).join(",")}}`;
+}

package/src/candidate-context.ts

@@ -0,0 +1,43 @@
+import { allHunks } from "./batcher.ts";
+import type { CandidateContext, DiffBatch, DiffHunk } from "./types.ts";
+
+const MAX_CONTEXT_LINES = 80;
+
+export function candidateContexts(
+  batches: readonly DiffBatch[],
+  candidatePointers: readonly string[],
+): readonly CandidateContext[] {
+  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: DiffHunk): string {
+  return `PATH ${hunk.filePath}
+${shorten(hunk.text)}`;
+}
+
+function shorten(text: string): string {
+  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: DiffHunk | undefined): number {
+  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/src/checks.ts

@@ -0,0 +1,132 @@
+import { checkId, type StupifyCheck } from "./types.ts";
+
+export const defaultChecks: readonly StupifyCheck[] = [
+  {
+    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,
+  },
+] as const;
+
+export function enabledChecks(checkIds: readonly string[] | null): readonly StupifyCheck[] {
+  if (!checkIds) return defaultChecks.filter((check) => check.enabledByDefault !== false);
+
+  const checksById = new Map<string, StupifyCheck>(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/src/command.ts

@@ -0,0 +1,218 @@
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
+import type { AuditContextMode, AuditPromptName, Command, Engine, ModelId, ScoutMode } from "./types.ts";
+
+const DEFAULT_SINCE = "2 weeks ago";
+const DEFAULT_MAX_CANDIDATES = 10;
+const DEFAULT_SCOUT_MODE: ScoutMode = "counter";
+const DEFAULT_AUDIT_CONTEXT: AuditContextMode = "repomix";
+const DEFAULT_AUDIT_PROMPT: AuditPromptName = "high_bar";
+const DEFAULT_AUDIT_BATCH_SIZE = 25;
+const DEFAULT_MAX_AUDIT_INPUT_TOKENS = 20_000;
+const DEFAULT_AUDIT_CONCURRENCY = 2;
+type InputMode =
+  | Readonly<{ kind: "since"; since: string }>
+  | Readonly<{ kind: "stdin" }>
+  | Readonly<{ kind: "commit"; commit: string }>
+  | Readonly<{ kind: "commits"; count: number }>;
+
+export function parseCommand(argv: readonly string[]): Command {
+  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 };
+  }
+
+  type ParseState = Readonly<{
+    inputMode: InputMode;
+    explicitInputMode: boolean;
+    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;
+  }>;
+
+  const initialState: ParseState = {
+    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: number, state: ParseState): ParseState {
+    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: ParseState, next: InputMode): ParseState {
+    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: string): boolean {
+  return value.length > 0 && !value.startsWith("-") && /^[A-Za-z0-9._/@~^:+-]+$/.test(value);
+}
+
+function isHelp(value: string): boolean {
+  return value === "--help" || value === "-h";
+}
+
+function isModelId(value: string): value is ModelId {
+  return value in MODEL_REGISTRY;
+}
+
+function isEngine(value: string): value is Engine {
+  return value === "raw-diff" || value === "sem";
+}
+
+function isScoutMode(value: string): value is ScoutMode {
+  return value === "counter" || value === "llm";
+}
+
+function isAuditContextMode(value: string): value is AuditContextMode {
+  return value === "none" || value === "repomix";
+}
+
+function isAuditPromptName(value: string): value is AuditPromptName {
+  return value === "strict" || value === "high_bar";
+}