@stupify/cli 0.0.8 → 0.0.10

package/dist/stupify.js

@@ -13,44 +13,47 @@ import { helpText, renderSearchRun } from "./render.js";
 import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
 import { semChangeSetForCommand } from "./sem-provider.js";
 import { createTracer } from "./trace.js";
+import { createCliUi } from "./ui.js";
 export async function main(argv = process.argv.slice(2)) {
     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.js");
-            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, startedAt) {
+export async function runSearchCommand(command, startedAt, ui = createCliUi({ quiet: command.json })) {
     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));
         },
     });
     const profile = await loadSearchProfile(command.searchProfilePath);
@@ -58,7 +61,7 @@ export async function runSearchCommand(command, startedAt) {
     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), {
         count: (v) => v.summary.total,
         detail: (v) => `${v.summary.fileCount} files`,
@@ -78,6 +81,7 @@ export async function runSearchCommand(command, startedAt) {
                 stats: {
                     elapsedMs: Date.now() - startedAt,
                     modelCalls: 0,
+                    committers: changeSet.committers,
                     skipped: true,
                     skipReason: "no_candidates",
                     filesChanged: changeSet.summary.fileCount,
@@ -114,6 +118,7 @@ export async function runSearchCommand(command, startedAt) {
                 stats: {
                     elapsedMs: Date.now() - startedAt,
                     modelCalls: 0,
+                    committers: changeSet.committers,
                     skipped: true,
                     skipReason: "no_candidates",
                     filesChanged: changeSet.summary.fileCount,
@@ -156,6 +161,7 @@ export async function runSearchCommand(command, startedAt) {
                     modelCalls: 0,
                     inputTokens: batches.estimatedInputTokens,
                     inputTokenCap: maxSearchInputTokens,
+                    committers: changeSet.committers,
                     skipped: true,
                     skipReason: "input_too_large",
                     filesChanged: changeSet.summary.fileCount,
@@ -175,13 +181,13 @@ export async function runSearchCommand(command, startedAt) {
             };
         }
         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;
@@ -192,7 +198,7 @@ export async function runSearchCommand(command, startedAt) {
             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;
             }
@@ -212,6 +218,7 @@ export async function runSearchCommand(command, startedAt) {
                 modelCalls,
                 inputTokens,
                 inputTokenCap: maxSearchInputTokens,
+                committers: changeSet.committers,
                 filesChanged: changeSet.summary.fileCount,
                 entitiesScanned: changeSet.summary.total,
                 candidates: contexts.length,
@@ -320,12 +327,14 @@ function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includ
         includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
     });
 }
-function printRunPlan(command, patternIds) {
+function printRunPlan(command, patternIds, ui) {
     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, ms, count, detail) {
     if (name === "entity.diff")

package/dist/types.d.ts

@@ -105,6 +105,7 @@ export type SourceRange = Readonly<{
     label: string;
     base: string;
     target: string;
+    committers?: readonly string[];
     stats: NetDiffStats;
 }>;
 export type SemChange = Readonly<{
@@ -130,6 +131,7 @@ export type SemChangeSet = Readonly<{
     label: string;
     base: string;
     target: string;
+    committers?: readonly string[];
     contextCwd: string;
     cleanup: () => Promise<void>;
     changes: readonly SemChange[];
@@ -214,6 +216,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/dist/ui.d.ts

@@ -0,0 +1,34 @@
+import { type SpinnerResult } from "@clack/prompts";
+export type CliUi = ReturnType<typeof createCliUi>;
+export type CliUiOptions = Readonly<{
+    quiet?: boolean;
+}>;
+type LogOptions = Readonly<{
+    force?: boolean;
+}>;
+export declare function createCliUi(options?: CliUiOptions): {
+    intro(title: string, logOptions?: LogOptions): void;
+    outro(message: string, logOptions?: LogOptions): void;
+    note(message: string, title?: string, logOptions?: LogOptions): void;
+    info(message: string, logOptions?: LogOptions): void;
+    step(message: string, logOptions?: LogOptions): void;
+    success(message: string, logOptions?: LogOptions): void;
+    warn(message: string, logOptions?: LogOptions): void;
+    error(message: string, logOptions?: LogOptions): void;
+    debug(message: string): void;
+    confirm(message: string): Promise<boolean>;
+    spinner(message: string, logOptions?: LogOptions): SpinnerResult;
+    progress(message: string, max: number, logOptions?: LogOptions): import("@clack/prompts").ProgressResult;
+    writeStdout(text: string): void;
+};
+export declare const format: {
+    heading: (value: string) => string;
+    label: (value: string) => string;
+    muted: (value: string) => string;
+    success: (value: string) => string;
+    warn: (value: string) => string;
+    error: (value: string) => string;
+};
+export declare function diagnostic(message: string): void;
+export declare function diagnosticError(message: string): void;
+export {};

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.8",
+  "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.8";
+export const VERSION = "0.0.10";
 import type { ModelConfig, ModelId } from "./types.ts";
 
 export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";

package/src/git.ts

@@ -96,6 +96,15 @@ export async function gitPath(pathspec: string): Promise<string> {
   }
 }
 
+export async function gitUserLabel(): Promise<string> {
+  const [name, email] = await Promise.all([
+    gitConfig("user.name"),
+    gitConfig("user.email"),
+  ]);
+  if (name && email) return `${name} <${email}>`;
+  return name || email || "working tree";
+}
+
 async function netDiff(base: string, target: string, label: string, id?: NetDiff["id"]): Promise<NetDiff> {
   const [text, stats, shortBase, shortTarget] = await Promise.all([
     diff(base, target),
@@ -114,20 +123,54 @@ async function netDiff(base: string, target: string, label: string, id?: NetDiff
 }
 
 async function sourceRange(base: string, target: string, label: string, id?: SourceRange["id"]): Promise<SourceRange> {
-  const [stats, shortBase, shortTarget] = await Promise.all([
+  const [stats, shortBase, shortTarget, committers] = await Promise.all([
     diffStats(base, target),
     shortCommit(base),
     shortCommit(target),
+    committersForRange(base, target),
   ]);
   return {
     id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
     label,
     base,
     target,
+    committers,
     stats,
   };
 }
 
+async function gitConfig(key: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["config", "--get", key]);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+
+async function committersForRange(base: string, target: string): Promise<readonly string[]> {
+  try {
+    const { stdout } = await execFileAsync("git", ["log", "--format=%cn <%ce>", `${base}..${target}`], {
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    return uniqueLines(stdout);
+  } catch {
+    return [];
+  }
+}
+
+function uniqueLines(value: string): readonly string[] {
+  const seen = new Set<string>();
+  const lines: string[] = [];
+  for (const line of value.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    lines.push(trimmed);
+  }
+  return lines;
+}
+
 async function baseBefore(since: string): Promise<string> {
   try {
     const { stdout } = await execFileAsync("git", [

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)