@stupify/cli 0.0.9 → 0.0.11

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),
@@ -200,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;
@@ -218,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;
       }
@@ -419,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

@@ -198,6 +198,7 @@ export type SearchMatch = Readonly<{
   checkWhy?: string;
   reason: string;
   proof: string;
+  snapshot?: string;
 }>;
 
 export type SearchRunJson = Readonly<{

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,
+  };
+}