@esneiderbravo/speclaw 2.0.16 → 2.0.18

package/dist/cli/commands/init.js

@@ -7,7 +7,7 @@ import { buildIndex } from "../../modules/compass/indexer.js";
 import { AGENTS, agentById } from "../../shared/agents.js";
 import { loadPacks } from "../../modules/tools/packs.js";
 import { list } from "../lib/args.js";
-import { ui, c, banner, renderProgress, clearProgress } from "../lib/ui.js";
+import { ui, c, banner, detectTheme, renderProgress, clearProgress } from "../lib/ui.js";
 import { checkForUpdates } from "../lib/update-check.js";
 import { reportTrackedLocalContent } from "../lib/untrack.js";
 const PACK_LABELS = {};
@@ -37,6 +37,9 @@ export async function runInit(flags) {
     let packs;
     const availablePacks = loadPacks();
     const packIds = Object.keys(availablePacks);
+    // Init is read once, top to bottom, on whatever background the user has —
+    // match the palette to it before the first styled line.
+    await detectTheme();
     banner();
     // Scaffolding with a stale version writes yesterday's foundation, so recommend
     // upgrading first — prominently, before any prompts, so there's time to cancel.

package/dist/cli/lib/ui.js

@@ -16,6 +16,110 @@ export const PALETTE = Object.freeze({
     amber: [245, 183, 61], // #F5B73D — warning (re-tuned)
     red: [255, 92, 71], // #FF5C47 — deny: errors
 });
+// The same slots tuned for a light terminal: the ink palette is near-invisible
+// on white (cream is ~1.1:1, signal cyan ~1.6:1), so each slot here holds at
+// least 4.5:1 against white paper #FFFFFF instead.
+// Covers: req~brand-terminal-palette~1
+export const LIGHT_PALETTE = Object.freeze({
+    cyan: [0, 122, 140], // #007A8C — deep signal
+    cyanDim: [0, 122, 140], // #007A8C
+    cream: [31, 35, 40], // #1F2328 — primary text on light paper
+    muted: [95, 102, 112], // #5F6670 — secondary text
+    green: [26, 127, 55], // #1A7F37 — success
+    amber: [154, 103, 0], // #9A6700 — warning
+    red: [207, 34, 46], // #CF222E — errors
+});
+/**
+ * The theme an explicit signal asks for: `SPECLAW_THEME=light|dark` wins, then
+ * `COLORFGBG` (`fg;bg`, set by rxvt, Konsole, and others), whose background
+ * index 7 or 15 means a light terminal. Returns `undefined` when neither says.
+ */
+export function themeFromEnv(env = process.env) {
+    const forced = env.SPECLAW_THEME?.toLowerCase();
+    if (forced === "light" || forced === "dark")
+        return forced;
+    const bg = env.COLORFGBG?.split(";").pop();
+    if (bg === undefined || bg === "")
+        return undefined;
+    return bg === "7" || bg === "15" ? "light" : "dark";
+}
+let active = themeFromEnv() === "light" ? LIGHT_PALETTE : PALETTE;
+/** Switch every brand color to the given theme's palette. */
+export function setTheme(theme) {
+    active = theme === "light" ? LIGHT_PALETTE : PALETTE;
+}
+/**
+ * The theme an OSC 11 background-color reply implies
+ * (`ESC ] 11 ; rgb:RRRR/GGGG/BBBB` with 1–4 hex digits per channel): light when
+ * the background's relative luminance is above one half.
+ */
+export function themeFromOsc11(reply) {
+    const m = /rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i.exec(reply);
+    if (!m)
+        return undefined;
+    const [r, g, b] = [m[1], m[2], m[3]].map((h) => parseInt(h, 16) / (16 ** h.length - 1));
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b > 0.5 ? "light" : "dark";
+}
+// Ask the terminal for its background color. Terminals that don't support the
+// query never answer, so the wait is capped; a reply arriving after the cap
+// would land in the next prompt's input, hence a generous-but-short window.
+function queryBackground(timeoutMs = 200) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY || !process.stdout.isTTY || typeof stdin.setRawMode !== "function") {
+        return Promise.resolve("");
+    }
+    return new Promise((resolve) => {
+        let buf = "";
+        const wasRaw = stdin.isRaw;
+        const done = () => {
+            clearTimeout(timer);
+            stdin.off("data", onData);
+            stdin.setRawMode(wasRaw);
+            stdin.pause();
+            resolve(buf);
+        };
+        const onData = (d) => {
+            buf += d.toString("latin1");
+            if (buf.includes("\x07") || buf.includes("\x1b\\"))
+                done();
+        };
+        const timer = setTimeout(done, timeoutMs);
+        stdin.setRawMode(true);
+        stdin.on("data", onData);
+        stdin.resume();
+        process.stdout.write("\x1b]11;?\x07");
+    });
+}
+// macOS appearance as a last resort: most terminals there follow the system
+// theme by default. `AppleInterfaceStyle` exists only in dark mode.
+async function macAppearance() {
+    if (process.platform !== "darwin")
+        return undefined;
+    const { execFile } = await import("node:child_process");
+    return new Promise((resolve) => {
+        execFile("defaults", ["read", "-g", "AppleInterfaceStyle"], { timeout: 500 }, (err, out) => {
+            if (err && typeof err.code !== "number")
+                return resolve(undefined);
+            resolve(/dark/i.test(String(out)) ? "dark" : "light");
+        });
+    });
+}
+/**
+ * Detect the terminal's background and switch to the matching palette. An
+ * explicit env signal ({@link themeFromEnv}) wins; otherwise the terminal is
+ * asked directly (OSC 11), then the macOS appearance is consulted. Meant for
+ * interactive commands before their first styled line; does nothing when
+ * color is off.
+ */
+export async function detectTheme() {
+    const fromEnv = themeFromEnv();
+    let theme = fromEnv ?? "dark";
+    if (colorOn && !fromEnv) {
+        theme = themeFromOsc11(await queryBackground()) ?? (await macAppearance()) ?? "dark";
+    }
+    setTheme(theme);
+    return theme;
+}
 const colorOn = (Boolean(process.stdout.isTTY) || process.env.FORCE_COLOR === "1") && !process.env.NO_COLOR;
 // Whether the terminal reliably renders the unicode box/block glyphs the brand
 // output uses. Non-Windows terminals are assumed capable; a Windows console is
@@ -81,13 +185,13 @@ export function link(label, url) {
 }
 /** Brand color helpers for composing styled strings. */
 export const c = {
-    cyan: (s) => paint(PALETTE.cyan, s),
-    cyanDim: (s) => paint(PALETTE.cyanDim, s),
-    cream: (s) => paint(PALETTE.cream, s),
-    muted: (s) => paint(PALETTE.muted, s),
-    green: (s) => paint(PALETTE.green, s),
-    amber: (s) => paint(PALETTE.amber, s),
-    red: (s) => paint(PALETTE.red, s),
+    cyan: (s) => paint(active.cyan, s),
+    cyanDim: (s) => paint(active.cyanDim, s),
+    cream: (s) => paint(active.cream, s),
+    muted: (s) => paint(active.muted, s),
+    green: (s) => paint(active.green, s),
+    amber: (s) => paint(active.amber, s),
+    red: (s) => paint(active.red, s),
     bold,
 };
 /** Styled output primitives used across the CLI. */

package/dist/modules/lawbook/ship.js

@@ -238,7 +238,7 @@ export function shipChange(projectPath, name, opts = {}) {
             archivedTo = specArchive(projectPath, name, date).archivedTo;
     }
     if (gatesPassed && isGitRepo(projectPath))
-        markShipped(projectPath);
+        markShipped(projectPath, name);
     const t4 = Date.now();
     const gatesMs = t2 - t1;
     return {
@@ -278,32 +278,69 @@ function git(projectPath, args) {
     const r = spawnSync("git", args, { cwd: projectPath, encoding: "utf8" });
     return r.status === 0 ? r.stdout : "";
 }
-/** Fingerprint of the last shipped work; a manual ship and the hook share it. */
+/** The last shipped work; a manual ship and the hook share it. */
 const SHIP_MARKER = path.join(".speclaw", "ship-last");
-function markShipped(projectPath) {
+function currentBranch(projectPath) {
+    return git(projectPath, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+}
+function markShipped(projectPath, change) {
     const marker = path.join(projectPath, SHIP_MARKER);
     fs.mkdirSync(path.dirname(marker), { recursive: true });
-    fs.writeFileSync(marker, workFingerprint(projectPath));
+    const body = {
+        branch: currentBranch(projectPath),
+        change,
+        fingerprint: workFingerprint(projectPath),
+    };
+    fs.writeFileSync(marker, JSON.stringify(body) + "\n");
+}
+/** The last ship marker, or null; a pre-2.0.17 marker (a bare fingerprint) has no change name. */
+function readMarker(projectPath) {
+    const marker = path.join(projectPath, SHIP_MARKER);
+    if (!fs.existsSync(marker))
+        return null;
+    const raw = fs.readFileSync(marker, "utf8").trim();
+    try {
+        const m = JSON.parse(raw);
+        if (typeof m.fingerprint === "string") {
+            return { branch: m.branch ?? "", change: m.change ?? "", fingerprint: m.fingerprint };
+        }
+    }
+    catch {
+        // Legacy marker: the fingerprint alone.
+    }
+    return { branch: "", change: "", fingerprint: raw };
 }
 /**
- * Fingerprint of the work outside `lawbook/changes/`: the diff against HEAD
- * plus untracked file names. Ship writes under `lawbook/changes/`, so its own
- * output never changes the fingerprint.
+ * Fingerprint of the branch's work outside `lawbook/changes/`: the working tree
+ * diffed against the merge base with `main`/`master`, plus untracked files
+ * (names and contents). Committing that work leaves it unchanged — a commit is not new work —
+ * and ship writes under `lawbook/changes/`, so its own output never changes it.
+ * Without a merge base it falls back to the diff against HEAD plus HEAD itself.
  */
 function workFingerprint(projectPath) {
-    const diff = git(projectPath, ["diff", "HEAD", "--", ".", ":(exclude)lawbook/changes"]);
-    const untracked = git(projectPath, ["ls-files", "--others", "--exclude-standard"])
-        .split("\n")
-        .filter((f) => f && !f.startsWith("lawbook/changes/") && !f.startsWith(".speclaw/"))
-        .join("\n");
-    const head = git(projectPath, ["rev-parse", "HEAD"]).trim();
-    return createHash("sha256").update(`${head}\n${diff}\n${untracked}`).digest("hex");
+    const base = mergeBase(projectPath, "main") ?? mergeBase(projectPath, "master");
+    const diff = git(projectPath, ["diff", base ?? "HEAD", "--", ".", ":(exclude)lawbook/changes"]);
+    const hash = createHash("sha256");
+    for (const f of git(projectPath, ["ls-files", "--others", "--exclude-standard"]).split("\n")) {
+        if (!f || f.startsWith("lawbook/changes/") || f.startsWith(".speclaw/"))
+            continue;
+        // Contents, not just names: editing a new, not-yet-added file is new work.
+        hash.update(`${f}\n`);
+        try {
+            hash.update(fs.readFileSync(path.join(projectPath, f)));
+        }
+        catch {
+            // Vanished or unreadable since listing: its name stands in.
+        }
+    }
+    const anchor = base ?? git(projectPath, ["rev-parse", "HEAD"]).trim();
+    return hash.update(`\n${anchor}\n${diff}`).digest("hex");
 }
 /**
  * The `Stop` hook body: when the agent ends a turn on a feature branch with
  * work that changed since the last ship, run {@link shipChange} for the change
- * named after the branch. Skips in milliseconds otherwise, so a turn that only
- * answered a question costs nothing.
+ * last shipped on this branch, else the one named after the branch. Skips in
+ * milliseconds otherwise, so a turn that only answered a question costs nothing.
  *
  * @param projectPath - Project root.
  * @returns Why it skipped, or the ship result.
@@ -311,15 +348,19 @@ function workFingerprint(projectPath) {
 export function shipOnStop(projectPath) {
     if (!isGitRepo(projectPath))
         return { skipped: "not-git" };
-    const branch = git(projectPath, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+    const branch = currentBranch(projectPath);
     if (!branch || ["main", "master", "HEAD"].includes(branch))
         return { skipped: "base-branch" };
     if (branchFiles(projectPath).length === 0)
         return { skipped: "no-changes" };
-    const marker = path.join(projectPath, SHIP_MARKER);
-    if (fs.existsSync(marker) && fs.readFileSync(marker, "utf8") === workFingerprint(projectPath)) {
+    const marker = readMarker(projectPath);
+    if (marker?.fingerprint === workFingerprint(projectPath)) {
         return { skipped: "unchanged-since-last-ship" };
     }
-    const change = changeNameForBranch(branch);
+    // A change shipped by name on this branch keeps receiving the branch's later
+    // work; the branch name would point at another (possibly archived) change.
+    const change = marker && marker.branch === branch && marker.change
+        ? marker.change
+        : changeNameForBranch(branch);
     return { skipped: null, change, result: shipChange(projectPath, change) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esneiderbravo/speclaw",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "publishConfig": {
     "access": "public"
   },