@yun520-1/heartflow 0.15.2 → 0.16.0

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

@@ -1,174 +0,0 @@
-#!/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

@@ -1,292 +0,0 @@
-#!/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

@@ -1,130 +0,0 @@
-#!/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()