continuous-improvement 1.1.0 → 2.1.1

package/bin/analyze.sh

@@ -0,0 +1,167 @@
+#!/usr/bin/env bash
+# analyze.sh — Read observations.jsonl, detect patterns, create instinct YAML files
+# Runs via /continuous-improvement command. Uses claude CLI with Haiku for cost-efficient analysis.
+
+set -euo pipefail
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# ---------------------------------------------------------------------------
+# Detect project
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+
+# ---------------------------------------------------------------------------
+# Check observations exist
+# ---------------------------------------------------------------------------
+if [[ ! -f "$OBS_FILE" ]] || [[ ! -s "$OBS_FILE" ]]; then
+  echo "No observations found at ${OBS_FILE}"
+  echo "Use Claude Code with hooks installed to generate observations."
+  exit 0
+fi
+
+OBS_COUNT=$(wc -l < "$OBS_FILE")
+echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
+
+if (( OBS_COUNT < 20 )); then
+  echo "Need at least 20 observations for meaningful analysis. Keep using Claude Code (${OBS_COUNT}/20)."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Read existing instincts to avoid duplicates
+# ---------------------------------------------------------------------------
+EXISTING_INSTINCTS=""
+for f in "${PROJECT_DIR}"/*.yaml "${INSTINCTS_DIR}/global"/*.yaml; do
+  [[ -f "$f" ]] && EXISTING_INSTINCTS="${EXISTING_INSTINCTS}$(cat "$f")"$'\n'
+done
+
+# ---------------------------------------------------------------------------
+# Take last 500 observations
+# ---------------------------------------------------------------------------
+RECENT_OBS=$(tail -500 "$OBS_FILE")
+
+# ---------------------------------------------------------------------------
+# Build analysis prompt
+# ---------------------------------------------------------------------------
+ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns as instinct YAML files.
+
+OBSERVATIONS (JSONL — each line is a tool call):
+${RECENT_OBS}
+
+EXISTING INSTINCTS (already learned — do NOT duplicate these):
+${EXISTING_INSTINCTS}
+
+YOUR TASK:
+1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
+2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
+3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
+4. Look for WORKFLOW PATTERNS — consistent ordering of operations
+5. Look for USER CORRECTIONS — user says no/stop/don't after an action
+
+OUTPUT FORMAT — output ONLY new instincts as YAML blocks, separated by ---:
+
+id: descriptive-kebab-case-id
+trigger: \"when [specific situation]\"
+confidence: 0.5
+domain: workflow|tooling|testing|patterns
+source: observation
+scope: project
+project_id: ${PROJECT_HASH}
+created: \"$(date -u +%Y-%m-%d)\"
+last_seen: \"$(date -u +%Y-%m-%d)\"
+observation_count: [number of times pattern was seen]
+---
+[One sentence describing the specific actionable behavior]
+
+Rules:
+- Only create instincts for patterns seen 3+ times
+- Start confidence at 0.5 (suggest level)
+- Be specific and actionable (not vague advice)
+- Different from existing instincts listed above
+
+If no new patterns are found, output exactly: NO_NEW_PATTERNS
+
+Output ONLY the YAML blocks or NO_NEW_PATTERNS. No explanation, no preamble."
+
+# ---------------------------------------------------------------------------
+# Run analysis with Haiku
+# ---------------------------------------------------------------------------
+echo "Analyzing patterns with Haiku..."
+RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
+  echo "Analysis failed — claude CLI error. Try running manually."
+  exit 1
+}
+
+if [[ "$RESULT" == "NO_NEW_PATTERNS" ]] || [[ -z "$RESULT" ]]; then
+  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Write instinct YAML files
+# ---------------------------------------------------------------------------
+mkdir -p "$PROJECT_DIR"
+
+NEW_COUNT=0
+while IFS= read -r -d '' block; do
+  [[ -z "$block" ]] && continue
+  # Extract id from the block
+  INSTINCT_ID=$(echo "$block" | grep -oP '(?<=^id: ).*' | head -1 | tr -d '"' | tr -d "'")
+  if [[ -n "$INSTINCT_ID" ]]; then
+    DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+    printf '%s\n' "$block" > "$DEST"
+    echo "  + ${INSTINCT_ID} → ${DEST}"
+    NEW_COUNT=$((NEW_COUNT + 1))
+  fi
+done < <(printf '%s\0' "$RESULT" | sed 's/\n---\n/\x00/g')
+
+# Fallback: if the splitting didn't work, try line-based parsing
+if (( NEW_COUNT == 0 )); then
+  # Try splitting on --- delimiter
+  INSTINCT_ID=""
+  BLOCK=""
+  while IFS= read -r line; do
+    if [[ "$line" == "---" ]] && [[ -n "$BLOCK" ]]; then
+      if [[ -n "$INSTINCT_ID" ]]; then
+        DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+        printf '%s\n' "$BLOCK" > "$DEST"
+        echo "  + ${INSTINCT_ID} → ${DEST}"
+        NEW_COUNT=$((NEW_COUNT + 1))
+      fi
+      INSTINCT_ID=""
+      BLOCK=""
+    else
+      BLOCK="${BLOCK}${line}"$'\n'
+      if [[ "$line" =~ ^id:\ (.+) ]]; then
+        INSTINCT_ID="${BASH_REMATCH[1]}"
+        INSTINCT_ID="${INSTINCT_ID//\"/}"
+        INSTINCT_ID="${INSTINCT_ID//\'/}"
+      fi
+    fi
+  done <<< "$RESULT"
+  # Handle last block
+  if [[ -n "$INSTINCT_ID" ]] && [[ -n "$BLOCK" ]]; then
+    DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+    printf '%s\n' "$BLOCK" > "$DEST"
+    echo "  + ${INSTINCT_ID} → ${DEST}"
+    NEW_COUNT=$((NEW_COUNT + 1))
+  fi
+fi
+
+echo ""
+echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"

package/bin/install.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+
+/**
+ * continuous-improvement installer
+ *
+ * Usage:
+ *   npx continuous-improvement install                # auto-detect & install
+ *   npx continuous-improvement install --target claude # install to ~/.claude/skills/ + Mulahazah
+ *   npx continuous-improvement install --target openclaw # install to ~/.openclaw/skills/
+ *   npx continuous-improvement install --target cursor # install to ~/.cursor/skills/
+ *   npx continuous-improvement install --target all    # install to all detected targets
+ *   npx continuous-improvement install --uninstall     # remove from all targets
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  chmodSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_SOURCE = join(__dirname, "..", "SKILL.md");
+const SKILL_NAME = "continuous-improvement";
+const REPO_ROOT = join(__dirname, "..");
+
+const TARGETS = {
+  claude: {
+    label: "Claude Code",
+    dir: join(homedir(), ".claude", "skills", SKILL_NAME),
+  },
+  openclaw: {
+    label: "OpenClaw",
+    dir: join(homedir(), ".openclaw", "skills", SKILL_NAME),
+  },
+  cursor: {
+    label: "Cursor",
+    dir: join(homedir(), ".cursor", "skills", SKILL_NAME),
+  },
+  codex: {
+    label: "Codex",
+    dir: join(homedir(), ".codex", "skills", SKILL_NAME),
+  },
+};
+
+function detectTargets() {
+  const detected = [];
+  for (const [key, target] of Object.entries(TARGETS)) {
+    const parentDir = dirname(target.dir);
+    const configDir = dirname(parentDir);
+    if (existsSync(configDir)) {
+      detected.push(key);
+    }
+  }
+  return detected;
+}
+
+function installTo(key) {
+  const target = TARGETS[key];
+  if (!target) {
+    console.error(`  Unknown target: ${key}`);
+    return false;
+  }
+
+  try {
+    mkdirSync(target.dir, { recursive: true });
+    copyFileSync(SKILL_SOURCE, join(target.dir, "SKILL.md"));
+    console.log(`  ✓ ${target.label} → ${target.dir}/SKILL.md`);
+
+    if (key === "claude") {
+      setupMulahazah();
+    }
+
+    return true;
+  } catch (err) {
+    console.error(`  ✗ ${target.label}: ${err.message}`);
+    return false;
+  }
+}
+
+function setupMulahazah() {
+  const home = homedir();
+  const instinctsDir = join(home, ".claude", "instincts");
+  const globalDir = join(instinctsDir, "global");
+
+  // 1. Create directory structure
+  mkdirSync(globalDir, { recursive: true });
+  console.log(`  ✓ Instincts dir → ${instinctsDir}/`);
+
+  // 2. Copy observe.sh and make executable
+  const observeSrc = join(REPO_ROOT, "hooks", "observe.sh");
+  const observeDest = join(instinctsDir, "observe.sh");
+  if (existsSync(observeSrc)) {
+    copyFileSync(observeSrc, observeDest);
+    chmodSync(observeDest, 0o755);
+    console.log(`  ✓ observe.sh → ${observeDest}`);
+  }
+
+  // 3. Copy /continuous-improvement command
+  const commandsDir = join(home, ".claude", "commands");
+  mkdirSync(commandsDir, { recursive: true });
+  const cmdSrc = join(REPO_ROOT, "commands", "continuous-improvement.md");
+  const cmdDest = join(commandsDir, "continuous-improvement.md");
+  if (existsSync(cmdSrc)) {
+    copyFileSync(cmdSrc, cmdDest);
+    console.log(`  ✓ /continuous-improvement command → ${cmdDest}`);
+  }
+
+  // 4. Patch ~/.claude/settings.json with hooks
+  patchClaudeSettings(observeDest);
+}
+
+function patchClaudeSettings(observePath) {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch {
+      console.warn(`  ! Could not parse ${settingsPath} — skipping hook patch`);
+      return;
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  const hookEntry = {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: `bash "${observePath}"`,
+      },
+    ],
+  };
+
+  let changed = false;
+
+  for (const hookType of ["PreToolUse", "PostToolUse"]) {
+    if (!Array.isArray(settings.hooks[hookType])) {
+      settings.hooks[hookType] = [];
+    }
+    const alreadyPatched = settings.hooks[hookType].some(
+      (h) =>
+        Array.isArray(h.hooks) &&
+        h.hooks.some((hh) => hh.command && hh.command.includes("observe.sh"))
+    );
+    if (!alreadyPatched) {
+      settings.hooks[hookType].push(hookEntry);
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`  ✓ Patched ~/.claude/settings.json with PreToolUse/PostToolUse hooks`);
+  } else {
+    console.log(`  ✓ settings.json already has observe.sh hooks — no change needed`);
+  }
+}
+
+function uninstallAll() {
+  console.log("\nUninstalling continuous-improvement skill...\n");
+  const home = homedir();
+  let removed = 0;
+
+  // 1. Remove skill files from all targets
+  for (const [key, target] of Object.entries(TARGETS)) {
+    const skillFile = join(target.dir, "SKILL.md");
+    if (existsSync(skillFile)) {
+      try {
+        rmSync(target.dir, { recursive: true });
+        console.log(`  ✓ Removed skill from ${target.label}`);
+        removed++;
+      } catch (err) {
+        console.error(`  ✗ ${target.label}: ${err.message}`);
+      }
+    }
+  }
+
+  // 2. Remove /continuous-improvement command
+  const cmdFile = join(home, ".claude", "commands", "continuous-improvement.md");
+  if (existsSync(cmdFile)) {
+    try {
+      rmSync(cmdFile);
+      console.log(`  ✓ Removed /continuous-improvement command`);
+    } catch (err) {
+      console.error(`  ✗ Command file: ${err.message}`);
+    }
+  }
+
+  // 3. Remove observe.sh from instincts dir
+  const observeFile = join(home, ".claude", "instincts", "observe.sh");
+  if (existsSync(observeFile)) {
+    try {
+      rmSync(observeFile);
+      console.log(`  ✓ Removed observe.sh`);
+    } catch (err) {
+      console.error(`  ✗ observe.sh: ${err.message}`);
+    }
+  }
+
+  // 4. Remove hooks from settings.json
+  const settingsPath = join(home, ".claude", "settings.json");
+  if (existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+      let changed = false;
+      for (const hookType of ["PreToolUse", "PostToolUse"]) {
+        if (Array.isArray(settings.hooks?.[hookType])) {
+          const before = settings.hooks[hookType].length;
+          settings.hooks[hookType] = settings.hooks[hookType].filter(
+            (h) =>
+              !(
+                Array.isArray(h.hooks) &&
+                h.hooks.some(
+                  (hh) => hh.command && hh.command.includes("observe.sh")
+                )
+              )
+          );
+          if (settings.hooks[hookType].length < before) changed = true;
+        }
+      }
+      if (changed) {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        console.log(`  ✓ Removed hooks from settings.json`);
+      }
+    } catch {
+      console.warn(`  ! Could not clean settings.json — remove hooks manually`);
+    }
+  }
+
+  if (removed === 0) {
+    console.log("  No skill installations found.");
+  }
+  console.log(
+    "\n  Note: Instinct data in ~/.claude/instincts/ was preserved.\n" +
+      "  To remove learned data too: rm -rf ~/.claude/instincts/\n"
+  );
+}
+
+function printUsage() {
+  console.log(`
+Usage: npx continuous-improvement install [options]
+
+Options:
+  --target <name>   Install to specific target (claude, openclaw, cursor, codex, all)
+  --uninstall       Remove from all targets
+  --help            Show this help
+
+Examples:
+  npx continuous-improvement install              # auto-detect & install
+  npx continuous-improvement install --target all  # install everywhere
+  npx continuous-improvement install --uninstall   # remove all
+`);
+}
+
+// --- Main ---
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (args.includes("--help") || args.includes("-h")) {
+  printUsage();
+  process.exit(0);
+}
+
+if (!command || !["install", "--help", "-h", "--uninstall"].includes(command)) {
+  printUsage();
+  process.exit(command ? 1 : 0);
+}
+
+if (args.includes("--uninstall")) {
+  uninstallAll();
+  process.exit(0);
+}
+
+console.log(`
+continuous-improvement v2.1
+Research → Plan → Execute → Verify → Reflect → Learn → Iterate
+`);
+
+const targetIdx = args.indexOf("--target");
+let targets;
+
+if (targetIdx !== -1 && args[targetIdx + 1]) {
+  const requested = args[targetIdx + 1].toLowerCase();
+  if (requested === "all") {
+    targets = Object.keys(TARGETS);
+  } else if (TARGETS[requested]) {
+    targets = [requested];
+  } else {
+    console.error(`Unknown target: ${requested}`);
+    console.error(`Available: ${Object.keys(TARGETS).join(", ")}, all`);
+    process.exit(1);
+  }
+} else {
+  targets = detectTargets();
+  if (targets.length === 0) {
+    console.log("No supported agent configs detected. Installing to Claude Code by default.\n");
+    targets = ["claude"];
+  } else {
+    console.log(`Detected: ${targets.map((t) => TARGETS[t].label).join(", ")}\n`);
+  }
+}
+
+console.log("Installing...\n");
+
+let installed = 0;
+for (const t of targets) {
+  if (installTo(t)) installed++;
+}
+
+const hasClaude = targets.includes("claude");
+
+console.log(`
+${installed > 0 ? "Done." : "Failed."} Installed to ${installed}/${targets.length} target(s).
+${hasClaude ? "\nHooks are capturing. System auto-levels as you use it." : ""}
+Next steps:
+  1. Start a new Claude Code session
+  2. Say: "Use the continuous-improvement framework to [your task]"
+  3. After your first task, run: /continuous-improvement
+`);

package/commands/continuous-improvement.md

@@ -0,0 +1,74 @@
+---
+name: continuous-improvement
+description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Run after finishing significant work."
+---
+
+# /continuous-improvement
+
+Run this after completing significant work. It does three things in order.
+
+## Step 1: Reflect
+
+Generate a reflection for this session based on what happened:
+
+```
+## Reflection — [Date]
+- What worked:
+- What failed:
+- What I'd do differently:
+- Rule to add:
+```
+
+If there's a "Rule to add", create an instinct YAML file with 0.6 starting confidence in the project's instinct directory.
+
+## Step 2: Analyze Observations
+
+Check `~/.claude/instincts/` for the current project (detect via git root → SHA-256 first 12 chars).
+
+Look at `~/.claude/instincts/<hash>/observations.jsonl`. If 20+ lines exist:
+
+1. Read the last 500 lines
+2. Read existing instinct `*.yaml` files (project + global)
+3. Detect patterns:
+   - User corrections → "don't do X" instincts
+   - Error→fix sequences → "when X fails, try Y"
+   - Repeated workflows (3+ times) → "for X, do A→B→C"
+   - Tool preferences → "use tool Y for task X"
+4. Create/update instinct YAML files
+5. Be conservative: only create instincts for 3+ observations of the same pattern
+
+If fewer than 20 observations, skip analysis and note the count.
+
+## Step 3: Show Status
+
+Display all instincts for the current project + global:
+
+```
+=== continuous-improvement ===
+
+## Level: [CAPTURE | ANALYZE | SUGGEST | AUTO-APPLY]
+
+## Session Reflection
+- What worked: [from this session]
+- What failed: [from this session]
+- What I'd do differently: [from this session]
+- Rule to add: [captured as instinct]
+
+## Learning
+  NEW  [instinct-id]        [domain]  [confidence]  (from reflection)
+   ↑   [instinct-id]        [domain]  [old]→[new]   (+N observations)
+
+## Instincts — [project-name] ([hash])
+  ● [0.85] instinct-id       domain   auto-apply
+  ◐ [0.60] instinct-id       domain   suggest
+  ○ [0.35] instinct-id       domain   silent
+
+## Instincts — global
+  ● [0.90] instinct-id       domain   auto-apply
+
+## Next
+- Keep working — hooks capture automatically
+- System auto-levels as instincts gain confidence
+```
+
+If no instincts or observations exist yet, explain this is expected — the system is in CAPTURE level and will create instincts after 20+ observations accumulate.