kodelyth-ecc 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.3.0 — Interactive arrow-key CLI menu (July 2026)
+
+Run `kodelythecc` (or `kodelyth-ecc`) with no args in a real terminal and an arrow-key menu opens.
+
+### Added
+
+**Interactive menu** (`scripts/cli/menu.js` — zero dependencies)
+- Arrow-key up/down navigation, Enter to select, `q` / esc / Ctrl+C to quit
+- Vim-style `j`/`k` also work
+- Options:
+  - **Update to vX.Y.Z** — only shown when a newer version exists on npm (24h-cached check)
+  - **Open Dashboard** — boot localhost dashboard (RTK + Terse + Codebase + Memory, all real data)
+  - **Install ECC for another IDE** — inline picker across 13 IDE targets, runs `--target X` non-interactively
+  - **RTK / Terse / Codebase status** — inline `kodelyth-ecc <sub> status` runs, then returns to menu on Enter
+  - **Run in background** — daemonises the dashboard, writes PID to `~/.kodelythecc/dashboard-daemon.pid`, log to `~/.kodelythecc/dashboard-daemon.log`, prints stop command
+  - **Exit**
+
+**Update checker** (`scripts/cli/update-check.js`)
+- Polls `https://registry.npmjs.org/kodelyth-ecc/latest` with 2.5s timeout
+- Result cached to `~/.kodelythecc/update-check.json` for 24 hours to avoid nagging or spam
+- Menu shows `up to date` / `latest: vX.Y.Z` / `update available: vX.Y.Z` (yellow) as appropriate
+- Non-blocking: menu renders in <1s even if npm is slow
+
+### Behaviour
+
+- **Menu opens only when interactive** — real TTY on both stdin and stdout, no `CI` env, no `KODELYTH_NO_MENU=1` env
+- **Piped stdin / CI runs the installer** — same as before, no menu, no breakage
+- **Passing any flag or subcommand** — skips the menu entirely
+- **Background daemon** — the dashboard child is `detach()`ed and `unref()`ed, survives the parent shell exit. Stop with `kill $(cat ~/.kodelythecc/dashboard-daemon.pid)`
+
+### Verified live on this Mac
+
+- `node bin/kodelyth-ecc.js` in a TTY → menu opens, arrow keys navigate
+- `echo | node bin/kodelyth-ecc.js` → menu correctly skips, installer runs as before
+- `require('./scripts/cli/update-check.js').check({current: '2.2.2'})` → live npm hit, returns `{latest: '2.2.2', updateAvailable: false, cached: false}` — real data, no fake fallback
+
 ## v2.2.0 — Codebase graph integration + self-documenting CLI (July 2026)
 
 ECC now stacks three complementary memory + savings layers, all local, all real:

package/VERSION

@@ -1 +1 @@
-2.2.1
+2.3.0

package/bin/kodelyth-ecc.js

@@ -33,6 +33,18 @@ const args    = process.argv.slice(2).filter((a, i, arr) => {
 });
 const isWin   = os.platform() === 'win32';
 
+// ── Interactive menu — fires when invoked with no args on a real terminal ───
+// Skip if the user passed any flag/subcommand, if piped/CI, or with --no-menu.
+if (args.length === 0
+    && process.stdin.isTTY
+    && process.stdout.isTTY
+    && !process.env.CI
+    && !process.env.KODELYTH_NO_MENU) {
+  require(path.join(ROOT, 'scripts', 'cli', 'menu.js')).main()
+    .catch(err => { process.stderr.write((err.stack || err.message) + '\n'); process.exit(1); });
+  return;
+}
+
 // ── Per-command help — runs BEFORE any subcommand block consumes --help ─────
 if (args[1] === '--help' || args[1] === '-h') {
   const HELP_MAP = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
@@ -56,7 +56,8 @@
     "productivity"
   ],
   "bin": {
-    "kodelyth-ecc": "bin/kodelyth-ecc.js"
+    "kodelyth-ecc": "bin/kodelyth-ecc.js",
+    "kodelythecc":  "bin/kodelyth-ecc.js"
   },
   "scripts": {
     "test": "node tests/run-all.js",

package/scripts/cli/menu.js

@@ -0,0 +1,288 @@
+// scripts/cli/menu.js
+// Interactive arrow-key CLI menu. Zero deps. Uses raw stdin + ANSI escapes.
+// Triggered when `kodelythecc` is run with no args in a TTY.
+
+'use strict';
+
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+
+// ── ANSI helpers (no chalk dep) ─────────────────────────────────────────────
+const C = {
+  reset:  '\x1b[0m',
+  dim:    '\x1b[2m',
+  bold:   '\x1b[1m',
+  cyan:   '\x1b[36m',
+  green:  '\x1b[32m',
+  yellow: '\x1b[33m',
+  magenta:'\x1b[35m',
+  red:    '\x1b[31m',
+  gray:   '\x1b[90m',
+  invert: '\x1b[7m',
+};
+
+function clear()       { process.stdout.write('\x1b[2J\x1b[H'); }
+function hideCursor()  { process.stdout.write('\x1b[?25l'); }
+function showCursor()  { process.stdout.write('\x1b[?25h'); }
+function moveTo(row)   { process.stdout.write(`\x1b[${row};1H`); }
+
+// ── Build the menu options dynamically ──────────────────────────────────────
+async function buildOptions({ ROOT }) {
+  const pkg = require(path.join(ROOT, 'package.json'));
+  const current = pkg.version;
+
+  // Update check — fires async, doesn't block the menu.
+  const { check } = require('./update-check.js');
+  const updateP = check({ current }).catch(() => ({ updateAvailable: false, latest: null }));
+
+  // Wait max 1s for the update check to return (so first render isn't a full 2.5s wait)
+  const update = await Promise.race([
+    updateP,
+    new Promise(r => setTimeout(() => r({ updateAvailable: false, latest: null, pending: true }), 1000)),
+  ]);
+
+  const opts = [];
+  if (update.updateAvailable) {
+    opts.push({
+      label: `Update to v${update.latest}`,
+      hint:  'npm i -g kodelyth-ecc  (installs new version)',
+      run:   () => runUpdate(),
+      badge: 'NEW',
+    });
+  }
+  opts.push({
+    label: 'Open Dashboard',
+    hint:  'localhost observability — RTK, Terse, Codebase, Memory (all real data)',
+    run:   () => runDashboard(),
+  });
+  opts.push({
+    label: 'Install ECC for another IDE',
+    hint:  'claude-code, cursor, windsurf, antigravity, codex, opencode, gemini, cline, roocode, kimi',
+    run:   () => pickIdeAndInstall(ROOT),
+  });
+  opts.push({
+    label: 'RTK status (input token savings)',
+    hint:  'Show RTK version + wired IDEs + savings',
+    run:   () => runSub(['rtk', 'status']),
+  });
+  opts.push({
+    label: 'Terse status (output compression)',
+    hint:  'Skill install state, ledger totals',
+    run:   () => runSub(['terse', 'status']),
+  });
+  opts.push({
+    label: 'Codebase graph status',
+    hint:  'codebase-memory-mcp (DeusData) — 158 languages, structural queries',
+    run:   () => runSub(['codebase', 'status']),
+  });
+  opts.push({
+    label: 'Memory stats (BM25 recall)',
+    hint:  'Local BM25 memory — captures, projects, top tags',
+    run:   () => runSub(['dashboard', '--port', '5747', '--no-open']),
+    background: true,
+    backgroundNote: 'Dashboard started at http://127.0.0.1:5747 — visit for full stats. Ctrl+C in this menu to stop watching.',
+  });
+  opts.push({
+    label: 'Run in background (dashboard + hooks live)',
+    hint:  'Detach dashboard as a daemon so /api routes stay reachable',
+    run:   () => runBackground(),
+  });
+  opts.push({
+    label: 'Exit',
+    hint:  '',
+    run:   () => process.exit(0),
+    exit:  true,
+  });
+
+  return { opts, current, update };
+}
+
+// ── Actions ─────────────────────────────────────────────────────────────────
+function runUpdate() {
+  cleanup();
+  console.log(`${C.cyan}Running: npm install -g kodelyth-ecc${C.reset}\n`);
+  const r = spawnSync('npm', ['install', '-g', 'kodelyth-ecc'], { stdio: 'inherit' });
+  process.exit(r.status ?? 0);
+}
+
+function runDashboard() {
+  cleanup();
+  console.log(`${C.cyan}Booting dashboard on http://127.0.0.1:5747${C.reset}`);
+  console.log(`${C.gray}(Ctrl+C to stop)${C.reset}\n`);
+  const r = spawnSync(process.execPath, [
+    path.join(__dirname, '..', '..', 'bin', 'kodelyth-ecc.js'),
+    'dashboard'
+  ], { stdio: 'inherit' });
+  process.exit(r.status ?? 0);
+}
+
+function runSub(args) {
+  cleanup();
+  const r = spawnSync(process.execPath, [
+    path.join(__dirname, '..', '..', 'bin', 'kodelyth-ecc.js'),
+    ...args,
+  ], { stdio: 'inherit' });
+  console.log(`\n${C.gray}Press Enter to return to menu…${C.reset}`);
+  waitForEnter().then(() => main().catch(() => process.exit(0)));
+}
+
+async function pickIdeAndInstall(ROOT) {
+  const targets = [
+    'claude-code', 'cursor-project', 'windsurf-home', 'windsurf-project',
+    'antigravity', 'codex-home', 'opencode', 'cline', 'roocode',
+    'gemini-home', 'gemini-project', 'kimi', 'aider',
+  ];
+  const chosen = await pick('Pick an IDE to install for', targets);
+  if (chosen == null) return main();
+  cleanup();
+  console.log(`${C.cyan}Installing ECC for ${targets[chosen]}…${C.reset}\n`);
+  const r = spawnSync(process.execPath, [
+    path.join(ROOT, 'bin', 'kodelyth-ecc.js'),
+    '--target', targets[chosen],
+  ], {
+    stdio: 'inherit',
+    env: { ...process.env, KODELYTH_NONINTERACTIVE: '1' },
+  });
+  console.log(`\n${C.gray}Press Enter to return to menu…${C.reset}`);
+  waitForEnter().then(() => main().catch(() => process.exit(0)));
+}
+
+function runBackground() {
+  cleanup();
+  const logDir = path.join(os.homedir(), '.kodelythecc');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFile = path.join(logDir, 'dashboard-daemon.log');
+  const pidFile = path.join(logDir, 'dashboard-daemon.pid');
+  const child = spawn(process.execPath, [
+    path.join(__dirname, '..', '..', 'bin', 'kodelyth-ecc.js'),
+    'dashboard', '--port', '5747', '--no-open',
+  ], {
+    detached: true, stdio: ['ignore', fs.openSync(logFile, 'a'), fs.openSync(logFile, 'a')],
+  });
+  child.unref();
+  fs.writeFileSync(pidFile, String(child.pid));
+  console.log(`${C.green}✓${C.reset} Dashboard daemon started (pid ${child.pid})`);
+  console.log(`  URL:    ${C.cyan}http://127.0.0.1:5747${C.reset}`);
+  console.log(`  Log:    ${logFile}`);
+  console.log(`  Pid:    ${pidFile}`);
+  console.log(`  Stop:   ${C.dim}kill $(cat ${pidFile})${C.reset}`);
+  process.exit(0);
+}
+
+// ── Render + keyboard loop ──────────────────────────────────────────────────
+let _keyHandler = null;
+function cleanup() {
+  showCursor();
+  try { process.stdin.setRawMode(false); } catch {}
+  try { process.stdin.pause(); } catch {}
+  if (_keyHandler) { process.stdin.removeListener('data', _keyHandler); _keyHandler = null; }
+}
+process.on('exit', cleanup);
+process.on('SIGINT',  () => { cleanup(); console.log(); process.exit(0); });
+process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+
+function render({ current, update, opts, index }) {
+  clear();
+  const w = process.stdout.columns || 80;
+  const bar = '─'.repeat(Math.max(20, w - 4));
+  let updateLine = C.gray + 'up to date' + C.reset;
+  if (update?.pending)         updateLine = C.dim + 'checking npm registry…' + C.reset;
+  else if (update?.updateAvailable) updateLine = C.yellow + `${C.bold}update available: v${update.latest}${C.reset}`;
+  else if (update?.latest && update.latest !== current) updateLine = C.gray + `latest: v${update.latest}` + C.reset;
+
+  console.log(`${C.cyan}${C.bold}⚙ Kodelyth ECC${C.reset}  ${C.gray}v${current}${C.reset}  ${C.dim}·${C.reset}  ${C.magenta}Elite Code Crew${C.reset}   ${updateLine}`);
+  console.log(`${C.gray}${bar}${C.reset}`);
+  console.log('');
+
+  for (let i = 0; i < opts.length; i++) {
+    const o = opts[i];
+    const active = i === index;
+    const marker = active ? `${C.cyan} ▸ ${C.reset}` : '   ';
+    const label  = active ? `${C.bold}${o.label}${C.reset}` : o.label;
+    const hint   = o.hint ? `${C.gray}${o.hint}${C.reset}` : '';
+    const badge  = o.badge ? ` ${C.yellow}[${o.badge}]${C.reset}` : '';
+    // Two columns: label (36 wide) then hint.
+    const labelText = (active ? '▸ ' : '  ') + o.label + (o.badge ? ` [${o.badge}]` : '');
+    const pad = ' '.repeat(Math.max(2, 40 - labelText.length));
+    const colored = active
+      ? `${C.cyan} ▸ ${C.bold}${o.label}${C.reset}${badge}${pad}${hint}`
+      : `   ${o.label}${badge}${pad}${hint}`;
+    console.log(colored);
+  }
+  console.log('');
+  console.log(`${C.gray}↑/↓ navigate  ·  ⏎ select  ·  q / esc / Ctrl+C to quit${C.reset}`);
+}
+
+async function pick(title, items) {
+  return new Promise((resolve) => {
+    let idx = 0;
+    const draw = () => {
+      clear();
+      console.log(`${C.cyan}${C.bold}${title}${C.reset}\n`);
+      for (let i = 0; i < items.length; i++) {
+        console.log(i === idx ? `${C.cyan} ▸ ${C.bold}${items[i]}${C.reset}` : `   ${items[i]}`);
+      }
+      console.log(`\n${C.gray}↑/↓ move · ⏎ pick · esc / q cancel${C.reset}`);
+    };
+    hideCursor();
+    process.stdin.setRawMode(true); process.stdin.resume();
+    draw();
+    const h = (b) => {
+      const s = b.toString();
+      if (s === '\x1b[A' || s === 'k') { idx = (idx - 1 + items.length) % items.length; draw(); }
+      else if (s === '\x1b[B' || s === 'j') { idx = (idx + 1) % items.length; draw(); }
+      else if (s === '\r' || s === '\n') {
+        process.stdin.removeListener('data', h); resolve(idx);
+      } else if (s === 'q' || s === '\x1b' || s === '\x03') {
+        process.stdin.removeListener('data', h); resolve(null);
+      }
+    };
+    process.stdin.on('data', h);
+  });
+}
+
+function waitForEnter() {
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true); process.stdin.resume();
+    const h = (b) => {
+      const s = b.toString();
+      if (s === '\r' || s === '\n' || s === 'q' || s === '\x1b' || s === '\x03') {
+        process.stdin.removeListener('data', h); resolve();
+      }
+    };
+    process.stdin.on('data', h);
+  });
+}
+
+// ── Main loop ───────────────────────────────────────────────────────────────
+async function main() {
+  const ROOT = path.join(__dirname, '..', '..');
+  const { opts, current, update } = await buildOptions({ ROOT });
+  let index = 0;
+  hideCursor();
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  render({ current, update, opts, index });
+
+  _keyHandler = (buf) => {
+    const s = buf.toString();
+    if (s === '\x1b[A' || s === 'k') { index = (index - 1 + opts.length) % opts.length; render({ current, update, opts, index }); }
+    else if (s === '\x1b[B' || s === 'j') { index = (index + 1) % opts.length; render({ current, update, opts, index }); }
+    else if (s === '\r' || s === '\n') {
+      const chosen = opts[index];
+      process.stdin.removeListener('data', _keyHandler);
+      _keyHandler = null;
+      Promise.resolve(chosen.run()).catch(err => {
+        cleanup();
+        console.error(err.message || err);
+        process.exit(1);
+      });
+    }
+    else if (s === 'q' || s === '\x1b' || s === '\x03') { cleanup(); console.log(); process.exit(0); }
+  };
+  process.stdin.on('data', _keyHandler);
+}
+
+module.exports = { main };

package/scripts/cli/update-check.js

@@ -0,0 +1,77 @@
+// scripts/cli/update-check.js
+// Poll npm for the latest kodelyth-ecc version. Cached for 24h to avoid spam.
+// Zero deps — uses Node's built-in https.
+
+'use strict';
+
+const https = require('https');
+const fs    = require('fs');
+const os    = require('os');
+const path  = require('path');
+
+const CACHE_DIR  = path.join(os.homedir(), '.kodelythecc');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
+const CACHE_TTL  = 24 * 60 * 60 * 1000; // 24h
+
+function readCache() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    if (Date.now() - raw.at < CACHE_TTL) return raw;
+  } catch { /* no cache or corrupt */ }
+  return null;
+}
+
+function writeCache(latest) {
+  try { fs.mkdirSync(CACHE_DIR, { recursive: true }); } catch {}
+  try { fs.writeFileSync(CACHE_FILE, JSON.stringify({ at: Date.now(), latest })); } catch {}
+}
+
+function fetchLatest() {
+  return new Promise((resolve) => {
+    const req = https.get('https://registry.npmjs.org/kodelyth-ecc/latest', {
+      timeout: 2500,
+      headers: { accept: 'application/json' },
+    }, (res) => {
+      if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(body).version || null); } catch { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+function cmpVersion(a, b) {
+  const pa = a.split('.').map(n => parseInt(n, 10) || 0);
+  const pb = b.split('.').map(n => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
+  }
+  return 0;
+}
+
+// Public: returns { current, latest, updateAvailable, cached } or nulls on failure.
+async function check({ current, force = false } = {}) {
+  if (!force) {
+    const c = readCache();
+    if (c) {
+      return {
+        current, latest: c.latest,
+        updateAvailable: c.latest && cmpVersion(c.latest, current) > 0,
+        cached: true,
+      };
+    }
+  }
+  const latest = await fetchLatest();
+  if (latest) writeCache(latest);
+  return {
+    current, latest,
+    updateAvailable: !!(latest && cmpVersion(latest, current) > 0),
+    cached: false,
+  };
+}
+
+module.exports = { check, cmpVersion };