@stupify/cli 0.0.8 → 0.0.10

package/src/render.ts

@@ -1,43 +1,42 @@
 import { VERSION } from "./constants.ts";
 import type { SearchCommand, SearchRunJson } from "./types.ts";
+import { format } from "./ui.ts";
 
 export function renderSearchRun(run: SearchRunJson, command: SearchCommand): string {
   if (command.json) return JSON.stringify(run, null, 2);
 
   if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
-    return `🧙 stupify 🪄
-Search input is too large for precise local search.
-Size:
+    return `${format.heading("Search input is too large for precise local search.")}
+${format.heading("Size:")}
 ~${run.stats.inputTokens ?? "unknown"} tokens
-Limit:
+${format.heading("Limit:")}
 ${run.stats.inputTokenCap ?? "unknown"} tokens
 Stupify skipped the search rather than review truncated context.
 Nothing was blocked.
-Try:
+${format.heading("Try:")}
 rerun with ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
   }
 
   if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
-    return `🧙 stupify 🪄
-Search complete.
-Patterns: ${run.patterns.join(", ")}
-No search targets found.`;
+    return `${format.heading("Search complete.")}
+${format.label("Patterns:")} ${run.patterns.join(", ")}
+${format.success("No search targets found.")}`;
   }
 
   if (run.matches.length === 0) {
-    return `🧙 stupify 🪄
-Search complete.
-Patterns: ${run.patterns.join(", ")}
-No judgment-offload signals found.`;
+    return `${format.heading("Search complete.")}
+${format.label("Patterns:")} ${run.patterns.join(", ")}
+${format.success("No judgment-offload signals found.")}`;
   }
 
-  return `🧙 stupify 🪄
-Possible judgment-offload detected:
-${run.matches.map((match, index) => `${index + 1}. ${match.patternId}
-   Why: ${match.checkWhy ?? "This pattern may indicate judgment-offload."}
-   Match: ${match.reason}
-   Proof: ${match.proof}`).join("\n")}
-Search mode is warn-only.`;
+  return `${format.warn("AI SLOP DETECTED")}
+${run.matches.map((match, index) => `${index + 1}.
+   ${format.muted("who:")} ${committerLabel(run)}
+   ${format.muted("what:")} ${match.patternId} - ${match.reason}
+   ${format.muted("when:")} ${sourceLabel(command)}
+   ${format.muted("where:")} ${match.proof}
+   ${format.muted("why:")} ${match.checkWhy ?? "This pattern may indicate judgment-offload."}`).join("\n")}
+${format.muted("Search mode is warn-only.")}`;
 }
 
 export function helpText(): string {
@@ -95,3 +94,18 @@ function sourceHint(command: SearchCommand): string {
   if (command.kind === "commits") return `--commits ${command.count}`;
   return "--stdin";
 }
+
+function sourceLabel(command: SearchCommand): string {
+  if (command.kind === "staged") return "staged changes";
+  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`;
+  return "stdin diff";
+}
+
+function committerLabel(run: SearchRunJson): string {
+  const committers = (run.stats.committers ?? []).filter(Boolean);
+  if (committers.length === 0) return "unknown committer";
+  if (committers.length <= 3) return committers.join(", ");
+  return `${committers.slice(0, 3).join(", ")} +${committers.length - 3} more`;
+}

package/src/sem-provider.ts

@@ -7,11 +7,13 @@ import { promisify } from "node:util";
 import { cachedJson, fingerprint } from "./cache.ts";
 import { readDiffFromStdin } from "./diff.ts";
 import {
+  gitUserLabel,
   sourceRangeForCommit,
   sourceRangeForRecentCommits,
   sourceRangeSince,
   stagedDiff,
 } from "./git.ts";
+import { diagnostic } from "./ui.ts";
 import type {
   SearchCommand,
   SemChange,
@@ -26,11 +28,12 @@ const execFileAsync = promisify(execFile);
 export async function semChangeSetForCommand(
   command: SearchCommand,
 ): Promise<SemChangeSet> {
-  if (command.kind === "stdin") return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem);
+  if (command.kind === "stdin") return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem, "stdin", ["stdin"]);
   if (command.kind === "staged") {
-    const diff = await stagedDiff();
-    if (!diff.text.trim()) return emptyChangeSet("staged", diff.stats);
-    return semChangeSetFromPatch(diff.text, command.debugSem, "staged");
+    const [diff, committer] = await Promise.all([stagedDiff(), gitUserLabel()]);
+    const committers = [committer];
+    if (!diff.text.trim()) return emptyChangeSet("staged", diff.stats, committers);
+    return semChangeSetFromPatch(diff.text, command.debugSem, "staged", committers);
   }
   if (command.kind === "commit") {
     const range = await sourceRangeForCommit(command.commit);
@@ -51,12 +54,17 @@ export async function semChangeSetForCommand(
   return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
 }
 
-function emptyChangeSet(label: string, stats: SourceRange["stats"]): SemChangeSet {
+function emptyChangeSet(
+  label: string,
+  stats: SourceRange["stats"],
+  committers?: readonly string[],
+): SemChangeSet {
   return {
     id: sourceId(label),
     label,
     base: label,
     target: label,
+    committers,
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
     changes: [],
@@ -79,7 +87,12 @@ async function semRangeForCommand(command: SearchCommand): Promise<SourceRange>
   throw new Error("sem cannot resolve stdin as a git range.");
 }
 
-async function semChangeSetFromPatch(patch: string, debugSem: boolean, label = "stdin"): Promise<SemChangeSet> {
+async function semChangeSetFromPatch(
+  patch: string,
+  debugSem: boolean,
+  label = "stdin",
+  committers?: readonly string[],
+): Promise<SemChangeSet> {
   if (!patch.trim()) throw new Error("No diff received on stdin.");
   const raw = await cachedJson(
     "sem-diff",
@@ -93,11 +106,12 @@ async function semChangeSetFromPatch(patch: string, debugSem: boolean, label = "
   );
   return {
     ...normalizeSemDiff(raw, {
-    id: sourceId(label),
-    label,
-    base: label,
-    target: label,
-    stats: { filesChanged: 0, additions: 0, deletions: 0 },
+      id: sourceId(label),
+      label,
+      base: label,
+      target: label,
+      committers,
+      stats: { filesChanged: 0, additions: 0, deletions: 0 },
     }),
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
@@ -140,14 +154,14 @@ async function withContextWorkspace(changeSet: SemChangeSet, debugSem: boolean):
 }
 
 async function runSem(args: readonly string[], debugSem: boolean, cwd = process.cwd()): Promise<unknown> {
-  if (debugSem) console.error(`sem ${args.join(" ")}`);
+  if (debugSem) diagnostic(`sem ${args.join(" ")}`);
   const { command, commandArgs } = resolveSemCommand(args);
   try {
     const { stdout, stderr } = await execFileAsync(command, commandArgs, {
       cwd,
       maxBuffer: 128 * 1024 * 1024,
     });
-    if (debugSem && stderr.trim()) console.error(stderr.trim());
+    if (debugSem && stderr.trim()) diagnostic(stderr.trim());
     return JSON.parse(stdout);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -156,7 +170,7 @@ async function runSem(args: readonly string[], debugSem: boolean, cwd = process.
 }
 
 async function runSemWithInput(args: readonly string[], stdin: string, debugSem: boolean): Promise<unknown> {
-  if (debugSem) console.error(`sem ${args.join(" ")}`);
+  if (debugSem) diagnostic(`sem ${args.join(" ")}`);
   const { command, commandArgs } = resolveSemCommand(args);
   return new Promise((resolve, reject) => {
     const child = spawn(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
@@ -167,7 +181,7 @@ async function runSemWithInput(args: readonly string[], stdin: string, debugSem:
     child.on("error", (error) => reject(error));
     child.on("close", (code) => {
       const stderrText = Buffer.concat(stderr).toString("utf8");
-      if (debugSem && stderrText.trim()) console.error(stderrText.trim());
+      if (debugSem && stderrText.trim()) diagnostic(stderrText.trim());
       if (code !== 0) {
         reject(new Error(`sem failed with exit code ${code}${stderrText ? `: ${stderrText.trim()}` : ""}`));
         return;
@@ -183,7 +197,7 @@ async function runSemWithInput(args: readonly string[], stdin: string, debugSem:
 }
 
 async function git(args: readonly string[], debugSem: boolean): Promise<void> {
-  if (debugSem) console.error(`git ${args.join(" ")}`);
+  if (debugSem) diagnostic(`git ${args.join(" ")}`);
   await execFileAsync("git", [...args], { maxBuffer: 128 * 1024 * 1024 });
 }
 
@@ -225,6 +239,7 @@ function normalizeSemDiff(value: unknown, range: SourceRange): SemChangeSet {
     label: range.label,
     base: range.base,
     target: range.target,
+    committers: range.committers,
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
     changes,

package/src/stupify.ts

@@ -20,46 +20,49 @@ import {
 } from "./search-profile.ts";
 import { semChangeSetForCommand } from "./sem-provider.ts";
 import { createTracer } from "./trace.ts";
+import { createCliUi, type CliUi } from "./ui.ts";
 import type { SearchCommand, SearchMatch, SearchProfile, SearchRunJson, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
 
 export async function main(argv = process.argv.slice(2)): Promise<number> {
   const startedAt = Date.now();
+  let ui = createCliUi();
   try {
     const command = parseCommand(argv);
     if (command.kind === "help") {
-      console.log(helpText());
+      ui.writeStdout(helpText());
       return 0;
     }
     if (command.kind === "hook") {
-      console.log(await runHookCommand(command.action));
+      ui.writeStdout(await runHookCommand(command.action));
       return 0;
     }
     if (command.kind === "doctor") {
       const result = await runDoctor();
-      console.log(result.text);
+      ui.writeStdout(result.text);
       return result.exitCode;
     }
     if (command.kind === "bench-search") {
       const { runSearchBench } = await import("./search-bench.ts");
-      console.log(await runSearchBench(command.configPath));
+      ui.writeStdout(await runSearchBench(command.configPath));
       return 0;
     }
 
-    const run = await runSearchCommand(command, startedAt);
-    console.log(renderSearchRun(run, command));
+    ui = createCliUi({ quiet: command.json });
+    const run = await runSearchCommand(command, startedAt, ui);
+    ui.writeStdout(renderSearchRun(run, command));
     return 0;
   } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
+    ui.error(error instanceof Error ? error.message : String(error), { force: true });
     return 1;
   }
 }
 
-export async function runSearchCommand(command: SearchCommand, startedAt: number): Promise<SearchRunJson> {
+export async function runSearchCommand(command: SearchCommand, startedAt: number, ui = createCliUi({ quiet: command.json })): Promise<SearchRunJson> {
   const t = createTracer({
     writeLine: () => undefined,
     onEvent: (event) => {
       if (command.json) return;
-      console.error(formatStep(event.name, event.ms, event.count, event.detail));
+      ui.step(formatStep(event.name, event.ms, event.count, event.detail));
     },
   });
 
@@ -68,7 +71,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
   const patternIds = checks.map((check) => check.id);
   const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
   const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
-  printRunPlan(command, patternIds);
+  printRunPlan(command, patternIds, ui);
   const { value: changeSet } = await t.trace(
     "entity.diff",
     () => semChangeSetForCommand(command),
@@ -93,6 +96,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         stats: {
           elapsedMs: Date.now() - startedAt,
           modelCalls: 0,
+          committers: changeSet.committers,
           skipped: true,
           skipReason: "no_candidates",
           filesChanged: changeSet.summary.fileCount,
@@ -134,6 +138,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         stats: {
           elapsedMs: Date.now() - startedAt,
           modelCalls: 0,
+          committers: changeSet.committers,
           skipped: true,
           skipReason: "no_candidates",
           filesChanged: changeSet.summary.fileCount,
@@ -177,6 +182,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
           modelCalls: 0,
           inputTokens: batches.estimatedInputTokens,
           inputTokenCap: maxSearchInputTokens,
+          committers: changeSet.committers,
           skipped: true,
           skipReason: "input_too_large",
           filesChanged: changeSet.summary.fileCount,
@@ -197,14 +203,14 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     }
 
     if (batches.wasSplit && !command.json) {
-      console.error(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
+      ui.warn(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
       if (batches.skippedTargets > 0) {
-        console.error(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
+        ui.warn(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
       }
     }
 
-    const modelPath = await firstRunModelBootstrap(command.model);
-    const model = await loadLocalModel(modelPath, command.model, "scout");
+    const modelPath = await firstRunModelBootstrap(command.model, ui);
+    const model = await loadLocalModel(modelPath, command.model, "scout", ui);
     const matches = [];
     let modelCalls = 0;
     let inputTokens = 0;
@@ -215,7 +221,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       if (batchInputTokens > maxSearchInputTokens) {
         exactSkippedTargets += batch.contexts.length;
         if (!command.json) {
-          console.error(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
+          ui.warn(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
         }
         continue;
       }
@@ -240,6 +246,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         modelCalls,
         inputTokens,
         inputTokenCap: maxSearchInputTokens,
+        committers: changeSet.committers,
         filesChanged: changeSet.summary.fileCount,
         entitiesScanned: changeSet.summary.total,
         candidates: contexts.length,
@@ -415,11 +422,17 @@ function buildSearchRequest(
 function printRunPlan(
   command: SearchCommand,
   patternIds: readonly string[],
+  ui: CliUi,
 ): void {
   if (command.json) return;
-  console.error("🧙 stupify 🪄");
-  console.error(`Search: ${sourceLabel(command)}`);
-  console.error(`Patterns: ${patternIds.join(", ")}`);
+  ui.intro("stupify");
+  ui.note(
+    [
+      `Search: ${sourceLabel(command)}`,
+      `Patterns: ${patternIds.join(", ")}`,
+    ].join("\n"),
+    "Run",
+  );
 }
 
 function formatStep(name: string, ms: number, count?: number, detail?: string): string {

package/src/types.ts

@@ -92,6 +92,7 @@ export type SourceRange = Readonly<{
   label: string;
   base: string;
   target: string;
+  committers?: readonly string[];
   stats: NetDiffStats;
 }>;
 
@@ -120,6 +121,7 @@ export type SemChangeSet = Readonly<{
   label: string;
   base: string;
   target: string;
+  committers?: readonly string[];
   contextCwd: string;
   cleanup: () => Promise<void>;
   changes: readonly SemChange[];
@@ -211,6 +213,7 @@ export type SearchRunJson = Readonly<{
     inputTokenCap?: number;
     skipped?: boolean;
     skipReason?: "input_too_large" | "no_candidates";
+    committers?: readonly string[];
     filesChanged?: number;
     entitiesScanned?: number;
     candidates?: number;

package/src/ui.ts

@@ -0,0 +1,187 @@
+import {
+  confirm as clackConfirm,
+  intro as clackIntro,
+  isCancel,
+  log,
+  note,
+  outro as clackOutro,
+  progress,
+  spinner,
+  type SpinnerResult,
+} from "@clack/prompts";
+import { createReadStream, createWriteStream, type ReadStream, type WriteStream } from "node:fs";
+import { platform } from "node:os";
+import { stdin, stderr, stdout } from "node:process";
+import type { Readable, Writable } from "node:stream";
+import pc from "picocolors";
+
+export type CliUi = ReturnType<typeof createCliUi>;
+
+export type CliUiOptions = Readonly<{
+  quiet?: boolean;
+}>;
+
+type LogOptions = Readonly<{
+  force?: boolean;
+}>;
+
+type PromptIo = Readonly<{
+  input: Readable;
+  output: Writable;
+  close: () => void;
+}>;
+
+export function createCliUi(options: CliUiOptions = {}) {
+  const quiet = options.quiet ?? false;
+  const output = stderr;
+
+  function shouldWrite(logOptions?: LogOptions): boolean {
+    return logOptions?.force === true || !quiet;
+  }
+
+  function withPromptIo<T>(
+    run: (io: PromptIo) => Promise<T>,
+  ): Promise<T> {
+    const io = promptIo();
+    return run(io).finally(() => io.close());
+  }
+
+  return {
+    intro(title: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) clackIntro(title, { output });
+    },
+
+    outro(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) clackOutro(message, { output });
+    },
+
+    note(message: string, title?: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) note(message, title, { output });
+    },
+
+    info(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) log.info(message, { output });
+    },
+
+    step(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) log.step(message, { output });
+    },
+
+    success(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) log.success(message, { output });
+    },
+
+    warn(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) log.warn(message, { output });
+    },
+
+    error(message: string, logOptions?: LogOptions): void {
+      if (shouldWrite(logOptions)) log.error(message, { output });
+    },
+
+    debug(message: string): void {
+      if (!quiet) log.message(message, { output, symbol: pc.dim("trace") });
+    },
+
+    async confirm(message: string): Promise<boolean> {
+      return withPromptIo(async (io) => {
+        const result = await clackConfirm({
+          message,
+          active: "Yes",
+          inactive: "No",
+          initialValue: false,
+          input: io.input,
+          output: io.output,
+        });
+        if (isCancel(result)) return false;
+        return result;
+      });
+    },
+
+    spinner(message: string, logOptions?: LogOptions): SpinnerResult {
+      if (!shouldWrite(logOptions)) return silentSpinner();
+      const active = spinner({ output });
+      active.start(message);
+      return active;
+    },
+
+    progress(message: string, max: number, logOptions?: LogOptions) {
+      if (!shouldWrite(logOptions)) return silentProgress();
+      const active = progress({ output, max });
+      active.start(message);
+      return active;
+    },
+
+    writeStdout(text: string): void {
+      stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+    },
+  };
+}
+
+export const format = {
+  heading: (value: string) => pc.bold(value),
+  label: (value: string) => pc.cyan(value),
+  muted: (value: string) => pc.dim(value),
+  success: (value: string) => pc.green(value),
+  warn: (value: string) => pc.yellow(value),
+  error: (value: string) => pc.red(value),
+};
+
+export function diagnostic(message: string): void {
+  log.message(message, {
+    output: stderr,
+    symbol: pc.dim("·"),
+    spacing: 0,
+    withGuide: false,
+  });
+}
+
+export function diagnosticError(message: string): void {
+  log.error(message, { output: stderr, spacing: 0, withGuide: false });
+}
+
+function promptIo(): PromptIo {
+  if (stdin.isTTY && stderr.isTTY) {
+    return { input: stdin, output: stderr, close: () => undefined };
+  }
+
+  if (platform() === "win32") {
+    throw new Error(
+      "No interactive terminal found. Run `stupify` once in an interactive terminal to set up the model.",
+    );
+  }
+
+  const input = createReadStream("/dev/tty");
+  const output = createWriteStream("/dev/tty");
+  return {
+    input,
+    output,
+    close: () => closePromptIo(input, output),
+  };
+}
+
+function closePromptIo(input: ReadStream, output: WriteStream): void {
+  input.destroy();
+  output.end();
+}
+
+function silentSpinner(): SpinnerResult {
+  return {
+    start: () => undefined,
+    stop: () => undefined,
+    cancel: () => undefined,
+    error: () => undefined,
+    message: () => undefined,
+    clear: () => undefined,
+    get isCancelled() {
+      return false;
+    },
+  };
+}
+
+function silentProgress() {
+  return {
+    ...silentSpinner(),
+    advance: () => undefined,
+  };
+}