@aayambansal/squint 0.1.0

package/dist/chunk-FQDSJRTY.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import {
+  lineSplitter
+} from "./chunk-YIVPCWSG.js";
+
+// src/devserver/devserver.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+
+// src/devserver/errors.ts
+var ERROR_SIGNATURES = [
+  /\berror\b.*\bTS\d+/i,
+  // tsc: error TS2304
+  /✘ \[ERROR\]/,
+  // esbuild
+  /\[vite\].*error/i,
+  /Internal server error/i,
+  /Failed to compile/i,
+  // webpack / next
+  /Module not found/i,
+  /Cannot find module/i,
+  /SyntaxError:/,
+  /ReferenceError:/,
+  /TypeError:/,
+  /Unhandled Rejection/i,
+  /^error\b/i,
+  // generic leading "error:"
+  /\bERROR\b/
+];
+var FALSE_POSITIVES = [
+  /0 errors?/i,
+  /no errors?/i,
+  /error-free/i,
+  /warnings? and 0/i
+];
+function isErrorLine(line) {
+  if (FALSE_POSITIVES.some((re) => re.test(line))) return false;
+  return ERROR_SIGNATURES.some((re) => re.test(line));
+}
+var URL_RE = /(https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+[^\s]*)/;
+function extractUrl(line) {
+  const match = URL_RE.exec(line);
+  if (!match || !match[1]) return null;
+  return match[1].replace(/\[[0-9;]*m/g, "").replace(/[.,)\]']+$/, "");
+}
+
+// src/devserver/devserver.ts
+function detectDevCommand(cwd) {
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  const script = pkg.scripts?.dev ? "dev" : pkg.scripts?.start ? "start" : null;
+  if (!script) return null;
+  const manager = fs.existsSync(path.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs.existsSync(path.join(cwd, "yarn.lock")) ? "yarn" : fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock")) ? "bun" : "npm";
+  const args = manager === "yarn" ? [script] : ["run", script];
+  return { command: manager, args, display: `${manager} ${args.join(" ")}` };
+}
+var BUFFER_LIMIT = 400;
+var DevServer = class {
+  constructor(cwd, callbacks = {}) {
+    this.cwd = cwd;
+    this.callbacks = callbacks;
+  }
+  cwd;
+  callbacks;
+  child = null;
+  lines = [];
+  state = "stopped";
+  url = null;
+  start(command) {
+    if (this.child) return true;
+    const cmd = command ?? detectDevCommand(this.cwd);
+    if (!cmd) return false;
+    this.setState("starting");
+    this.lines = [];
+    this.url = null;
+    const child = spawn(cmd.command, cmd.args, {
+      cwd: this.cwd,
+      env: { ...process.env, FORCE_COLOR: "0" },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    this.child = child;
+    const capture = (chunk) => splitter.push(chunk);
+    const splitter = lineSplitter((line) => {
+      const clean = line.replace(/\[[0-9;]*m/g, "");
+      this.record(clean);
+      if (!this.url) {
+        const url = extractUrl(clean);
+        if (url) {
+          this.url = url;
+          this.setState("running");
+          this.callbacks.onUrl?.(url);
+        }
+      }
+    });
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", capture);
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", capture);
+    child.on("error", () => {
+      this.child = null;
+      this.setState("crashed");
+    });
+    child.on("close", () => {
+      this.child = null;
+      if (this.state !== "stopped") this.setState("crashed");
+    });
+    return true;
+  }
+  stop() {
+    if (!this.child) return;
+    this.setState("stopped");
+    this.child.kill("SIGTERM");
+    this.child = null;
+  }
+  /** Error lines captured after `since` (ms epoch), for fix-loop prompts. */
+  errorsSince(since) {
+    return this.lines.filter((l) => l.isError && l.at >= since).map((l) => l.text);
+  }
+  /** Recent raw output, newest last — context for fix prompts. */
+  tail(count) {
+    return this.lines.slice(-count).map((l) => l.text);
+  }
+  record(text) {
+    this.lines.push({ at: Date.now(), text, isError: isErrorLine(text) });
+    if (this.lines.length > BUFFER_LIMIT) this.lines.splice(0, this.lines.length - BUFFER_LIMIT);
+  }
+  setState(state) {
+    this.state = state;
+    this.callbacks.onStateChange?.(state);
+  }
+};
+function buildFixPrompt(errors, recentOutput) {
+  const errorBlock = errors.slice(-20).join("\n");
+  const context = recentOutput.slice(-30).join("\n");
+  return `The dev server reports errors after your last change. Diagnose and fix them. Do not paper over an error with try/catch \u2014 find the root cause.
+
+## Dev server errors
+
+${errorBlock}
+
+## Recent dev server output
+
+${context}`;
+}
+
+export {
+  detectDevCommand,
+  DevServer,
+  buildFixPrompt
+};

package/dist/chunk-MGHJSERZ.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import {
+  findEngineBinary,
+  lineSplitter,
+  truncate
+} from "./chunk-YIVPCWSG.js";
+
+// src/runner/run.ts
+import { spawn } from "child_process";
+function runAgent(engine, opts, onEvent, signal) {
+  return new Promise((resolve) => {
+    const binaryPath = findEngineBinary(engine);
+    if (!binaryPath) {
+      const error = `${engine.name} not found on PATH. Install it: ${engine.install}`;
+      onEvent({ type: "error", text: error });
+      resolve({ ok: false, error });
+      return;
+    }
+    const startedAt = Date.now();
+    let result = null;
+    let stderrTail = "";
+    const child = spawn(binaryPath, engine.buildArgs(opts), {
+      cwd: opts.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const emit = (event) => {
+      if (event.type === "result") {
+        result = {
+          ok: event.ok,
+          sessionId: event.sessionId,
+          costUsd: event.costUsd,
+          durationMs: event.durationMs
+        };
+      }
+      onEvent(event);
+    };
+    const parse = engine.createParser?.();
+    const stdout = lineSplitter((line) => {
+      if (parse) {
+        for (const event of parse(line)) emit(event);
+      } else {
+        emit({ type: "text", text: line });
+      }
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderrTail = truncate(stderrTail + chunk, 2e3);
+    });
+    const onAbort = () => child.kill("SIGTERM");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      const error = `Failed to start ${engine.name}: ${err.message}`;
+      onEvent({ type: "error", text: error });
+      resolve({ ok: false, error });
+    });
+    child.on("close", (code) => {
+      signal?.removeEventListener("abort", onAbort);
+      stdout.flush();
+      if (signal?.aborted) {
+        onEvent({ type: "status", text: "interrupted" });
+        resolve({ ok: false, error: "interrupted", durationMs: Date.now() - startedAt });
+        return;
+      }
+      if (result) {
+        resolve({ ...result, durationMs: result.durationMs ?? Date.now() - startedAt });
+        return;
+      }
+      if (code === 0) {
+        resolve({ ok: true, durationMs: Date.now() - startedAt });
+        return;
+      }
+      const error = `${engine.name} exited with code ${code}${stderrTail ? `
+${stderrTail.trim()}` : ""}`;
+      onEvent({ type: "error", text: error });
+      resolve({ ok: false, error, durationMs: Date.now() - startedAt });
+    });
+  });
+}
+
+export {
+  runAgent
+};

package/dist/chunk-MURKQ7SI.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  findBinary
+} from "./chunk-YIVPCWSG.js";
+
+// src/preview/chrome.ts
+import { spawn } from "child_process";
+import fs from "fs";
+var MAC_CHROMES = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+];
+var PATH_CHROMES = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"];
+function findChrome() {
+  if (process.platform === "darwin") {
+    for (const candidate of MAC_CHROMES) {
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  for (const name of PATH_CHROMES) {
+    const found = findBinary(name);
+    if (found) return found;
+  }
+  return null;
+}
+function screenshot(chromePath, url, outPath, opts) {
+  return new Promise((resolve) => {
+    const args = [
+      "--headless=new",
+      "--disable-gpu",
+      // CI runners commonly need this; local runs keep the sandbox.
+      ...process.env.CI ? ["--no-sandbox"] : [],
+      "--hide-scrollbars",
+      "--force-device-scale-factor=1",
+      `--window-size=${opts.width},${opts.height}`,
+      `--virtual-time-budget=${opts.settleMs ?? 4e3}`,
+      `--screenshot=${outPath}`,
+      url
+    ];
+    const child = spawn(chromePath, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve({ ok: false, error: "screenshot timed out" });
+    }, opts.timeoutMs ?? 2e4);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ ok: false, error: err.message });
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      if (fs.existsSync(outPath) && fs.statSync(outPath).size > 0) {
+        resolve({ ok: true });
+      } else {
+        resolve({ ok: false, error: stderr.trim().split("\n").slice(-2).join(" ") || "no image produced" });
+      }
+    });
+  });
+}
+
+export {
+  findChrome,
+  screenshot
+};

package/dist/chunk-NT2HR4RD.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+// src/prompt/brief.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_BRIEF = `You are acting as a senior product designer and frontend engineer. Treat every change as production work, not a demo.
+
+Direction before code:
+- Commit to one specific visual direction derived from what this product is for, and state it in one sentence before implementing. If the direction could be guessed from the product category alone, sharpen it until it couldn't.
+- Choose a color strategy deliberately: restrained (neutrals + one accent), committed (one dominant color owning 30\u201360% of the surface), or a small palette of 3\u20135 named roles. Never purple/violet gradients unless asked. Body text contrast stays at least 4.5:1 \u2014 no light gray body copy "for elegance".
+- Typography: at most two families, paired on contrast (display serif + geometric sans, or sans + mono). Never Inter/Roboto/Open Sans/system defaults for display type. Pair weight extremes (300 against 700\u2013900); display sizes jump 3x over body, not 1.5x.
+
+Tokens are the system:
+- Define or extend design tokens (CSS variables / theme config) first, then compose the UI from them. Never scatter literal colors or one-off spacing values through components.
+- One spacing rhythm on a 4/8px grid; one type scale with a ratio of at least 1.25 between steps.
+
+Banned tells \u2014 these read instantly as machine-generated:
+- Purple gradient on white; glassmorphism cards; cream/beige page background as a reflex "warmth" move
+- Emoji as icons; identical icon-topped card grids; stat banner rows; numbered 01/02/03 section markers
+- Tiny all-caps tracked eyebrow labels over every section; gradient text; colored left-border strips on cards
+- Centered hero + badge + three feature cards; unmodified component-library defaults
+If someone could look at the result and say "AI made that" without doubt, it has failed.
+
+Craft details:
+- Every interactive element gets hover, focus-visible, and active treatment; keyboard focus stays visible.
+- Anything that loads data gets loading, empty, and error states.
+- Motion: 150\u2013250ms ease-out; one orchestrated entrance with staggered reveals beats scattered micro-interactions; honor prefers-reduced-motion; never leave content invisible until a scroll observer fires.
+- Body line length 65\u201375ch; text-wrap: balance on headings.
+
+Engineering:
+- Follow the repo's existing conventions and extend its patterns; new components in new files, small and focused; semantic HTML.
+- Responsive from 360px up with no horizontal overflow \u2014 check intermediate widths, not just phone and desktop.
+- Let errors surface instead of swallowing them in try/catch; log clearly so failures can be traced.
+- Not done until the app builds cleanly, typechecks, and renders without console errors.`;
+var FIRST_TURN_ADDENDUM = `This is the opening move on this task: establish the design foundation before building. State the visual direction, set up the tokens/theme first, then build components from them. The first render should feel like a designed product, not a scaffold \u2014 impressive on sight.`;
+function loadBrief(cwd) {
+  const custom = path.join(cwd, ".squint", "brief.md");
+  try {
+    const text = fs.readFileSync(custom, "utf8").trim();
+    if (text.length > 0) return text;
+  } catch {
+  }
+  return DEFAULT_BRIEF;
+}
+function composePrompt(ask, opts) {
+  if (opts.noBrief) return ask;
+  const brief = loadBrief(opts.cwd);
+  const firstTurn = opts.firstTurn ?? true;
+  const addendum = firstTurn ? `
+
+${FIRST_TURN_ADDENDUM}` : "";
+  return `${brief}${addendum}
+
+## Task
+
+${ask}`;
+}
+
+export {
+  DEFAULT_BRIEF,
+  FIRST_TURN_ADDENDUM,
+  composePrompt
+};

package/dist/chunk-OJTW5SYY.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+// src/preview/cdp.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+function hasWebSocket() {
+  return typeof globalThis.WebSocket === "function";
+}
+var CdpConnection = class _CdpConnection {
+  ws;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  constructor(ws) {
+    this.ws = ws;
+    ws.addEventListener("message", (event) => {
+      let data;
+      try {
+        data = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (typeof data.id === "number") {
+        const entry = this.pending.get(data.id);
+        if (entry) {
+          this.pending.delete(data.id);
+          if (data.error) entry.reject(new Error(data.error.message ?? "CDP error"));
+          else entry.resolve(data.result);
+        }
+      } else if (typeof data.method === "string") {
+        this.listeners.get(data.method)?.(data.params, data.sessionId);
+      }
+    });
+  }
+  static connect(url, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new Error("CDP connect timeout"));
+      }, timeoutMs);
+      ws.addEventListener("open", () => {
+        clearTimeout(timer);
+        resolve(new _CdpConnection(ws));
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error("CDP connect failed"));
+      });
+    });
+  }
+  send(method, params = {}, sessionId) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, method, params, ...sessionId ? { sessionId } : {} }));
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`CDP timeout: ${method}`));
+        }
+      }, 15e3);
+    });
+  }
+  on(method, handler) {
+    this.listeners.set(method, handler);
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+};
+function launchChrome(chromePath) {
+  return new Promise((resolve, reject) => {
+    const profileDir = fs.mkdtempSync(path.join(os.tmpdir(), "squint-chrome-"));
+    const child = spawn(
+      chromePath,
+      [
+        "--headless=new",
+        "--disable-gpu",
+        ...process.env.CI ? ["--no-sandbox"] : [],
+        "--no-first-run",
+        "--remote-debugging-port=0",
+        `--user-data-dir=${profileDir}`,
+        "about:blank"
+      ],
+      { stdio: ["ignore", "ignore", "pipe"] }
+    );
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("Chrome did not announce DevTools endpoint"));
+    }, 15e3);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      const match = /DevTools listening on (ws:\/\/[^\s]+)/.exec(stderr);
+      if (match && match[1]) {
+        clearTimeout(timer);
+        resolve({ child, wsUrl: match[1], profileDir });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", () => clearTimeout(timer));
+  });
+}
+var describe = (value) => {
+  if (value == null) return "";
+  if (typeof value === "object") {
+    return String(value.description ?? value.value ?? JSON.stringify(value));
+  }
+  return String(value);
+};
+async function cdpCapture(chromePath, url, outDir, viewports, settleMs = 2500) {
+  const { child, wsUrl, profileDir } = await launchChrome(chromePath);
+  const report = { consoleErrors: [], pageErrors: [], failedRequests: [] };
+  const shots = [];
+  const requests = /* @__PURE__ */ new Map();
+  let connection = null;
+  try {
+    connection = await CdpConnection.connect(wsUrl, 1e4);
+    const { targetId } = await connection.send("Target.createTarget", { url: "about:blank" });
+    const { sessionId } = await connection.send("Target.attachToTarget", { targetId, flatten: true });
+    connection.on("Runtime.consoleAPICalled", (params) => {
+      if (params.type === "error" || params.type === "assert") {
+        const text = (params.args ?? []).map(describe).join(" ");
+        if (text) report.consoleErrors.push(text);
+      }
+    });
+    connection.on("Runtime.exceptionThrown", (params) => {
+      const detail = params.exceptionDetails;
+      const text = detail?.exception?.description ?? detail?.text;
+      if (text) report.pageErrors.push(String(text).split("\n").slice(0, 3).join("\n"));
+    });
+    connection.on("Network.requestWillBeSent", (params) => {
+      requests.set(params.requestId, params.request?.url ?? "unknown");
+    });
+    connection.on("Network.responseReceived", (params) => {
+      const status = params.response?.status ?? 0;
+      if (status >= 400) {
+        report.failedRequests.push(`${status} ${params.response?.url ?? requests.get(params.requestId) ?? ""}`);
+      }
+    });
+    connection.on("Network.loadingFailed", (params) => {
+      if (params.canceled) return;
+      const target = requests.get(params.requestId);
+      if (target) report.failedRequests.push(`${params.errorText ?? "failed"} ${target}`);
+    });
+    let loaded = false;
+    connection.on("Page.loadEventFired", () => {
+      loaded = true;
+    });
+    await connection.send("Runtime.enable", {}, sessionId);
+    await connection.send("Network.enable", {}, sessionId);
+    await connection.send("Page.enable", {}, sessionId);
+    await connection.send("Page.navigate", { url }, sessionId);
+    const deadline = Date.now() + 12e3;
+    while (!loaded && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await new Promise((resolve) => setTimeout(resolve, settleMs));
+    for (const viewport of viewports) {
+      await connection.send(
+        "Emulation.setDeviceMetricsOverride",
+        {
+          width: viewport.width,
+          height: viewport.height,
+          deviceScaleFactor: 1,
+          mobile: viewport.width < 500
+        },
+        sessionId
+      );
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      const { data } = await connection.send("Page.captureScreenshot", { format: "png" }, sessionId);
+      const outPath = path.join(outDir, `${viewport.name}.png`);
+      fs.writeFileSync(outPath, Buffer.from(data, "base64"));
+      shots.push({ name: viewport.name, path: outPath });
+    }
+  } finally {
+    connection?.close();
+    child.kill("SIGKILL");
+    setTimeout(() => fs.rmSync(profileDir, { recursive: true, force: true }), 500).unref?.();
+  }
+  return { report, shots };
+}
+
+export {
+  hasWebSocket,
+  cdpCapture
+};