@aayambansal/squint 0.2.7 → 0.2.8

package/README.md

@@ -132,6 +132,7 @@ 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 autoReview true # big visual change → automatic self-critique
 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

package/dist/{chunk-RZOQPFXC.js → chunk-YTO2YRF7.js}

@@ -9,6 +9,7 @@ var COMMANDS = [
   { name: "shot", description: "screenshot the app at mobile/tablet/desktop" },
   { name: "review", args: "[focus]", description: "screenshots + the engine critiques its own rendered work" },
   { name: "variants", args: "<2-4> <ask>", description: "parallel design explorations; apply/list/clean" },
+  { name: "sandbox", args: "[on|diff|apply|discard]", description: "asks accumulate in a shadow worktree until you apply" },
   { name: "undo", description: "revert the last ask (files only)" },
   { name: "checkpoints", description: "list per-ask checkpoints" },
   { name: "restore", args: "<n>", description: "rewind files to before ask n" },

package/dist/cli.js

@@ -30,7 +30,7 @@ import {
 } from "./chunk-CHZE3UHK.js";
 import {
   completeCommand
-} from "./chunk-RZOQPFXC.js";
+} from "./chunk-YTO2YRF7.js";
 import {
   runAgent
 } from "./chunk-C7WKNJG6.js";
@@ -265,22 +265,22 @@ function registerProject(program2) {
     }
   });
   skillsCommand.command("init").description("Scaffold .squint/rules.md and an example skill").action(async () => {
-    const fs2 = await import("fs");
+    const fs3 = await import("fs");
     const nodePath = await import("path");
     const cwd = process.cwd();
     const skillsDir = nodePath.join(cwd, ".squint", "skills");
-    fs2.mkdirSync(skillsDir, { recursive: true });
+    fs3.mkdirSync(skillsDir, { recursive: true });
     const rules = nodePath.join(cwd, ".squint", "rules.md");
-    if (!fs2.existsSync(rules)) {
-      fs2.writeFileSync(
+    if (!fs3.existsSync(rules)) {
+      fs3.writeFileSync(
         rules,
         "# Project rules\n\nThese ride along on every squint ask. Keep them short \u2014 cut anything that would not cause a mistake if removed.\n"
       );
       console.log(pc3.green("\u2713 .squint/rules.md"));
     }
     const example = nodePath.join(skillsDir, "example.md");
-    if (!fs2.existsSync(example)) {
-      fs2.writeFileSync(
+    if (!fs3.existsSync(example)) {
+      fs3.writeFileSync(
         example,
         "---\ntriggers: example, sample\n---\n\nThis note is injected only when an ask mentions one of the triggers above.\nDocument the parts of this repo an agent would otherwise rediscover every time:\nwhere state lives, which helpers to reuse, what not to touch.\n"
       );
@@ -289,7 +289,7 @@ function registerProject(program2) {
     console.log(pc3.dim("rules are always-on; skills inject when an ask mentions a trigger"));
   });
   program2.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 fs3 = await import("fs");
     const nodePath = await import("path");
     const { FAMILIES, getFamily, renderFamilyBrief } = await import("./families-2G5SLLY7.js");
     if (!familyId) {
@@ -307,13 +307,13 @@ function registerProject(program2) {
       return;
     }
     const target = nodePath.join(process.cwd(), ".squint", "brief.md");
-    if (fs2.existsSync(target) && !options.force) {
+    if (fs3.existsSync(target) && !options.force) {
       console.error(pc3.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");
+    fs3.mkdirSync(nodePath.dirname(target), { recursive: true });
+    fs3.writeFileSync(target, renderFamilyBrief(family) + "\n");
     console.log(pc3.green(`\u2713 ${family.name} direction written to .squint/brief.md`));
     console.log(pc3.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
   });
@@ -533,21 +533,21 @@ Next: ${pc6.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
     console.log(pc6.dim("then describe what to build \u2014 /dev starts the preview server"));
   });
   program2.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 fs3 = await import("fs");
     const nodePath = await import("path");
     const { patchViteConfig, TAGGER_FILENAME, TAGGER_SOURCE } = await import("./source-ZZU245VN.js");
     const cwd = process.cwd();
     const taggerPath = nodePath.join(cwd, TAGGER_FILENAME);
-    fs2.writeFileSync(taggerPath, TAGGER_SOURCE);
+    fs3.writeFileSync(taggerPath, TAGGER_SOURCE);
     console.log(pc6.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));
+    const configPath = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].map((name) => nodePath.join(cwd, name)).find((candidate) => fs3.existsSync(candidate));
     if (!configPath) {
       console.log(pc6.yellow("\u25CB no vite config found \u2014 add the plugin manually:"));
       console.log(pc6.dim(`  import squintTagger from './${TAGGER_FILENAME}'
   plugins: [squintTagger(), \u2026]`));
       return;
     }
-    const source = fs2.readFileSync(configPath, "utf8");
+    const source = fs3.readFileSync(configPath, "utf8");
     const patched = patchViteConfig(source);
     if (patched === "already") {
       console.log(pc6.dim("vite config already wired"));
@@ -556,7 +556,7 @@ Next: ${pc6.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
       console.log(pc6.dim(`  import squintTagger from './${TAGGER_FILENAME}'
   plugins: [squintTagger(), \u2026]`));
     } else {
-      fs2.writeFileSync(configPath, patched);
+      fs3.writeFileSync(configPath, patched);
       console.log(pc6.green(`\u2713 ${nodePath.basename(configPath)} wired`));
     }
     console.log(
@@ -570,11 +570,97 @@ import { render } from "ink";
 
 // src/tui/App.tsx
 import { Box as Box2, Static, Text as Text3, useApp, useInput } from "ink";
-import path3 from "path";
+import path4 from "path";
 import { useMemo, useRef, useState as useState2, useSyncExternalStore } from "react";
 
 // src/session/engine.ts
+import path3 from "path";
+
+// src/vcs/sandbox.ts
+import { execFileSync } from "child_process";
+import fs2 from "fs";
 import path2 from "path";
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function sandboxDir(cwd) {
+  return path2.join(cwd, ".squint", "sandbox");
+}
+function sandboxExists(cwd) {
+  return fs2.existsSync(path2.join(sandboxDir(cwd), ".git"));
+}
+function openSandbox(cwd) {
+  const dir = sandboxDir(cwd);
+  if (sandboxExists(cwd)) return { dir, reused: true };
+  fs2.rmSync(dir, { recursive: true, force: true });
+  fs2.mkdirSync(path2.dirname(dir), { recursive: true });
+  git(cwd, ["worktree", "add", "--force", "--detach", dir, "HEAD"]);
+  const mainModules = path2.join(cwd, "node_modules");
+  const sandboxModules = path2.join(dir, "node_modules");
+  if (fs2.existsSync(mainModules) && !fs2.existsSync(sandboxModules)) {
+    fs2.symlinkSync(mainModules, sandboxModules, "dir");
+  }
+  return { dir, reused: false };
+}
+function sandboxDiffStat(cwd) {
+  if (!sandboxExists(cwd)) return null;
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const stat = git(dir, ["diff", "--cached", "--shortstat", "HEAD"]);
+    return stat.length > 0 ? stat : null;
+  } catch {
+    return null;
+  }
+}
+function sandboxFiles(cwd) {
+  if (!sandboxExists(cwd)) return [];
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const out = git(dir, ["diff", "--cached", "--name-status", "HEAD"]);
+    return out.length > 0 ? out.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
+function applySandbox(cwd) {
+  if (!sandboxExists(cwd)) return { ok: false, detail: "no sandbox open" };
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const patch = git(dir, ["diff", "--binary", "--cached", "HEAD"]);
+    if (patch.length === 0) return { ok: false, detail: "sandbox has no changes" };
+    const patchFile = path2.join(cwd, ".squint", "sandbox.patch");
+    fs2.writeFileSync(patchFile, patch + "\n");
+    git(cwd, ["apply", "--whitespace=nowarn", patchFile]);
+    fs2.rmSync(patchFile, { force: true });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message.split("\n")[0] : String(err) };
+  }
+}
+function discardSandbox(cwd) {
+  if (!sandboxExists(cwd)) return false;
+  const dir = sandboxDir(cwd);
+  try {
+    const link = path2.join(dir, "node_modules");
+    if (fs2.existsSync(link) && fs2.lstatSync(link).isSymbolicLink()) fs2.rmSync(link);
+  } catch {
+  }
+  try {
+    git(cwd, ["worktree", "remove", "--force", dir]);
+  } catch {
+    fs2.rmSync(dir, { recursive: true, force: true });
+  }
+  try {
+    git(cwd, ["worktree", "prune"]);
+  } catch {
+  }
+  return true;
+}
+
+// src/session/engine.ts
 var MAX_AUTO_FIX_ATTEMPTS = 2;
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var Session = class {
@@ -592,7 +678,8 @@ var Session = class {
       totals: { costUsd: 0, turns: 0 },
       queue: [],
       mode: "safe",
-      problems: []
+      problems: [],
+      sandbox: false
     };
     if (opts.autoDev && detectDevCommand(opts.cwd)) {
       this.devServer().start();
@@ -762,15 +849,33 @@ var Session = class {
       this.push("assistant", text);
     }
   }
+  /** Where engines run and servers start: the sandbox worktree when on. */
+  execCwd() {
+    return this.state.sandbox ? sandboxDir(this.opts.cwd) : this.opts.cwd;
+  }
   devServer() {
     if (!this.dev) {
-      this.dev = new DevServer(this.opts.cwd, {
+      this.dev = new DevServer(this.execCwd(), {
         onStateChange: (devState) => this.notify({ devState }),
         onUrl: (url) => this.notify({ devUrl: url })
       });
     }
     return this.dev;
   }
+  /** Rebind the dev server after the execution tree changes. */
+  resetDevServer() {
+    const wasRunning = this.dev && this.dev.state !== "stopped";
+    this.dev?.stop();
+    this.dev = null;
+    this.notify({ devUrl: null, devState: "stopped" });
+    if (wasRunning) {
+      const command = detectDevCommand(this.execCwd());
+      if (command) {
+        this.devServer().start(command);
+        this.push("status", `dev server restarting in ${this.state.sandbox ? "the sandbox" : "the real tree"}`);
+      }
+    }
+  }
   turnEdits = 0;
   turnTools = 0;
   toolStreak = 0;
@@ -849,7 +954,7 @@ var Session = class {
       engine,
       {
         prompt,
-        cwd: this.opts.cwd,
+        cwd: this.execCwd(),
         model: this.state.model,
         mode: this.state.mode,
         sessionId: engine.supportsResume ? this.sessionId : void 0
@@ -892,9 +997,9 @@ var Session = class {
       }
     }
     if (result.ok && this.opts.autoCheck !== false) {
-      const fastGates = detectFastGates(this.opts.cwd);
+      const fastGates = detectFastGates(this.execCwd());
       if (fastGates.length > 0) {
-        const gateResults = await runGates(this.opts.cwd, fastGates);
+        const gateResults = await runGates(this.execCwd(), fastGates);
         const failures = gateResults.filter((r) => !r.ok);
         if (failures.length > 0) {
           this.addProblem(
@@ -969,7 +1074,7 @@ ${errors.slice(-5).join("\n")}`);
   async submit(ask) {
     this.fixAttempts = 0;
     this.autoReviewedThisAsk = false;
-    const snapshot = takeSnapshot(this.opts.cwd);
+    const snapshot = this.state.sandbox ? null : takeSnapshot(this.opts.cwd);
     if (snapshot) {
       this.checkpoints.push({
         snapshot,
@@ -1049,7 +1154,7 @@ ${errors.slice(-5).join("\n")}`);
     if (result.shots.length > 0) {
       this.push(
         "status",
-        `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path2.dirname(result.shots[0].path)}`
+        `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path3.dirname(result.shots[0].path)}`
       );
     }
     if (result.runtime) {
@@ -1176,12 +1281,12 @@ They are objective defects, not style preferences.`
       }
       case "save": {
         void (async () => {
-          const fs2 = await import("fs");
-          const path4 = await import("path");
-          const dir = path4.join(this.opts.cwd, ".squint", "transcripts");
-          fs2.mkdirSync(dir, { recursive: true });
+          const fs3 = await import("fs");
+          const path5 = await import("path");
+          const dir = path5.join(this.opts.cwd, ".squint", "transcripts");
+          fs3.mkdirSync(dir, { recursive: true });
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-          const file = path4.join(dir, `${stamp}.md`);
+          const file = path5.join(dir, `${stamp}.md`);
           const lines = [`# squint session \u2014 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}`, ""];
           for (const item of this.state.items) {
             switch (item.role) {
@@ -1201,8 +1306,8 @@ They are objective defects, not style preferences.`
             }
           }
           lines.push("", `> ${this.summary()}`);
-          fs2.writeFileSync(file, lines.join("\n") + "\n");
-          this.push("status", `saved transcript \u2192 ${path4.relative(this.opts.cwd, file)}`);
+          fs3.writeFileSync(file, lines.join("\n") + "\n");
+          this.push("status", `saved transcript \u2192 ${path5.relative(this.opts.cwd, file)}`);
         })();
         break;
       }
@@ -1320,6 +1425,57 @@ They are objective defects, not style preferences.`
         this.push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
         break;
       }
+      case "sandbox": {
+        if (this.state.running) {
+          this.push("status", "wait for the current turn before changing sandbox state");
+          break;
+        }
+        if (arg === "diff") {
+          const stat = sandboxDiffStat(this.opts.cwd);
+          if (!stat) {
+            this.push("status", sandboxExists(this.opts.cwd) ? "sandbox is clean" : "no sandbox open \u2014 /sandbox on");
+          } else {
+            this.push("status", `${stat}
+${sandboxFiles(this.opts.cwd).join("\n")}`);
+          }
+          break;
+        }
+        if (arg === "apply") {
+          const applied = applySandbox(this.opts.cwd);
+          if (applied.ok) {
+            discardSandbox(this.opts.cwd);
+            this.notify({ sandbox: false });
+            this.resetDevServer();
+            this.push("status", "sandbox applied to the real tree \u2014 review with git diff");
+          } else {
+            this.push("error", applied.detail ?? "apply failed");
+          }
+          break;
+        }
+        if (arg === "discard" || arg === "off") {
+          const had = discardSandbox(this.opts.cwd);
+          this.notify({ sandbox: false });
+          this.resetDevServer();
+          this.push("status", had ? "sandbox discarded \u2014 the real tree was never touched" : "no sandbox open");
+          break;
+        }
+        if (arg === "on" || arg === "") {
+          if (!isGitRepo(this.opts.cwd)) {
+            this.push("error", "sandbox needs a git repo with at least one commit");
+            break;
+          }
+          const { reused } = openSandbox(this.opts.cwd);
+          this.notify({ sandbox: true });
+          this.resetDevServer();
+          this.push(
+            "status",
+            `${reused ? "rejoined the open sandbox" : "sandbox opened"} \u2014 asks now accumulate in a shadow worktree; /sandbox diff \xB7 apply \xB7 discard`
+          );
+          break;
+        }
+        this.push("status", "usage: /sandbox [on] \xB7 diff \xB7 apply \xB7 discard");
+        break;
+      }
       case "variants": {
         const [sub, ...subRest] = arg.split(/\s+/);
         if (sub === "apply") {
@@ -1395,7 +1551,7 @@ They are objective defects, not style preferences.`
         this.notify({ items: [], totals: { costUsd: 0, turns: 0 } });
         break;
       case "help": {
-        void import("./commands-TYAKF276.js").then(({ commandHelp }) => this.push("status", commandHelp()));
+        void import("./commands-N33DKZKC.js").then(({ commandHelp }) => this.push("status", commandHelp()));
         break;
       }
       case "quit":
@@ -1925,11 +2081,12 @@ function App({
           ]
         }
       ),
+      state.sandbox && /* @__PURE__ */ jsx3(Text3, { color: theme2.accent, bold: true, children: " [sandbox]" }),
       " ",
       state.engineId,
       state.model ? ` \xB7 ${state.model}` : "",
       " \xB7 ",
-      path3.basename(cwd),
+      path4.basename(cwd),
       devBadge,
       totalsBadge,
       state.problems.length > 0 && /* @__PURE__ */ jsxs3(Text3, { color: theme2.error, children: [
@@ -1979,7 +2136,7 @@ function registerTui(program2) {
 }
 
 // src/cli.tsx
-var VERSION = "0.2.7";
+var VERSION = "0.2.8";
 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);
 registerRun(program);

package/dist/{commands-TYAKF276.js → commands-N33DKZKC.js}

@@ -3,7 +3,7 @@ import {
   COMMANDS,
   commandHelp,
   completeCommand
-} from "./chunk-RZOQPFXC.js";
+} from "./chunk-YTO2YRF7.js";
 export {
   COMMANDS,
   commandHelp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aayambansal/squint",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Lovable for your terminal — a frontend harness on top of Claude Code, Codex, and other coding agents.",
   "type": "module",
   "license": "MIT",