continuous-improvement 2.1.0 → 2.1.1

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="promo/combined.gif" alt="Before vs After continuous-improvement" width="700" />
+  <img src="assets/combined.gif" alt="Before vs After continuous-improvement" width="700" />
 </p>
 
 # continuous-improvement

package/bin/analyze.sh

@@ -1,115 +1,167 @@
 #!/usr/bin/env bash
-# analyze.sh — Read observations.jsonl, detect patterns, append rules to rules.md
-# This is the actual analysis pipeline. Runs via /continuous-improvement or observer-loop.
-# Uses claude CLI with Haiku for cost-efficient analysis.
+# 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
 
-MULAHAZAH_DIR="${HOME}/.claude/mulahazah"
-RULES_FILE="${MULAHAZAH_DIR}/rules.md"
-GLOBAL_OBS="${MULAHAZAH_DIR}/observations.jsonl"
+INSTINCTS_DIR="${HOME}/.claude/instincts"
 
+# ---------------------------------------------------------------------------
 # Detect project
-PROJECT_DIR=""
-PROJECT_OBS=""
-if REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null); then
-  PROJECT_HASH=$(printf '%s' "$REPO_ROOT" | sha256sum | cut -c1-12)
-  PROJECT_DIR="${MULAHAZAH_DIR}/projects/${PROJECT_HASH}"
-  PROJECT_OBS="${PROJECT_DIR}/observations.jsonl"
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
 fi
-
-# Find observations file
-OBS_FILE=""
-if [ -n "$PROJECT_OBS" ] && [ -f "$PROJECT_OBS" ]; then
-  OBS_FILE="$PROJECT_OBS"
-elif [ -f "$GLOBAL_OBS" ]; then
-  OBS_FILE="$GLOBAL_OBS"
+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
 
-if [ -z "$OBS_FILE" ] || [ ! -s "$OBS_FILE" ]; then
-  echo "No observations found. Use Claude Code with hooks installed to generate observations."
+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"
+echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
 
-if [ "$OBS_COUNT" -lt 5 ]; then
-  echo "Need at least 5 observations for meaningful analysis. Keep using Claude Code."
+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 rules to avoid duplicates
-EXISTING_RULES=""
-if [ -f "$RULES_FILE" ]; then
-  EXISTING_RULES=$(cat "$RULES_FILE")
-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 200 observations (keep prompt size manageable)
-RECENT_OBS=$(tail -200 "$OBS_FILE")
+# ---------------------------------------------------------------------------
+# 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.
+# ---------------------------------------------------------------------------
+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 RULES (already learned — do NOT duplicate these):
-${EXISTING_RULES}
+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
-
-OUTPUT FORMAT — output ONLY new rules, one per line, as markdown list items:
-- Rule: [specific actionable rule based on observed pattern]
-
-Rules must be:
-- Specific and actionable (not vague advice)
-- Based on actual observed patterns (cite the tools/sequence you saw)
-- Different from existing rules listed above
-- Useful for future sessions
+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 rules list or NO_NEW_PATTERNS. No explanation, no preamble."
+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
+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
 
-# Append new rules to rules.md
-echo "" >> "$RULES_FILE" 2>/dev/null || true
-mkdir -p "$(dirname "$RULES_FILE")"
-{
-  if [ ! -f "$RULES_FILE" ]; then
-    echo "# Learned Rules"
-    echo ""
-    echo "Rules extracted from session observations by Mulahazah."
-    echo "Remove any rule that causes problems. Keep what helps."
-    echo ""
-    echo "---"
-    echo ""
+# ---------------------------------------------------------------------------
+# 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
-  echo "## $(date +%Y-%m-%d) analysis"
-  echo ""
-  echo "$RESULT"
-  echo ""
-} >> "$RULES_FILE"
-
-# Count new rules
-NEW_COUNT=$(echo "$RESULT" | grep -c "^- " || true)
-echo ""
-echo "Added $NEW_COUNT new rules to $RULES_FILE"
+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 "$RESULT"
+echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"

package/bin/install.mjs

@@ -169,23 +169,82 @@ function patchClaudeSettings(observePath) {
 
 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 from ${target.label}`);
+        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 installations found.");
+    console.log("  No skill installations found.");
   }
-  console.log();
+  console.log(
+    "\n  Note: Instinct data in ~/.claude/instincts/ was preserved.\n" +
+      "  To remove learned data too: rm -rf ~/.claude/instincts/\n"
+  );
 }
 
 function printUsage() {
@@ -207,12 +266,18 @@ Examples:
 // --- 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "7-law discipline framework with auto-leveling instinct learning for AI agents — research, plan, execute, verify, reflect, learn, iterate",
   "keywords": [
     "ai-agent",