monomind 1.16.6 → 1.16.7

package/packages/@monomind/cli/.claude/helpers/memory.cjs

@@ -0,0 +1,193 @@
+'use strict';
+/**
+ * Memory context bridge for hook-handler.cjs
+ * Also usable as a CLI script: node memory.cjs [get|set|delete|clear|keys] [args...]
+ *
+ * CLI data path: $CLAUDE_PROJECT_DIR/.monomind/data/memory.json  (or process.cwd())
+ * Module API:    store(key, value, namespace), retrieve(query, namespace)
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+// ── CLI storage (flat JSON key→value map) ─────────────────────────────────────
+
+const DATA_DIR = path.join(CWD, '.monomind', 'data');
+const MEMORY_FILE = path.join(DATA_DIR, 'memory.json');
+
+function ensureDataDir() {
+  try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
+}
+
+function loadMemory() {
+  try {
+    if (!fs.existsSync(MEMORY_FILE)) return {};
+    var st = fs.statSync(MEMORY_FILE);
+    if (st.size > 10 * 1024 * 1024) return {};
+    return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function saveMemory(data) {
+  ensureDataDir();
+  try {
+    fs.writeFileSync(MEMORY_FILE, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+// ── CLI commands ──────────────────────────────────────────────────────────────
+
+function cmdGet(key) {
+  var data = loadMemory();
+  if (!key) {
+    // Return all non-internal keys
+    var out = {};
+    for (var k in data) {
+      if (!k.startsWith('_')) out[k] = data[k];
+    }
+    process.stdout.write(JSON.stringify(out) + '\n');
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(data, key)) {
+    process.stdout.write(JSON.stringify(data[key]) + '\n');
+  } else {
+    process.stdout.write('undefined\n');
+  }
+  process.exit(0);
+}
+
+function cmdSet(key, value) {
+  if (!key) {
+    process.stderr.write('Key required\n');
+    process.exit(1);
+  }
+  var data = loadMemory();
+  data[key] = value;
+  data._updated = new Date().toISOString();
+  saveMemory(data);
+  process.stdout.write('Set: ' + key + '\n');
+  process.exit(0);
+}
+
+function cmdDelete(key) {
+  if (!key) {
+    process.stderr.write('Key required\n');
+    process.exit(1);
+  }
+  var data = loadMemory();
+  delete data[key];
+  data._updated = new Date().toISOString();
+  saveMemory(data);
+  process.stdout.write('Deleted: ' + key + '\n');
+  process.exit(0);
+}
+
+function cmdClear() {
+  saveMemory({});
+  process.stdout.write('Memory cleared\n');
+  process.exit(0);
+}
+
+function cmdKeys() {
+  var data = loadMemory();
+  var keys = Object.keys(data).filter(function(k) { return !k.startsWith('_'); });
+  if (keys.length > 0) {
+    process.stdout.write(keys.join('\n') + '\n');
+  } else {
+    process.stdout.write('');
+  }
+  process.exit(0);
+}
+
+function cmdUsage() {
+  process.stdout.write(
+    'Usage: memory.cjs [get|set|delete|clear|keys] [key] [value...]\n' +
+    '  get [key]         — get a key or all keys\n' +
+    '  set <key> <value> — set a key\n' +
+    '  delete <key>      — delete a key\n' +
+    '  clear             — clear all keys\n' +
+    '  keys              — list all user-defined keys\n'
+  );
+  process.exit(0);
+}
+
+// ── Module API (for hook-handler.cjs require()) ───────────────────────────────
+
+const HOOK_MEMORY_DIR = path.join(CWD, '.monomind', 'memory');
+const HOOK_MEMORY_INDEX = path.join(HOOK_MEMORY_DIR, 'hook-memory.json');
+var MAX_INDEX_SIZE = 50 * 1024 * 1024;
+
+function ensureHookDir() {
+  try { fs.mkdirSync(HOOK_MEMORY_DIR, { recursive: true }); } catch (_) {}
+}
+
+function loadIndex() {
+  try {
+    if (!fs.existsSync(HOOK_MEMORY_INDEX)) return [];
+    var st = fs.statSync(HOOK_MEMORY_INDEX);
+    if (st.size > MAX_INDEX_SIZE) return [];
+    return JSON.parse(fs.readFileSync(HOOK_MEMORY_INDEX, 'utf-8'));
+  } catch (_) {
+    return [];
+  }
+}
+
+function saveIndex(entries) {
+  ensureHookDir();
+  try {
+    var trimmed = entries.slice(-500);
+    fs.writeFileSync(HOOK_MEMORY_INDEX, JSON.stringify(trimmed, null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+function store(key, value, namespace) {
+  var entries = loadIndex();
+  var ns = String(namespace || 'default').slice(0, 128);
+  key = String(key || '').slice(0, 512);
+  entries = entries.filter(function(e) { return !(e.key === key && e.namespace === ns); });
+  entries.push({ key: key, value: value, namespace: ns, storedAt: new Date().toISOString() });
+  saveIndex(entries);
+}
+
+function retrieve(query, namespace) {
+  var entries = loadIndex();
+  var ns = namespace || null;
+  if (ns) entries = entries.filter(function(e) { return e.namespace === ns; });
+  if (!query) return entries.slice(-10);
+  var q = String(query).toLowerCase();
+  var scored = entries.map(function(e) {
+    var text = (e.key + ' ' + JSON.stringify(e.value || '')).toLowerCase();
+    var score = 0;
+    var words = q.split(/\s+/);
+    for (var i = 0; i < words.length; i++) {
+      if (words[i] && text.includes(words[i])) score++;
+    }
+    return { entry: e, score: score };
+  });
+  return scored
+    .filter(function(s) { return s.score > 0; })
+    .sort(function(a, b) { return b.score - a.score; })
+    .slice(0, 10)
+    .map(function(s) { return s.entry; });
+}
+
+// ── Entry point: run CLI when spawned directly ────────────────────────────────
+
+if (require.main === module) {
+  var args = process.argv.slice(2);
+  var cmd = args[0];
+  switch (cmd) {
+    case 'get':    cmdGet(args[1]); break;
+    case 'set':    cmdSet(args[1], args.slice(2).join(' ')); break;
+    case 'delete': cmdDelete(args[1]); break;
+    case 'clear':  cmdClear(); break;
+    case 'keys':   cmdKeys(); break;
+    default:       cmdUsage(); break;
+  }
+}
+
+module.exports = { store, retrieve };

package/packages/@monomind/cli/.claude/helpers/metrics-db.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * metrics-db.mjs — Lightweight metrics aggregation helper.
+ * Reads .monomind/metrics/*.json files and produces summary output.
+ *
+ * Commands:
+ *   sync    — aggregate metrics files → JSON summary (default)
+ *   status  — print current metrics status as JSON
+ *   export  — export metrics to timestamped file
+ *   (other) — print usage hint, exit 0
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const METRICS_DIR = path.join(CWD, '.monomind', 'metrics');
+
+function safeRead(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function aggregate() {
+  const recentEdits = safeRead(path.join(METRICS_DIR, 'recent-edits.json'));
+  const toolCalls = safeRead(path.join(METRICS_DIR, 'tool-calls.json'));
+  const hookLatency = safeRead(path.join(METRICS_DIR, 'hook-latency.json'));
+  const tokenSummary = safeRead(path.join(METRICS_DIR, 'token-summary.json'));
+
+  return {
+    aggregatedAt: new Date().toISOString(),
+    recentEdits: recentEdits ? (recentEdits.edits || []).length : 0,
+    toolCalls: toolCalls ? Object.keys(toolCalls.calls || {}).length : 0,
+    hookLatency: hookLatency ? Object.keys(hookLatency).filter(k => k !== 'lastUpdated').length : 0,
+    tokenSummary: tokenSummary ? { todayCost: tokenSummary.todayCost, monthCost: tokenSummary.monthCost } : null,
+  };
+}
+
+function cmdSync() {
+  const summary = aggregate();
+  process.stdout.write(JSON.stringify(summary) + '\n');
+  process.exit(0);
+}
+
+function cmdStatus() {
+  const summary = aggregate();
+  process.stdout.write(JSON.stringify({ status: 'ok', metrics: summary }) + '\n');
+  process.exit(0);
+}
+
+function cmdExport() {
+  const summary = aggregate();
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const exportPath = path.join(METRICS_DIR, `export-${ts}.json`);
+  try {
+    fs.mkdirSync(METRICS_DIR, { recursive: true });
+    fs.writeFileSync(exportPath, JSON.stringify(summary, null, 2));
+    process.stdout.write(`Exported metrics to ${exportPath}\n`);
+  } catch (e) {
+    process.stdout.write(`Exported metrics (in-memory only): ${JSON.stringify(summary)}\n`);
+  }
+  process.exit(0);
+}
+
+function cmdUsage(unknownCmd) {
+  process.stdout.write(
+    `Usage: metrics-db.mjs [sync|status|export]\n` +
+    (unknownCmd ? `  Unknown command: ${unknownCmd}\n` : '')
+  );
+  process.exit(0);
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+const cmd = process.argv[2] || 'sync';
+
+switch (cmd) {
+  case 'sync':    cmdSync();   break;
+  case 'status':  cmdStatus(); break;
+  case 'export':  cmdExport(); break;
+  default:        cmdUsage(cmd); break;
+}

package/packages/@monomind/cli/.claude/helpers/monolean-activate.cjs

@@ -0,0 +1,20 @@
+'use strict';
+const { getDefaultMode, setMode, clearMode } = require('./monolean-config.cjs');
+const { getMonoleanInstructions } = require('./monolean-instructions.cjs');
+const fs = require('fs');
+const path = require('path');
+
+const mode = getDefaultMode();
+if (!mode || mode === 'off') { clearMode(); process.exit(0); }
+
+setMode(mode);
+
+// Write mode for statusline
+const metricsDir = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.monomind/metrics');
+try {
+  fs.mkdirSync(metricsDir, { recursive: true });
+  fs.writeFileSync(path.join(metricsDir, 'monolean-mode.json'), JSON.stringify({ mode, ts: Date.now() }));
+} catch {}
+
+const instructions = getMonoleanInstructions(mode);
+process.stdout.write(instructions);

package/packages/@monomind/cli/.claude/helpers/monolean-config.cjs

@@ -0,0 +1,76 @@
+'use strict';
+const path = require('path');
+const fs = require('fs');
+
+const VALID_MODES = ['off', 'lite', 'full', 'ultra', 'review'];
+const DEFAULT_MODE = 'full';
+const STATE_RELPATH = '.monomind/state/monolean-mode';
+
+// Walk up from CLAUDE_PROJECT_DIR then cwd to find the project root containing the state file.
+// Required for SubagentStart hooks where CLAUDE_PROJECT_DIR may differ from the parent project.
+function findStateFile() {
+  const candidates = [];
+  if (process.env.CLAUDE_PROJECT_DIR) {
+    candidates.push(process.env.CLAUDE_PROJECT_DIR);
+  }
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    candidates.push(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const base of candidates) {
+    const p = path.join(base, STATE_RELPATH);
+    if (fs.existsSync(p)) return p;
+  }
+  // Fall back to writing relative to CLAUDE_PROJECT_DIR or cwd (for setMode)
+  return path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), STATE_RELPATH);
+}
+
+function normalizeMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return ['off', 'lite', 'full', 'ultra'].includes(normalized) ? normalized : null;
+}
+
+function normalizePersistedMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return VALID_MODES.includes(normalized) ? normalized : null;
+}
+
+function getDefaultMode() {
+  const env = process.env.MONOLEAN_DEFAULT_MODE;
+  if (env && VALID_MODES.includes(env.toLowerCase())) return env.toLowerCase();
+  try {
+    const val = fs.readFileSync(findStateFile(), 'utf8').trim();
+    if (val && VALID_MODES.includes(val)) return val;
+  } catch { /* fall through */ }
+  return DEFAULT_MODE;
+}
+
+function setMode(mode) {
+  const f = findStateFile();
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  fs.writeFileSync(f, mode);
+}
+
+function readMode() {
+  try { return fs.readFileSync(findStateFile(), 'utf8').trim() || null; } catch { return null; }
+}
+
+function clearMode() {
+  try { fs.unlinkSync(findStateFile()); } catch {}
+}
+
+function isDeactivationCommand(text) {
+  const t = String(text || '').trim().toLowerCase().replace(/[.!?\s]+$/, '');
+  return t === 'stop monolean' || t === 'normal mode';
+}
+
+module.exports = {
+  VALID_MODES, DEFAULT_MODE,
+  normalizeMode, normalizePersistedMode,
+  getDefaultMode, setMode, readMode, clearMode, isDeactivationCommand,
+};

package/packages/@monomind/cli/.claude/helpers/monolean-instructions.cjs

@@ -0,0 +1,109 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require('./monolean-config.cjs');
+
+const INDEPENDENT_MODES = new Set(['review']);
+
+// Resolve the SKILL.md path lazily, walking up from cwd if CLAUDE_PROJECT_DIR doesn't have it.
+// Required for SubagentStart hooks where CLAUDE_PROJECT_DIR may differ from the parent project.
+function findSkillPath() {
+  const candidates = [];
+  if (process.env.CLAUDE_PROJECT_DIR) {
+    candidates.push(process.env.CLAUDE_PROJECT_DIR);
+  }
+  // Walk up from cwd to find the project root containing the skill
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    candidates.push(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const base of candidates) {
+    const p = path.join(base, '.claude', 'skills', 'monolean', 'SKILL.md');
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+  const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
+
+  return withoutFrontmatter
+    .split(/\r?\n/)
+    .filter((line) => {
+      const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+      if (tableLabel) {
+        const labelMode = normalizeMode(tableLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      const exampleLabel = line.match(/^-\s*([^:]+):\s*/);
+      if (exampleLabel) {
+        const labelMode = normalizeMode(exampleLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      return true;
+    })
+    .join('\n');
+}
+
+function getFallbackInstructions(mode) {
+  return 'MONOLEAN MODE ACTIVE — level: ' + mode + '\n\n' +
+    'You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.\n\n' +
+    '## Persistence\n\n' +
+    'ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop monolean" / "normal mode".\n\n' +
+    'Current level: **' + mode + '**. Switch: `/monolean lite|full|ultra`.\n\n' +
+    '## The ladder\n\n' +
+    'Before any code, stop at the first rung that holds (the ladder runs after you understand the problem, not instead of it — read the code it touches and trace the real flow first):\n' +
+    '1. Does this need to be built at all? (YAGNI)\n' +
+    '2. Does it already exist in this codebase? Reuse what is already here, do not re-write it.\n' +
+    '3. Does the standard library do this? Use it.\n' +
+    '4. Does a native platform feature cover it? Use it.\n' +
+    '5. Does an already-installed dependency solve it? Use it.\n' +
+    '6. Can this be one line? Make it one line.\n' +
+    '7. Only then: write the minimum code that works.\n\n' +
+    'Bug fix = root cause, not symptom: grep every caller of the function you touch and fix the shared function once.\n\n' +
+    '## Rules\n\n' +
+    'No abstractions that were not requested. No avoidable dependencies. No boilerplate nobody asked for. ' +
+    'Deletion over addition. Boring over clever. Fewest files possible. ' +
+    'Mark intentional simplifications with a `monolean:` comment — a shortcut with a known ceiling names the ceiling and the upgrade path.\n\n' +
+    '## Output\n\n' +
+    'Code first. Then at most three short lines: what was skipped, when to add it.\n\n' +
+    '## When NOT to be lean\n\n' +
+    'Never simplify away: input validation at trust boundaries, error handling that prevents data loss, ' +
+    'security measures, accessibility basics, anything the user explicitly asked to keep. ' +
+    'Lean code without its check is unfinished: non-trivial logic leaves ONE runnable check behind.\n\n' +
+    '## Boundaries\n\n' +
+    'Monolean governs what you build, not how you talk. "stop monolean" or "normal mode": revert. Level persists until changed or session end.';
+}
+
+function getMonoleanInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
+
+  if (INDEPENDENT_MODES.has(configuredMode)) {
+    return 'MONOLEAN MODE ACTIVE — level: ' + configuredMode + '. Behavior defined by /monolean-' + configuredMode + ' skill.';
+  }
+
+  const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
+
+  const skillPath = findSkillPath();
+  if (skillPath) {
+    try {
+      return 'MONOLEAN MODE ACTIVE — level: ' + effectiveMode + '\n\n' +
+        filterSkillBodyForMode(fs.readFileSync(skillPath, 'utf8'), effectiveMode);
+    } catch (e) {
+      // fall through to hardcoded fallback
+    }
+  }
+  return getFallbackInstructions(effectiveMode);
+}
+
+module.exports = {
+  filterSkillBodyForMode,
+  getFallbackInstructions,
+  getMonoleanInstructions,
+};

package/packages/@monomind/cli/.claude/helpers/monolean-propagate.cjs

@@ -0,0 +1,9 @@
+'use strict';
+const { readMode } = require('./monolean-config.cjs');
+const { getMonoleanInstructions } = require('./monolean-instructions.cjs');
+
+const mode = readMode();
+if (!mode || mode === 'off') process.exit(0);
+
+const instructions = getMonoleanInstructions(mode);
+process.stdout.write(instructions);

package/packages/@monomind/cli/.claude/helpers/monolean-tracker.cjs

@@ -0,0 +1,18 @@
+'use strict';
+const { VALID_MODES, setMode, clearMode, isDeactivationCommand } = require('./monolean-config.cjs');
+
+let data = '';
+process.stdin.on('data', d => data += d);
+process.stdin.on('end', () => {
+  try {
+    const parsed = JSON.parse(data);
+    const prompt = String(parsed.prompt || '');
+    if (isDeactivationCommand(prompt)) { clearMode(); process.exit(0); }
+    const m = prompt.match(/^[/@$]monolean\s*(\w+)?/i);
+    if (!m) process.exit(0);
+    const requested = (m[1] || 'full').toLowerCase();
+    if (!VALID_MODES.includes(requested)) process.exit(0);
+    if (requested === 'off') clearMode();
+    else setMode(requested);
+  } catch { /* ignore parse errors */ }
+});