@suwujs/codex-vault 0.7.0 → 0.7.2

package/vault/.codex-vault/hooks/claude/classify-message.py

@@ -1,305 +0,0 @@
-#!/usr/bin/env python3
-"""Classify user messages and inject routing hints — Claude Code version.
-
-Lightweight version: 5 core signals + session-end vault integrity check.
-Outputs hookSpecificOutput with systemMessage for Claude Code terminal display.
-"""
-import json
-import os
-import subprocess
-import sys
-import re
-from pathlib import Path
-
-
-SIGNALS = [
-    {
-        "name": "DECISION",
-        "skill": "/dump",
-        "message": "DECISION detected — suggest the user run /dump to capture this decision",
-        "auto_message": "DECISION detected — execute /dump now to capture this decision from the user's message",
-        "patterns": [
-            "decided", "deciding", "decision", "we chose", "agreed to",
-            "let's go with", "the call is", "we're going with",
-        ],
-    },
-    {
-        "name": "WIN",
-        "skill": "/dump",
-        "message": "WIN detected — suggest the user run /dump to record this achievement",
-        "auto_message": "WIN detected — execute /dump now to record this achievement from the user's message",
-        "patterns": [
-            "achieved", "won", "praised",
-            "kudos", "shoutout", "great feedback", "recognized",
-        ],
-    },
-    {
-        "name": "PROJECT UPDATE",
-        "skill": "/dump",
-        "message": "PROJECT UPDATE detected — suggest the user run /dump to log this progress",
-        "auto_message": "PROJECT UPDATE detected — execute /dump now to log this progress from the user's message",
-        "patterns": [
-            "project update", "sprint", "milestone",
-            "shipped", "shipping", "launched", "launching",
-            "completed", "completing", "released", "releasing",
-            "deployed", "deploying",
-            "went live", "rolled out", "merged", "cut the release",
-        ],
-    },
-    {
-        "name": "QUERY",
-        "skill": "/recall",
-        "message": "QUERY detected — suggest the user run /recall to check existing knowledge first",
-        "auto_message": "QUERY detected — execute /recall now to search vault for relevant information before answering",
-        "patterns": [
-            "what is", "how does", "why did", "compare", "analyze",
-            "explain the", "what's the difference", "summarize the",
-            "relationship between",
-        ],
-    },
-    {
-        "name": "INGEST",
-        "skill": "/ingest",
-        "message": "INGEST detected — suggest the user run /ingest to process the source",
-        "auto_message": "INGEST detected — execute /ingest now to process the source from the user's message",
-        "patterns": [
-            "ingest", "process this", "read this article",
-            "summarize this", "new source", "clip this", "web clip",
-        ],
-    },
-]
-
-SESSION_END_PATTERNS = [
-    "wrap up", "wrapping up", "that's all", "that's it",
-    "done for now", "done for today", "i'm done", "call it a day",
-    "end session", "bye", "goodbye", "good night", "see you",
-    "结束", "收工", "今天到这", "就这样",
-]
-
-
-def _match(patterns, text):
-    for phrase in patterns:
-        if re.search(r'(?<![a-zA-Z])' + re.escape(phrase) + r'(?![a-zA-Z])', text):
-            return True
-    return False
-
-
-def _find_vault_root():
-    """Find vault root from CWD — check for Home.md/brain/, then vault/ subdir."""
-    cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
-    if os.path.isfile(os.path.join(cwd, "Home.md")) or os.path.isdir(os.path.join(cwd, "brain")):
-        return cwd
-    vault_sub = os.path.join(cwd, "vault")
-    if os.path.isdir(vault_sub) and (
-        os.path.isfile(os.path.join(vault_sub, "Home.md")) or
-        os.path.isdir(os.path.join(vault_sub, "brain"))
-    ):
-        return vault_sub
-    return None
-
-
-def _read_mode():
-    """Read classify mode from vault config. Default: suggest."""
-    vault_root = _find_vault_root()
-    if not vault_root:
-        return "suggest"
-    config_path = os.path.join(vault_root, ".codex-vault", "config.json")
-    try:
-        with open(config_path) as f:
-            config = json.load(f)
-        mode = config.get("classify_mode", "suggest")
-        if mode in ("suggest", "auto"):
-            return mode
-    except (OSError, ValueError, KeyError):
-        pass
-    return "suggest"
-
-
-def _get_changed_files(vault_root):
-    """Get list of changed/new .md files relative to vault root."""
-    files = set()
-    try:
-        # Staged + unstaged changes
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "HEAD"],
-            capture_output=True, text=True, cwd=vault_root, timeout=5,
-        )
-        for f in result.stdout.strip().splitlines():
-            if f.endswith(".md"):
-                files.add(f)
-
-        # Untracked files
-        result = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"],
-            capture_output=True, text=True, cwd=vault_root, timeout=5,
-        )
-        for f in result.stdout.strip().splitlines():
-            if f.endswith(".md"):
-                files.add(f)
-    except Exception:
-        pass
-    return files
-
-
-def _check_vault_integrity(vault_root):
-    """Check for common memory-write omissions."""
-    warnings = []
-    changed = _get_changed_files(vault_root)
-    if not changed:
-        return warnings
-
-    # Check 1: New work notes but Index.md not updated
-    new_work = [f for f in changed if f.startswith("work/active/") and f != "work/Index.md"]
-    index_updated = "work/Index.md" in changed
-    if new_work and not index_updated:
-        names = ", ".join(os.path.basename(f).replace(".md", "") for f in new_work)
-        warnings.append(f"New work notes ({names}) but work/Index.md not updated")
-
-    # Check 2: Decision content written but brain/Key Decisions.md not updated
-    decision_keywords = ["decided", "decision", "agreed to", "we chose", "the call is"]
-    brain_decisions_updated = "brain/Key Decisions.md" in changed
-    if not brain_decisions_updated:
-        for f in changed:
-            if f.endswith(".md") and not f.startswith("brain/"):
-                try:
-                    content = Path(os.path.join(vault_root, f)).read_text(encoding="utf-8").lower()
-                    if any(kw in content for kw in decision_keywords):
-                        warnings.append(
-                            f"'{f}' contains decision content but brain/Key Decisions.md not updated"
-                        )
-                        break
-                except Exception:
-                    pass
-
-    # Check 3: Pattern content written but brain/Patterns.md not updated
-    pattern_keywords = ["pattern", "convention", "always do", "never do", "recurring"]
-    brain_patterns_updated = "brain/Patterns.md" in changed
-    if not brain_patterns_updated:
-        for f in changed:
-            if f.endswith(".md") and not f.startswith("brain/"):
-                try:
-                    content = Path(os.path.join(vault_root, f)).read_text(encoding="utf-8").lower()
-                    if any(kw in content for kw in pattern_keywords):
-                        warnings.append(
-                            f"'{f}' contains pattern content but brain/Patterns.md not updated"
-                        )
-                        break
-                except Exception:
-                    pass
-
-    # Check 4: operation log not updated after significant changes
-    log_updated = "log.md" in changed
-    significant_changes = len([f for f in changed
-                               if f.startswith(("work/", "reference/", "brain/"))]) >= 2
-    if significant_changes and not log_updated:
-        warnings.append("Multiple vault changes but log.md not updated")
-
-    return warnings
-
-
-def classify(prompt, mode="suggest"):
-    p = prompt.lower()
-    key = "auto_message" if mode == "auto" else "message"
-    return [s[key] for s in SIGNALS if _match(s["patterns"], p)]
-
-
-def is_session_end(prompt):
-    p = prompt.lower()
-    return _match(SESSION_END_PATTERNS, p)
-
-
-def main():
-    try:
-        input_data = json.load(sys.stdin)
-    except (ValueError, EOFError, OSError):
-        sys.exit(0)
-
-    prompt = input_data.get("prompt", "")
-    if not isinstance(prompt, str) or not prompt:
-        sys.exit(0)
-
-    signal_messages = []
-    session_end_messages = []
-
-    try:
-        mode = _read_mode()
-
-        # Regular signal classification
-        signals = classify(prompt, mode)
-        signal_messages.extend(signals)
-
-        # Session-end check (always suggest mode — never auto-execute wrap-up)
-        if is_session_end(prompt):
-            vault_root = _find_vault_root()
-            if vault_root:
-                integrity_warnings = _check_vault_integrity(vault_root)
-                if integrity_warnings:
-                    session_end_messages.append(
-                        "SESSION END — vault integrity check found issues:\n"
-                        + "\n".join(f"  - {w}" for w in integrity_warnings)
-                        + "\nFix these before wrapping up."
-                    )
-                else:
-                    session_end_messages.append("SESSION END — vault integrity check passed.")
-    except Exception:
-        sys.exit(0)
-
-    parts = []
-
-    if signal_messages:
-        hints = "\n".join(f"- {s}" for s in signal_messages)
-        if mode == "auto":
-            parts.append(
-                "Auto-execute the following skills based on user intent:\n"
-                + hints
-                + "\n\nExecute the skill immediately with the user's message as input. Do not ask for confirmation."
-            )
-        else:
-            parts.append(
-                "Skill suggestions (do NOT auto-execute — suggest the skill to the user and let them decide):\n"
-                + hints
-                + "\n\nWait for the user to invoke the skill. Do not create vault notes without explicit user action."
-            )
-
-    if session_end_messages:
-        hints = "\n".join(f"- {s}" for s in session_end_messages)
-        parts.append(
-            "Skill suggestions (do NOT auto-execute — suggest the skill to the user and let them decide):\n"
-            + hints
-            + "\n\nWait for the user to invoke the skill. Do not create vault notes without explicit user action."
-        )
-
-    if parts:
-        context = "\n\n".join(parts)
-
-        # Build feedback label
-        matched = [s for s in SIGNALS if _match(s["patterns"], prompt.lower())]
-        feedback_parts = []
-        for s in matched:
-            feedback_parts.append(f"{s['name']} → {s['skill']}")
-        if is_session_end(prompt):
-            feedback_parts.append("SESSION END → /wrap-up")
-        icon = "\U0001f504" if mode == "auto" else "\U0001f4a1"
-        label = ", ".join(feedback_parts) if feedback_parts else "intent detected"
-
-        # Hook trigger notification
-        print(f"  {icon} vault: {label}")
-
-        output = {
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": context
-            },
-            "systemMessage": f"{icon} vault: {label}"
-        }
-        json.dump(output, sys.stdout)
-        sys.stdout.flush()
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception:
-        sys.exit(0)

package/vault/.codex-vault/hooks/claude/session-start.py

@@ -1,383 +0,0 @@
-#!/usr/bin/env python3
-"""Session-start hook for Claude Code — injects vault context into the agent's prompt.
-
-Outputs structured JSON: additionalContext for LLM, systemMessage for terminal.
-
-Dynamic context: adapts git log window, reads full North Star,
-shows all active work, and includes uncommitted changes.
-"""
-import json
-import os
-import re
-import subprocess
-import sys
-from collections import Counter
-from datetime import datetime
-from pathlib import Path
-
-
-def _find_vault_root():
-    """Find vault root from CWD — check for Home.md/brain/, then vault/ subdir."""
-    cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
-    if os.path.isfile(os.path.join(cwd, "Home.md")) or os.path.isdir(os.path.join(cwd, "brain")):
-        return cwd
-    vault_sub = os.path.join(cwd, "vault")
-    if os.path.isdir(vault_sub) and (
-        os.path.isfile(os.path.join(vault_sub, "Home.md")) or
-        os.path.isdir(os.path.join(vault_sub, "brain"))
-    ):
-        return vault_sub
-    return None
-
-
-def _run_git(args, cwd, timeout=5):
-    """Run git command and return stdout lines."""
-    try:
-        result = subprocess.run(
-            ["git"] + args,
-            capture_output=True, text=True, cwd=cwd, timeout=timeout,
-        )
-        return result.stdout.strip().splitlines() if result.stdout.strip() else []
-    except Exception:
-        return []
-
-
-def _git_log_oneline(cwd, since=None, max_count=None):
-    """Get git log --oneline entries."""
-    args = ["log", "--oneline", "--no-merges"]
-    if since:
-        args.append(f"--since={since}")
-    if max_count:
-        args.extend(["-n", str(max_count)])
-    return _run_git(args, cwd)
-
-
-def _git_status_short(cwd):
-    """Get git status --short output."""
-    return _run_git(["status", "--short", "--", "."], cwd)
-
-
-def _read_file(path):
-    """Read file content, return empty string on error."""
-    try:
-        return Path(path).read_text(encoding="utf-8")
-    except Exception:
-        return ""
-
-
-def _find_md_files(vault_dir):
-    """Find all .md files in vault, excluding non-vault directories."""
-    exclude = {".git", ".obsidian", "thinking", ".claude", ".codex",
-               ".codex-vault", ".codex-mem", "node_modules"}
-    files = []
-    for root, dirs, filenames in os.walk(vault_dir):
-        dirs[:] = [d for d in dirs if d not in exclude]
-        for f in filenames:
-            if f.endswith(".md"):
-                rel = os.path.relpath(os.path.join(root, f), vault_dir)
-                files.append(f"./{rel}")
-    return sorted(files)
-
-
-def _folder_summary(all_files):
-    """Generate folder summary with file counts."""
-    folders = Counter()
-    for f in all_files:
-        parts = f[2:].split("/")  # strip ./
-        folders[parts[0] if len(parts) > 1 else "."] += 1
-    return [f"  {folder}/ ({count} files)"
-            for folder, count in folders.most_common()]
-
-
-def _key_files(all_files):
-    """Filter for key vault files."""
-    pattern = re.compile(
-        r"(Home|Index|North Star|Memories|Key Decisions|Patterns|log)\.md$")
-    return [f for f in all_files if pattern.search(f)]
-
-
-def _mtime_ok(vault_dir, rel_path, cutoff):
-    """Check if file was modified after cutoff timestamp."""
-    try:
-        return os.path.getmtime(os.path.join(vault_dir, rel_path.lstrip("./"))) > cutoff
-    except Exception:
-        return False
-
-
-def _north_star_goal(vault_dir):
-    """Extract first goal from North Star for banner display."""
-    ns_path = os.path.join(vault_dir, "brain", "North Star.md")
-    if not os.path.isfile(ns_path):
-        return None
-    content = _read_file(ns_path)
-    in_focus = False
-    for line in content.splitlines():
-        if re.match(r"^## Current Focus", line):
-            in_focus = True
-            continue
-        if in_focus and line.startswith("## "):
-            break
-        if in_focus and re.match(r"^- .+", line):
-            goal = line[2:].strip()
-            return goal[:40] if goal else None
-    return None
-
-
-# ── Context builder (→ additionalContext for LLM) ──────────────────────
-
-
-def _build_context(vault_dir):
-    lines = []
-    lines.append("## Session Context")
-    lines.append("")
-
-    # Date
-    lines.append("### Date")
-    now = datetime.now()
-    lines.append(f"{now.strftime('%Y-%m-%d')} ({now.strftime('%A')})")
-    lines.append("")
-
-    # North Star — full file
-    lines.append("### North Star")
-    ns_path = os.path.join(vault_dir, "brain", "North Star.md")
-    if os.path.isfile(ns_path):
-        lines.append(_read_file(ns_path))
-    else:
-        lines.append("(No North Star found — create brain/North Star.md to set goals)")
-    lines.append("")
-
-    # Recent changes — adaptive window
-    lines.append("### Recent Changes")
-    commits_48h = _git_log_oneline(vault_dir, since="48 hours ago")
-    if commits_48h:
-        lines.append("(last 48 hours)")
-        lines.extend(commits_48h[:15])
-    else:
-        commits_7d = _git_log_oneline(vault_dir, since="7 days ago")
-        if commits_7d:
-            lines.append("(nothing in 48h — showing last 7 days)")
-            lines.extend(commits_7d[:15])
-        else:
-            lines.append("(nothing recent — showing last 5 commits)")
-            commits = _git_log_oneline(vault_dir, max_count=5)
-            lines.extend(commits if commits else ["(no git history)"])
-    lines.append("")
-
-    # Recent operations from log.md
-    lines.append("### Recent Operations")
-    log_path = os.path.join(vault_dir, "log.md")
-    if os.path.isfile(log_path):
-        entries = [l for l in _read_file(log_path).splitlines()
-                   if l.startswith("## [")]
-        lines.extend(entries[-5:] if entries else ["(no entries in log.md)"])
-    else:
-        lines.append("(no log.md)")
-    lines.append("")
-
-    # Active work
-    lines.append("### Active Work")
-    active_dir = os.path.join(vault_dir, "work", "active")
-    if os.path.isdir(active_dir):
-        work_files = sorted(f for f in os.listdir(active_dir) if f.endswith(".md"))
-        if work_files:
-            for f in work_files:
-                lines.append(f.replace(".md", ""))
-        else:
-            lines.append("(none)")
-    else:
-        lines.append("(no work/active/ directory)")
-    lines.append("")
-
-    # Uncommitted changes
-    lines.append("### Uncommitted Changes")
-    changes = _git_status_short(vault_dir)
-    lines.extend(changes[:20] if changes else ["(working tree clean)"])
-    lines.append("")
-
-    # Recently modified brain files
-    lines.append("### Recently Modified Brain Files")
-    brain_dir = os.path.join(vault_dir, "brain")
-    if os.path.isdir(brain_dir):
-        cutoff = datetime.now().timestamp() - 7 * 86400
-        recent = sorted(
-            f.replace(".md", "")
-            for f in os.listdir(brain_dir)
-            if f.endswith(".md") and os.path.getmtime(os.path.join(brain_dir, f)) > cutoff
-        )
-        if recent:
-            lines.append("(modified in last 7 days)")
-            lines.extend(recent)
-        else:
-            lines.append("(no recent changes)")
-    lines.append("")
-
-    # Vault file listing — tiered
-    lines.append("### Vault Files")
-    all_files = _find_md_files(vault_dir)
-    n = len(all_files)
-
-    if n <= 20:
-        lines.extend(all_files)
-
-    elif n <= 50:
-        hot = [f for f in all_files
-               if not re.match(r"\./sources/|\./work/archive/", f)]
-        cold = n - len(hot)
-        lines.extend(hot)
-        if cold > 0:
-            lines.append("")
-            lines.append(f"(+ {cold} files in sources/ and work/archive/ — use /recall to search)")
-
-    elif n <= 150:
-        lines.append(f"({n} files — showing summary)")
-        lines.append("")
-        lines.extend(_folder_summary(all_files))
-        lines.append("")
-        lines.append("Recently modified (7 days):")
-        cutoff = datetime.now().timestamp() - 7 * 86400
-        recent = [f for f in all_files if _mtime_ok(vault_dir, f, cutoff)]
-        lines.extend(recent if recent else ["  (none)"])
-        lines.append("")
-        lines.append("Key files:")
-        lines.extend(_key_files(all_files))
-
-    else:
-        lines.append(f"({n} files — showing summary)")
-        lines.append("")
-        lines.extend(_folder_summary(all_files))
-        lines.append("")
-        lines.append("Recently modified (3 days):")
-        cutoff = datetime.now().timestamp() - 3 * 86400
-        recent = [f for f in all_files if _mtime_ok(vault_dir, f, cutoff)]
-        lines.extend(recent if recent else ["  (none)"])
-        lines.append("")
-        lines.append("Key files:")
-        lines.extend(_key_files(all_files))
-        lines.append("")
-        lines.append("Use /recall <topic> to search the vault.")
-
-    return "\n".join(lines)
-
-
-# ── ANSI colors (oh-my-codex style) ──────────────────────────────────
-
-RESET = "\x1b[0m"
-BOLD = "\x1b[1m"
-DIM = "\x1b[2m"
-CYAN = "\x1b[36m"
-GREEN = "\x1b[32m"
-YELLOW = "\x1b[33m"
-SEP = f" {DIM}|{RESET} "
-
-
-def _c(code, text):
-    return f"{code}{text}{RESET}"
-
-
-# ── Banner builder (→ systemMessage for terminal) ──────────────────────
-
-
-def _build_banner(vault_dir):
-    # --- Line 1: statusline ---
-    elements = []
-
-    # Git branch
-    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], vault_dir)
-    if branch:
-        elements.append(_c(CYAN, branch[0]))
-
-    # North Star goal
-    goal = _north_star_goal(vault_dir)
-    if goal:
-        elements.append(f"\U0001f3af {goal}")
-    else:
-        elements.append(_c(DIM, "\U0001f3af no goal set"))
-
-    # Active work
-    active_dir = os.path.join(vault_dir, "work", "active")
-    work_files = sorted(
-        f.replace(".md", "")
-        for f in os.listdir(active_dir) if f.endswith(".md")
-    ) if os.path.isdir(active_dir) else []
-    if work_files:
-        names = ", ".join(work_files[:3])
-        suffix = f" +{len(work_files) - 3}" if len(work_files) > 3 else ""
-        elements.append(_c(GREEN, f"active:{len(work_files)}") + _c(DIM, f" {names}{suffix}"))
-    else:
-        elements.append(_c(DIM, "active:0"))
-
-    # Changes
-    changes = _git_status_short(vault_dir)
-    if changes:
-        elements.append(_c(YELLOW, f"changes:{len(changes)}"))
-    else:
-        elements.append(_c(GREEN, "clean"))
-
-    label = _c(BOLD, "[Vault]")
-    statusline = label + " " + SEP.join(elements)
-
-    # --- Line 2+: recent commits ---
-    lines = ["", statusline]
-    commits = _git_log_oneline(vault_dir, since="7 days ago")
-    if not commits:
-        commits = _git_log_oneline(vault_dir, max_count=3)
-    if commits:
-        for c in commits[:3]:
-            # hash in cyan, message in dim
-            parts = c.split(" ", 1)
-            if len(parts) == 2:
-                lines.append(f"  {_c(DIM, parts[0])} {_c(DIM, parts[1])}")
-            else:
-                lines.append(f"  {_c(DIM, c)}")
-
-    # --- Line: vault file count ---
-    all_files = _find_md_files(vault_dir)
-    lines.append(_c(DIM, f"  {len(all_files)} notes"))
-    lines.append("")
-
-    return "\n".join(lines)
-
-
-# ── Main ───────────────────────────────────────────────────────────────
-
-
-def main():
-    vault_dir = _find_vault_root()
-    if not vault_dir:
-        output = {
-            "hookSpecificOutput": {
-                "hookEventName": "SessionStart",
-                "additionalContext": "## Session Context\n\n(No vault found)"
-            }
-        }
-        json.dump(output, sys.stdout)
-        sys.exit(0)
-
-    # Read hook input for session metadata
-    try:
-        event = json.load(sys.stdin)
-    except Exception:
-        event = {}
-
-    context = _build_context(vault_dir)
-    banner = _build_banner(vault_dir)
-
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "SessionStart",
-            "additionalContext": context
-        },
-        "systemMessage": banner
-    }
-
-    json.dump(output, sys.stdout)
-    sys.stdout.flush()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception:
-        # Never block session start
-        sys.exit(0)