sprag-cli 3.56.0 → 3.58.0

package/src/harness.js

@@ -214,16 +214,38 @@ export function harnessInit({ root = findProjectRoot(), force = false, scope = '
   const block = harnessClaudeMdBlock(scope);
   if (existsSync(cmPath)) {
     const existing = readFileSync(cmPath, 'utf8');
-    if (existing.includes(HARNESS_BLOCK_BEGIN) && !force) {
+    const hasBegin = existing.includes(HARNESS_BLOCK_BEGIN);
+    const blockRe = new RegExp(
+      `${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
+      'm',
+    );
+    const hasCompleteBlock = blockRe.test(existing);
+    if (hasBegin && !hasCompleteBlock) {
+      // A begin marker with no end marker after it: the extent of our block is
+      // unknowable, so replacing or appending would either eat the user's text
+      // or leave a second block beside the broken one. Touch nothing.
+      result.skipped.push(`${cmPath} (harness block has a begin marker but no end marker — fix it manually)`);
+      result.brokenBlock = true;
+    } else if (hasCompleteBlock) {
       // Already has a harness block — replace it in-place, preserving the
-      // user's other content above/below.
-      const re = new RegExp(
-        `${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
-        'm',
-      );
-      const next = existing.replace(re, block);
-      writeFileSync(cmPath, next);
-      result.wrote.push(cmPath + ' (block updated in place)');
+      // user's other content above/below. This holds with or without --force:
+      // --force used to fall through to the append branch, which added a second
+      // block on every run.
+      // A replacer function, not the string: `$&` or `$1` in a block would be
+      // read as a replacement pattern.
+      const next = existing.replace(blockRe, () => block);
+      if (next === existing) {
+        result.skipped.push(`${cmPath} (harness block already up to date)`);
+      } else {
+        if (force) {
+          const stamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+          const bak = `${cmPath}.bak-${stamp}`;
+          writeFileSync(bak, existing);
+          result.backedUp.push(bak);
+        }
+        writeFileSync(cmPath, next);
+        result.wrote.push(cmPath + ' (block updated in place)');
+      }
     } else {
       // Backup as safety net, then APPEND the harness block to existing
       // content (do not clobber). Users keep all their prior CLAUDE.md content;
@@ -295,7 +317,16 @@ export function harnessUninit({ root = findProjectRoot(), purgeRatchet = false,
 
   if (existsSync(cmPath)) {
     const existing = readFileSync(cmPath, 'utf8');
-    if (existing.includes(HARNESS_BLOCK_BEGIN)) {
+    const beginIdx = existing.indexOf(HARNESS_BLOCK_BEGIN);
+    const uninitRe = new RegExp(
+      `\\n*${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
+      'm',
+    );
+    if (beginIdx !== -1 && !uninitRe.test(existing)) {
+      // Begin marker without an end marker: nothing to cut safely, and writing
+      // the file back unchanged would still report a removal.
+      result.skipped.push(`${cmPath} (harness block has a begin marker but no end marker — fix it manually)`);
+    } else if (beginIdx !== -1) {
       const stamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
       const bak = `${cmPath}.bak-${stamp}`;
       writeFileSync(bak, existing);
@@ -575,7 +606,7 @@ export function harnessRmRule(n, { root = findProjectRoot(), scope = 'project',
  * has explicitly disabled harness display, or when there's no CLAUDE.md and
  * no .claude/ at all (silent in non-init'd projects so we don't nag).
  */
-export function harnessStatusForStatusline(cfg, { root } = {}) {
+export function harnessStatusForStatusline(cfg, { root, liveWindow = null } = {}) {
   if (cfg && cfg.harness && cfg.harness.enabled === false) return null;
   const projectRoot = root || findProjectRoot();
   const status = harnessStatus(projectRoot);
@@ -620,7 +651,7 @@ export function harnessStatusForStatusline(cfg, { root } = {}) {
   // exempt — the setting cannot change anything for them.
   if (!warning) {
     try {
-      warning = compactWindowWarningForStatusline(projectRoot, cfg);
+      warning = compactWindowWarningForStatusline(projectRoot, cfg, { liveWindow });
     } catch { /* settings unreadable — stay silent */ }
   }
   // Below session-quality warnings: a promoted delegation rule whose

package/src/history.js

@@ -50,7 +50,8 @@ function hms(d = new Date()) {
 
 function loadState() {
   try {
-    return JSON.parse(readFileSync(STATE_PATH, 'utf8'));
+    const s = JSON.parse(readFileSync(STATE_PATH, 'utf8'));
+    return s && typeof s === 'object' && !Array.isArray(s) ? s : { chip: null, ts: null };
   } catch {
     return { chip: null, ts: null };
   }
@@ -218,7 +219,10 @@ export function recordChip(chip, contextHints = {}) {
     ko = `✓ 해소됨 (이전: ${chipKo(last)})`;
   }
   appendDayLine(en, ko, now, tips);
-  saveState({ chip: current, ts: now.toISOString() });
+  // The state file also holds one `cap_<window>` slot per rate-limit window
+  // (recordCapTransition). Saving the chip alone wiped them, so the next render
+  // saw a window at 90% as newly crossed and logged the cap warning again.
+  saveState({ ...state, chip: current, ts: now.toISOString() });
   return true;
 }
 

package/src/hook-manager.js

@@ -9,21 +9,26 @@
  * removes the copy, the staleness, and the orphan in one move.
  */
 
-import { readFile, writeFile, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
+import { mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { CLI_NAME } from './cli-name.js';
+import { claudeUserDir } from './paths.js';
+import { isOurSubcommand, isLegacyCacheMonitorCommand, readSettings, writeSettings } from './installer.js';
 
-const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+// Resolved per call, not at import: the paths follow the current home directory.
+const settingsPath = () => join(claudeUserDir(), 'settings.json');
 // Legacy copied-file location — removed on install/uninstall so machines that
 // installed an older version don't keep a dead hook script around.
-const LEGACY_HOOK_DEST = join(homedir(), '.claude', 'cache-monitor-hook.cjs');
-const HOOK_MARKER = 'cache-monitor-hook';
+const legacyHookDest = () => join(claudeUserDir(), 'cache-monitor-hook.cjs');
 
+// Ours means the current subcommand form (`<cli> --hook-run ...`) or the exact
+// legacy copied-file form. A command that only mentions either string, such as
+// `echo "sprag --hook-run"`, belongs to somebody else.
 function isCacheMonitorHook(nh) {
   const cmd = nh?.command;
   if (typeof cmd !== 'string') return false;
-  return cmd.includes(HOOK_MARKER) || cmd.includes('--hook-run');
+  return isOurSubcommand(cmd, '--hook-run') || isLegacyCacheMonitorCommand(cmd);
 }
 
 /**
@@ -51,21 +56,31 @@ function countCacheMonitorHooks(groups) {
   return n;
 }
 
+function fail(message) {
+  console.log(message);
+  process.exitCode = 1;
+  return false;
+}
+
 export async function installHook({ threshold = 0.7 } = {}) {
-  let settings;
-  try {
-    const raw = await readFile(SETTINGS_PATH, 'utf8');
-    settings = JSON.parse(raw);
-  } catch {
-    settings = {};
+  const SETTINGS_PATH = settingsPath();
+  // Only a missing file starts from an empty object. A file that exists but
+  // cannot be parsed (or is not an object) is the user's configuration;
+  // replacing it with a fresh object would wipe everything in it.
+  const read = readSettings(SETTINGS_PATH);
+  if (read.state === 'unusable') {
+    return fail(`✗ ${SETTINGS_PATH} is ${read.reason} — hook not installed, file left untouched.`);
   }
+  const settings = read.settings;
 
-  if (!settings.hooks) settings.hooks = {};
+  if (settings.hooks === undefined || settings.hooks === null) settings.hooks = {};
+  if (typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+    return fail(`✗ hooks in ${SETTINGS_PATH} is not an object — hook not installed, file left untouched.`);
+  }
   if (settings.hooks.PostToolUse !== undefined && !Array.isArray(settings.hooks.PostToolUse)) {
     // Someone else's data in a shape we do not understand; overwriting it with
     // [] would discard it. Leave the file alone and say so.
-    console.log(`⚠ hooks.PostToolUse in ${SETTINGS_PATH} is not an array — hook not installed.`);
-    return;
+    return fail(`✗ hooks.PostToolUse in ${SETTINGS_PATH} is not an array — hook not installed, file left untouched.`);
   }
   if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
 
@@ -84,10 +99,12 @@ export async function installHook({ threshold = 0.7 } = {}) {
     ],
   });
 
-  await writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+  mkdirSync(claudeUserDir(), { recursive: true });
+  const writeProblem = writeSettings(SETTINGS_PATH, settings);
+  if (writeProblem) return fail(`✗ Hook not installed: ${writeProblem}`);
 
   // Clean up the legacy copy left by older versions.
-  await rm(LEGACY_HOOK_DEST, { force: true }).catch(() => {});
+  await rm(legacyHookDest(), { force: true }).catch(() => {});
 
   console.log(`✓ Hook installed (PostToolUse → ${CLI_NAME} --hook-run)`);
   console.log(`  Settings updated: ${SETTINGS_PATH}`);
@@ -96,29 +113,34 @@ export async function installHook({ threshold = 0.7 } = {}) {
 }
 
 export async function uninstallHook() {
-  let settings;
-  try {
-    const raw = await readFile(SETTINGS_PATH, 'utf8');
-    settings = JSON.parse(raw);
-  } catch {
+  const SETTINGS_PATH = settingsPath();
+  const read = readSettings(SETTINGS_PATH);
+  if (read.state === 'absent') {
     console.log('No settings.json found, nothing to uninstall.');
     return;
   }
+  if (read.state === 'unusable') {
+    return fail(`✗ ${SETTINGS_PATH} is ${read.reason} — nothing removed, file left untouched.`);
+  }
+  const settings = read.settings;
 
   if (Array.isArray(settings.hooks?.PostToolUse)) {
-    const before = countCacheMonitorHooks(settings.hooks.PostToolUse);
-    settings.hooks.PostToolUse = withoutCacheMonitorHooks(settings.hooks.PostToolUse);
-    const removed = before;
-
-    if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
-    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
-
-    await writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8');
-    console.log(`✓ Removed ${removed} hook(s) from settings.json`);
+    const removed = countCacheMonitorHooks(settings.hooks.PostToolUse);
+    if (removed > 0) {
+      settings.hooks.PostToolUse = withoutCacheMonitorHooks(settings.hooks.PostToolUse);
+      if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+      if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+      const writeProblem = writeSettings(SETTINGS_PATH, settings);
+      if (writeProblem) return fail(`✗ Hook not removed: ${writeProblem}`);
+      console.log(`✓ Removed ${removed} hook(s) from settings.json`);
+    } else {
+      console.log('No cache-monitor hook found in settings.');
+    }
   } else {
     console.log('No cache-monitor hook found in settings.');
   }
 
   // The legacy copied hook file is dead weight either way.
-  await rm(LEGACY_HOOK_DEST, { force: true }).catch(() => {});
+  await rm(legacyHookDest(), { force: true }).catch(() => {});
 }