@stupify/cli 0.0.9 → 0.0.10

package/dist/ui.js

@@ -0,0 +1,143 @@
+import { confirm as clackConfirm, intro as clackIntro, isCancel, log, note, outro as clackOutro, progress, spinner, } from "@clack/prompts";
+import { createReadStream, createWriteStream } from "node:fs";
+import { platform } from "node:os";
+import { stdin, stderr, stdout } from "node:process";
+import pc from "picocolors";
+export function createCliUi(options = {}) {
+    const quiet = options.quiet ?? false;
+    const output = stderr;
+    function shouldWrite(logOptions) {
+        return logOptions?.force === true || !quiet;
+    }
+    function withPromptIo(run) {
+        const io = promptIo();
+        return run(io).finally(() => io.close());
+    }
+    return {
+        intro(title, logOptions) {
+            if (shouldWrite(logOptions))
+                clackIntro(title, { output });
+        },
+        outro(message, logOptions) {
+            if (shouldWrite(logOptions))
+                clackOutro(message, { output });
+        },
+        note(message, title, logOptions) {
+            if (shouldWrite(logOptions))
+                note(message, title, { output });
+        },
+        info(message, logOptions) {
+            if (shouldWrite(logOptions))
+                log.info(message, { output });
+        },
+        step(message, logOptions) {
+            if (shouldWrite(logOptions))
+                log.step(message, { output });
+        },
+        success(message, logOptions) {
+            if (shouldWrite(logOptions))
+                log.success(message, { output });
+        },
+        warn(message, logOptions) {
+            if (shouldWrite(logOptions))
+                log.warn(message, { output });
+        },
+        error(message, logOptions) {
+            if (shouldWrite(logOptions))
+                log.error(message, { output });
+        },
+        debug(message) {
+            if (!quiet)
+                log.message(message, { output, symbol: pc.dim("trace") });
+        },
+        async confirm(message) {
+            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, logOptions) {
+            if (!shouldWrite(logOptions))
+                return silentSpinner();
+            const active = spinner({ output });
+            active.start(message);
+            return active;
+        },
+        progress(message, max, logOptions) {
+            if (!shouldWrite(logOptions))
+                return silentProgress();
+            const active = progress({ output, max });
+            active.start(message);
+            return active;
+        },
+        writeStdout(text) {
+            stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+        },
+    };
+}
+export const format = {
+    heading: (value) => pc.bold(value),
+    label: (value) => pc.cyan(value),
+    muted: (value) => pc.dim(value),
+    success: (value) => pc.green(value),
+    warn: (value) => pc.yellow(value),
+    error: (value) => pc.red(value),
+};
+export function diagnostic(message) {
+    log.message(message, {
+        output: stderr,
+        symbol: pc.dim("·"),
+        spacing: 0,
+        withGuide: false,
+    });
+}
+export function diagnosticError(message) {
+    log.error(message, { output: stderr, spacing: 0, withGuide: false });
+}
+function 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, output) {
+    input.destroy();
+    output.end();
+}
+function silentSpinner() {
+    return {
+        start: () => undefined,
+        stop: () => undefined,
+        cancel: () => undefined,
+        error: () => undefined,
+        message: () => undefined,
+        clear: () => undefined,
+        get isCancelled() {
+            return false;
+        },
+    };
+}
+function silentProgress() {
+    return {
+        ...silentSpinner(),
+        advance: () => undefined,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Local-only diagnostic CLI for checking whether AI is making you dumber.",
   "private": false,
   "type": "module",
@@ -44,6 +44,8 @@
   },
   "dependencies": {
     "@ataraxy-labs/sem": "^0.3.24",
+    "@clack/prompts": "^1.2.0",
+    "picocolors": "^1.1.1",
     "repomix": "^1.14.0"
   }
 }

package/src/analysis.ts

@@ -2,6 +2,7 @@ import { cachedJson, fingerprint } from "./cache.ts";
 import type { LocalModel } from "./model.ts";
 import { searchPrompt } from "./prompts.ts";
 import type { SearchMatch, SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
+import { diagnostic, diagnosticError } from "./ui.ts";
 
 export async function runSearch(
   model: LocalModel,
@@ -150,8 +151,8 @@ Your previous response was not valid JSON. Return the requested JSON object only
   const retryParsed = parseJson(retry);
   if (retryParsed.ok) return retryParsed.value;
 
-  console.error("Raw model output:");
-  console.error(retry);
+  diagnosticError("Raw model output:");
+  diagnostic(retry);
   throw new Error("Model returned invalid JSON.");
 }
 

package/src/constants.ts

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.9";
+export const VERSION = "0.0.10";
 import type { ModelConfig, ModelId } from "./types.ts";
 
 export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";

package/src/model.ts

@@ -1,5 +1,4 @@
 import { execFile, spawn } from "node:child_process";
-import { createReadStream, createWriteStream } from "node:fs";
 import {
   mkdir,
   open,
@@ -10,16 +9,11 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { homedir, platform } from "node:os";
-import {
-  stdin as input,
-  stderr as statusOutput,
-  stdout as output,
-} from "node:process";
-import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { MODEL_REGISTRY } from "./constants.ts";
 import type { ModelId } from "./types.ts";
+import type { CliUi } from "./ui.ts";
 
 const execFileAsync = promisify(execFile);
 const LLAMA_SERVER_HOST = "127.0.0.1";
@@ -51,22 +45,23 @@ export type LocalModel = Readonly<{
 
 export async function firstRunModelBootstrap(
   modelId: ModelId,
+  ui: CliUi,
 ): Promise<string> {
   const selectedModel = MODEL_REGISTRY[modelId];
   const modelDir = path.join(cacheDir(), "models");
   const modelPath = path.join(modelDir, selectedModel.file);
   if (await exists(modelPath)) return modelPath;
 
-  console.error(`No local Stupify model found.
+  ui.note(`No local Stupify model found.
 Stupify runs locally.
 Download this model now?
 Model: ${selectedModel.name}
-Size: ${selectedModel.size}`);
+Size: ${selectedModel.size}`, "Setup", { force: true });
 
-  if (!(await confirm("Continue? y/N "))) throw new Error("Setup cancelled.");
+  if (!(await ui.confirm("Continue?"))) throw new Error("Setup cancelled.");
 
   await mkdir(modelDir, { recursive: true });
-  await downloadModel(modelPath, selectedModel.url);
+  await downloadModel(modelPath, selectedModel.url, ui);
   if (!(await exists(modelPath)))
     throw new Error("Model download failed: file was not created.");
   return modelPath;
@@ -75,18 +70,17 @@ Size: ${selectedModel.size}`);
 export async function loadLocalModel(
   modelPath: string,
   modelId: ModelId,
-  profile: ModelProfile = "scout",
+  profile: ModelProfile,
+  ui: CliUi,
 ): Promise<LocalModel> {
   const selectedModel = MODEL_REGISTRY[modelId];
   const runtime = modelRuntime(profile);
   const runningModel = await runningServerModel(runtime.baseUrl);
 
   if (runningModel) {
-    if (runningModel !== modelId) await stopManagedServer(runtime);
+    if (runningModel !== modelId) await stopManagedServer(runtime, ui);
     if (runningModel === modelId) {
-      console.error(
-        `Using local model: ${selectedModel.name}`,
-      );
+      ui.info(`Using local model: ${selectedModel.name}`);
       return {
         id: modelId,
         name: selectedModel.name,
@@ -97,8 +91,15 @@ export async function loadLocalModel(
   }
 
   await ensureLlamaServerBinary();
-  await startLlamaServer(modelPath, modelId, selectedModel.name, runtime);
-  await waitForServer(runtime.baseUrl, modelId);
+  await startLlamaServer(modelPath, modelId, selectedModel.name, runtime, ui);
+  const ready = ui.spinner(`Waiting for local ${profile} model`);
+  try {
+    await waitForServer(runtime.baseUrl, modelId);
+    ready.stop(`Local ${profile} model ready`);
+  } catch (error) {
+    ready.error(`Local ${profile} model failed to start`);
+    throw error;
+  }
   return {
     id: modelId,
     name: selectedModel.name,
@@ -159,6 +160,7 @@ async function startLlamaServer(
   modelId: ModelId,
   modelName: string,
   runtime: ModelRuntime,
+  ui: CliUi,
 ): Promise<void> {
   const logDir = path.join(cacheDir(), "logs");
   await mkdir(logDir, { recursive: true });
@@ -166,8 +168,8 @@ async function startLlamaServer(
   const out = await open(logPath, "a");
   const err = await open(logPath, "a");
 
-  console.error(`Starting local model server: ${modelName}`);
-  console.error(`llama-server log: ${logPath}`);
+  ui.step(`Starting local model server: ${modelName}`);
+  ui.info(`llama-server log: ${logPath}`);
 
   const args = [
     "-m",
@@ -206,7 +208,7 @@ async function startLlamaServer(
   await err.close();
 }
 
-async function stopManagedServer(runtime: ModelRuntime): Promise<void> {
+async function stopManagedServer(runtime: ModelRuntime, ui: CliUi): Promise<void> {
   const pid = await managedServerPid(runtime);
   if (!pid) {
     const runningModel = await runningServerModel(runtime.baseUrl);
@@ -214,9 +216,7 @@ async function stopManagedServer(runtime: ModelRuntime): Promise<void> {
 Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server.`);
   }
 
-  console.error(
-    "Restarting local model server for selected model.",
-  );
+  ui.step("Restarting local model server for selected model.");
   try {
     process.kill(pid, "SIGTERM");
   } catch {
@@ -279,11 +279,13 @@ function sleep(ms: number): Promise<void> {
 async function downloadModel(
   modelPath: string,
   modelUrl: string,
+  ui: CliUi,
 ): Promise<void> {
   const tempPath = `${modelPath}.download`;
   await rm(tempPath, { force: true });
 
-  console.error("Downloading model...");
+  const downloadSpinner = ui.spinner("Downloading model");
+  let downloadProgress: ReturnType<CliUi["progress"]> | null = null;
   try {
     const response = await fetch(modelUrl);
     if (!response.ok || !response.body)
@@ -292,8 +294,13 @@ async function downloadModel(
     const total = Number(response.headers.get("content-length") ?? 0);
     let received = 0;
     let lastPrint = 0;
+    let lastProgressBytes = 0;
     const reader = response.body.getReader();
     const file = await open(tempPath, "wx");
+    if (total > 0) {
+      downloadSpinner.clear();
+      downloadProgress = ui.progress("Downloading model", total);
+    }
 
     try {
       while (true) {
@@ -304,51 +311,38 @@ async function downloadModel(
         const now = Date.now();
         if (total > 0 && now - lastPrint > 500) {
           lastPrint = now;
-          statusOutput.write(
-            `\r${formatBytes(received)} / ${formatBytes(total)}`,
+          downloadProgress?.advance(
+            received - lastProgressBytes,
+            `${formatBytes(received)} / ${formatBytes(total)}`,
           );
+          lastProgressBytes = received;
         }
       }
     } finally {
       await file.close();
     }
 
-    if (total > 0)
-      statusOutput.write(
-        `\r${formatBytes(received)} / ${formatBytes(total)}\n`,
+    if (downloadProgress && received > lastProgressBytes) {
+      downloadProgress.advance(
+        received - lastProgressBytes,
+        `${formatBytes(received)} / ${formatBytes(total)}`,
       );
+    }
+    const activeProgress = downloadProgress ?? downloadSpinner;
+    activeProgress.stop(
+      total > 0
+        ? `Downloaded ${formatBytes(received)} / ${formatBytes(total)}`
+        : "Downloaded model",
+    );
     await rename(tempPath, modelPath);
   } catch (error) {
+    const activeProgress = downloadProgress ?? downloadSpinner;
+    activeProgress.error("Model download failed");
     await rm(tempPath, { force: true });
     throw error;
   }
 }
 
-async function confirm(question: string): Promise<boolean> {
-  const rl = createInterface(terminalIo());
-  try {
-    const answer = (await rl.question(question)).trim().toLowerCase();
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
-  }
-}
-
-function terminalIo(): {
-  input: NodeJS.ReadableStream;
-  output: NodeJS.WritableStream;
-} {
-  if (input.isTTY) return { input, output };
-  if (platform() !== "win32")
-    return {
-      input: createReadStream("/dev/tty"),
-      output: createWriteStream("/dev/tty"),
-    };
-  throw new Error(
-    "No local Stupify model found. Run `stupify` once in an interactive terminal to set up the model.",
-  );
-}
-
 function cacheDir(): string {
   if (process.env.STUPIFY_CACHE_DIR) return process.env.STUPIFY_CACHE_DIR;
   if (process.env.XDG_CACHE_HOME)

package/src/render.ts

@@ -1,45 +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 🪄
-AI SLOP DETECTED
+  return `${format.warn("AI SLOP DETECTED")}
 ${run.matches.map((match, index) => `${index + 1}.
-   who: ${committerLabel(run)}
-   what: ${match.patternId} - ${match.reason}
-   when: ${sourceLabel(command)}
-   where: ${match.proof}
-   why: ${match.checkWhy ?? "This pattern may indicate judgment-offload."}`).join("\n")}
-Search mode is warn-only.`;
+   ${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 {

package/src/sem-provider.ts

@@ -13,6 +13,7 @@ import {
   sourceRangeSince,
   stagedDiff,
 } from "./git.ts";
+import { diagnostic } from "./ui.ts";
 import type {
   SearchCommand,
   SemChange,
@@ -153,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);
@@ -169,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"] });
@@ -180,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;
@@ -196,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 });
 }
 

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 {