@esneiderbravo/speclaw 2.0.17 → 2.0.19

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/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { parseFlags, REPEATABLE_FLAGS } from "./lib/args.js";
-import { ui, header } from "./lib/ui.js";
+import { ui, header, detectTheme } from "./lib/ui.js";
 import { maybeNotifyUpdate } from "./lib/update-check.js";
 import { GLOBAL_HELP as HELP, helpFor, knownCommands, wantsHelp } from "./lib/help.js";
 // Commands that open with the one-line branded header. These are the
@@ -38,13 +38,15 @@ const HEADER_COMMANDS = new Set([
  * child process. `budget --json`, `doctor --json`, and `coverage` when emitting
  * TAP/JSON (or when stdout is not a TTY) are machine-consumed and suppress the
  * header. `session-start` and `reindex-file` are not header-eligible: they must print
- * nothing.
+ * nothing. The palette is matched to the terminal background first, so every
+ * styled line after it — not only `init`'s — stays legible on a light theme.
  */
-function maybeHeader(cmd, flags) {
+async function maybeHeader(cmd, flags) {
     if (!process.stdout.isTTY && process.env.FORCE_COLOR !== "1")
         return;
     if (!HEADER_COMMANDS.has(cmd))
         return;
+    await detectTheme();
     // A self-update child re-runs `update`; the parent already printed the header.
     if (cmd === "update" && process.env.SPECLAW_SELF_UPDATED)
         return;
@@ -172,7 +174,7 @@ async function main() {
         return;
     }
     const flags = parseFlags(rest, REPEATABLE_FLAGS);
-    maybeHeader(cmd, flags);
+    await maybeHeader(cmd, flags);
     await dispatch(cmd, flags);
     // The SessionStart and edit hooks must stay silent: no update notice either.
     if (cmd === "session-start" || cmd === "reindex-file" || cmd === "ship-on-stop")

package/dist/cli/lib/ui.js

@@ -16,6 +16,113 @@ 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);
+    // Child speclaw processes (a self-update re-run) inherit the answer instead
+    // of querying the terminal again.
+    process.env.SPECLAW_THEME ??= 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 +188,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

@@ -79,10 +79,28 @@ function branchFiles(projectPath) {
         return [];
     const base = mergeBase(projectPath, "main") ?? mergeBase(projectPath, "master");
     const committed = base ? changedFiles(projectPath, base) : [];
-    return [...new Set([...committed, ...worktreeChangedFiles(projectPath)])]
+    return [
+        ...new Set([
+            ...committed,
+            ...worktreeChangedFiles(projectPath),
+            ...untrackedFiles(projectPath),
+        ]),
+    ]
         .filter((f) => !f.startsWith("lawbook/changes/"))
         .sort();
 }
+/** New files not yet added, outside ship's own output (`lawbook/changes/`, `.speclaw/`). */
+function untrackedFiles(projectPath) {
+    return git(projectPath, [
+        "-c",
+        "core.quotePath=false",
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+    ])
+        .split("\n")
+        .filter((f) => f && !f.startsWith("lawbook/changes/") && !f.startsWith(".speclaw/"));
+}
 function secs(ms) {
     return `${(ms / 1000).toFixed(1)} s`;
 }
@@ -311,30 +329,41 @@ function readMarker(projectPath) {
     return { branch: "", change: "", fingerprint: raw };
 }
 /**
- * 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.
+ * Fingerprint of the branch's work outside `lawbook/changes/` and `.speclaw/`: every path that
+ * differs from the merge base with `main`/`master` or is untracked, with its
+ * working-tree contents. A file hashes the same whether it is untracked, staged
+ * or committed, so committing work — new files included — is not new work; ship
+ * writes under `lawbook/changes/`, so its own output never changes it either.
+ * Without a merge base it falls back to the paths changed against HEAD plus HEAD itself.
  */
 function workFingerprint(projectPath) {
     const base = mergeBase(projectPath, "main") ?? mergeBase(projectPath, "master");
-    const diff = git(projectPath, ["diff", base ?? "HEAD", "--", ".", ":(exclude)lawbook/changes"]);
+    const tracked = git(projectPath, [
+        "-c",
+        "core.quotePath=false",
+        "diff",
+        "--name-only",
+        base ?? "HEAD",
+        "--",
+        ".",
+        ":(exclude)lawbook/changes",
+        ":(exclude).speclaw",
+    ]).split("\n");
     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/"))
+    for (const f of [...new Set([...tracked, ...untrackedFiles(projectPath)])].sort()) {
+        if (!f)
             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.
+            // Deleted, vanished or unreadable: its name stands in.
+            hash.update("\0");
         }
     }
     const anchor = base ?? git(projectPath, ["rev-parse", "HEAD"]).trim();
-    return hash.update(`\n${anchor}\n${diff}`).digest("hex");
+    return hash.update(`\n${anchor}\n`).digest("hex");
 }
 /**
  * The `Stop` hook body: when the agent ends a turn on a feature branch with

package/package.json

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