continuous-improvement 2.2.0 → 3.0.0

package/bin/mcp-server.mjs

@@ -0,0 +1,543 @@
+#!/usr/bin/env node
+
+/**
+ * continuous-improvement MCP Server
+ *
+ * Exposes instincts, observations, and reflection as MCP tools + resources.
+ * Two modes: beginner (3 tools) and expert (all tools).
+ *
+ * Usage:
+ *   node bin/mcp-server.mjs                  # default: beginner mode
+ *   node bin/mcp-server.mjs --mode expert    # all tools
+ *   node bin/mcp-server.mjs --mode beginner  # explicit beginner
+ */
+
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const VERSION = "3.0.0";
+const INSTINCTS_DIR = join(homedir(), ".claude", "instincts");
+const GLOBAL_DIR = join(INSTINCTS_DIR, "global");
+
+const args = process.argv.slice(2);
+const modeIdx = args.indexOf("--mode");
+const MODE = modeIdx !== -1 && args[modeIdx + 1] ? args[modeIdx + 1] : "beginner";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getProjectHash() {
+  try {
+    const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
+    const hash = execSync(`printf '%s' "${root}" | sha256sum | cut -c1-12`, {
+      encoding: "utf8",
+      shell: "/bin/bash",
+    }).trim();
+    return { root, hash, name: basename(root) };
+  } catch {
+    return { root: "global", hash: "global", name: "global" };
+  }
+}
+
+function readInstincts(projectHash) {
+  const instincts = [];
+  const dirs = [GLOBAL_DIR];
+  if (projectHash !== "global") {
+    dirs.push(join(INSTINCTS_DIR, projectHash));
+  }
+
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    for (const file of readdirSync(dir)) {
+      if (!file.endsWith(".yaml")) continue;
+      try {
+        const content = readFileSync(join(dir, file), "utf8");
+        const parsed = parseYamlInstinct(content);
+        if (parsed) instincts.push(parsed);
+      } catch {
+        // skip malformed files
+      }
+    }
+  }
+  return instincts;
+}
+
+function parseYamlInstinct(content) {
+  const lines = content.split("\n");
+  const meta = {};
+  let body = "";
+  let inBody = false;
+
+  for (const line of lines) {
+    if (line.trim() === "---" && Object.keys(meta).length > 0) {
+      inBody = true;
+      continue;
+    }
+    if (inBody) {
+      body += line + "\n";
+    } else {
+      const match = line.match(/^(\w[\w_-]*):\s*(.+)/);
+      if (match) {
+        let val = match[2].trim().replace(/^["']|["']$/g, "");
+        if (!isNaN(val) && val !== "") val = parseFloat(val);
+        meta[match[1]] = val;
+      }
+    }
+  }
+
+  if (!meta.id) return null;
+  return { ...meta, body: body.trim() };
+}
+
+function countObservations(projectHash) {
+  const obsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
+  if (!existsSync(obsFile)) return 0;
+  try {
+    const content = readFileSync(obsFile, "utf8");
+    return content.split("\n").filter((l) => l.trim()).length;
+  } catch {
+    return 0;
+  }
+}
+
+function getRecentObservations(projectHash, limit = 50) {
+  const obsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
+  if (!existsSync(obsFile)) return [];
+  try {
+    const lines = readFileSync(obsFile, "utf8").split("\n").filter((l) => l.trim());
+    return lines.slice(-limit).map((l) => {
+      try { return JSON.parse(l); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function detectLevel(projectHash) {
+  const obsCount = countObservations(projectHash);
+  const instincts = readInstincts(projectHash);
+  const hasHighConfidence = instincts.some((i) => i.confidence >= 0.7);
+  const hasMidConfidence = instincts.some((i) => i.confidence >= 0.5 && i.confidence < 0.7);
+
+  if (hasHighConfidence) return "AUTO-APPLY";
+  if (hasMidConfidence) return "SUGGEST";
+  if (obsCount >= 20 || instincts.length > 0) return "ANALYZE";
+  return "CAPTURE";
+}
+
+function writeInstinct(projectHash, instinct) {
+  const dir = instinct.scope === "global" ? GLOBAL_DIR : join(INSTINCTS_DIR, projectHash);
+  mkdirSync(dir, { recursive: true });
+
+  const yaml = [
+    `id: ${instinct.id}`,
+    `trigger: "${instinct.trigger}"`,
+    `confidence: ${instinct.confidence}`,
+    `domain: ${instinct.domain || "workflow"}`,
+    `source: ${instinct.source || "manual"}`,
+    `scope: ${instinct.scope || "project"}`,
+    `project_id: ${projectHash}`,
+    `created: "${new Date().toISOString().split("T")[0]}"`,
+    `last_seen: "${new Date().toISOString().split("T")[0]}"`,
+    `observation_count: ${instinct.observation_count || 1}`,
+    "---",
+    instinct.body,
+  ].join("\n");
+
+  writeFileSync(join(dir, `${instinct.id}.yaml`), yaml + "\n");
+}
+
+function updateInstinctConfidence(projectHash, instinctId, delta) {
+  const instincts = readInstincts(projectHash);
+  const instinct = instincts.find((i) => i.id === instinctId);
+  if (!instinct) return null;
+
+  const newConf = Math.max(0, Math.min(0.9, (instinct.confidence || 0.5) + delta));
+  instinct.confidence = Math.round(newConf * 100) / 100;
+  instinct.last_seen = new Date().toISOString().split("T")[0];
+  writeInstinct(projectHash, instinct);
+  return instinct;
+}
+
+// ---------------------------------------------------------------------------
+// MCP Protocol (JSON-RPC over stdio, no SDK dependency)
+// ---------------------------------------------------------------------------
+
+const BEGINNER_TOOLS = [
+  {
+    name: "ci_status",
+    description: "Show current level, instinct count, and observation count for this project. Good starting point to see what the system has learned.",
+    inputSchema: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "ci_instincts",
+    description: "List all learned instincts for this project with their confidence levels and behaviors.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        min_confidence: { type: "number", description: "Minimum confidence to show (default: 0)", default: 0 },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "ci_reflect",
+    description: "Generate a structured reflection for the current session. Provide a summary of what you worked on.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: { type: "string", description: "Brief summary of what was done this session" },
+      },
+      required: ["summary"],
+    },
+  },
+];
+
+const EXPERT_TOOLS = [
+  {
+    name: "ci_reinforce",
+    description: "Accept or reject an instinct suggestion. Adjusts confidence: +0.15 for accept, -0.1 for reject.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instinct_id: { type: "string", description: "The instinct ID to reinforce" },
+        accepted: { type: "boolean", description: "true = accept (+0.15), false = reject (-0.1)" },
+      },
+      required: ["instinct_id", "accepted"],
+    },
+  },
+  {
+    name: "ci_create_instinct",
+    description: "Manually create a new instinct with a trigger, body, and starting confidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Unique instinct ID (kebab-case)" },
+        trigger: { type: "string", description: "When this instinct applies" },
+        body: { type: "string", description: "The behavior to follow" },
+        confidence: { type: "number", description: "Starting confidence 0.0-0.9 (default: 0.6)", default: 0.6 },
+        domain: { type: "string", description: "Domain: workflow|tooling|testing|patterns|code-style", default: "workflow" },
+        scope: { type: "string", description: "Scope: project|global", default: "project" },
+      },
+      required: ["id", "trigger", "body"],
+    },
+  },
+  {
+    name: "ci_observations",
+    description: "View recent tool call observations captured by hooks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of recent observations to return (default: 20)", default: 20 },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "ci_export",
+    description: "Export all instincts as a JSON array for sharing or backup.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scope: { type: "string", description: "Which instincts: project|global|all (default: all)", default: "all" },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "ci_import",
+    description: "Import instincts from a JSON array. Skips duplicates by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instincts_json: { type: "string", description: "JSON array of instinct objects to import" },
+        scope: { type: "string", description: "Import to: project|global (default: project)", default: "project" },
+      },
+      required: ["instincts_json"],
+    },
+  },
+];
+
+function getAllTools() {
+  if (MODE === "expert") return [...BEGINNER_TOOLS, ...EXPERT_TOOLS];
+  return BEGINNER_TOOLS;
+}
+
+// ---------------------------------------------------------------------------
+// Tool handlers
+// ---------------------------------------------------------------------------
+
+function handleTool(name, params) {
+  const project = getProjectHash();
+
+  switch (name) {
+    case "ci_status": {
+      const level = detectLevel(project.hash);
+      const obsCount = countObservations(project.hash);
+      const instincts = readInstincts(project.hash);
+      const byConfidence = {
+        silent: instincts.filter((i) => i.confidence < 0.5).length,
+        suggest: instincts.filter((i) => i.confidence >= 0.5 && i.confidence < 0.7).length,
+        autoApply: instincts.filter((i) => i.confidence >= 0.7).length,
+      };
+
+      return text([
+        `## continuous-improvement Status`,
+        ``,
+        `**Project:** ${project.name}`,
+        `**Level:** ${level}`,
+        `**Observations:** ${obsCount}`,
+        `**Instincts:** ${instincts.length} total`,
+        `  - Silent (< 0.5): ${byConfidence.silent}`,
+        `  - Suggest (0.5-0.69): ${byConfidence.suggest}`,
+        `  - Auto-apply (0.7+): ${byConfidence.autoApply}`,
+        ``,
+        `**Mode:** ${MODE}`,
+        level === "CAPTURE" ? `\n_Keep working — hooks are capturing. Analysis begins at 20 observations._` : "",
+      ].join("\n"));
+    }
+
+    case "ci_instincts": {
+      const minConf = params.min_confidence || 0;
+      const instincts = readInstincts(project.hash).filter((i) => i.confidence >= minConf);
+
+      if (instincts.length === 0) return text("No instincts found. Keep working — the system learns from your sessions.");
+
+      const lines = instincts
+        .sort((a, b) => b.confidence - a.confidence)
+        .map((i) => {
+          const behavior = i.confidence >= 0.7 ? "AUTO-APPLY" : i.confidence >= 0.5 ? "SUGGEST" : "silent";
+          return `- **${i.id}** (${i.confidence}) [${behavior}]\n  Trigger: ${i.trigger}\n  ${i.body}`;
+        });
+
+      return text(`## Instincts for ${project.name}\n\n${lines.join("\n\n")}`);
+    }
+
+    case "ci_reflect": {
+      const summary = params.summary || "No summary provided";
+      const reflection = [
+        `## Reflection — ${new Date().toISOString().split("T")[0]}`,
+        ``,
+        `**Session summary:** ${summary}`,
+        ``,
+        `Use this template to reflect:`,
+        `- **What worked:**`,
+        `- **What failed:**`,
+        `- **What I'd do differently:**`,
+        `- **Rule to add:** (becomes an instinct at 0.6 confidence)`,
+      ].join("\n");
+
+      return text(reflection);
+    }
+
+    case "ci_reinforce": {
+      if (MODE !== "expert") return error("ci_reinforce requires expert mode. Start server with --mode expert");
+      const delta = params.accepted ? 0.15 : -0.1;
+      const updated = updateInstinctConfidence(project.hash, params.instinct_id, delta);
+      if (!updated) return error(`Instinct "${params.instinct_id}" not found`);
+      return text(`${params.accepted ? "Accepted" : "Rejected"} **${updated.id}** — confidence now ${updated.confidence}`);
+    }
+
+    case "ci_create_instinct": {
+      if (MODE !== "expert") return error("ci_create_instinct requires expert mode");
+      writeInstinct(project.hash, {
+        id: params.id,
+        trigger: params.trigger,
+        body: params.body,
+        confidence: params.confidence || 0.6,
+        domain: params.domain || "workflow",
+        source: "manual",
+        scope: params.scope || "project",
+        observation_count: 1,
+      });
+      return text(`Created instinct **${params.id}** with confidence ${params.confidence || 0.6}`);
+    }
+
+    case "ci_observations": {
+      if (MODE !== "expert") return error("ci_observations requires expert mode");
+      const limit = params.limit || 20;
+      const obs = getRecentObservations(project.hash, limit);
+      if (obs.length === 0) return text("No observations yet. Hooks capture tool calls automatically.");
+      const lines = obs.map((o) => `[${o.ts}] ${o.event} — ${o.tool}`);
+      return text(`## Recent Observations (${obs.length})\n\n${lines.join("\n")}`);
+    }
+
+    case "ci_export": {
+      if (MODE !== "expert") return error("ci_export requires expert mode");
+      const scope = params.scope || "all";
+      let instincts = readInstincts(project.hash);
+      if (scope === "project") instincts = instincts.filter((i) => i.scope === "project");
+      if (scope === "global") instincts = instincts.filter((i) => i.scope === "global");
+      return text(JSON.stringify(instincts, null, 2));
+    }
+
+    case "ci_import": {
+      if (MODE !== "expert") return error("ci_import requires expert mode");
+      let toImport;
+      try {
+        toImport = JSON.parse(params.instincts_json);
+      } catch {
+        return error("Invalid JSON. Provide a JSON array of instinct objects.");
+      }
+      if (!Array.isArray(toImport)) return error("Expected a JSON array");
+
+      const existing = readInstincts(project.hash);
+      const existingIds = new Set(existing.map((i) => i.id));
+      let imported = 0;
+
+      for (const inst of toImport) {
+        if (!inst.id || !inst.trigger || !inst.body) continue;
+        if (existingIds.has(inst.id)) continue;
+        writeInstinct(project.hash, {
+          ...inst,
+          scope: params.scope || inst.scope || "project",
+          source: "imported",
+        });
+        imported++;
+      }
+
+      return text(`Imported ${imported} instincts (${toImport.length - imported} skipped as duplicates)`);
+    }
+
+    default:
+      return error(`Unknown tool: ${name}`);
+  }
+}
+
+function text(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+
+function error(t) {
+  return { content: [{ type: "text", text: t }], isError: true };
+}
+
+// ---------------------------------------------------------------------------
+// JSON-RPC stdio transport (zero dependencies)
+// ---------------------------------------------------------------------------
+
+const rl = createInterface({ input: process.stdin, terminal: false });
+let buffer = "";
+
+rl.on("line", (line) => {
+  buffer += line;
+  try {
+    const msg = JSON.parse(buffer);
+    buffer = "";
+    handleMessage(msg);
+  } catch {
+    // incomplete JSON, keep buffering
+  }
+});
+
+function send(response) {
+  const json = JSON.stringify(response);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+
+function handleMessage(msg) {
+  const { id, method, params } = msg;
+
+  switch (method) {
+    case "initialize":
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: { listChanged: false },
+            resources: { subscribe: false, listChanged: false },
+          },
+          serverInfo: {
+            name: "continuous-improvement",
+            version: VERSION,
+          },
+        },
+      });
+      break;
+
+    case "notifications/initialized":
+      // no response needed
+      break;
+
+    case "tools/list":
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: { tools: getAllTools() },
+      });
+      break;
+
+    case "tools/call": {
+      const result = handleTool(params.name, params.arguments || {});
+      send({ jsonrpc: "2.0", id, result });
+      break;
+    }
+
+    case "resources/list": {
+      const project = getProjectHash();
+      const resources = [
+        {
+          uri: `instincts://project/${project.hash}`,
+          name: `${project.name} instincts`,
+          description: `Learned instincts for ${project.name}`,
+          mimeType: "application/json",
+        },
+        {
+          uri: "instincts://global",
+          name: "Global instincts",
+          description: "Cross-project instincts",
+          mimeType: "application/json",
+        },
+      ];
+      send({ jsonrpc: "2.0", id, result: { resources } });
+      break;
+    }
+
+    case "resources/read": {
+      const uri = params.uri;
+      const project = getProjectHash();
+      let instincts;
+
+      if (uri === "instincts://global") {
+        instincts = readInstincts("global").filter((i) => i.scope === "global");
+      } else {
+        instincts = readInstincts(project.hash);
+      }
+
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          contents: [
+            {
+              uri,
+              text: JSON.stringify(instincts, null, 2),
+              mimeType: "application/json",
+            },
+          ],
+        },
+      });
+      break;
+    }
+
+    default:
+      if (id) {
+        send({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` },
+        });
+      }
+  }
+}
+
+console.error(`continuous-improvement MCP server v${VERSION} started (mode: ${MODE})`);

package/hooks/session.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# session.sh — SessionStart/SessionEnd hook for continuous-improvement
+# SessionStart: loads instincts and prints status
+# SessionEnd: prompts reflection
+# Always exits 0 — never blocks the session
+trap 'exit 0' EXIT ERR INT TERM
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# Read stdin
+INPUT="$(cat)"
+[[ -z "$INPUT" ]] && exit 0
+
+# ---------------------------------------------------------------------------
+# Detect event type from hook context
+# ---------------------------------------------------------------------------
+# SessionStart hooks receive no tool_name, SessionEnd hooks may vary.
+# We detect based on the hook_type field or the calling context.
+EVENT_TYPE=""
+if command -v jq &>/dev/null; then
+  EVENT_TYPE="$(printf '%s' "$INPUT" | jq -r '.hook_type // .event_type // "unknown"' 2>/dev/null)"
+else
+  if printf '%s' "$INPUT" | grep -q '"SessionStart"'; then
+    EVENT_TYPE="SessionStart"
+  elif printf '%s' "$INPUT" | grep -q '"SessionEnd"'; then
+    EVENT_TYPE="SessionEnd"
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Project detection (same as observe.sh)
+# ---------------------------------------------------------------------------
+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_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+
+# ---------------------------------------------------------------------------
+# SessionStart: count observations and instincts, print brief status
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionStart" || "$EVENT_TYPE" == "unknown" ]]; then
+  OBS_COUNT=0
+  INSTINCT_COUNT=0
+
+  OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+  if [[ -f "$OBS_FILE" ]]; then
+    OBS_COUNT="$(wc -l < "$OBS_FILE" 2>/dev/null || echo 0)"
+  fi
+
+  # Count yaml files in project + global
+  for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+    if [[ -d "$dir" ]]; then
+      count="$(find "$dir" -maxdepth 1 -name '*.yaml' 2>/dev/null | wc -l)"
+      INSTINCT_COUNT=$((INSTINCT_COUNT + count))
+    fi
+  done
+
+  # Determine level
+  LEVEL="CAPTURE"
+  if (( OBS_COUNT >= 20 )) || (( INSTINCT_COUNT > 0 )); then
+    LEVEL="ANALYZE"
+  fi
+
+  # Check for high-confidence instincts
+  if (( INSTINCT_COUNT > 0 )); then
+    for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+      if [[ -d "$dir" ]]; then
+        for f in "$dir"/*.yaml; do
+          [[ -f "$f" ]] || continue
+          conf="$(grep '^confidence:' "$f" 2>/dev/null | head -1 | sed 's/confidence: *//')"
+          if [[ -n "$conf" ]]; then
+            # Compare as integer (multiply by 100)
+            int_conf="$(printf '%.0f' "$(echo "$conf * 100" | bc 2>/dev/null || echo 0)")"
+            if (( int_conf >= 70 )); then
+              LEVEL="AUTO-APPLY"
+              break 2
+            elif (( int_conf >= 50 )); then
+              LEVEL="SUGGEST"
+            fi
+          fi
+        done
+      fi
+    done
+  fi
+
+  # Write status to stderr (visible in hook output, not blocking)
+  echo "[continuous-improvement] Level: ${LEVEL} | Observations: ${OBS_COUNT} | Instincts: ${INSTINCT_COUNT}" >&2
+fi
+
+# ---------------------------------------------------------------------------
+# SessionEnd: remind to reflect
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionEnd" ]]; then
+  echo "[continuous-improvement] Session ending. Run /continuous-improvement to reflect and capture learnings." >&2
+fi
+
+exit 0

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "continuous-improvement",
-  "version": "2.2.0",
-  "description": "7-law discipline framework with auto-leveling instinct learning for AI agents — research, plan, execute, verify, reflect, learn, iterate",
+  "version": "3.0.0",
+  "description": "The 7 Laws of AI Agent Discipline — stop your agent from skipping steps, guessing, and declaring 'done' without verifying. Auto-leveling instinct learning with MCP server plugin for Claude Code, Cursor, Codex, Gemini CLI.",
   "keywords": [
-    "ai-agent",
     "claude-code",
+    "claude-code-skill",
+    "ai-agent",
+    "agent-skill",
     "codex",
-    "openclaw",
     "cursor",
-    "skill",
-    "continuous-improvement",
+    "gemini-cli",
+    "ai-discipline",
     "workflow",
     "productivity",
     "mulahazah",
     "instinct",
     "learning",
-    "hooks"
+    "hooks",
+    "continuous-improvement",
+    "mcp",
+    "mcp-server",
+    "plugin"
   ],
   "author": "naimkatiman",
   "license": "MIT",
@@ -27,6 +32,9 @@
   "bin": {
     "continuous-improvement": "./bin/install.mjs"
   },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
   "files": [
     "SKILL.md",
     "QUICKSTART.md",
@@ -34,7 +42,8 @@
     "README.md",
     "bin/",
     "hooks/",
-    "commands/"
+    "commands/",
+    "plugins/"
   ],
   "type": "module"
 }