@aayambansal/squint 0.2.0 → 0.2.2

package/README.md

@@ -86,10 +86,11 @@ From source: `git clone https://github.com/aayambansal/squint.git && cd squint &
    and catches what the server never prints: blank pages, exceptions, failed requests.
 5. **The agent looks at its work.** `/review` screenshots mobile/tablet/desktop and
    re-prompts the engine to critique what it can see — then fix it.
-6. **Gates keep it honest.** `/check` runs typecheck, lint, test, build — failures come
-   back with orders not to weaken the checks.
-7. **Everything is reversible.** Each ask is snapshotted via git plumbing; `/undo` reverts
-   the whole turn while your own uncommitted work survives.
+6. **Gates keep it honest.** Typecheck + lint run automatically after *every* turn and
+   auto-fix (capped); `/check` adds tests and the build — failures come back with orders
+   not to weaken the checks.
+7. **Everything is reversible.** Every ask records a checkpoint; `/undo` pops the last,
+   `/restore <n>` rewinds files to any earlier point — your own uncommitted work survives.
 8. **Point at things.** Alt+S in the browser, click any element, and a self-locating
    reference lands on your clipboard to paste into squint.
 9. **Explore in parallel.** `squint variants gen 3 "<ask>"` builds the same ask three ways —
@@ -122,18 +123,44 @@ squint check                      # gates: typecheck -> lint -> test -> build
 squint shot http://localhost:5173 # screenshots at 390/768/1440
 squint brief                      # list design directions
 squint brief cinematic-dark       # commit one for this repo
-squint tag                        # add the Alt+S element picker to any Vite app
+squint tag                        # Alt+S element picker: pin elements + notes, alt+enter copies all
 squint variants gen 3 "<ask>"     # 3 parallel design explorations
 squint variants apply terminal    # keep the winner
+squint skills init                # scaffold .squint/rules.md + a trigger-matched skill
 squint config set engine claude
 squint config set models.claude claude-sonnet-5
 squint config set autoDev true    # dev server starts with the TUI
 squint config set autoFix true    # errors auto-route back (max 2 tries)
+squint config set autoCheck false # skip the per-turn typecheck+lint pass
+squint config set theme ocean     # amber · ocean · moss · rose · mono
+squint config set bell false      # no bell on turn completion
 squint doctor                     # engines + Chrome + WebSocket check
+squint doctor --probe             # run every engine end to end, verify auth actually works
 ```
 
-Inside the TUI: `/dev` `/check` `/fix` `/shot` `/review [focus]` `/undo` `/resume`
-`/engine <id>` `/model <name>` `/clear` — `Esc` interrupts, arrows recall history.
+**Inside the TUI:**
+
+- **Modes**: `shift+tab` cycles `safe` (edits auto-approved) → `plan` (read-only
+  investigation) → `yolo` (no friction), mapped to each engine's native permission flags.
+- **Type ahead**: keep typing while the agent works — Enter queues asks that dispatch in
+  order; `/queue clear` drops them. `Esc` interrupts the current turn.
+- **Editing**: a real line editor — arrows move, `alt+←/→` jump words, `ctrl+a/e/k/u/w`,
+  `↑/↓` history. `ctrl+c` twice exits with a session summary.
+- **Problems**: findings from gates, the dev server, the runtime probe, and a11y sweeps
+  collect into a list — `/problems` shows it, `/fix` sends everything as one turn,
+  `/fix <n>` targets one. The footer counts what's open.
+- **Variants without leaving**: `/variants 3 <ask>` runs parallel explorations with
+  streaming per-family status; `/variants apply <id>` keeps the winner.
+- **Commands**: `/dev` `/check` `/problems` `/fix [n]` `/shot` `/review [focus]`
+  `/variants` `/undo` `/checkpoints` `/restore <n>` `/mode` `/theme` `/resume`
+  `/engine <id>` `/model <name>` `/clear`.
+- Assistant output renders as markdown; the done line measures real work via git
+  (`3 files +42 −7`); the footer tracks session turns and cost; a bell rings when a
+  turn finishes.
+
+**Project knowledge** rides along automatically: `.squint/rules.md` on every ask, and
+`.squint/skills/*.md` (frontmatter `triggers: auth, login`) only when an ask mentions a
+trigger — deterministic context routing, no embeddings.
 
 ## Design directions
 

package/dist/cdp-SFWNP7OA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  cdpCapture,
+  hasWebSocket,
+  pixelDiffPct
+} from "./chunk-OC6RU6XH.js";
+export {
+  cdpCapture,
+  hasWebSocket,
+  pixelDiffPct
+};

package/dist/{chrome-K4BKFOYS.js → chrome-RD7XQ767.js}

@@ -2,8 +2,8 @@
 import {
   findChrome,
   screenshot
-} from "./chunk-Z46MXU64.js";
-import "./chunk-MCYQXOE7.js";
+} from "./chunk-P3V5CWH5.js";
+import "./chunk-2LRIKWBU.js";
 export {
   findChrome,
   screenshot

package/dist/{chunk-ZJOU46X4.js → chunk-2IW2MMCY.js}

@@ -1,7 +1,17 @@
 #!/usr/bin/env node
+import {
+  variantsRoot
+} from "./chunk-LCS47EAG.js";
+import {
+  findChrome,
+  screenshot
+} from "./chunk-P3V5CWH5.js";
 import {
   lineSplitter
-} from "./chunk-MCYQXOE7.js";
+} from "./chunk-2LRIKWBU.js";
+
+// src/variants/shots.ts
+import path2 from "path";
 
 // src/devserver/devserver.ts
 import { spawn } from "child_process";
@@ -149,8 +159,55 @@ ${errorBlock}
 ${context}`;
 }
 
+// src/variants/shots.ts
+var URL_TIMEOUT_MS = 45e3;
+function waitForUrl(server) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const poll = setInterval(() => {
+      if (server.url) {
+        clearInterval(poll);
+        resolve(server.url);
+      } else if (Date.now() - startedAt > URL_TIMEOUT_MS || server.state === "crashed") {
+        clearInterval(poll);
+        resolve(null);
+      }
+    }, 200);
+  });
+}
+async function screenshotVariants(cwd, variants) {
+  const chrome = findChrome();
+  if (!chrome) {
+    return variants.map((v) => ({ familyId: v.family.id, error: "no Chrome found" }));
+  }
+  const shots = [];
+  for (const variant of variants) {
+    const command = detectDevCommand(variant.dir);
+    if (!command) {
+      shots.push({ familyId: variant.family.id, error: "no dev script" });
+      continue;
+    }
+    const server = new DevServer(variant.dir);
+    server.start(command);
+    const url = await waitForUrl(server);
+    if (!url) {
+      server.stop();
+      shots.push({ familyId: variant.family.id, error: "dev server did not announce a URL" });
+      continue;
+    }
+    const outPath = path2.join(variantsRoot(cwd), `${variant.family.id}.png`);
+    const result = await screenshot(chrome, url, outPath, { width: 1440, height: 900 });
+    server.stop();
+    shots.push(
+      result.ok ? { familyId: variant.family.id, path: outPath } : { familyId: variant.family.id, error: result.error }
+    );
+  }
+  return shots;
+}
+
 export {
   detectDevCommand,
   DevServer,
-  buildFixPrompt
+  buildFixPrompt,
+  screenshotVariants
 };

package/dist/{chunk-4MMIJXYD.js → chunk-73ULM6HF.js}

@@ -2,11 +2,11 @@
 import {
   cdpCapture,
   hasWebSocket
-} from "./chunk-VJGE7HSP.js";
+} from "./chunk-OC6RU6XH.js";
 import {
   findChrome,
   screenshot
-} from "./chunk-Z46MXU64.js";
+} from "./chunk-P3V5CWH5.js";
 
 // src/preview/preview.ts
 import fs2 from "fs";
@@ -126,16 +126,29 @@ ${blocks.join("\n\n")}
 
 Fix these first \u2014 a page that errors is broken regardless of how it looks.`;
 }
-async function probeRuntime(url) {
+async function probeRuntime(url, cwd) {
   const chrome = findChrome();
   if (!chrome || !hasWebSocket()) return null;
   try {
-    const { report } = await cdpCapture(chrome, url, os.tmpdir(), [], 1500);
-    return report;
+    const dir = cwd ? previewDir(cwd) : os.tmpdir();
+    const { report, shots } = await cdpCapture(
+      chrome,
+      url,
+      dir,
+      cwd ? [{ name: "pulse", width: 1280, height: 800 }] : [],
+      1500
+    );
+    return { report, pulsePath: shots[0]?.path };
   } catch {
     return null;
   }
 }
+async function comparePulse(previous, current) {
+  const chrome = findChrome();
+  if (!chrome || !hasWebSocket()) return null;
+  const { pixelDiffPct } = await import("./cdp-SFWNP7OA.js");
+  return pixelDiffPct(chrome, previous, current);
+}
 function buildRuntimeFixPrompt(report) {
   return `The running app has runtime problems.${runtimeSection(report)}
 
@@ -169,6 +182,7 @@ export {
   captureViewports,
   runtimeSummary,
   probeRuntime,
+  comparePulse,
   buildRuntimeFixPrompt,
   buildReviewPrompt
 };

package/dist/{chunk-7XUORM3K.js → chunk-LCS47EAG.js}

@@ -1,14 +1,12 @@
 #!/usr/bin/env node
 import {
   FAMILIES,
+  FIRST_TURN_ADDENDUM,
   renderFamilyBrief
-} from "./chunk-5IR2AZVK.js";
+} from "./chunk-P3H4N2EN.js";
 import {
   runAgent
-} from "./chunk-FPTBBHOH.js";
-import {
-  FIRST_TURN_ADDENDUM
-} from "./chunk-NT2HR4RD.js";
+} from "./chunk-OTG4ZB4R.js";
 
 // src/variants/variants.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-VJGE7HSP.js → chunk-OC6RU6XH.js}

@@ -152,6 +152,55 @@ var describe = (value) => {
   }
   return String(value);
 };
+async function pixelDiffPct(chromePath, pngA, pngB) {
+  const { child, wsUrl, profileDir } = await launchChrome(chromePath);
+  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 });
+    await connection.send("Runtime.enable", {}, sessionId);
+    const expression = `(async () => {
+      const load = (src) => new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = () => reject(new Error('decode'));
+        img.src = src;
+      });
+      const a = await load('data:image/png;base64,${pngA.toString("base64")}');
+      const b = await load('data:image/png;base64,${pngB.toString("base64")}');
+      const w = Math.min(a.width, b.width), h = Math.min(a.height, b.height);
+      if (w === 0 || h === 0) return null;
+      const draw = (img) => {
+        const c = document.createElement('canvas');
+        c.width = w; c.height = h;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        return ctx.getImageData(0, 0, w, h).data;
+      };
+      const da = draw(a), db = draw(b);
+      let differ = 0, total = 0;
+      for (let i = 0; i < da.length; i += 8) {
+        total++;
+        if (Math.abs(da[i] - db[i]) > 8 || Math.abs(da[i + 1] - db[i + 1]) > 8 || Math.abs(da[i + 2] - db[i + 2]) > 8) differ++;
+      }
+      const sizePenalty = (a.width !== b.width || a.height !== b.height) ? 1 : 0;
+      return Math.min(100, (differ / total) * 100 + sizePenalty);
+    })()`;
+    const { result } = await connection.send(
+      "Runtime.evaluate",
+      { expression, awaitPromise: true, returnByValue: true },
+      sessionId
+    );
+    return typeof result?.value === "number" ? result.value : null;
+  } catch {
+    return null;
+  } finally {
+    connection?.close();
+    child.kill("SIGKILL");
+    setTimeout(() => fs.rmSync(profileDir, { recursive: true, force: true }), 500).unref?.();
+  }
+}
 async function cdpCapture(chromePath, url, outDir, viewports, settleMs = 2500, audit = false) {
   const { child, wsUrl, profileDir } = await launchChrome(chromePath);
   const report = { consoleErrors: [], pageErrors: [], failedRequests: [] };
@@ -239,5 +288,6 @@ async function cdpCapture(chromePath, url, outDir, viewports, settleMs = 2500, a
 
 export {
   hasWebSocket,
+  pixelDiffPct,
   cdpCapture
 };

package/dist/{chunk-FPTBBHOH.js → chunk-OTG4ZB4R.js}

@@ -3,7 +3,7 @@ import {
   findEngineBinary,
   lineSplitter,
   truncate
-} from "./chunk-MCYQXOE7.js";
+} from "./chunk-2LRIKWBU.js";
 
 // src/runner/run.ts
 import { spawn } from "child_process";

package/dist/{chunk-5IR2AZVK.js → chunk-P3H4N2EN.js}

@@ -1,7 +1,60 @@
 #!/usr/bin/env node
-import {
-  DEFAULT_BRIEF
-} from "./chunk-NT2HR4RD.js";
+
+// 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}`;
+}
 
 // src/prompt/families.ts
 var FAMILIES = [
@@ -121,6 +174,8 @@ ${coreStandards()}`;
 }
 
 export {
+  FIRST_TURN_ADDENDUM,
+  composePrompt,
   FAMILIES,
   getFamily,
   renderFamilyBrief

package/dist/{chunk-Z46MXU64.js → chunk-P3V5CWH5.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   findBinary
-} from "./chunk-MCYQXOE7.js";
+} from "./chunk-2LRIKWBU.js";
 
 // src/preview/chrome.ts
 import { spawn } from "child_process";

package/dist/{chunk-W6MYXQIU.js → chunk-VNLM53RJ.js}

@@ -79,10 +79,11 @@ const PICKER = \`(() => {
   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)');
+      if (!active) { window.__squintFinishNote?.(true); window.__squintCompile?.(); box.style.display = 'none'; tip.style.display = 'none'; }
+      else toast('squint picker on \u2014 click elements to pin, alt+enter copies all (esc cancels)');
     } else if (e.key === 'Escape' && active) {
-      active = false; box.style.display = 'none'; tip.style.display = 'none';
+      active = false; window.__squintFinishNote?.(false); window.__squintClearPins?.();
+      box.style.display = 'none'; tip.style.display = 'none';
     }
   });
   addEventListener('mousemove', (e) => {
@@ -97,16 +98,65 @@ const PICKER = \`(() => {
     tip.style.top = Math.max(r.top - 26, 2) + 'px';
     tip.textContent = '<' + s.tag + '> ' + rel(s.file);
   }, true);
+  // Multi-pin annotations: each click drops a numbered pin with a note;
+  // alt+enter (or toggling the picker off) compiles them into one blob.
+  const pins = [];
+  const badges = [];
+  const noteBox = document.createElement('input');
+  noteBox.style.cssText = 'position:fixed;z-index:2147483647;background:#1b1b1b;color:#fff;border:2px solid #e8a33d;border-radius:3px;padding:4px 8px;font:12px ui-monospace,monospace;display:none;width:280px;outline:none;';
+  noteBox.placeholder = 'note for this pin \u2014 enter to keep, esc to drop';
+  document.documentElement.append(noteBox);
+  let pending = null;
+  const addBadge = (el, n) => {
+    const r = el.getBoundingClientRect();
+    const b = document.createElement('div');
+    b.textContent = String(n);
+    b.style.cssText = 'position:fixed;z-index:2147483647;background:#e8a33d;color:#1b1b1b;font:bold 11px ui-monospace,monospace;border-radius:8px;min-width:16px;height:16px;text-align:center;line-height:16px;pointer-events:none;';
+    b.style.left = Math.max(r.left - 6, 2) + 'px';
+    b.style.top = Math.max(r.top - 6, 2) + 'px';
+    document.documentElement.append(b);
+    badges.push(b);
+  };
+  const clearPins = () => { pins.length = 0; badges.forEach((b) => b.remove()); badges.length = 0; };
+  const compile = () => {
+    if (pins.length === 0) return;
+    const blob = pins.length === 1 && !pins[0].note
+      ? pins[0].ref
+      : pins.map((p, i) => (i + 1) + '. ' + p.ref + (p.note ? ' \u2014 ' + p.note : '')).join('\\\\n');
+    window.__squintLastPick = blob;
+    const count = pins.length;
+    clearPins();
+    const done = () => toast('copied ' + count + ' annotation' + (count === 1 ? '' : 's') + ' \u2014 paste into squint');
+    if (navigator.clipboard?.writeText) navigator.clipboard.writeText(blob).then(done, done);
+    else done();
+  };
+  const finishNote = (keep) => {
+    if (!pending) return;
+    if (keep) { pins.push({ ref: pending.ref, note: noteBox.value.trim() }); addBadge(pending.el, pins.length); }
+    pending = null; noteBox.value = ''; noteBox.style.display = 'none';
+  };
+  noteBox.addEventListener('keydown', (e) => {
+    e.stopPropagation();
+    if (e.key === 'Enter') { finishNote(true); if (e.altKey) { compile(); active = false; box.style.display = 'none'; } }
+    else if (e.key === 'Escape') finishNote(false);
+  });
+  window.__squintFinishNote = finishNote;
+  window.__squintCompile = compile;
+  window.__squintClearPins = clearPins;
+  addEventListener('keydown', (e) => {
+    if (active && e.altKey && e.key === 'Enter') { finishNote(true); compile(); active = false; box.style.display = 'none'; tip.style.display = 'none'; }
+  });
   addEventListener('click', (e) => {
-    if (!active) return;
+    if (!active || e.target === noteBox) return;
     e.preventDefault(); e.stopPropagation();
+    finishNote(true);
     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';
+    pending = { el, ref: describe(el) };
+    const r = el.getBoundingClientRect();
+    noteBox.style.display = 'block';
+    noteBox.style.left = Math.min(r.left, innerWidth - 310) + 'px';
+    noteBox.style.top = Math.min(r.bottom + 4, innerHeight - 34) + 'px';
+    noteBox.focus();
   }, true);
 })();\`
 `;

package/dist/chunk-XZKQZKEE.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+// src/prompt/skills.ts
+import fs from "fs";
+import path from "path";
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
+function parseSkill(name, raw) {
+  const match = FRONTMATTER_RE.exec(raw);
+  if (!match) return null;
+  const body = raw.slice(match[0].length).trim();
+  const triggersLine = /(^|\n)triggers:[ \t]*(.*)/.exec(match[1]);
+  if (!triggersLine) return null;
+  let triggers;
+  const inline = triggersLine[2].trim();
+  if (inline.length > 0) {
+    triggers = inline.split(",").map((t) => t.trim().toLowerCase());
+  } else {
+    triggers = [...match[1].matchAll(/\n\s*-\s+(.+)/g)].map((m) => m[1].trim().toLowerCase());
+  }
+  triggers = triggers.filter((t) => t.length > 0);
+  if (triggers.length === 0 || body.length === 0) return null;
+  return { name, triggers, body };
+}
+function loadSkills(cwd) {
+  const dir = path.join(cwd, ".squint", "skills");
+  let entries;
+  try {
+    entries = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort()) {
+    try {
+      const skill = parseSkill(entry.replace(/\.md$/, ""), fs.readFileSync(path.join(dir, entry), "utf8"));
+      if (skill) skills.push(skill);
+    } catch {
+    }
+  }
+  return skills;
+}
+function loadRules(cwd) {
+  try {
+    const text = fs.readFileSync(path.join(cwd, ".squint", "rules.md"), "utf8").trim();
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+}
+function matchSkills(skills, ask) {
+  const haystack = ask.toLowerCase();
+  return skills.filter((skill) => skill.triggers.some((t) => haystack.includes(t)));
+}
+function enrich(cwd, ask) {
+  const parts = [];
+  const rules = loadRules(cwd);
+  if (rules) parts.push(`## Project rules (always apply)
+
+${rules}`);
+  const matched = matchSkills(loadSkills(cwd), ask);
+  for (const skill of matched) {
+    parts.push(`## Project notes: ${skill.name}
+
+${skill.body}`);
+  }
+  return {
+    sections: parts.length > 0 ? `
+
+${parts.join("\n\n")}` : "",
+    matchedSkills: matched.map((s) => s.name)
+  };
+}
+
+export {
+  parseSkill,
+  loadSkills,
+  loadRules,
+  matchSkills,
+  enrich
+};

package/dist/{chunk-WTA6YYBY.js → chunk-YHRAOBI2.js}

@@ -28,6 +28,22 @@ function takeSnapshot(cwd) {
     return null;
   }
 }
+function diffStatSince(cwd, snapshot) {
+  try {
+    const source = snapshot.stashHash ?? "HEAD";
+    const stat = git(cwd, ["diff", "--shortstat", source]);
+    const files = /(\d+) files? changed/.exec(stat);
+    if (!files) return null;
+    const insertions = /(\d+) insertions?/.exec(stat);
+    const deletions = /(\d+) deletions?/.exec(stat);
+    let out = `${files[1]} file${files[1] === "1" ? "" : "s"}`;
+    if (insertions) out += ` +${insertions[1]}`;
+    if (deletions) out += ` \u2212${deletions[1]}`;
+    return out;
+  } catch {
+    return null;
+  }
+}
 function restoreSnapshot(cwd, snapshot) {
   try {
     const before = new Set(snapshot.untracked);
@@ -50,5 +66,6 @@ function restoreSnapshot(cwd, snapshot) {
 export {
   isGitRepo,
   takeSnapshot,
+  diffStatSince,
   restoreSnapshot
 };