@jhizzard/termdeck 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"
@@ -30,7 +30,7 @@
     "dev": "node packages/server/src/index.js",
     "server": "node packages/server/src/index.js",
     "start": "NODE_ENV=production node packages/cli/src/index.js",
-    "test": "node --test packages/server/tests/**/*.test.js",
+    "test": "node --test packages/server/tests/**/*.test.js packages/cli/tests/**/*.test.js packages/stack-installer/tests/**/*.test.js",
     "install:app": "bash install.sh",
     "sync-rumen-functions": "bash scripts/sync-rumen-functions.sh",
     "sync:agents": "node scripts/sync-agent-instructions.js"

package/packages/cli/src/index.js

@@ -202,18 +202,27 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
-// Subcommand dispatch — handle `termdeck init --mnestra|--rumen` before
-// falling through to the default launcher's flag parsing. The `require` of
-// init-*.js is lazy so users running the normal `termdeck` command never pay
-// the cost of loading pg / supabase helpers at startup.
+// Subcommand dispatch — handle `termdeck init [--mnestra|--rumen|--project|--auto|--mcp-supabase]`
+// before falling through to the default launcher's flag parsing. The `require`
+// of init-*.js is lazy so users running the normal `termdeck` command never
+// pay the cost of loading pg / supabase helpers at startup.
+//
+// Sprint 64 T1: added the no-subflag default (`termdeck init` with no mode
+// argument or with `--auto` / `--mcp-supabase`) routing to the new
+// `init.js` top-level orchestrator. The orchestrator runs init-mnestra
+// then init-rumen with a unified UX. `--auto` drives MCP-mediated
+// auto-provisioning. Existing modes (--mnestra / --rumen / --project)
+// stay callable independently for advanced users + CI fixtures.
 if (args[0] === 'init') {
   const mode = args[1];
   const rest = args.slice(2);
 
-  // Sprint 37 T2: refuse mode-mixing. The dispatch picks args[1] as the
-  // single mode flag, but a user who writes `init --project foo --mnestra`
+  // Sprint 37 T2 + Sprint 64 T1: refuse explicit-mode-mixing. The dispatch picks
+  // args[1] as the single mode flag, but a user who writes `init --project foo --mnestra`
   // probably intended only one of those. Surface the conflict instead of
-  // silently picking the first.
+  // silently picking the first. The `--auto` / `--mcp-supabase` flags are
+  // NOT in this list — they're handled by init.js (the orchestrator) and
+  // can co-exist with init.js's own flag set.
   const MODES = ['--project', '--mnestra', '--rumen'];
   const presentModes = MODES.filter((m) => args.slice(1).includes(m));
   if (presentModes.length > 1) {
@@ -221,19 +230,19 @@ if (args[0] === 'init') {
     process.exit(1);
   }
 
-  const run = (modPath) => {
+  const run = (modPath, argv) => {
     const fn = require(modPath);
-    return fn(rest).then((code) => process.exit(code || 0));
+    return fn(argv).then((code) => process.exit(code || 0));
   };
   if (mode === '--mnestra') {
-    run(path.join(__dirname, 'init-mnestra.js')).catch((err) => {
+    run(path.join(__dirname, 'init-mnestra.js'), rest).catch((err) => {
       console.error('[cli] init --mnestra failed:', err && err.stack || err);
       process.exit(1);
     });
     return;
   }
   if (mode === '--rumen') {
-    run(path.join(__dirname, 'init-rumen.js')).catch((err) => {
+    run(path.join(__dirname, 'init-rumen.js'), rest).catch((err) => {
       console.error('[cli] init --rumen failed:', err && err.stack || err);
       process.exit(1);
     });
@@ -242,16 +251,44 @@ if (args[0] === 'init') {
   if (mode === '--project') {
     // init-project takes the project name as its first positional arg, plus
     // optional --dry-run / --force flags. Pass `rest` straight through.
-    run(path.join(__dirname, 'init-project.js')).catch((err) => {
+    run(path.join(__dirname, 'init-project.js'), rest).catch((err) => {
       console.error('[cli] init --project failed:', err && err.stack || err);
       process.exit(1);
     });
     return;
   }
-  console.error('Usage: termdeck init --mnestra | --rumen | --project <name>');
-  console.error('  termdeck init --mnestra            Configure Tier 2 memory (Supabase + Mnestra)');
-  console.error('  termdeck init --rumen              Deploy Tier 3 async learning (Rumen)');
-  console.error('  termdeck init --project <name>     Scaffold a new project with CLAUDE.md + orchestration docs');
+
+  // Sprint 64 T1: default (no mode) OR `--auto` / `--mcp-supabase` → route to
+  // the unified orchestrator at init.js. It runs init-mnestra + init-rumen +
+  // doctor with a single progress UX. Forward ALL post-`init` args (mode
+  // arg included so init.js parses --auto / --mcp-supabase itself).
+  const orchestratorArgs = args.slice(1);
+  if (mode === undefined || mode === '--auto' || mode === '--mcp-supabase'
+      || (typeof mode === 'string' && mode.startsWith('-') && mode !== '-h')) {
+    // The leading-dash check catches things like `--help`, `--reset`,
+    // `--from-env`, `--dry-run` etc. — those are init.js orchestrator flags,
+    // not unknown sub-modes. Route to init.js with them intact.
+    run(path.join(__dirname, 'init.js'), orchestratorArgs).catch((err) => {
+      console.error('[cli] init failed:', err && err.stack || err);
+      process.exit(1);
+    });
+    return;
+  }
+  // `-h` alone after `init` → orchestrator help
+  if (mode === '-h') {
+    run(path.join(__dirname, 'init.js'), ['--help']).catch((err) => {
+      console.error('[cli] init failed:', err && err.stack || err);
+      process.exit(1);
+    });
+    return;
+  }
+  console.error('Usage: termdeck init [--auto] | --mnestra | --rumen | --project <name>');
+  console.error('  termdeck init                       Unified setup (Mnestra + Rumen + doctor)');
+  console.error('  termdeck init --auto                Auto-provision via Supabase MCP (alias: --mcp-supabase)');
+  console.error('  termdeck init --mnestra             Configure Tier 2 memory (Supabase + Mnestra)');
+  console.error('  termdeck init --rumen               Deploy Tier 3 async learning (Rumen)');
+  console.error('  termdeck init --project <name>      Scaffold a new project with CLAUDE.md + orchestration docs');
+  console.error('  termdeck init --help                Show full flag reference');
   process.exit(1);
 }
 

package/packages/cli/src/init-mnestra.js

@@ -684,6 +684,12 @@ const SETTINGS_JSON_PATH = path.join(require('os').homedir(), '.claude', 'settin
 const HOOK_COMMAND = 'node ~/.claude/hooks/memory-session-end.js';
 const HOOK_TIMEOUT_SECONDS = 30;
 
+// Sprint 64 T3 — PreCompact hook (Investigation 2 of CRITICAL-READ-FIRST-
+// 2026-05-07.md). Lives alongside the SessionEnd hook; refreshes via the
+// same Sprint 51.6 T3 version-stamp gate.
+const PRECOMPACT_HOOK_COMMAND = 'node ~/.claude/hooks/memory-pre-compact.js';
+const PRECOMPACT_HOOK_TIMEOUT_SECONDS = 30;
+
 function _isSessionEndHookEntry(entry) {
   return entry && typeof entry.command === 'string'
     && entry.command.includes('memory-session-end.js');
@@ -739,6 +745,42 @@ function _mergeSessionEndHookEntry(settings, opts = {}) {
   return { settings, status: migrated ? 'migrated-from-stop' : 'installed' };
 }
 
+// Sprint 64 T3 — PreCompact entry detection + merge. Hoisted mirror of
+// `_isPreCompactHookEntry` / `_mergePreCompactHookEntry` in
+// `packages/stack-installer/src/index.js` (same reasoning as the SessionEnd
+// duplication above: the published @jhizzard/termdeck tarball ships only
+// `packages/stack-installer/assets/hooks/**`, not `.../src/**`).
+function _isPreCompactHookEntry(entry) {
+  return entry && typeof entry.command === 'string'
+    && entry.command.includes('memory-pre-compact.js');
+}
+
+function _mergePreCompactHookEntry(settings, opts = {}) {
+  const command = opts.command || PRECOMPACT_HOOK_COMMAND;
+  const timeout = opts.timeout != null ? opts.timeout : PRECOMPACT_HOOK_TIMEOUT_SECONDS;
+  const entry = { type: 'command', command, timeout };
+
+  if (!settings.hooks || typeof settings.hooks !== 'object') settings.hooks = {};
+  if (!Array.isArray(settings.hooks.PreCompact)) settings.hooks.PreCompact = [];
+
+  for (const group of settings.hooks.PreCompact) {
+    if (!group || !Array.isArray(group.hooks)) continue;
+    if (group.hooks.some(_isPreCompactHookEntry)) {
+      return { settings, status: 'already-installed' };
+    }
+  }
+
+  const wildcardGroup = settings.hooks.PreCompact.find(
+    (g) => g && g.matcher === '*' && Array.isArray(g.hooks)
+  );
+  if (wildcardGroup) {
+    wildcardGroup.hooks.push(entry);
+  } else {
+    settings.hooks.PreCompact.push({ matcher: '*', hooks: [entry] });
+  }
+  return { settings, status: 'installed' };
+}
+
 function _readSettingsJson(filePath) {
   if (!fs.existsSync(filePath)) {
     return { settings: {}, status: 'no-file' };
@@ -808,6 +850,43 @@ function migrateSettingsJsonHookEntry(opts = {}) {
   return { status: merge.status, settingsPath, backup };
 }
 
+// Sprint 64 T3 — settings.json wiring for the PreCompact hook. Parallel to
+// migrateSettingsJsonHookEntry above but simpler (no Stop→event migration
+// branch; PreCompact didn't exist pre-Sprint-64).
+function migrateSettingsJsonPreCompactEntry(opts = {}) {
+  const dryRun = !!opts.dryRun;
+  const settingsPath = opts.settingsPath || SETTINGS_JSON_PATH;
+
+  const read = _readSettingsJson(settingsPath);
+  if (read.status === 'malformed') {
+    return { status: 'malformed', error: read.error, settingsPath };
+  }
+
+  const before = JSON.stringify(read.settings);
+  const merge = _mergePreCompactHookEntry(read.settings);
+  const after = JSON.stringify(merge.settings);
+  const noChange = before === after;
+
+  if (merge.status === 'already-installed' || noChange) {
+    return { status: 'already-installed', settingsPath };
+  }
+
+  if (dryRun) {
+    return { status: 'would-' + merge.status, settingsPath };
+  }
+
+  let backup = null;
+  if (read.status === 'ok' || read.status === 'empty') {
+    const stamp = new Date().toISOString().replace(/[-:T.Z]/g, '').slice(0, 14);
+    backup = `${settingsPath}.bak.${stamp}`;
+    try { fs.copyFileSync(settingsPath, backup); }
+    catch (_) { backup = null; }
+  }
+
+  _writeSettingsJson(settingsPath, merge.settings);
+  return { status: merge.status, settingsPath, backup };
+}
+
 function runSettingsJsonMigration({ dryRun = false } = {}) {
   const debug = !!process.env.TERMDECK_DEBUG_WIREUP;
   step('Reconciling ~/.claude/settings.json hook event mapping (Stop → SessionEnd)...');
@@ -841,6 +920,29 @@ function runSettingsJsonMigration({ dryRun = false } = {}) {
     process.stdout.write(`    ! settings.json migration failed: ${err.message} (continuing)\n`);
     if (debug) process.stderr.write(`[wire-up-debug] runSettingsJsonMigration threw: ${err && err.stack || err}\n`);
   }
+
+  // Sprint 64 T3 — wire the PreCompact hook into settings.json. Brand new in
+  // Sprint 64 (no legacy migration), so the merge either creates the entry or
+  // reports already-installed; nothing else to do.
+  step('Reconciling ~/.claude/settings.json PreCompact wiring...');
+  try {
+    const r = migrateSettingsJsonPreCompactEntry({ dryRun });
+    if (debug) process.stderr.write(`[wire-up-debug] runSettingsJsonMigration pre-compact return: ${JSON.stringify(r)}\n`);
+    if (r.status === 'already-installed') {
+      ok('already wired (PreCompact)');
+    } else if (r.status === 'installed') {
+      ok(r.backup ? `installed (PreCompact; backup: ${path.basename(r.backup)})` : 'installed (PreCompact)');
+    } else if (r.status === 'would-installed') {
+      ok('would install (PreCompact) (dry-run)');
+    } else if (r.status === 'malformed') {
+      ok(`(skipped: settings.json malformed: ${r.error})`);
+    } else {
+      ok(`(${r.status})`);
+    }
+  } catch (err) {
+    process.stdout.write(`    ! PreCompact wiring failed: ${err.message} (continuing)\n`);
+    if (debug) process.stderr.write(`[wire-up-debug] runSettingsJsonMigration pre-compact threw: ${err && err.stack || err}\n`);
+  }
 }
 
 function runHookRefresh({ dryRun = false } = {}) {
@@ -876,6 +978,35 @@ function runHookRefresh({ dryRun = false } = {}) {
     process.stdout.write(`    ! hook refresh failed: ${err.message} (continuing)\n`);
     if (debug) process.stderr.write(`[wire-up-debug] runHookRefresh threw: ${err && err.stack || err}\n`);
   }
+
+  // Sprint 64 T3 — also refresh the PreCompact hook. Re-uses the same
+  // version-stamp gate (refreshBundledHookIfNewer is parameterized by
+  // destPath + sourcePath; both hooks carry the `@termdeck/stack-installer-
+  // hook v<N>` marker the gate reads).
+  step('Refreshing ~/.claude/hooks/memory-pre-compact.js (if bundled is newer)...');
+  try {
+    const HOME = require('os').homedir();
+    const PRE_DEST = path.join(HOME, '.claude', 'hooks', 'memory-pre-compact.js');
+    const PRE_SOURCE = path.join(__dirname, '..', '..', 'stack-installer', 'assets', 'hooks', 'memory-pre-compact.js');
+    const r = refreshBundledHookIfNewer({ dryRun, destPath: PRE_DEST, sourcePath: PRE_SOURCE });
+    if (debug) process.stderr.write(`[wire-up-debug] runHookRefresh pre-compact return: ${JSON.stringify(r)}\n`);
+    if (r.status === 'refreshed') {
+      ok(`refreshed v${r.from ?? 0} → v${r.to} (backup: ${path.basename(r.backup)})`);
+    } else if (r.status === 'would-refresh') {
+      ok(`would-refresh v${r.from ?? 0} → v${r.to} (dry-run)`);
+    } else if (r.status === 'installed') {
+      ok(`installed v${r.bundled} (no prior copy)`);
+    } else if (r.status === 'would-install') {
+      ok(`would-install v${r.bundled} (dry-run, no prior copy)`);
+    } else if (r.status === 'up-to-date') {
+      ok(`up-to-date (v${r.installed})`);
+    } else {
+      ok(`(${r.status}${r.message ? ': ' + r.message : ''})`);
+    }
+  } catch (err) {
+    process.stdout.write(`    ! pre-compact hook refresh failed: ${err.message} (continuing)\n`);
+    if (debug) process.stderr.write(`[wire-up-debug] runHookRefresh pre-compact threw: ${err && err.stack || err}\n`);
+  }
 }
 
 function printNextSteps() {