@yun520-1/heartflow 0.15.2

package/src/core/cortex-integration/hooks/on_session_start.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Capy Cortex Hook: SessionStart - Morning briefing.
+Injects top anti-patterns, preferences, and principles into every new session.
+Runs ONCE per session start. Must be fast (<200ms)."""
+
+import json
+import sys
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+
+DB_PATH = Path(__file__).parent.parent / "cortex.db"
+
+
+def is_noise_content(content):
+    """Filter out garbage content that shouldn't be injected."""
+    if not content or len(content) > 300:
+        return True
+
+    noise_substrings = [
+        "session is being continued",
+        "Base directory for this skill",
+    ]
+
+    content_lower = content.lower()
+    for noise in noise_substrings:
+        if noise.lower() in content_lower:
+            return True
+
+    # Skip HTML/XML tags
+    if content.strip().startswith("<"):
+        return True
+
+    return False
+
+
+def main():
+    try:
+        data = json.loads(sys.stdin.read())
+    except Exception:
+        data = {}
+
+    if not DB_PATH.exists():
+        return
+
+    try:
+        db = sqlite3.connect(str(DB_PATH))
+        db.row_factory = sqlite3.Row
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA busy_timeout=3000")
+
+        # Get anti-patterns with quality filter
+        all_anti_patterns = db.execute(
+            "SELECT content, severity, confidence FROM anti_patterns "
+            "WHERE confidence >= 0.6 "
+            "ORDER BY severity DESC, confidence DESC LIMIT 20"
+        ).fetchall()
+
+        anti_patterns = [
+            ap for ap in all_anti_patterns
+            if not is_noise_content(ap['content'])
+        ][:5]  # Max 5 after filtering
+
+        # Get preferences with quality filter
+        all_prefs = db.execute(
+            "SELECT content, confidence FROM preferences "
+            "WHERE confidence >= 0.6 "
+            "ORDER BY confidence DESC, occurrences DESC LIMIT 10"
+        ).fetchall()
+
+        prefs = [
+            p for p in all_prefs
+            if not is_noise_content(p['content'])
+        ][:3]  # Max 3 after filtering
+
+        # Get principles with quality filter
+        all_principles = db.execute(
+            "SELECT content, confidence FROM principles "
+            "WHERE confidence >= 0.6 "
+            "ORDER BY confidence DESC LIMIT 15"
+        ).fetchall()
+
+        principles = [
+            p for p in all_principles
+            if not is_noise_content(p['content'])
+        ][:5]  # Max 5 after filtering
+
+        # Get metadata for header
+        rule_count = db.execute(
+            "SELECT COUNT(*) FROM rules WHERE maturity != 'deprecated'"
+        ).fetchone()[0]
+
+        last_maintenance = db.execute(
+            "SELECT value FROM meta WHERE key = 'last_maintenance'"
+        ).fetchone()
+
+        maintenance_date = "unknown"
+        if last_maintenance and last_maintenance['value']:
+            try:
+                dt = datetime.fromisoformat(last_maintenance['value'])
+                maintenance_date = dt.strftime("%Y-%m-%d")
+            except Exception:
+                pass
+
+        # Phase 4E: Detect topics from workspace path
+        detected_topics = []
+        cwd = data.get("cwd", "")
+        try:
+            import importlib.util
+            te_path = Path(__file__).resolve().parent.parent / "scripts" / "topic_engine.py"
+            # SECURITY: validate resolved path stays within HeartFlow's scripts directory
+            # to prevent any path traversal risk from cwd being set to unexpected locations
+            if te_path.resolve().parent != (Path(__file__).resolve().parent.parent):
+                te_path = None
+            if te_path and te_path.exists():
+                spec = importlib.util.spec_from_file_location("topic_engine", str(te_path))
+                if spec is not None and spec.loader is not None:
+                    te = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(te)  # noqa: S322
+                    detected_topics = te.detect_topics_fast(cwd, file_paths=[cwd])
+        except Exception:
+            pass
+
+        # Log session start event with detected topics
+        db.execute(
+            "INSERT INTO events (event_type, metadata) VALUES (?, ?)",
+            ("session_start", json.dumps({
+                "session_id": data.get("session_id", ""),
+                "cwd": cwd,
+                "detected_topics": detected_topics,
+            }))
+        )
+        db.commit()
+        db.close()
+
+        lines = []
+        if anti_patterns or prefs or principles:
+            lines.append("## Cortex v3: Knowledge")
+            lines.append(f"({rule_count} rules, last maintained: {maintenance_date})\n")
+
+        if anti_patterns:
+            lines.append("### NEVER DO (learned from past mistakes)")
+            for ap in anti_patterns:
+                lines.append(f"- [{ap['severity'].upper()}] {ap['content']}")
+            lines.append("")
+
+        if prefs:
+            lines.append("### User Preferences")
+            for p in prefs:
+                lines.append(f"- {p['content']}")
+            lines.append("")
+
+        if principles:
+            lines.append("### Principles (distilled from experience)")
+            for p in principles:
+                lines.append(f"- {p['content']}")
+            lines.append("")
+
+        if lines:
+            context = "\n".join(lines)
+            output = {
+                "hookSpecificOutput": {
+                    "hookEventName": "SessionStart",
+                    "additionalContext": context
+                }
+            }
+            print(json.dumps(output))
+
+    except Exception:
+        pass  # Hooks must NEVER crash
+
+
+if __name__ == "__main__":
+    main()

package/src/core/cortex-integration/hooks/on_tool_failure.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""Capy Cortex Hook: PostToolUseFailure - Pain reflex.
+Records actionable tool failures as error patterns. Runs async (non-blocking)."""
+
+import json
+import sys
+import sqlite3
+import re
+from pathlib import Path
+
+DB_PATH = Path(__file__).parent.parent / "cortex.db"
+
+# Tools to skip - errors from these are not actionable
+SKIP_TOOLS = {"TaskOutput", "Read"}
+
+# Error pattern extractors with categories
+ERROR_PATTERNS = [
+    # npm/yarn dependency errors
+    (r"(?:npm|yarn) ERR.*?(?:ERESOLVE|peer dep|conflict)", "dependency_error",
+     "npm dependency resolution: use --legacy-peer-deps or resolve version conflicts"),
+    (r"Cannot find module ['\"]([^'\"]+)['\"]", "dependency_error",
+     lambda m: f"Missing Node.js module '{m.group(1)}': run npm install"),
+    (r"ModuleNotFoundError: No module named ['\"]([^'\"]+)['\"]", "dependency_error",
+     lambda m: f"Missing Python module '{m.group(1)}': run pip install"),
+
+    # File system errors
+    (r"(?:No such file or directory|ENOENT).*?['\"]([^'\"]+)['\"]", "file_not_found",
+     lambda m: f"File not found: verify path exists: {m.group(1)}"),
+    (r"(?:Permission denied|EACCES)", "permission_denied",
+     "Permission denied: check file permissions or run with appropriate access"),
+    (r"(?:EEXIST|File exists)", "file_exists",
+     "File already exists: remove existing file or use different path"),
+
+    # Compilation errors
+    (r"(?:SyntaxError|ParseError|Unexpected token)", "syntax_error",
+     "Syntax error: review code for syntax issues"),
+    (r"TypeError: .* is not a function", "type_error",
+     "Type error: verify function exists and is callable"),
+    (r"ReferenceError: (\\w+) is not defined", "reference_error",
+     lambda m: f"Undefined reference: '{m.group(1)}' not declared"),
+    (r"(?:compilation failed|build error|compile error)", "compilation_error",
+     "Compilation failed: review error output for specific issues"),
+
+    # Network errors
+    (r"(?:ECONNREFUSED|Connection refused|ETIMEDOUT)", "network_error",
+     "Network connection failed: verify service is running and accessible"),
+    (r"(?:getaddrinfo|DNS lookup failed|EAI_AGAIN)", "network_error",
+     "DNS resolution failed: check network connectivity"),
+    (r"(?:404|Not Found|HTTP.*?404)", "network_error",
+     "HTTP 404: verify URL endpoint exists"),
+    (r"(?:401|403|Unauthorized|Forbidden)", "auth_error",
+     "Authentication failed: verify credentials or permissions"),
+
+    # Git errors
+    (r"fatal: (?:not a git repository|Not a git repository)", "git_error",
+     "Not a git repository: initialize git or run from git root"),
+    (r"error: Your local changes.*?would be overwritten", "git_error",
+     "Git conflict: commit or stash local changes before merge/checkout"),
+    (r"fatal: remote.*?already exists", "git_error",
+     "Git remote exists: use different name or update existing remote"),
+
+    # Database errors
+    (r"(?:OperationalError|database is locked)", "database_error",
+     "Database locked: close other connections or retry"),
+    (r"(?:IntegrityError|UNIQUE constraint failed)", "database_error",
+     "Database integrity violation: check for duplicate entries"),
+
+    # Port/socket errors
+    (r"(?:EADDRINUSE|address already in use).*?port (\\d+)", "port_conflict",
+     lambda m: f"Port {m.group(1)} already in use: stop existing service or use different port"),
+
+    # Memory/resource errors
+    (r"(?:OutOfMemoryError|heap out of memory|Cannot allocate memory)", "resource_error",
+     "Out of memory: reduce memory usage or increase available memory"),
+    (r"(?:EMFILE|too many open files)", "resource_error",
+     "Too many open files: close unused file handles or increase limit"),
+]
+
+
+def normalize_error_text(text):
+    """Remove noise from error text for better pattern matching."""
+    # Remove tool IDs (toolu_bdrk_xxxx)
+    text = re.sub(r"toolu_[a-zA-Z0-9_]+", "", text)
+    # Remove common timestamps
+    text = re.sub(r"\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}", "", text)
+    # Remove hex addresses/hashes
+    text = re.sub(r"0x[0-9a-fA-F]+", "", text)
+    # Remove UUIDs
+    text = re.sub(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", "", text)
+    # Normalize whitespace
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def extract_error_pattern(tool_name, tool_response, tool_input=None):
+    """Extract actionable error pattern from tool response.
+
+    Returns (category, actionable_insight, pattern_key) or None if not actionable.
+    """
+    # Normalize the error text
+    normalized = normalize_error_text(tool_response)
+
+    # Try to match known patterns
+    for pattern_re, category, insight_template in ERROR_PATTERNS:
+        match = re.search(pattern_re, tool_response, re.IGNORECASE | re.DOTALL)
+        if match:
+            # Generate insight (either static string or lambda)
+            if callable(insight_template):
+                insight = insight_template(match)
+            else:
+                insight = insight_template
+
+            # Create pattern key for deduplication (category + normalized pattern)
+            pattern_key = f"{category}:{normalized[:200]}"
+            return category, insight, pattern_key
+
+    # Check for generic exit codes without useful info
+    if re.search(r"Exit code \d+$", tool_response.strip()):
+        return None  # Skip generic exit codes
+
+    # If error is too short or too long, skip
+    if len(normalized) < 10 or len(normalized) > 1000:
+        return None
+
+    return None
+
+
+def find_similar_pattern(db, insight, category):
+    """Check if similar error pattern exists in database.
+    Uses exact content match (fast, indexed) with FTS5 fallback.
+    Returns rule ID if found, None otherwise.
+    """
+    try:
+        # 1. Exact content match (uses unique index)
+        result = db.execute(
+            "SELECT id FROM rules WHERE content = ? LIMIT 1",
+            (insight,)
+        ).fetchone()
+        if result:
+            return result[0]
+
+        # 2. FTS5 fuzzy fallback - match on significant words
+        words = [w for w in insight.lower().split() if len(w) > 4 and w.isalnum()][:5]
+        if words:
+            fts_q = " AND ".join(words)
+            if fts_q:
+                result = db.execute("""
+                    SELECT r.id FROM rules_fts
+                    JOIN rules r ON rules_fts.rowid = r.id
+                    WHERE rules_fts MATCH ? AND r.category = ?
+                    LIMIT 1
+                """, (fts_q, category)).fetchone()
+                if result:
+                    return result[0]
+    except Exception:
+        pass
+    return None
+
+
+def main():
+    try:
+        data = json.loads(sys.stdin.read())
+    except Exception:
+        return
+
+    if not DB_PATH.exists():
+        return
+
+    try:
+        tool_name = data.get("tool_name", "unknown")
+        tool_response = str(data.get("tool_response", ""))
+        session_id = data.get("session_id", "")
+        workspace = data.get("source_workspace", "")
+
+        # Skip non-actionable tools
+        if tool_name in SKIP_TOOLS:
+            return
+
+        # Skip empty responses
+        if not tool_response or len(tool_response.strip()) < 5:
+            return
+
+        tool_input = data.get("tool_input", {})
+        normalized = normalize_error_text(tool_response)
+
+        # Path 1: Regex extraction (fast, <1ms cache for known patterns)
+        result = extract_error_pattern(tool_name, tool_response, tool_input)
+        extraction_method = 'regex'
+        quality_score = 0
+
+        if result:
+            category, insight, pattern_key = result
+        elif len(normalized) >= 30:
+            # Path 2: LLM quality-gated extraction (causal analysis + quality score)
+            try:
+                sys.path.insert(0, str(Path(__file__).parent.parent / "scripts"))
+                from llm_extract import extract_with_quality_gate
+                llm_rule, score = extract_with_quality_gate(
+                    tool_name, tool_input, tool_response, session_id=session_id)
+                if llm_rule:
+                    category = llm_rule['category']
+                    insight = llm_rule['content']
+                    pattern_key = f"llm_v2:{category}:{normalized[:150]}"
+                    extraction_method = 'llm_v2'
+                    quality_score = score
+                else:
+                    return  # Below quality threshold or LLM failed
+            except Exception:
+                return
+        else:
+            return  # Not actionable
+
+        # Store pattern with deduplication
+        db = sqlite3.connect(str(DB_PATH))
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA busy_timeout=3000")
+
+        # Check for existing similar pattern
+        existing_id = find_similar_pattern(db, insight, category)
+
+        if existing_id:
+            # Increment occurrence count
+            db.execute("""
+                UPDATE rules SET
+                    occurrences = occurrences + 1,
+                    last_seen = datetime('now')
+                WHERE id = ?
+            """, (existing_id,))
+        else:
+            # Create new error pattern
+            evidence_json = json.dumps({
+                "pattern_key": pattern_key,
+                "tool": tool_name,
+                "example_response": tool_response[:300]
+            })
+
+            db.execute("""
+                INSERT INTO rules (
+                    content, category, confidence, occurrences,
+                    maturity, harmful_count, source_session, source_workspace,
+                    evidence, quality_score, extraction_method,
+                    created_at, last_seen
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+            """, (insight, category, 0.5, 1, 'candidate', 0, session_id, workspace,
+                  evidence_json, quality_score, extraction_method))
+
+            # Auto-assign topic (Phase 4F)
+            new_rule_id = db.execute("SELECT last_insert_rowid()").fetchone()[0]
+            try:
+                sys.path.insert(0, str(Path(__file__).parent.parent / "scripts"))
+                from topic_engine import detect_topic_for_rule
+                topic = detect_topic_for_rule(insight, category)
+                topic_row = db.execute(
+                    "SELECT id FROM topics WHERE name = ?", (topic,)
+                ).fetchone()
+                if topic_row:
+                    db.execute(
+                        "INSERT OR IGNORE INTO rule_topics (rule_id, topic_id) VALUES (?, ?)",
+                        (new_rule_id, topic_row[0])
+                    )
+                    db.execute(
+                        "UPDATE topics SET rule_count = rule_count + 1 WHERE id = ?",
+                        (topic_row[0],)
+                    )
+            except Exception:
+                pass  # Topic assignment is best-effort
+
+        # Log event
+        db.execute(
+            "INSERT INTO events (event_type, metadata) VALUES (?, ?)",
+            ("tool_failure_pattern", json.dumps({
+                "tool": tool_name,
+                "category": category,
+                "pattern_key": pattern_key[:100]
+            }))
+        )
+
+        db.commit()
+        db.close()
+
+        # Mark TF-IDF as dirty
+        db2 = sqlite3.connect(str(DB_PATH))
+        db2.execute("UPDATE meta SET value = '1' WHERE key = 'tfidf_dirty'")
+        db2.commit()
+        db2.close()
+
+    except Exception:
+        pass  # Hooks must NEVER crash
+
+
+if __name__ == "__main__":
+    main()

package/src/core/cortex-integration/hooks/on_tool_success.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Capy Cortex Hook: PostToolUse - Success credit.
+When tools succeed, credit recently surfaced rules to close the feedback loop.
+This is the MISSING PIECE that makes Cortex actually learn from success."""
+
+import json
+import sys
+import sqlite3
+from pathlib import Path
+
+DB_PATH = Path(__file__).parent.parent / "cortex.db"
+
+# Tools where success is meaningful (skip Read, Glob, Grep - they always "succeed")
+CREDIT_TOOLS = {"Bash", "Write", "Edit", "NotebookEdit"}
+
+# Skip tools that are internal/meta
+SKIP_TOOLS = {"TaskOutput", "TodoWrite", "SendMessage", "AskUserQuestion"}
+
+# Confidence boost per successful credit (small, accumulates over time)
+CONFIDENCE_BOOST = 0.02
+MAX_CONFIDENCE = 0.95
+
+
+def is_success(tool_name, tool_response):
+    """Determine if a tool response indicates success."""
+    if not tool_response:
+        return False
+
+    response_str = str(tool_response)
+
+    # Bash: check for error indicators
+    if tool_name == "Bash":
+        # Explicit failure indicators
+        fail_indicators = [
+            "Exit code", "Error:", "error:", "ENOENT", "EACCES",
+            "Permission denied", "command not found", "No such file",
+            "npm ERR", "ModuleNotFoundError", "SyntaxError",
+            "TypeError", "ReferenceError", "fatal:",
+        ]
+        for indicator in fail_indicators:
+            if indicator in response_str:
+                return False
+        return True
+
+    # Write/Edit: success if no error
+    if tool_name in ("Write", "Edit", "NotebookEdit"):
+        if "error" in response_str.lower() or "failed" in response_str.lower():
+            return False
+        return True
+
+    return True
+
+
+def main():
+    try:
+        data = json.loads(sys.stdin.read())
+    except Exception:
+        return
+
+    if not DB_PATH.exists():
+        return
+
+    try:
+        tool_name = data.get("tool_name", "unknown")
+        tool_response = str(data.get("tool_response", ""))
+        session_id = data.get("session_id", "")
+
+        # Skip non-meaningful tools
+        if tool_name in SKIP_TOOLS:
+            return
+        if tool_name not in CREDIT_TOOLS:
+            return
+
+        # Only credit on success
+        if not is_success(tool_name, tool_response):
+            return
+
+        db = sqlite3.connect(str(DB_PATH))
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA busy_timeout=2000")
+
+        # Find recently surfaced rules for this session (not yet credited)
+        surfaced = db.execute("""
+            SELECT id, rule_id FROM surfaced_rules
+            WHERE session_id = ? AND credited = 0
+            ORDER BY surfaced_at DESC LIMIT 10
+        """, (session_id,)).fetchall()
+
+        if not surfaced:
+            db.close()
+            return
+
+        credited_count = 0
+        for surf_id, rule_id in surfaced:
+            # Increment helpful_count and boost confidence
+            db.execute("""
+                UPDATE rules SET
+                    helpful_count = helpful_count + 1,
+                    confidence = MIN(confidence + ?, ?),
+                    last_seen = datetime('now')
+                WHERE id = ? AND maturity != 'deprecated'
+            """, (CONFIDENCE_BOOST, MAX_CONFIDENCE, rule_id))
+
+            # Mark as credited so we don't double-count
+            db.execute(
+                "UPDATE surfaced_rules SET credited = 1 WHERE id = ?",
+                (surf_id,)
+            )
+            credited_count += 1
+
+        if credited_count > 0:
+            # Log the credit event
+            db.execute(
+                "INSERT INTO events (event_type, metadata) VALUES (?, ?)",
+                ("success_credit", json.dumps({
+                    "session_id": session_id,
+                    "tool": tool_name,
+                    "rules_credited": credited_count,
+                }))
+            )
+
+        db.commit()
+        db.close()
+
+    except Exception:
+        pass  # Hooks must NEVER crash
+
+
+if __name__ == "__main__":
+    main()