@aayambansal/squint 0.1.0

package/dist/chunk-UHVE42IQ.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  FAMILIES,
+  renderFamilyBrief
+} from "./chunk-5IR2AZVK.js";
+import {
+  runAgent
+} from "./chunk-MGHJSERZ.js";
+import {
+  FIRST_TURN_ADDENDUM
+} from "./chunk-NT2HR4RD.js";
+
+// src/variants/variants.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+var MAX_VARIANTS = 4;
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function variantsRoot(cwd) {
+  return path.join(cwd, ".squint", "variants");
+}
+function pickFamilies(n) {
+  return FAMILIES.slice(0, Math.min(n, MAX_VARIANTS, FAMILIES.length));
+}
+function createVariantWorktree(cwd, family) {
+  const dir = path.join(variantsRoot(cwd), family.id);
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(dir), { recursive: true });
+  git(cwd, ["worktree", "add", "--force", "--detach", dir, "HEAD"]);
+  const mainModules = path.join(cwd, "node_modules");
+  const variantModules = path.join(dir, "node_modules");
+  if (fs.existsSync(mainModules) && !fs.existsSync(variantModules)) {
+    fs.symlinkSync(mainModules, variantModules, "dir");
+  }
+  return { family, dir };
+}
+function variantPrompt(family, ask) {
+  return `${renderFamilyBrief(family)}
+
+${FIRST_TURN_ADDENDUM}
+
+## Task
+
+${ask}
+
+Note: this is one of several parallel design explorations of the same task. Commit hard to the ${family.name} direction \u2014 differentiation between explorations is the point. Do not hedge toward a middle ground.`;
+}
+async function runVariants(cwd, ask, n, engine, model, onStatus) {
+  const families = pickFamilies(n);
+  const variants = families.map((family) => {
+    onStatus(family.id, "preparing worktree");
+    return createVariantWorktree(cwd, family);
+  });
+  return Promise.all(
+    variants.map(async (variant) => {
+      onStatus(variant.family.id, "engine running");
+      const result = await runAgent(
+        engine,
+        { prompt: variantPrompt(variant.family, ask), cwd: variant.dir, model },
+        (event) => {
+          if (event.type === "tool") onStatus(variant.family.id, `\u2699 ${event.name}`);
+          if (event.type === "error") onStatus(variant.family.id, `\u2717 ${event.text.split("\n")[0]}`);
+        }
+      );
+      onStatus(
+        variant.family.id,
+        result.ok ? `done${result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : ""}` : `failed${result.error ? ` \xB7 ${result.error.split("\n")[0]}` : ""}`
+      );
+      return { variant, result };
+    })
+  );
+}
+function listVariants(cwd) {
+  try {
+    return fs.readdirSync(variantsRoot(cwd), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function applyVariant(cwd, familyId) {
+  const dir = path.join(variantsRoot(cwd), familyId);
+  if (!fs.existsSync(dir)) {
+    return { ok: false, detail: `no variant "${familyId}" \u2014 run squint variants list` };
+  }
+  try {
+    git(dir, ["add", "-A"]);
+    const patch = git(dir, ["diff", "--binary", "--cached", "HEAD"]);
+    if (patch.length === 0) {
+      return { ok: false, detail: "variant made no changes" };
+    }
+    const patchFile = path.join(variantsRoot(cwd), `${familyId}.patch`);
+    fs.writeFileSync(patchFile, patch + "\n");
+    git(cwd, ["apply", "--whitespace=nowarn", patchFile]);
+    fs.rmSync(patchFile, { force: true });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message.split("\n")[0] : String(err) };
+  }
+}
+function cleanVariants(cwd) {
+  const ids = listVariants(cwd);
+  for (const id of ids) {
+    const dir = path.join(variantsRoot(cwd), id);
+    try {
+      const link = path.join(dir, "node_modules");
+      if (fs.existsSync(link) && fs.lstatSync(link).isSymbolicLink()) fs.rmSync(link);
+    } catch {
+    }
+    try {
+      git(cwd, ["worktree", "remove", "--force", dir]);
+    } catch {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  try {
+    git(cwd, ["worktree", "prune"]);
+  } catch {
+  }
+  fs.rmSync(variantsRoot(cwd), { recursive: true, force: true });
+  return ids.length;
+}
+
+export {
+  MAX_VARIANTS,
+  variantsRoot,
+  pickFamilies,
+  createVariantWorktree,
+  variantPrompt,
+  runVariants,
+  listVariants,
+  applyVariant,
+  cleanVariants
+};

package/dist/chunk-W6MYXQIU.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+// src/tagger/source.ts
+var TAGGER_FILENAME = "squint-tagger.mjs";
+var TAGGER_SOURCE = `// squint element tagger \u2014 dev-only Vite plugin.
+// Alt+S in the browser toggles the picker; clicking an element copies
+// its JSX source location (file:line:col) to paste into squint.
+const VIRTUAL_ID = '\\0squint-jsx-dev-runtime'
+
+export default function squintTagger() {
+  let actualRuntime = null
+  return {
+    name: 'squint-tagger',
+    apply: 'serve',
+    enforce: 'pre',
+
+    async resolveId(id, importer) {
+      if (id === 'react/jsx-dev-runtime') {
+        const resolved = await this.resolve(id, importer, { skipSelf: true })
+        if (!resolved) return null
+        actualRuntime = resolved.id
+        return VIRTUAL_ID
+      }
+      return null
+    },
+
+    load(id) {
+      if (id !== VIRTUAL_ID || !actualRuntime) return null
+      return [
+        'import * as runtime from ' + JSON.stringify(actualRuntime) + ';',
+        'export const Fragment = runtime.Fragment;',
+        'export const jsxDEV = (type, props, key, isStatic, source, self) => {',
+        '  if (source && props && typeof type === "string") {',
+        '    const info = { file: source.fileName, line: source.lineNumber, col: source.columnNumber, tag: type };',
+        '    const prevRef = props.ref;',
+        '    props = { ...props, ref: (node) => {',
+        '      if (node && node.nodeType === 1) node.__squintSource = info;',
+        '      if (typeof prevRef === "function") return prevRef(node);',
+        '      if (prevRef && typeof prevRef === "object") prevRef.current = node;',
+        '    } };',
+        '  }',
+        '  return runtime.jsxDEV(type, props, key, isStatic, source, self);',
+        '};',
+      ].join('\\n')
+    },
+
+    // NOTE: jsxDEV line numbers reflect the transformed module (dev
+    // preambles shift them), so the picker treats them as approximate
+    // and copies tag + class list + text alongside \u2014 self-locating for
+    // any agent regardless of build pipeline.
+
+    transformIndexHtml() {
+      return [{ tag: 'script', attrs: { type: 'module' }, children: PICKER, injectTo: 'body' }]
+    },
+  }
+}
+
+const PICKER = \`(() => {
+  if (window.__squintPicker) return; window.__squintPicker = true;
+  let active = false;
+  const box = document.createElement('div');
+  box.style.cssText = 'position:fixed;pointer-events:none;z-index:2147483646;border:2px solid #e8a33d;background:rgba(232,163,61,.08);display:none;font:12px ui-monospace,monospace;';
+  const tip = document.createElement('div');
+  tip.style.cssText = 'position:fixed;z-index:2147483647;background:#1b1b1b;color:#fff;padding:4px 8px;border-radius:3px;font:12px ui-monospace,monospace;display:none;pointer-events:none;max-width:70vw;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
+  document.documentElement.append(box, tip);
+  const find = (el) => { while (el && el !== document.body) { if (el.__squintSource) return el; el = el.parentElement; } return null; };
+  const rel = (file) => file.replace(location.origin, '').replace(/^.*?\\\\/(src\\\\/)/, '$1');
+  const describe = (el) => {
+    const s = el.__squintSource;
+    const cls = (el.getAttribute('class') || '').trim();
+    const text = (el.textContent || '').trim().replace(/\\\\s+/g, ' ').slice(0, 40);
+    return rel(s.file) + ' <' + s.tag + (cls ? ' class="' + cls + '"' : '') + '>' + (text ? ' "' + text + '"' : '');
+  };
+  const toast = (text) => {
+    tip.textContent = text; tip.style.display = 'block';
+    tip.style.left = '12px'; tip.style.top = '12px';
+    setTimeout(() => { if (!active) tip.style.display = 'none'; }, 2200);
+  };
+  addEventListener('keydown', (e) => {
+    if (e.altKey && (e.key === 's' || e.key === 'S' || e.code === 'KeyS')) {
+      active = !active;
+      if (!active) { box.style.display = 'none'; tip.style.display = 'none'; }
+      else toast('squint picker on \u2014 click an element (esc to cancel)');
+    } else if (e.key === 'Escape' && active) {
+      active = false; box.style.display = 'none'; tip.style.display = 'none';
+    }
+  });
+  addEventListener('mousemove', (e) => {
+    if (!active) return;
+    const el = find(e.target); if (!el) { box.style.display = 'none'; return; }
+    const r = el.getBoundingClientRect(); const s = el.__squintSource;
+    box.style.display = 'block';
+    box.style.left = r.left + 'px'; box.style.top = r.top + 'px';
+    box.style.width = r.width + 'px'; box.style.height = r.height + 'px';
+    tip.style.display = 'block';
+    tip.style.left = Math.min(r.left, innerWidth - 340) + 'px';
+    tip.style.top = Math.max(r.top - 26, 2) + 'px';
+    tip.textContent = '<' + s.tag + '> ' + rel(s.file);
+  }, true);
+  addEventListener('click', (e) => {
+    if (!active) return;
+    e.preventDefault(); e.stopPropagation();
+    const el = find(e.target); if (!el) return;
+    const ref = describe(el);
+    window.__squintLastPick = ref;
+    const done = () => toast('copied \u2014 paste into squint: ' + ref);
+    if (navigator.clipboard?.writeText) navigator.clipboard.writeText(ref).then(done, done);
+    else done();
+    active = false; box.style.display = 'none';
+  }, true);
+})();\`
+`;
+function patchViteConfig(source) {
+  if (source.includes("squint-tagger") || source.includes("squintTagger")) return "already";
+  const pluginsMatch = /plugins:\s*\[/.exec(source);
+  if (!pluginsMatch) return null;
+  const withPlugin = source.slice(0, pluginsMatch.index) + pluginsMatch[0].replace("[", "[squintTagger(), ") + source.slice(pluginsMatch.index + pluginsMatch[0].length);
+  return `import squintTagger from './${TAGGER_FILENAME}'
+${withPlugin}`;
+}
+
+export {
+  TAGGER_FILENAME,
+  TAGGER_SOURCE,
+  patchViteConfig
+};

package/dist/chunk-WTA6YYBY.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+// src/vcs/snapshot.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function isGitRepo(cwd) {
+  try {
+    return git(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
+  } catch {
+    return false;
+  }
+}
+function listUntracked(cwd) {
+  const out = git(cwd, ["ls-files", "--others", "--exclude-standard"]);
+  return out.length > 0 ? out.split("\n") : [];
+}
+function takeSnapshot(cwd) {
+  try {
+    if (!isGitRepo(cwd)) return null;
+    git(cwd, ["rev-parse", "HEAD"]);
+    const stashHash = git(cwd, ["stash", "create"]) || null;
+    return { stashHash, untracked: listUntracked(cwd), at: Date.now() };
+  } catch {
+    return null;
+  }
+}
+function restoreSnapshot(cwd, snapshot) {
+  try {
+    const before = new Set(snapshot.untracked);
+    const created = listUntracked(cwd).filter((file) => !before.has(file));
+    for (const file of created) {
+      fs.rmSync(path.join(cwd, file), { force: true });
+    }
+    const source = snapshot.stashHash ?? "HEAD";
+    git(cwd, ["restore", "--source", source, "--worktree", "--", "."]);
+    return { restored: true, deletedFiles: created.length };
+  } catch (err) {
+    return {
+      restored: false,
+      deletedFiles: 0,
+      detail: err instanceof Error ? err.message.split("\n")[0] : String(err)
+    };
+  }
+}
+
+export {
+  isGitRepo,
+  takeSnapshot,
+  restoreSnapshot
+};