continuous-improvement 1.0.0

package/scripts/install.js

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const rootDir = path.resolve(__dirname, '..');
+const homeDir = os.homedir();
+const cwd = process.cwd();
+
+const args = process.argv.slice(2);
+const command = args[0];
+const flags = new Set(args.slice(1));
+const dryRun = flags.has('--dry-run');
+const useGlobal = flags.has('--global');
+
+const TARGET_FLAGS = ['claude', 'codex', 'cursor', 'openclaw', 'chatgpt'];
+const selectedTarget = TARGET_FLAGS.find((name) => flags.has(`--${name}`));
+
+const CODING_AGENT_BLOCK = `## Operating Rules (continuous-improvement)
+
+1. RESEARCH before executing — check docs, rate limits, existing implementations
+2. PLAN before coding — write what you will build, what you won't, how to verify, and fallback
+3. ONE THING at a time — complete and verify each task before starting the next
+4. VERIFY before reporting — run it, check the output, confirm it matches expected
+5. REFLECT after sessions — log what worked, what failed, what to change
+6. ITERATE means one change at a time — fix before adding, verify before proceeding
+7. LEARN from every session — patterns become instincts, corrections weaken bad behaviors, nothing is permanent without reinforcement
+`;
+
+const CURSOR_BLOCK = `Follow continuous-improvement: Research → Plan → Execute (one thing) → Verify → Reflect → Iterate.
+Never report "done" without verification.
+Never add features before fixing bugs.
+Never execute without checking docs first.
+`;
+
+const CHATGPT_BLOCK = `Follow the continuous-improvement loop for all tasks:
+1. Research first — what exists? what can break? what are the limits?
+2. Plan — what to build, what NOT to build, how to verify, fallback plan
+3. Execute one thing at a time — finish and verify before starting the next
+4. Verify before saying "done" — actually check the output
+5. Reflect — what worked, what failed, what to do differently
+6. Iterate — one change at a time, verify each before proceeding
+`;
+
+function usage(code = 0) {
+  console.log(`continuous-improvement\n\nUsage:\n  continuous-improvement install [--claude|--codex|--cursor|--openclaw|--chatgpt] [--global] [--dry-run]\n  continuous-improvement uninstall [--claude|--codex|--cursor|--openclaw]\n\nExamples:\n  npx continuous-improvement install\n  npx continuous-improvement install --claude\n  npx continuous-improvement install --cursor\n  npx continuous-improvement install --openclaw\n  npx continuous-improvement install --chatgpt\n  npx continuous-improvement install --claude --global\n  npx continuous-improvement uninstall --codex\n`);
+  process.exit(code);
+}
+
+function exists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function ensureDir(dirPath) {
+  if (dryRun) return;
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readUtf8(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function writeUtf8(filePath, content) {
+  if (dryRun) return;
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function appendBlock(filePath, block) {
+  const trimmedBlock = block.trim();
+  const existing = exists(filePath) ? readUtf8(filePath) : '';
+
+  if (existing.includes(trimmedBlock)) {
+    return { changed: false, reason: 'already-installed' };
+  }
+
+  const next = existing.trim().length === 0
+    ? `${trimmedBlock}\n`
+    : `${existing.replace(/\s*$/, '')}\n\n${trimmedBlock}\n`;
+
+  writeUtf8(filePath, next);
+  return { changed: true };
+}
+
+function removeBlock(filePath, block) {
+  if (!exists(filePath)) {
+    return { changed: false, reason: 'not-found' };
+  }
+
+  const trimmedBlock = block.trim();
+  const existing = readUtf8(filePath);
+
+  if (!existing.includes(trimmedBlock)) {
+    return { changed: false, reason: 'not-installed' };
+  }
+
+  const next = existing
+    .replace(new RegExp(`\\n?\\n?${escapeRegExp(trimmedBlock)}\\n?`, 'm'), '\n')
+    .replace(/^\s+|\s+$/g, '');
+
+  writeUtf8(filePath, next ? `${next}\n` : '');
+  return { changed: true };
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function copySkill() {
+  const sourceDir = path.join(rootDir, 'skills', 'continuous-improvement');
+  const destDir = path.join(homeDir, '.openclaw', 'skills', 'continuous-improvement');
+  const sourceFile = path.join(sourceDir, 'SKILL.md');
+  const destFile = path.join(destDir, 'SKILL.md');
+  const content = readUtf8(sourceFile);
+
+  if (exists(destFile) && readUtf8(destFile) === content) {
+    return { target: 'openclaw', location: destFile, changed: false, reason: 'already-installed' };
+  }
+
+  writeUtf8(destFile, content);
+  return { target: 'openclaw', location: destFile, changed: true };
+}
+
+function setupMulahazah() {
+  const mulahazahDir = path.join(homeDir, '.claude', 'mulahazah');
+  const instinctsPersonalDir = path.join(mulahazahDir, 'instincts', 'personal');
+  const projectsDir = path.join(mulahazahDir, 'projects');
+
+  ensureDir(mulahazahDir);
+  ensureDir(instinctsPersonalDir);
+  ensureDir(projectsDir);
+
+  const configDest = path.join(mulahazahDir, 'config.json');
+  if (!exists(configDest)) {
+    const configSrc = path.join(rootDir, 'config.json');
+    if (exists(configSrc)) {
+      writeUtf8(configDest, readUtf8(configSrc));
+    }
+  }
+
+  const projectsRegistry = path.join(mulahazahDir, 'projects.json');
+  if (!exists(projectsRegistry)) {
+    writeUtf8(projectsRegistry, JSON.stringify({}, null, 2) + '\n');
+  }
+
+  return { location: mulahazahDir, changed: true };
+}
+
+function installHooks() {
+  const mulahazahDir = path.join(homeDir, '.claude', 'mulahazah');
+  const hookDest = path.join(mulahazahDir, 'observe.sh');
+  const hookSrc = path.join(rootDir, 'hooks', 'observe.sh');
+
+  ensureDir(mulahazahDir);
+
+  if (exists(hookSrc)) {
+    writeUtf8(hookDest, readUtf8(hookSrc));
+    if (!dryRun) {
+      fs.chmodSync(hookDest, 0o755);
+    }
+  }
+
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  let settings = {};
+  if (exists(settingsPath)) {
+    try {
+      settings = JSON.parse(readUtf8(settingsPath));
+    } catch (_) {
+      settings = {};
+    }
+  }
+
+  const hookEntry = { matcher: '*', hooks: [{ type: 'command', command: hookDest }] };
+
+  let changed = false;
+
+  for (const hookType of ['PreToolUse', 'PostToolUse']) {
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks[hookType]) settings.hooks[hookType] = [];
+
+    const alreadyInstalled = settings.hooks[hookType].some(
+      (entry) => entry.hooks && entry.hooks.some((h) => h.command === hookDest)
+    );
+
+    if (!alreadyInstalled) {
+      settings.hooks[hookType].push(hookEntry);
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    writeUtf8(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+
+  return { location: settingsPath, changed };
+}
+
+function copyObserverFiles() {
+  const agentsSrc = path.join(rootDir, 'agents');
+  const agentsDest = path.join(homeDir, '.claude', 'mulahazah', 'agents');
+
+  ensureDir(agentsDest);
+
+  const filesToCopy = ['observer.md', 'observer-loop.sh', 'start-observer.sh'];
+  let changed = false;
+
+  for (const fileName of filesToCopy) {
+    const srcFile = path.join(agentsSrc, fileName);
+    const destFile = path.join(agentsDest, fileName);
+
+    if (exists(srcFile)) {
+      const content = readUtf8(srcFile);
+      const existingContent = exists(destFile) ? readUtf8(destFile) : null;
+      if (existingContent !== content) {
+        writeUtf8(destFile, content);
+        if (!dryRun && fileName.endsWith('.sh')) {
+          fs.chmodSync(destFile, 0o755);
+        }
+        changed = true;
+      }
+    }
+  }
+
+  return { location: agentsDest, changed };
+}
+
+function uninstallHooks() {
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  if (!exists(settingsPath)) return;
+
+  let settings;
+  try {
+    settings = JSON.parse(readUtf8(settingsPath));
+  } catch (_) {
+    return;
+  }
+
+  if (!settings.hooks) return;
+
+  const mulahazahDir = path.join(homeDir, '.claude', 'mulahazah');
+  const hookDest = path.join(mulahazahDir, 'observe.sh');
+
+  let changed = false;
+  for (const hookType of ['PreToolUse', 'PostToolUse']) {
+    if (!Array.isArray(settings.hooks[hookType])) continue;
+    const before = settings.hooks[hookType].length;
+    settings.hooks[hookType] = settings.hooks[hookType].filter(
+      (entry) => !(entry.hooks && entry.hooks.some((h) => h.command === hookDest))
+    );
+    if (settings.hooks[hookType].length === 0) {
+      delete settings.hooks[hookType];
+    }
+    if (settings.hooks[hookType] === undefined || settings.hooks[hookType].length !== before) {
+      changed = true;
+    }
+  }
+
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (changed) {
+    writeUtf8(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+}
+
+function installClaude(globalInstall = useGlobal) {
+  const filePath = globalInstall
+    ? path.join(homeDir, '.claude', 'CLAUDE.md')
+    : path.join(cwd, 'CLAUDE.md');
+  const result = appendBlock(filePath, CODING_AGENT_BLOCK);
+  return { target: 'claude', location: filePath, ...result };
+}
+
+function installCodex() {
+  const filePath = path.join(cwd, 'AGENTS.md');
+  const result = appendBlock(filePath, CODING_AGENT_BLOCK);
+  return { target: 'codex', location: filePath, ...result };
+}
+
+function installCursor() {
+  const filePath = path.join(cwd, '.cursorrules');
+  const result = appendBlock(filePath, CURSOR_BLOCK);
+  return { target: 'cursor', location: filePath, ...result };
+}
+
+function installChatgpt() {
+  return { target: 'chatgpt', location: 'stdout', changed: true, printed: CHATGPT_BLOCK };
+}
+
+function uninstallClaude(globalInstall = useGlobal) {
+  const filePath = globalInstall
+    ? path.join(homeDir, '.claude', 'CLAUDE.md')
+    : path.join(cwd, 'CLAUDE.md');
+  const result = removeBlock(filePath, CODING_AGENT_BLOCK);
+  return { target: 'claude', location: filePath, ...result };
+}
+
+function uninstallCodex() {
+  const filePath = path.join(cwd, 'AGENTS.md');
+  const result = removeBlock(filePath, CODING_AGENT_BLOCK);
+  return { target: 'codex', location: filePath, ...result };
+}
+
+function uninstallCursor() {
+  const filePath = path.join(cwd, '.cursorrules');
+  const result = removeBlock(filePath, CURSOR_BLOCK);
+  return { target: 'cursor', location: filePath, ...result };
+}
+
+function uninstallOpenclaw() {
+  const destFile = path.join(homeDir, '.openclaw', 'skills', 'continuous-improvement', 'SKILL.md');
+  if (!exists(destFile)) {
+    return { target: 'openclaw', location: destFile, changed: false, reason: 'not-installed' };
+  }
+  if (!dryRun) {
+    fs.rmSync(path.dirname(destFile), { recursive: true, force: true });
+  }
+  return { target: 'openclaw', location: destFile, changed: true };
+}
+
+function detectTargets() {
+  const targets = [];
+  if (exists(path.join(cwd, 'CLAUDE.md'))) targets.push('claude');
+  if (exists(path.join(cwd, 'AGENTS.md'))) targets.push('codex');
+  if (exists(path.join(cwd, '.cursorrules'))) targets.push('cursor');
+  if (exists(path.join(homeDir, '.openclaw'))) targets.push('openclaw');
+  if (targets.length === 0) {
+    if (exists(path.join(homeDir, '.claude'))) targets.push('claude-global');
+  }
+  return targets;
+}
+
+function installTarget(target) {
+  switch (target) {
+    case 'claude': {
+      const claudeResult = installClaude(false);
+      const mulahazahResult = setupMulahazah();
+      const hooksResult = installHooks();
+      const observerResult = copyObserverFiles();
+      return { ...claudeResult, mulahazah: mulahazahResult, hooks: hooksResult, observer: observerResult };
+    }
+    case 'claude-global': {
+      const claudeResult = installClaude(true);
+      const mulahazahResult = setupMulahazah();
+      const hooksResult = installHooks();
+      const observerResult = copyObserverFiles();
+      return { ...claudeResult, mulahazah: mulahazahResult, hooks: hooksResult, observer: observerResult };
+    }
+    case 'codex':
+      return installCodex();
+    case 'cursor':
+      return installCursor();
+    case 'openclaw':
+      return copySkill();
+    case 'chatgpt':
+      return installChatgpt();
+    default:
+      throw new Error(`Unknown target: ${target}`);
+  }
+}
+
+function uninstallTarget(target) {
+  switch (target) {
+    case 'claude':
+      uninstallHooks();
+      return uninstallClaude(false);
+    case 'claude-global':
+      uninstallHooks();
+      return uninstallClaude(true);
+    case 'codex':
+      return uninstallCodex();
+    case 'cursor':
+      return uninstallCursor();
+    case 'openclaw':
+      return uninstallOpenclaw();
+    default:
+      throw new Error(`Unknown target for uninstall: ${target}`);
+  }
+}
+
+if (!command || command === '--help' || command === '-h' || flags.has('--help') || flags.has('-h')) {
+  usage(0);
+}
+
+if (command !== 'install' && command !== 'uninstall') {
+  console.error(`Unknown command: ${command}`);
+  usage(1);
+}
+
+const targets = selectedTarget ? [selectedTarget] : detectTargets();
+
+if (targets.length === 0) {
+  console.log('No target detected automatically.');
+  console.log('Try one of:');
+  console.log('  npx continuous-improvement install --claude');
+  console.log('  npx continuous-improvement install --codex');
+  console.log('  npx continuous-improvement install --cursor');
+  console.log('  npx continuous-improvement install --openclaw');
+  console.log('  npx continuous-improvement install --chatgpt');
+  process.exit(0);
+}
+
+const results = command === 'install'
+  ? targets.map(installTarget)
+  : targets.filter((target) => target !== 'chatgpt').map(uninstallTarget);
+
+console.log(`continuous-improvement ${command}\n`);
+for (const result of results) {
+  if (result.printed) {
+    console.log(`✓ ${result.target}: copy this into ChatGPT Custom Instructions\n`);
+    console.log(result.printed);
+    continue;
+  }
+
+  const status = command === 'install'
+    ? (result.changed ? 'installed' : (result.reason || 'unchanged'))
+    : (result.changed ? 'removed' : (result.reason || 'unchanged'));
+  console.log(`✓ ${result.target}: ${status} → ${result.location}${dryRun ? ' (dry-run)' : ''}`);
+
+  if (command === 'install' && result.mulahazah) {
+    console.log(`  ✓ mulahazah: directory created → ~/.claude/mulahazah/`);
+  }
+  if (command === 'install' && result.hooks) {
+    console.log(`  ✓ hooks: PreToolUse + PostToolUse → ~/.claude/settings.json`);
+  }
+  if (command === 'install' && result.observer) {
+    console.log(`  ✓ observer: agent files copied → ~/.claude/mulahazah/agents/`);
+    console.log(`  To start background observer: ~/.claude/mulahazah/agents/start-observer.sh`);
+    console.log(`  Run /continuous-improvement after your next session to see what was learned.`);
+  }
+}

package/skills/continuous-improvement/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: continuous-improvement
+description: "Install structured self-improvement loops with instinct-based learning into Claude Code — research, plan, execute, verify, reflect, learn, iterate. Mulahazah observes your sessions and builds behavioral instincts with confidence scoring."
+---
+
+# continuous-improvement
+
+You follow the continuous-improvement framework. These 7 laws govern all your work.
+
+## Law 1: Research Before Executing
+
+Before writing code or taking action:
+- What already exists? Search the codebase and package registries.
+- What are the constraints? Rate limits, quotas, memory, time.
+- What can break? Side effects, dependencies, data risks.
+- What's the simplest path? Fewest files, fewest dependencies.
+
+If you can't answer these, research first.
+
+## Law 2: Plan Is Sacred
+
+Before executing, state:
+- **WILL build:** Specific deliverables with completion criteria
+- **Will NOT build:** Explicit anti-scope
+- **Verification:** The exact check that proves it works
+- **Fallback:** What to do if it fails (not "try again")
+
+## Law 3: One Thing at a Time
+
+- Complete and verify one task before starting the next
+- Never spawn parallel work for tasks you can do directly
+- Never report completion until you've checked actual output
+- If you want to "also quickly add" something — stop. Finish first.
+
+## Law 4: Verify Before Reporting
+
+"Done" requires ALL of:
+- Code runs without errors
+- Output matches expected result
+- You checked the **actual** result, not assumed it
+- Build passes
+- You can explain what changed in one sentence
+
+## Law 5: Reflect After Every Session
+
+After non-trivial tasks:
+```
+## Reflection
+- What worked:
+- What failed:
+- What I'd do differently:
+- Rule to add:
+```
+
+The "Rule to add" field feeds Law 7 — it becomes an instinct with 0.6 starting confidence.
+
+## Law 6: Iterate Means One Thing
+
+One change → verify → next change.
+
+Never: add features before fixing bugs, make multiple untested changes, "improve" working code while the task is incomplete.
+
+## Law 7: Learn From Every Session
+
+Your sessions create knowledge. Capture it.
+
+- Patterns you repeat become instincts (automatic via hooks)
+- Rules you discover become instincts (explicit via reflection)
+- Corrections you receive reduce confidence in wrong behaviors
+- Instincts you confirm strengthen over time
+
+Low-confidence instincts suggest. High-confidence instincts apply.
+If the user corrects you, the instinct weakens. If they don't, it strengthens.
+
+Nothing learned is permanent. Everything decays without reinforcement.
+
+### Instinct Behavior
+
+Before starting work, check for relevant instincts in `~/.claude/mulahazah/`:
+- Load project-scoped instincts from `projects/<hash>/instincts/personal/`
+- Load global instincts from `instincts/personal/`
+
+Apply instincts based on confidence:
+- **0.3-0.5 (silent):** Stored but not surfaced. Learning in progress.
+- **0.5-0.7 (suggest):** Mention inline when relevant. "Consider: [instinct action]"
+- **0.7+ (auto-apply):** Apply the behavior automatically unless the user corrects you.
+
+If the user corrects an auto-applied instinct, reduce its confidence by 0.1.
+
+## The Loop
+
+```
+Research → Plan → Execute (one thing) → Verify → Reflect → Learn → Iterate
+```
+
+If you're skipping a step, that's the step you need most.
+
+## /continuous-improvement Command
+
+Run `/continuous-improvement` after completing significant work. It provides:
+
+1. **Reflect** — Generate Law 5 reflection for the session
+2. **Analyze** — Process pending observations into instincts
+3. **Status** — Show all instincts with confidence levels
+4. **Suggest** — Surface actionable insights
+
+Subcommands:
+- `/continuous-improvement status` — Instinct overview only
+- `/continuous-improvement projects` — List all known projects
+- `/continuous-improvement analyze` — Force analysis of pending observations
+- `/continuous-improvement reflect` — Trigger reflection manually