feed-the-machine 1.6.0 → 1.7.0

package/hooks/ftm-event-logger.mjs

@@ -1,107 +1,107 @@
-#!/usr/bin/env node
-
-/**
- * FTM Event Logger — PostToolUse hook
- * Appends structured JSONL entries to ~/.claude/ftm-state/events.log
- * Debounced: fires every 3rd tool use to avoid overhead
- */
-
-import { readFileSync, appendFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-const HOME = homedir();
-const STATE_DIR = join(HOME, '.claude', 'ftm-state');
-const LOG_PATH = join(STATE_DIR, 'events.log');
-const COUNTER_PATH = join(STATE_DIR, '.event-counter');
-const ARCHIVE_DIR = join(STATE_DIR, 'event-archives');
-const MAX_AGE_DAYS = 30;
-
-// Ensure directories exist
-if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
-
-// Read stdin for hook input
-let input = '';
-process.stdin.setEncoding('utf-8');
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  try {
-    const hookData = JSON.parse(input);
-
-    // Debounce: only fire every 3rd tool use
-    let counter = 0;
-    try {
-      counter = parseInt(readFileSync(COUNTER_PATH, 'utf-8').trim(), 10) || 0;
-    } catch { /* first run */ }
-
-    counter++;
-    writeFileSync(COUNTER_PATH, String(counter));
-
-    if (counter % 3 !== 0) {
-      process.exit(0); // Skip this invocation
-    }
-
-    // Build log entry
-    const entry = {
-      timestamp: new Date().toISOString(),
-      event_type: 'tool_use',
-      tool_name: hookData.tool_name || 'unknown',
-      tool_input_keys: hookData.tool_input ? Object.keys(hookData.tool_input) : [],
-      session_id: process.env.CLAUDE_SESSION_ID || 'unknown',
-      skill_context: detectSkillContext(hookData),
-    };
-
-    // Append JSONL
-    appendFileSync(LOG_PATH, JSON.stringify(entry) + '\n');
-
-    // Log rotation: check once per 100 writes
-    if (counter % 100 === 0) {
-      rotateOldEntries();
-    }
-
-  } catch (e) {
-    // Never crash — logging failure should not block execution
-    process.exit(0);
-  }
-});
-
-function detectSkillContext(hookData) {
-  const toolName = hookData.tool_name || '';
-  if (toolName === 'Skill') return hookData.tool_input?.skill || 'unknown-skill';
-  if (toolName === 'Agent') return 'agent-dispatch';
-  return null;
-}
-
-function rotateOldEntries() {
-  try {
-    if (!existsSync(LOG_PATH)) return;
-
-    const lines = readFileSync(LOG_PATH, 'utf-8').split('\n').filter(Boolean);
-    const cutoff = Date.now() - (MAX_AGE_DAYS * 24 * 60 * 60 * 1000);
-
-    const recent = [];
-    const archived = [];
-
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (new Date(entry.timestamp).getTime() > cutoff) {
-          recent.push(line);
-        } else {
-          archived.push(line);
-        }
-      } catch {
-        recent.push(line); // Keep unparseable lines
-      }
-    }
-
-    if (archived.length > 0) {
-      if (!existsSync(ARCHIVE_DIR)) mkdirSync(ARCHIVE_DIR, { recursive: true });
-      const archivePath = join(ARCHIVE_DIR, `events-${new Date().toISOString().slice(0, 10)}.log`);
-      appendFileSync(archivePath, archived.join('\n') + '\n');
-      writeFileSync(LOG_PATH, recent.join('\n') + (recent.length > 0 ? '\n' : ''));
-    }
-  } catch {
-    // Rotation failure is non-critical
-  }
-}
+#!/usr/bin/env node
+
+/**
+ * FTM Event Logger — PostToolUse hook
+ * Appends structured JSONL entries to ~/.claude/ftm-state/events.log
+ * Debounced: fires every 3rd tool use to avoid overhead
+ */
+
+import { readFileSync, appendFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+const STATE_DIR = join(HOME, '.claude', 'ftm-state');
+const LOG_PATH = join(STATE_DIR, 'events.log');
+const COUNTER_PATH = join(STATE_DIR, '.event-counter');
+const ARCHIVE_DIR = join(STATE_DIR, 'event-archives');
+const MAX_AGE_DAYS = 30;
+
+// Ensure directories exist
+if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+
+// Read stdin for hook input
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const hookData = JSON.parse(input);
+
+    // Debounce: only fire every 3rd tool use
+    let counter = 0;
+    try {
+      counter = parseInt(readFileSync(COUNTER_PATH, 'utf-8').trim(), 10) || 0;
+    } catch { /* first run */ }
+
+    counter++;
+    writeFileSync(COUNTER_PATH, String(counter));
+
+    if (counter % 3 !== 0) {
+      process.exit(0); // Skip this invocation
+    }
+
+    // Build log entry
+    const entry = {
+      timestamp: new Date().toISOString(),
+      event_type: 'tool_use',
+      tool_name: hookData.tool_name || 'unknown',
+      tool_input_keys: hookData.tool_input ? Object.keys(hookData.tool_input) : [],
+      session_id: process.env.CLAUDE_SESSION_ID || 'unknown',
+      skill_context: detectSkillContext(hookData),
+    };
+
+    // Append JSONL
+    appendFileSync(LOG_PATH, JSON.stringify(entry) + '\n');
+
+    // Log rotation: check once per 100 writes
+    if (counter % 100 === 0) {
+      rotateOldEntries();
+    }
+
+  } catch (e) {
+    // Never crash — logging failure should not block execution
+    process.exit(0);
+  }
+});
+
+function detectSkillContext(hookData) {
+  const toolName = hookData.tool_name || '';
+  if (toolName === 'Skill') return hookData.tool_input?.skill || 'unknown-skill';
+  if (toolName === 'Agent') return 'agent-dispatch';
+  return null;
+}
+
+function rotateOldEntries() {
+  try {
+    if (!existsSync(LOG_PATH)) return;
+
+    const lines = readFileSync(LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+    const cutoff = Date.now() - (MAX_AGE_DAYS * 24 * 60 * 60 * 1000);
+
+    const recent = [];
+    const archived = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (new Date(entry.timestamp).getTime() > cutoff) {
+          recent.push(line);
+        } else {
+          archived.push(line);
+        }
+      } catch {
+        recent.push(line); // Keep unparseable lines
+      }
+    }
+
+    if (archived.length > 0) {
+      if (!existsSync(ARCHIVE_DIR)) mkdirSync(ARCHIVE_DIR, { recursive: true });
+      const archivePath = join(ARCHIVE_DIR, `events-${new Date().toISOString().slice(0, 10)}.log`);
+      appendFileSync(archivePath, archived.join('\n') + '\n');
+      writeFileSync(LOG_PATH, recent.join('\n') + (recent.length > 0 ? '\n' : ''));
+    }
+  } catch {
+    // Rotation failure is non-critical
+  }
+}

package/hooks/ftm-install-hooks.sh

@@ -0,0 +1,240 @@
+#!/bin/bash
+# ftm-install-hooks.sh
+# Installs all ftm-*.sh hooks into ~/.claude/hooks/ and updates settings.json
+#
+# Usage: bash hooks/ftm-install-hooks.sh [--dry-run]
+#
+# What it does:
+#   1. Copies all ftm-*.sh hooks to ~/.claude/hooks/
+#   2. Makes all hooks executable
+#   3. Updates ~/.claude/settings.json with correct hook entries
+#      - Removes old eng-buddy hook entries
+#      - Adds ftm- prefixed hook entries
+#      - Ensures SessionEnd hooks are in SEPARATE matcher entries
+#        (ftm-session-snapshot.sh first, ftm-session-end.sh second)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HOOKS_DEST="$HOME/.claude/hooks"
+SETTINGS_FILE="$HOME/.claude/settings.json"
+DRY_RUN=false
+
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=true ;;
+  esac
+done
+
+log() { echo "[ftm-install-hooks] $*"; }
+dry() { echo "[DRY RUN] $*"; }
+
+# --- Step 1: Copy hooks ---
+log "Copying ftm-*.sh hooks to $HOOKS_DEST"
+mkdir -p "$HOOKS_DEST"
+
+for hook in "$SCRIPT_DIR"/ftm-*.sh; do
+  name="$(basename "$hook")"
+  dest="$HOOKS_DEST/$name"
+  if [ "$DRY_RUN" = true ]; then
+    dry "cp $hook -> $dest"
+  else
+    cp "$hook" "$dest"
+    chmod +x "$dest"
+    log "  installed $name"
+  fi
+done
+
+# Also install non-sh ftm hooks if present (e.g., .mjs)
+for hook in "$SCRIPT_DIR"/ftm-*.mjs; do
+  [ -f "$hook" ] || continue
+  name="$(basename "$hook")"
+  dest="$HOOKS_DEST/$name"
+  if [ "$DRY_RUN" = true ]; then
+    dry "cp $hook -> $dest"
+  else
+    cp "$hook" "$dest"
+    log "  installed $name"
+  fi
+done
+
+# --- Step 2: Update settings.json ---
+if [ ! -f "$SETTINGS_FILE" ]; then
+  log "ERROR: $SETTINGS_FILE not found — cannot update hook entries"
+  exit 1
+fi
+
+log "Updating $SETTINGS_FILE hook entries"
+
+if [ "$DRY_RUN" = true ]; then
+  dry "Would update settings.json:"
+  dry "  - Remove eng-buddy hook entries"
+  dry "  - Add ftm-auto-log.sh to UserPromptSubmit"
+  dry "  - Add ftm-pre-compaction.sh to UserPromptSubmit"
+  dry "  - Add ftm-post-compaction.sh to UserPromptSubmit"
+  dry "  - Add ftm-learning-capture.sh to PostToolUse"
+  dry "  - Add ftm-session-snapshot.sh to SessionEnd (matcher entry 1)"
+  dry "  - Add ftm-session-end.sh to SessionEnd (matcher entry 2, separate)"
+  exit 0
+fi
+
+python3 - "$SETTINGS_FILE" << 'PYEOF'
+import json, sys, copy
+from pathlib import Path
+
+settings_path = sys.argv[1]
+hooks_dir = str(Path.home() / ".claude/hooks")
+
+with open(settings_path) as f:
+    settings = json.load(f)
+
+hooks = settings.setdefault("hooks", {})
+
+# Helper: remove hooks by command substring
+def remove_hook_commands(hook_list, substrings):
+    """Remove hook entries whose command contains any of the given substrings."""
+    result = []
+    for entry in hook_list:
+        hooks_in_entry = entry.get("hooks", [])
+        filtered = [
+            h for h in hooks_in_entry
+            if not any(s in h.get("command", "") for s in substrings)
+        ]
+        if filtered:
+            entry = dict(entry)
+            entry["hooks"] = filtered
+            result.append(entry)
+    return result
+
+ENG_BUDDY_HOOKS = [
+    "eng-buddy-auto-log",
+    "eng-buddy-draft-enforcer",
+    "eng-buddy-learning-capture",
+    "eng-buddy-session-snapshot",
+    "eng-buddy-session-end",
+    "eng-buddy-pre-compaction",
+    "eng-buddy-post-compaction",
+    "eng-buddy-task-sync",
+    "eng-buddy-session-manager",
+]
+
+# --- Clean eng-buddy entries from all hook events ---
+for event in list(hooks.keys()):
+    hooks[event] = remove_hook_commands(hooks[event], ENG_BUDDY_HOOKS)
+
+# --- UserPromptSubmit: add ftm hooks to existing matcher-less entry (or create one) ---
+ups_hooks = hooks.setdefault("UserPromptSubmit", [])
+
+FTM_UPS_COMMANDS = [
+    f"{hooks_dir}/ftm-auto-log.sh",
+    f"{hooks_dir}/ftm-pre-compaction.sh",
+    f"{hooks_dir}/ftm-post-compaction.sh",
+]
+
+# Find the first matcher-less (global) entry
+global_entry = None
+for entry in ups_hooks:
+    if not entry.get("matcher"):
+        global_entry = entry
+        break
+
+if global_entry is None:
+    global_entry = {"hooks": []}
+    ups_hooks.insert(0, global_entry)
+
+existing_cmds = {h["command"] for h in global_entry["hooks"]}
+for cmd in FTM_UPS_COMMANDS:
+    if cmd not in existing_cmds:
+        global_entry["hooks"].append({"type": "command", "command": cmd})
+
+# --- PostToolUse: add ftm-learning-capture to existing global entry ---
+ptu_hooks = hooks.setdefault("PostToolUse", [])
+
+FTM_PTU_COMMANDS = [
+    f"{hooks_dir}/ftm-learning-capture.sh",
+]
+
+# Find global (no matcher or empty matcher) PostToolUse entry
+ptu_global = None
+for entry in ptu_hooks:
+    matcher = entry.get("matcher", "")
+    if not matcher:
+        ptu_global = entry
+        break
+
+if ptu_global is None:
+    ptu_global = {"hooks": []}
+    ptu_hooks.insert(0, ptu_global)
+
+existing_ptu_cmds = {h["command"] for h in ptu_global["hooks"]}
+for cmd in FTM_PTU_COMMANDS:
+    if cmd not in existing_ptu_cmds:
+        ptu_global["hooks"].insert(0, {"type": "command", "command": cmd})
+
+# --- SessionEnd: ensure snapshot and end are in SEPARATE matcher entries ---
+# Snapshot must complete before end (snapshot reads context.json status; end modifies it)
+se_hooks = hooks.setdefault("SessionEnd", [])
+
+SNAPSHOT_CMD = f"{hooks_dir}/ftm-session-snapshot.sh"
+END_CMD = f"{hooks_dir}/ftm-session-end.sh"
+
+# Check if already present
+has_snapshot = any(
+    any(h.get("command") == SNAPSHOT_CMD for h in e.get("hooks", []))
+    for e in se_hooks
+)
+has_end = any(
+    any(h.get("command") == END_CMD for h in e.get("hooks", []))
+    for e in se_hooks
+)
+
+# Remove any combined entry that has both (shouldn't happen but clean up if so)
+cleaned_se = []
+for entry in se_hooks:
+    cmds = [h.get("command", "") for h in entry.get("hooks", [])]
+    if SNAPSHOT_CMD in cmds and END_CMD in cmds:
+        # Split into two separate entries
+        snap_hooks = [h for h in entry["hooks"] if h.get("command") != END_CMD]
+        end_hooks = [h for h in entry["hooks"] if h.get("command") == END_CMD]
+        other_hooks = [h for h in entry["hooks"] if h.get("command") not in (SNAPSHOT_CMD, END_CMD)]
+        if snap_hooks or other_hooks:
+            cleaned_se.append({"hooks": snap_hooks + other_hooks})
+        if end_hooks:
+            cleaned_se.append({"hooks": end_hooks})
+        has_snapshot = True
+        has_end = True
+    else:
+        cleaned_se.append(entry)
+se_hooks[:] = cleaned_se
+
+# Add snapshot entry (first)
+if not has_snapshot:
+    se_hooks.insert(0, {"hooks": [{"type": "command", "command": SNAPSHOT_CMD}]})
+
+# Add end entry (separate, after snapshot)
+if not has_end:
+    # Find position of snapshot entry and insert end after it
+    snap_idx = next(
+        (i for i, e in enumerate(se_hooks)
+         if any(h.get("command") == SNAPSHOT_CMD for h in e.get("hooks", []))),
+        -1
+    )
+    insert_pos = snap_idx + 1 if snap_idx >= 0 else len(se_hooks)
+    se_hooks.insert(insert_pos, {"hooks": [{"type": "command", "command": END_CMD}]})
+
+with open(settings_path, "w") as f:
+    json.dump(settings, f, indent=2)
+    f.write("\n")
+
+print("settings.json updated successfully")
+PYEOF
+
+log "Hook installation complete."
+log ""
+log "Installed hooks:"
+for hook in "$HOOKS_DEST"/ftm-*.sh; do
+  [ -f "$hook" ] || continue
+  echo "  $(basename "$hook")"
+done
+log ""
+log "Verify with: ls $HOOKS_DEST/ftm-*.sh | wc -l"

package/hooks/ftm-learning-capture.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# ftm-learning-capture.sh
+# Hook: Capture write/task completions into learning engine DB
+# Trigger: PostToolUse
+#
+# Behavior:
+# - Runs only for active ftm sessions (context.json has non-completed task)
+# - Captures Write/Edit/Bash/task-style MCP completions into learning events
+# - Routes known categories into knowledge files via brain.py if available
+# - If category mapping is unknown, asks Claude to confirm category expansion
+
+set -euo pipefail
+
+FTM_STATE="$HOME/.claude/ftm-state"
+CONTEXT_JSON="$FTM_STATE/blackboard/context.json"
+
+PAYLOAD=$(cat)
+if [ -z "$PAYLOAD" ]; then
+  exit 0
+fi
+
+HOOK_EVENT=$(printf '%s' "$PAYLOAD" | python3 -c '
+import json, sys
+try:
+    print(json.load(sys.stdin).get("hook_event_name", ""))
+except Exception:
+    print("")
+' 2>/dev/null)
+
+if [ "$HOOK_EVENT" != "PostToolUse" ]; then
+  exit 0
+fi
+
+TOOL_NAME=$(printf '%s' "$PAYLOAD" | python3 -c '
+import json, sys
+try:
+    print(json.load(sys.stdin).get("tool_name", ""))
+except Exception:
+    print("")
+' 2>/dev/null)
+
+case "$TOOL_NAME" in
+  Write|Edit|MultiEdit|NotebookEdit|Bash|Task|mcp__*) ;;
+  *) exit 0 ;;
+esac
+
+# Session gating: check if context.json has an active (non-completed) session
+IS_FTM_ACTIVE=$(python3 -c "
+import json, sys
+try:
+    with open('$CONTEXT_JSON') as f:
+        d = json.load(f)
+    task = d.get('current_task', {})
+    status = task.get('status', '')
+    print('1' if status not in ('', 'completed', 'none') else '0')
+except Exception:
+    print('0')
+" 2>/dev/null)
+
+if [ "$IS_FTM_ACTIVE" != "1" ]; then
+  exit 0
+fi
+
+# Attempt brain.py capture if available (ftm skill may ship its own brain.py)
+BRAIN_PY="$HOME/.claude/skills/ftm/bin/brain.py"
+if [ ! -f "$BRAIN_PY" ]; then
+  BRAIN_PY="$HOME/.claude/ftm-state/brain.py"
+fi
+
+if [ -f "$BRAIN_PY" ]; then
+  RESULT=$(printf '%s' "$PAYLOAD" | python3 "$BRAIN_PY" --capture-post-tool 2>/dev/null || echo '{"recorded": false}')
+
+  NEEDS_EXPANSION=$(printf '%s' "$RESULT" | python3 -c '
+import json, sys
+try:
+    print("1" if json.load(sys.stdin).get("needs_category_expansion") else "0")
+except Exception:
+    print("0")
+' 2>/dev/null)
+
+  if [ "$NEEDS_EXPANSION" = "1" ]; then
+    PROPOSED_CATEGORY=$(printf '%s' "$RESULT" | python3 -c '
+import json, sys
+try:
+    print(json.load(sys.stdin).get("proposed_category", "new-category"))
+except Exception:
+    print("new-category")
+' 2>/dev/null)
+
+    SAFE_PROPOSED=$(printf '%s' "$PROPOSED_CATEGORY" | tr -cd '[:alnum:]-_')
+    if [ -z "$SAFE_PROPOSED" ]; then
+      SAFE_PROPOSED="new-category"
+    fi
+
+    echo ""
+    echo "[Learning Engine] Captured a completion event that does not match an existing learning category."
+    echo "Before wrapping up, ask the user:"
+    echo "\"Should we add learning category '$SAFE_PROPOSED' so future ftm completions route cleanly?\""
+    echo ""
+  fi
+fi
+
+# --- Feed Playbook Tracer if active trace exists ---
+ACTIVE_TRACE_FILE="$FTM_STATE/.active-trace-id"
+if [ -f "$ACTIVE_TRACE_FILE" ] && [ -f "$BRAIN_PY" ]; then
+    TRACE_ID=$(cat "$ACTIVE_TRACE_FILE")
+    printf '%s' "$PAYLOAD" | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+tool_name = d.get('tool_name', '')
+if tool_name:
+    event = {'trace_id': '$TRACE_ID', 'event': {'type': 'tool_call', 'tool': tool_name, 'params': d.get('tool_input', {})}}
+    json.dump(event, sys.stdout)
+" 2>/dev/null | python3 "$BRAIN_PY" --playbook-trace-event 2>/dev/null
+fi
+
+exit 0