@aayambansal/squint 0.1.0

package/dist/cli.js

@@ -0,0 +1,968 @@
+#!/usr/bin/env node
+import {
+  DevServer,
+  buildFixPrompt,
+  detectDevCommand
+} from "./chunk-FQDSJRTY.js";
+import {
+  runAgent
+} from "./chunk-MGHJSERZ.js";
+import {
+  composePrompt
+} from "./chunk-NT2HR4RD.js";
+import {
+  buildGatePrompt,
+  detectGates,
+  runGates
+} from "./chunk-43VZK47W.js";
+import {
+  buildReviewPrompt,
+  buildRuntimeFixPrompt,
+  captureViewports,
+  clearState,
+  loadState,
+  probeRuntime,
+  runtimeSummary,
+  saveState
+} from "./chunk-4XHTAWTH.js";
+import "./chunk-OJTW5SYY.js";
+import "./chunk-MURKQ7SI.js";
+import {
+  detectEngines,
+  engines,
+  getEngine
+} from "./chunk-YIVPCWSG.js";
+import {
+  restoreSnapshot,
+  takeSnapshot
+} from "./chunk-WTA6YYBY.js";
+
+// src/cli.tsx
+import { Command } from "commander";
+import { render } from "ink";
+import pc from "picocolors";
+
+// src/config/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  /** Default engine id (claude, codex, gemini, opencode, amp, cursor, copilot, aider). */
+  engine: z.string().optional(),
+  /** Per-engine model overrides, e.g. { claude: "claude-sonnet-5" }. */
+  models: z.record(z.string()).optional(),
+  /** Start the project's dev server automatically when the TUI opens. */
+  autoDev: z.boolean().optional(),
+  /** Automatically send dev-server errors back to the engine (max 2 attempts). */
+  autoFix: z.boolean().optional(),
+  /** Probe the running app's runtime after each clean turn (default on). */
+  autoProbe: z.boolean().optional()
+});
+function defaultPaths(cwd) {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), ".config");
+  return {
+    globalFile: path.join(base, "squint", "config.json"),
+    projectFile: path.join(cwd, ".squint", "config.json")
+  };
+}
+function readConfigFile(file) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    return ConfigSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    throw new Error(`Invalid config at ${file}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function loadConfig(paths) {
+  const global = readConfigFile(paths.globalFile);
+  const project = readConfigFile(paths.projectFile);
+  return {
+    ...global,
+    ...project,
+    models: { ...global.models, ...project.models }
+  };
+}
+function resolveEngineId(config, override) {
+  return override ?? config.engine ?? "claude";
+}
+function resolveModel(config, engineId, override) {
+  return override ?? config.models?.[engineId];
+}
+function setConfigValue(file, key, value) {
+  const current = readConfigFile(file);
+  let next;
+  if (key === "engine") {
+    next = { ...current, engine: value };
+  } else if (key === "autoDev" || key === "autoFix" || key === "autoProbe") {
+    if (value !== "true" && value !== "false") {
+      throw new Error(`"${key}" must be true or false`);
+    }
+    next = { ...current, [key]: value === "true" };
+  } else if (key.startsWith("models.")) {
+    const engineId = key.slice("models.".length);
+    if (!engineId) throw new Error("Usage: squint config set models.<engineId> <model>");
+    next = { ...current, models: { ...current.models, [engineId]: value } };
+  } else {
+    throw new Error(`Unknown config key "${key}". Supported: engine, autoDev, autoFix, autoProbe, models.<engineId>`);
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+
+// src/tui/App.tsx
+import { Box, Static, Text as Text2, useApp, useInput } from "ink";
+import path2 from "path";
+import { useCallback, useEffect as useEffect2, useRef, useState as useState2 } from "react";
+
+// src/tui/messages.tsx
+import { Text } from "ink";
+import { useEffect, useState } from "react";
+
+// src/tui/theme.ts
+var theme = {
+  accent: "#e8a33d",
+  dim: "gray",
+  user: "#7aa2f7",
+  error: "#f7768e",
+  success: "#9ece6a",
+  tool: "#7dcfff"
+};
+
+// src/tui/messages.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function WorkingLine({ startedAt }) {
+  const [frame, setFrame] = useState(0);
+  const [elapsed, setElapsed] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
+      setElapsed(Math.floor((Date.now() - startedAt) / 1e3));
+    }, 80);
+    return () => clearInterval(timer);
+  }, [startedAt]);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.accent, children: SPINNER_FRAMES[frame] }),
+    /* @__PURE__ */ jsxs(Text, { color: theme.dim, children: [
+      " ",
+      "working\u2026 ",
+      elapsed,
+      "s \xB7 esc to interrupt"
+    ] })
+  ] });
+}
+function MessageLine({ message }) {
+  switch (message.role) {
+    case "user":
+      return /* @__PURE__ */ jsxs(Text, { color: theme.user, wrap: "wrap", children: [
+        "\u276F ",
+        message.text
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: message.text });
+    case "status":
+      return /* @__PURE__ */ jsxs(Text, { color: theme.dim, wrap: "wrap", children: [
+        "\xB7 ",
+        message.text
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs(Text, { color: theme.tool, wrap: "wrap", children: [
+        "\u2699 ",
+        message.text
+      ] });
+    case "thinking":
+      return /* @__PURE__ */ jsx(Text, { color: theme.dim, italic: true, wrap: "wrap", children: message.text });
+    case "error":
+      return /* @__PURE__ */ jsxs(Text, { color: theme.error, wrap: "wrap", children: [
+        "\u2717 ",
+        message.text
+      ] });
+  }
+}
+
+// src/tui/App.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX_AUTO_FIX_ATTEMPTS = 2;
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function App({ cwd, initialEngine, initialModel, autoDev, autoFix, autoProbe }) {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState2([]);
+  const [input, setInput] = useState2("");
+  const [running, setRunning] = useState2(false);
+  const [runStartedAt, setRunStartedAt] = useState2(0);
+  const [engineId, setEngineId] = useState2(initialEngine);
+  const [model, setModel] = useState2(initialModel);
+  const [liveText, setLiveText] = useState2("");
+  const [devState, setDevState] = useState2("stopped");
+  const [devUrl, setDevUrl] = useState2(null);
+  const liveRef = useRef("");
+  const idRef = useRef(0);
+  const sessionRef = useRef(void 0);
+  const devRef = useRef(null);
+  const abortRef = useRef(null);
+  const pendingFixRef = useRef(null);
+  const snapshotRef = useRef(null);
+  const fixAttemptsRef = useRef(0);
+  const reviewTipShownRef = useRef(false);
+  const historyRef = useRef([]);
+  const historyIndexRef = useRef(-1);
+  const push = useCallback((role, text) => {
+    idRef.current += 1;
+    setMessages((prev) => [...prev, { id: idRef.current, role, text }]);
+  }, []);
+  const commitLive = useCallback(() => {
+    if (liveRef.current.length > 0) {
+      push("assistant", liveRef.current);
+      liveRef.current = "";
+      setLiveText("");
+    }
+  }, [push]);
+  const getDevServer = useCallback(() => {
+    if (!devRef.current) {
+      devRef.current = new DevServer(cwd, {
+        onStateChange: setDevState,
+        onUrl: setDevUrl
+      });
+    }
+    return devRef.current;
+  }, [cwd]);
+  useEffect2(() => {
+    if (autoDev && detectDevCommand(cwd)) {
+      getDevServer().start();
+    }
+    const saved = loadState(cwd);
+    if (saved) {
+      try {
+        if (getEngine(saved.engine).supportsResume) {
+          const mins = Math.max(1, Math.round((Date.now() - saved.at) / 6e4));
+          push(
+            "status",
+            `previous session (${mins}m ago${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}) \u2014 /resume to continue`
+          );
+        }
+      } catch {
+      }
+    }
+    return () => devRef.current?.stop();
+  }, [autoDev, cwd, getDevServer, push]);
+  const handleEvent = useCallback(
+    (event) => {
+      switch (event.type) {
+        case "status":
+          commitLive();
+          push("status", event.text);
+          break;
+        case "delta":
+          liveRef.current += event.text;
+          setLiveText(liveRef.current);
+          break;
+        case "text":
+          if (event.streamed) {
+            liveRef.current = "";
+            setLiveText("");
+            push("assistant", event.text);
+          } else {
+            liveRef.current += (liveRef.current.length > 0 ? "\n" : "") + event.text;
+            setLiveText(liveRef.current);
+          }
+          break;
+        case "thinking":
+          commitLive();
+          push("thinking", event.text);
+          break;
+        case "tool":
+          commitLive();
+          push("tool", event.detail ? `${event.name} \xB7 ${event.detail}` : event.name);
+          break;
+        case "error":
+          commitLive();
+          push("error", event.text);
+          break;
+        case "result":
+          if (event.sessionId) sessionRef.current = event.sessionId;
+          break;
+        case "raw":
+          break;
+      }
+    },
+    [push, commitLive]
+  );
+  const runTurn = useCallback(
+    async (prompt, display) => {
+      push("user", display);
+      setRunning(true);
+      setRunStartedAt(Date.now());
+      const runStart = Date.now();
+      const engine = getEngine(engineId);
+      const abort = new AbortController();
+      abortRef.current = abort;
+      const result = await runAgent(
+        engine,
+        {
+          prompt,
+          cwd,
+          model,
+          sessionId: engine.supportsResume ? sessionRef.current : void 0
+        },
+        handleEvent,
+        abort.signal
+      );
+      abortRef.current = null;
+      commitLive();
+      if (result.ok) {
+        const cost = result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : "";
+        const secs = result.durationMs !== void 0 ? ` \xB7 ${(result.durationMs / 1e3).toFixed(0)}s` : "";
+        push("status", `done${secs}${cost}`);
+        if (sessionRef.current) {
+          saveState(cwd, {
+            engine: engineId,
+            sessionId: sessionRef.current,
+            model,
+            lastAsk: display.length > 80 ? `${display.slice(0, 79)}\u2026` : display,
+            at: Date.now()
+          });
+        }
+      }
+      const dev = devRef.current;
+      if (result.error !== "interrupted" && dev && (dev.state === "running" || dev.state === "starting")) {
+        await delay(1500);
+        const errors = dev.errorsSince(runStart);
+        if (errors.length > 0) {
+          pendingFixRef.current = {
+            prompt: buildFixPrompt(errors, dev.tail(30)),
+            display: "\u26D1 fix dev server errors"
+          };
+          push("error", `dev server: ${errors.length} error line(s)
+${errors.slice(-5).join("\n")}`);
+          if (autoFix && fixAttemptsRef.current < MAX_AUTO_FIX_ATTEMPTS) {
+            fixAttemptsRef.current += 1;
+            push("status", `auto-fix attempt ${fixAttemptsRef.current}/${MAX_AUTO_FIX_ATTEMPTS}`);
+            setRunning(false);
+            await runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
+            return;
+          }
+          push("status", "type /fix to send them to the engine");
+        } else {
+          pendingFixRef.current = null;
+          if (autoProbe !== false && devUrl) {
+            const report = await probeRuntime(devUrl);
+            const summary = report ? runtimeSummary(report) : null;
+            if (report && summary) {
+              pendingFixRef.current = {
+                prompt: buildRuntimeFixPrompt(report),
+                display: "\u26D1 fix runtime errors"
+              };
+              push("error", `runtime: ${summary}`);
+              if (autoFix && fixAttemptsRef.current < MAX_AUTO_FIX_ATTEMPTS) {
+                fixAttemptsRef.current += 1;
+                push("status", `auto-fix attempt ${fixAttemptsRef.current}/${MAX_AUTO_FIX_ATTEMPTS}`);
+                setRunning(false);
+                await runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
+                return;
+              }
+              push("status", "type /fix to send them to the engine");
+            }
+          }
+          if (!reviewTipShownRef.current && devUrl) {
+            reviewTipShownRef.current = true;
+            push("status", "tip: /review screenshots the app and has the engine critique its own work");
+          }
+        }
+      }
+      setRunning(false);
+    },
+    [cwd, engineId, model, push, handleEvent, commitLive, autoFix, autoProbe, devUrl]
+  );
+  const capture = useCallback(async () => {
+    if (!devUrl) {
+      push("error", "dev server not running \u2014 /dev first");
+      return null;
+    }
+    push("status", "capturing screenshots\u2026");
+    const result = await captureViewports(cwd, devUrl);
+    if (!result) {
+      push("error", "no Chrome/Chromium found for screenshots");
+      return null;
+    }
+    for (const err of result.errors) push("error", `screenshot ${err}`);
+    if (result.shots.length > 0) {
+      push("status", `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path2.dirname(result.shots[0].path)}`);
+    }
+    if (result.runtime) {
+      const summary = runtimeSummary(result.runtime);
+      if (summary) {
+        push("error", `runtime: ${summary}`);
+        pendingFixRef.current = {
+          prompt: buildRuntimeFixPrompt(result.runtime),
+          display: "\u26D1 fix runtime errors"
+        };
+        push("status", "type /fix to send them to the engine");
+      } else {
+        push("status", "runtime clean \u2014 no console errors, exceptions, or failed requests");
+      }
+    }
+    return result.shots.length > 0 ? result : null;
+  }, [cwd, devUrl, push]);
+  const submit = useCallback(
+    async (ask) => {
+      fixAttemptsRef.current = 0;
+      snapshotRef.current = takeSnapshot(cwd);
+      const isFirstTurn = sessionRef.current === void 0;
+      const prompt = isFirstTurn ? composePrompt(ask, { cwd, firstTurn: true }) : ask;
+      await runTurn(prompt, ask);
+    },
+    [cwd, runTurn]
+  );
+  const handleCommand = useCallback(
+    (command) => {
+      const [name, ...rest] = command.slice(1).split(/\s+/);
+      const arg = rest.join(" ").trim();
+      switch (name) {
+        case "engine":
+          if (!arg) {
+            push("status", `engines: ${engines.map((e) => e.id).join(", ")}`);
+          } else {
+            try {
+              getEngine(arg);
+              setEngineId(arg);
+              sessionRef.current = void 0;
+              push("status", `engine \u2192 ${arg} (new session)`);
+            } catch (err) {
+              push("error", err instanceof Error ? err.message : String(err));
+            }
+          }
+          break;
+        case "model":
+          setModel(arg || void 0);
+          push("status", arg ? `model \u2192 ${arg}` : "model \u2192 engine default");
+          break;
+        case "dev": {
+          const dev = getDevServer();
+          if (dev.state === "stopped" || dev.state === "crashed") {
+            const devCommand = detectDevCommand(cwd);
+            if (!devCommand) {
+              push("error", "no dev/start script found in package.json");
+            } else {
+              dev.start(devCommand);
+              push("status", `dev server starting \xB7 ${devCommand.display}`);
+            }
+          } else {
+            dev.stop();
+            setDevUrl(null);
+            push("status", "dev server stopped");
+          }
+          break;
+        }
+        case "fix":
+          if (!pendingFixRef.current) {
+            push("status", "nothing to fix \u2014 no captured errors or failed gates");
+          } else {
+            void runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
+          }
+          break;
+        case "check":
+          void (async () => {
+            const gates = detectGates(cwd);
+            if (gates.length === 0) {
+              push("status", "no gates detected in this project");
+              return;
+            }
+            push("status", `running gates: ${gates.map((g) => g.id).join(" \u2192 ")}`);
+            setRunning(true);
+            setRunStartedAt(Date.now());
+            const results = await runGates(cwd, gates, (result) => {
+              push(
+                result.ok ? "status" : "error",
+                `${result.ok ? "\u2713" : "\u2717"} ${result.gate.id} \xB7 ${(result.durationMs / 1e3).toFixed(1)}s`
+              );
+            });
+            setRunning(false);
+            const failures = results.filter((r) => !r.ok);
+            if (failures.length > 0) {
+              pendingFixRef.current = {
+                prompt: buildGatePrompt(failures),
+                display: `\u26D1 fix failing gates: ${failures.map((f) => f.gate.id).join(", ")}`
+              };
+              push("status", "type /fix to send failures to the engine");
+            } else {
+              push("status", "all gates passed");
+            }
+          })();
+          break;
+        case "shot":
+          void capture();
+          break;
+        case "review":
+          void (async () => {
+            const result = await capture();
+            if (result) {
+              await runTurn(
+                buildReviewPrompt(result.shots, arg || void 0, result.runtime),
+                `\u{1F441} review rendered UI${arg ? ` \xB7 ${arg}` : ""}`
+              );
+            }
+          })();
+          break;
+        case "undo": {
+          const snapshot = snapshotRef.current;
+          if (!snapshot) {
+            push("status", "nothing to undo \u2014 no ask this session, or not a git repo with commits");
+            break;
+          }
+          const result = restoreSnapshot(cwd, snapshot);
+          if (result.restored) {
+            snapshotRef.current = null;
+            push(
+              "status",
+              `reverted the last ask${result.deletedFiles > 0 ? ` \xB7 removed ${result.deletedFiles} created file(s)` : ""}`
+            );
+          } else {
+            push("error", `undo failed: ${result.detail ?? "unknown error"}`);
+          }
+          break;
+        }
+        case "resume": {
+          const saved = loadState(cwd);
+          if (!saved) {
+            push("status", "no previous session for this project");
+            break;
+          }
+          try {
+            if (!getEngine(saved.engine).supportsResume) {
+              push("status", `previous engine ${saved.engine} cannot resume sessions`);
+              break;
+            }
+          } catch {
+            push("error", `previous engine ${saved.engine} is no longer available`);
+            break;
+          }
+          setEngineId(saved.engine);
+          if (saved.model) setModel(saved.model);
+          sessionRef.current = saved.sessionId;
+          push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
+          break;
+        }
+        case "clear":
+          setMessages([]);
+          sessionRef.current = void 0;
+          clearState(cwd);
+          break;
+        case "help":
+          push(
+            "status",
+            "/engine <id> \xB7 /model <name> \xB7 /dev (start/stop server) \xB7 /check (quality gates) \xB7 /fix (send failures) \xB7 /shot (screenshots) \xB7 /review [focus] (visual self-critique) \xB7 /undo (revert last ask) \xB7 /resume (last session) \xB7 /clear (new session) \xB7 /quit"
+          );
+          break;
+        case "quit":
+        case "exit":
+          devRef.current?.stop();
+          exit();
+          break;
+        default:
+          push("error", `unknown command /${name} \u2014 try /help`);
+      }
+    },
+    [push, exit, cwd, getDevServer, runTurn, capture]
+  );
+  useInput((char, key) => {
+    if (key.ctrl && char === "c") {
+      devRef.current?.stop();
+      exit();
+      return;
+    }
+    if (running) {
+      if (key.escape) abortRef.current?.abort();
+      return;
+    }
+    if (key.return) {
+      const value = input.trim();
+      setInput("");
+      historyIndexRef.current = -1;
+      if (!value) return;
+      historyRef.current.push(value);
+      if (value.startsWith("/")) {
+        handleCommand(value);
+      } else {
+        void submit(value);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      const history = historyRef.current;
+      if (history.length === 0) return;
+      const next = historyIndexRef.current === -1 ? history.length - 1 : Math.max(historyIndexRef.current - 1, 0);
+      historyIndexRef.current = next;
+      setInput(history[next] ?? "");
+      return;
+    }
+    if (key.downArrow) {
+      const history = historyRef.current;
+      if (historyIndexRef.current === -1) return;
+      const next = historyIndexRef.current + 1;
+      if (next >= history.length) {
+        historyIndexRef.current = -1;
+        setInput("");
+      } else {
+        historyIndexRef.current = next;
+        setInput(history[next] ?? "");
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+    if (char && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + char);
+    }
+  });
+  const devBadge = devState === "running" ? ` \xB7 ${devUrl ?? "dev running"}` : devState === "starting" ? " \xB7 dev starting\u2026" : devState === "crashed" ? " \xB7 dev crashed" : "";
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Static, { items: messages, children: (message) => /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsx2(MessageLine, { message }) }, message.id) }),
+    liveText.length > 0 && /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsx2(Text2, { wrap: "wrap", children: liveText }) }),
+    /* @__PURE__ */ jsx2(Box, { marginTop: 1, children: running ? /* @__PURE__ */ jsx2(WorkingLine, { startedAt: runStartedAt }) : /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u276F " }),
+      input,
+      /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u258F" })
+    ] }) }),
+    /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsxs2(Text2, { color: theme.dim, children: [
+      engineId,
+      model ? ` \xB7 ${model}` : "",
+      " \xB7 ",
+      path2.basename(cwd),
+      devBadge,
+      " \xB7 /help"
+    ] }) })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("squint").description("Lovable for your terminal \u2014 a frontend harness on top of Claude Code, Codex, and friends.").version(VERSION);
+program.command("run").description("Run one prompt headlessly and stream the result").argument("<prompt...>", "what to build or change").option("-e, --engine <id>", "engine to use (claude, codex, gemini, opencode)").option("-m, --model <name>", "model override for the engine").option("--no-brief", "send the prompt without the squint design brief").option("--json", "emit normalized agent events as ndjson").action(
+  async (promptWords, options) => {
+    const cwd = process.cwd();
+    const config = loadConfig(defaultPaths(cwd));
+    const engineId = resolveEngineId(config, options.engine);
+    const engine = getEngine(engineId);
+    const model = resolveModel(config, engineId, options.model);
+    const ask = promptWords.join(" ");
+    const prompt = composePrompt(ask, { cwd, noBrief: !options.brief });
+    const onEvent = options.json ? (event) => {
+      if (event.type !== "delta") console.log(JSON.stringify(event));
+    } : createPrinter();
+    if (!options.json) console.log(pc.dim(`squint \xB7 ${engine.id}${model ? ` \xB7 ${model}` : ""}`));
+    const result = await runAgent(engine, { prompt, cwd, model }, onEvent);
+    if (options.json) {
+      console.log(JSON.stringify({ type: "summary", ...result }));
+    } else if (result.ok) {
+      const cost = result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : "";
+      const secs = result.durationMs !== void 0 ? ` \xB7 ${(result.durationMs / 1e3).toFixed(0)}s` : "";
+      console.log(pc.green(`\u2713 done${secs}${cost}`));
+    }
+    if (!result.ok) process.exitCode = 1;
+  }
+);
+program.command("engines").description("List engines and whether they are installed").action(() => {
+  for (const { engine, path: binaryPath } of detectEngines()) {
+    const status = binaryPath ? pc.green("\u2713") : pc.red("\u2717");
+    const location = binaryPath ?? pc.dim(`not found \u2014 ${engine.install}`);
+    console.log(`${status} ${engine.id.padEnd(10)} ${engine.name.padEnd(14)} ${location}`);
+  }
+});
+program.command("doctor").description("Check squint prerequisites and engine availability").action(async () => {
+  const [major] = process.versions.node.split(".");
+  const nodeOk = Number(major) >= 20;
+  console.log(`${nodeOk ? pc.green("\u2713") : pc.red("\u2717")} node ${process.versions.node}${nodeOk ? "" : " (need >= 20)"}`);
+  const detected = detectEngines();
+  for (const { engine, path: binaryPath } of detected) {
+    const status = binaryPath ? pc.green("\u2713") : pc.yellow("\u25CB");
+    console.log(`${status} ${engine.name}${binaryPath ? "" : pc.dim(` \u2014 install: ${engine.install}`)}`);
+  }
+  const { findChrome } = await import("./chrome-4WNYZZ42.js");
+  const { hasWebSocket } = await import("./cdp-5OHNGQXV.js");
+  const chrome = findChrome();
+  console.log(
+    chrome ? `${pc.green("\u2713")} Chrome ${pc.dim(chrome)}` : `${pc.yellow("\u25CB")} Chrome ${pc.dim("\u2014 screenshots and runtime probing disabled")}`
+  );
+  console.log(
+    hasWebSocket() ? `${pc.green("\u2713")} WebSocket ${pc.dim("runtime console/network capture available")}` : `${pc.yellow("\u25CB")} WebSocket ${pc.dim("\u2014 node 22+ enables runtime capture; screenshots still work")}`
+  );
+  const available = detected.filter((d) => d.path !== null);
+  if (available.length === 0) {
+    console.log(pc.red("\nNo engines found. Install at least one to use squint."));
+    process.exitCode = 1;
+  } else {
+    console.log(pc.dim(`
+${available.length} engine(s) ready.`));
+  }
+});
+program.command("init").description("Scaffold a new Vite + React + TS + Tailwind app with token-first CSS").argument("[dir]", "target directory", ".").option("--force", "write into a non-empty directory").option("--no-install", "skip npm install").action(async (dir, options) => {
+  const { installDependencies, writeTemplate } = await import("./init-7AYGAKOS.js");
+  let result;
+  try {
+    result = writeTemplate(dir, { force: options.force });
+  } catch (err) {
+    console.error(pc.red(`\u2717 ${err instanceof Error ? err.message : String(err)}`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc.green(`\u2713 scaffolded ${result.files.length} files in ${result.dir}`));
+  if (options.install) {
+    console.log(pc.dim("installing dependencies\u2026"));
+    const ok = await installDependencies(result.dir);
+    if (!ok) {
+      console.error(pc.red("\u2717 npm install failed \u2014 run it manually"));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const cd = result.dir === "." ? "" : `cd ${result.dir} && `;
+  console.log(`
+Next: ${pc.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
+  console.log(pc.dim("then describe what to build \u2014 /dev starts the preview server"));
+});
+program.command("tag").description("Add the element picker to this Vite app (Alt+S in the browser \u2192 click \u2192 file:line:col)").action(async () => {
+  const fs2 = await import("fs");
+  const nodePath = await import("path");
+  const { patchViteConfig, TAGGER_FILENAME, TAGGER_SOURCE } = await import("./source-MEXHWVP4.js");
+  const cwd = process.cwd();
+  const taggerPath = nodePath.join(cwd, TAGGER_FILENAME);
+  fs2.writeFileSync(taggerPath, TAGGER_SOURCE);
+  console.log(pc.green(`\u2713 ${TAGGER_FILENAME} written`));
+  const configPath = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].map((name) => nodePath.join(cwd, name)).find((candidate) => fs2.existsSync(candidate));
+  if (!configPath) {
+    console.log(pc.yellow("\u25CB no vite config found \u2014 add the plugin manually:"));
+    console.log(pc.dim(`  import squintTagger from './${TAGGER_FILENAME}'
+  plugins: [squintTagger(), \u2026]`));
+    return;
+  }
+  const source = fs2.readFileSync(configPath, "utf8");
+  const patched = patchViteConfig(source);
+  if (patched === "already") {
+    console.log(pc.dim("vite config already wired"));
+  } else if (patched === null) {
+    console.log(pc.yellow(`\u25CB could not patch ${nodePath.basename(configPath)} automatically \u2014 add:`));
+    console.log(pc.dim(`  import squintTagger from './${TAGGER_FILENAME}'
+  plugins: [squintTagger(), \u2026]`));
+  } else {
+    fs2.writeFileSync(configPath, patched);
+    console.log(pc.green(`\u2713 ${nodePath.basename(configPath)} wired`));
+  }
+  console.log(pc.dim("\nin the running app: Alt+S \u2192 click an element \u2192 paste the copied file:line:col into squint"));
+});
+var variantsCommand = program.command("variants").description("Parallel design explorations \u2014 one aesthetic family each, pick with your eyes");
+variantsCommand.command("gen").description("Generate n variants of one ask in parallel (n engine runs \u2014 n\xD7 cost)").argument("<n>", "how many variants (max 4)").argument("<prompt...>", "what to build").option("-e, --engine <id>", "engine to use").option("-m, --model <name>", "model override").option("--no-shots", "skip the screenshot pass").action(
+  async (nRaw, promptWords, options) => {
+    const cwd = process.cwd();
+    const n = Number.parseInt(nRaw, 10);
+    if (!Number.isInteger(n) || n < 2 || n > 4) {
+      console.error(pc.red("\u2717 n must be 2\u20134"));
+      process.exitCode = 1;
+      return;
+    }
+    const { isGitRepo } = await import("./snapshot-KKUY5RR6.js");
+    if (!isGitRepo(cwd)) {
+      console.error(pc.red("\u2717 variants need a git repo with at least one commit"));
+      process.exitCode = 1;
+      return;
+    }
+    const { runVariants, cleanVariants } = await import("./variants-VVIYT7WI.js");
+    const config = loadConfig(defaultPaths(cwd));
+    const engineId = resolveEngineId(config, options.engine);
+    const engine = getEngine(engineId);
+    const model = resolveModel(config, engineId, options.model);
+    const ask = promptWords.join(" ");
+    cleanVariants(cwd);
+    console.log(pc.dim(`generating ${n} directions in parallel via ${engine.id} \u2014 this runs ${n} engine sessions`));
+    const runs = await runVariants(
+      cwd,
+      ask,
+      n,
+      engine,
+      model,
+      (familyId, text) => console.log(`${pc.cyan(familyId.padEnd(18))} ${pc.dim(text)}`)
+    );
+    const succeeded = runs.filter((r) => r.result.ok);
+    if (options.shots && succeeded.length > 0) {
+      const { screenshotVariants } = await import("./shots-ADBOBALL.js");
+      console.log(pc.dim("capturing screenshots\u2026"));
+      const shots = await screenshotVariants(cwd, succeeded.map((r) => r.variant));
+      for (const shot of shots) {
+        console.log(`${pc.green("\u2713")} ${shot.familyId.padEnd(18)} ${shot.path ?? pc.dim(shot.error ?? "")}`);
+      }
+    }
+    console.log(
+      `
+${succeeded.length}/${runs.length} variants ready in .squint/variants/ \u2014 ` + pc.bold("squint variants apply <id>") + pc.dim(" applies the winner, squint variants clean discards all")
+    );
+    if (succeeded.length === 0) process.exitCode = 1;
+  }
+);
+variantsCommand.command("list").description("List generated variants").action(async () => {
+  const { listVariants } = await import("./variants-VVIYT7WI.js");
+  const ids = listVariants(process.cwd());
+  if (ids.length === 0) {
+    console.log(pc.dim('no variants \u2014 squint variants gen <n> "<ask>"'));
+    return;
+  }
+  for (const id of ids) console.log(id);
+});
+variantsCommand.command("apply").description("Apply one variant\u2019s changes to the main tree and discard the rest").argument("<id>", "family id of the winning variant").action(async (id) => {
+  const { applyVariant, cleanVariants } = await import("./variants-VVIYT7WI.js");
+  const cwd = process.cwd();
+  const result = applyVariant(cwd, id);
+  if (!result.ok) {
+    console.error(pc.red(`\u2717 ${result.detail}`));
+    process.exitCode = 1;
+    return;
+  }
+  cleanVariants(cwd);
+  console.log(pc.green(`\u2713 applied ${id} to the working tree`) + pc.dim(" \u2014 review with git diff"));
+});
+variantsCommand.command("clean").description("Discard all variants").action(async () => {
+  const { cleanVariants } = await import("./variants-VVIYT7WI.js");
+  const count = cleanVariants(process.cwd());
+  console.log(pc.dim(`removed ${count} variant(s)`));
+});
+program.command("brief").description("Set a committed design direction for this project (.squint/brief.md)").argument("[family]", "aesthetic family id (omit to list)").option("--force", "overwrite an existing project brief").action(async (familyId, options) => {
+  const fs2 = await import("fs");
+  const nodePath = await import("path");
+  const { FAMILIES, getFamily, renderFamilyBrief } = await import("./families-RVP5BWQD.js");
+  if (!familyId) {
+    console.log(pc.bold("Aesthetic families") + pc.dim(" \u2014 squint brief <id>\n"));
+    for (const family2 of FAMILIES) {
+      console.log(`${pc.green(family2.id.padEnd(18))} ${family2.name.padEnd(22)} ${pc.dim(family2.summary)}`);
+    }
+    console.log(pc.dim("\nThe brief wraps every ask; edit .squint/brief.md to remix."));
+    return;
+  }
+  const family = getFamily(familyId);
+  if (!family) {
+    console.error(pc.red(`\u2717 unknown family "${familyId}" \u2014 run squint brief to list`));
+    process.exitCode = 1;
+    return;
+  }
+  const target = nodePath.join(process.cwd(), ".squint", "brief.md");
+  if (fs2.existsSync(target) && !options.force) {
+    console.error(pc.red(`\u2717 ${target} exists \u2014 use --force to overwrite`));
+    process.exitCode = 1;
+    return;
+  }
+  fs2.mkdirSync(nodePath.dirname(target), { recursive: true });
+  fs2.writeFileSync(target, renderFamilyBrief(family) + "\n");
+  console.log(pc.green(`\u2713 ${family.name} direction written to .squint/brief.md`));
+  console.log(pc.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
+});
+program.command("check").description("Run this project\u2019s quality gates (typecheck, lint, test, build)").action(async () => {
+  const { detectGates: detectGates2, runGates: runGates2 } = await import("./gates-G5DABJWQ.js");
+  const cwd = process.cwd();
+  const gates = detectGates2(cwd);
+  if (gates.length === 0) {
+    console.log(pc.dim("no gates detected (no package.json scripts, tsconfig, or eslint config)"));
+    return;
+  }
+  console.log(pc.dim(`running ${gates.map((g) => g.id).join(" \u2192 ")}`));
+  const results = await runGates2(cwd, gates, (result) => {
+    const mark = result.ok ? pc.green("\u2713") : pc.red("\u2717");
+    console.log(`${mark} ${result.gate.id.padEnd(10)} ${pc.dim(`${(result.durationMs / 1e3).toFixed(1)}s \xB7 ${result.gate.display}`)}`);
+    if (!result.ok) console.log(pc.dim(result.outputTail.split("\n").slice(-12).join("\n")));
+  });
+  if (results.some((r) => !r.ok)) process.exitCode = 1;
+});
+program.command("shot").description("Screenshot a running app at mobile/tablet/desktop viewports").argument("<url>", "URL of the running app (e.g. http://localhost:5173)").action(async (url) => {
+  const { captureViewports: captureViewports2 } = await import("./preview-5PCHDJL7.js");
+  const result = await captureViewports2(process.cwd(), url);
+  if (!result) {
+    console.error(pc.red("\u2717 no Chrome/Chromium found"));
+    process.exitCode = 1;
+    return;
+  }
+  for (const shot of result.shots) console.log(`${pc.green("\u2713")} ${shot.name.padEnd(8)} ${shot.path}`);
+  for (const error of result.errors) console.error(pc.red(`\u2717 ${error}`));
+  if (result.shots.length === 0) process.exitCode = 1;
+});
+var configCommand = program.command("config").description("Read or change squint configuration");
+configCommand.command("get").description("Print the resolved configuration").action(() => {
+  const paths = defaultPaths(process.cwd());
+  console.log(JSON.stringify(loadConfig(paths), null, 2));
+});
+configCommand.command("set").description("Set a value (keys: engine, models.<engineId>)").argument("<key>").argument("<value>").option("--project", "write to this project (.squint/config.json) instead of global").action((key, value, options) => {
+  const paths = defaultPaths(process.cwd());
+  const file = options.project ? paths.projectFile : paths.globalFile;
+  setConfigValue(file, key, value);
+  console.log(pc.green(`\u2713 ${key} = ${value}`) + pc.dim(` (${file})`));
+});
+configCommand.command("path").description("Show config file locations").action(() => {
+  const paths = defaultPaths(process.cwd());
+  console.log(`global   ${paths.globalFile}`);
+  console.log(`project  ${paths.projectFile}`);
+});
+program.action(() => {
+  const cwd = process.cwd();
+  const config = loadConfig(defaultPaths(cwd));
+  const engineId = resolveEngineId(config);
+  const model = resolveModel(config, engineId);
+  render(
+    /* @__PURE__ */ jsx3(
+      App,
+      {
+        cwd,
+        initialEngine: engineId,
+        initialModel: model,
+        autoDev: config.autoDev,
+        autoFix: config.autoFix,
+        autoProbe: config.autoProbe
+      }
+    )
+  );
+});
+function createPrinter() {
+  let streaming = false;
+  return (event) => {
+    switch (event.type) {
+      case "status":
+        console.log(pc.dim(`\xB7 ${event.text}`));
+        break;
+      case "delta":
+        streaming = true;
+        process.stdout.write(event.text);
+        break;
+      case "text":
+        if (event.streamed && streaming) {
+          process.stdout.write("\n");
+        } else {
+          console.log(event.text);
+        }
+        streaming = false;
+        break;
+      case "thinking":
+        console.log(pc.dim(pc.italic(event.text)));
+        break;
+      case "tool":
+        if (streaming) {
+          process.stdout.write("\n");
+          streaming = false;
+        }
+        console.log(pc.cyan(`\u2699 ${event.name}${event.detail ? ` \xB7 ${event.detail}` : ""}`));
+        break;
+      case "error":
+        console.error(pc.red(`\u2717 ${event.text}`));
+        break;
+      case "result":
+      case "raw":
+        break;
+    }
+  };
+}
+program.parseAsync(process.argv);