aiwcli 0.10.2 → 0.11.0

package/dist/templates/_shared/hooks/archive_plan.py

@@ -1,169 +0,0 @@
-#!/usr/bin/env python3
-"""Plan archival hook for ExitPlanMode PermissionRequest event.
-
-This hook runs when ExitPlanMode is requested (BEFORE user accepts/rejects),
-extracting the plan path from the tool input and archiving it to the
-context's plans/ folder. It does NOT modify state.json plan fields or mode.
-
-Separation of concerns:
-- archive_plan.py (PermissionRequest) -> archives file only, no state.json changes
-- plan_accepted.py (PostToolUse) -> assigns plan fields (hash/signature/path) to state.json
-- session_end.py (SessionEnd) -> transitions active -> has_plan when plan is assigned
-- context_selector.py -> matches plan content, transitions has_plan -> active
-
-Usage in .claude/settings.json:
-{
-  "hooks": {
-    "PermissionRequest": [{
-      "matcher": "ExitPlanMode",
-      "hooks": [{
-        "type": "command",
-        "command": "python .aiwcli/_shared/hooks/archive_plan.py",
-        "timeout": 5000
-      }]
-    }]
-  }
-}
-"""
-import re
-import sys
-from pathlib import Path
-from typing import Optional
-
-# Add parent directories to path for imports
-SCRIPT_DIR = Path(__file__).resolve().parent
-SHARED_LIB = SCRIPT_DIR.parent / "lib"
-sys.path.insert(0, str(SHARED_LIB.parent))
-
-from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_warn, log_error
-from lib.base.utils import project_dir
-from lib.base.constants import get_context_dir
-from lib.context.context_store import get_context_by_session_id
-from lib.context.plan_manager import archive_plan, extract_plan_path_from_result
-
-# Import debug cleanup function from cc-native lib
-_cc_native_lib = SCRIPT_DIR.parent / "_cc-native" / "lib"
-sys.path.insert(0, str(_cc_native_lib))
-try:
-    from debug import cleanup_debug_folder
-except ImportError:
-    def cleanup_debug_folder(context_path):
-        pass
-
-
-def _find_plan_path(hook_input: dict, project_root: Path) -> Optional[str]:
-    """Find the plan file path from hook input or standard locations."""
-    tool_input = hook_input.get("tool_input", {})
-    tool_result = hook_input.get("tool_result", "")
-    hook_event = hook_input.get("hook_event_name", "")
-    tool_name = hook_input.get("tool_name", "")
-
-    plan_path = None
-
-    # For ExitPlanMode, extract from tool result
-    if tool_name == "ExitPlanMode" and tool_result:
-        plan_path = extract_plan_path_from_result(tool_result)
-        if plan_path:
-            log_info("archive_plan", f"Extracted plan path from result: {plan_path}")
-
-    # Check tool_input for plan path
-    if not plan_path:
-        plan_path = tool_input.get("plan_path") or tool_input.get("planPath")
-
-    # Search standard locations
-    if not plan_path:
-        log_debug("archive_plan", "No plan_path found, searching standard locations...")
-        claude_plans_dir = Path.home() / ".claude" / "plans"
-        if claude_plans_dir.exists():
-            claude_plans = sorted(
-                claude_plans_dir.glob("*.md"),
-                key=lambda p: p.stat().st_mtime,
-                reverse=True,
-            )
-            if claude_plans:
-                plan_path = str(claude_plans[0])
-
-    if not plan_path:
-        for fallback in [
-            project_root / "_output" / "cc-native" / "plans" / "current-plan.md",
-            project_root / "_output" / "plans" / "current-plan.md",
-            project_root / "plan.md",
-        ]:
-            if fallback.exists():
-                plan_path = str(fallback)
-                break
-
-    return plan_path
-
-
-def on_plan_archive():
-    """Archive plan on PermissionRequest:ExitPlanMode — file archival only, no state.json changes."""
-    hook_input = load_hook_input()
-    if not hook_input:
-        log_warn("archive_plan", "No valid JSON input")
-        return
-
-    hook_event = hook_input.get("hook_event_name", "unknown")
-    tool_name = hook_input.get("tool_name", "")
-
-    log_info("archive_plan", f"Hook triggered: {hook_event}, tool: {tool_name}")
-
-    # Only handle PermissionRequest for ExitPlanMode
-    if not (hook_event == "PermissionRequest" and tool_name == "ExitPlanMode"):
-        log_debug("archive_plan", "Skipping: not PermissionRequest:ExitPlanMode")
-        return
-
-    if hook_input.get("stop_hook_active", False):
-        log_debug("archive_plan", "Stop hook active, skipping")
-        return
-
-    project_root = project_dir(hook_input)
-    plan_path = _find_plan_path(hook_input, project_root)
-
-    if not plan_path:
-        log_warn("archive_plan", "Could not find plan file, skipping archival")
-        return
-
-    # Resolve plan path
-    plan_file = Path(plan_path)
-    if not plan_file.is_absolute():
-        plan_file = project_root / plan_path
-
-    log_debug("archive_plan", f"Resolved plan file: {plan_file}")
-
-    if not plan_file.exists():
-        log_error("archive_plan", f"Plan file not found: {plan_file}")
-        return
-
-    # Find context by session ID
-    session_id = hook_input.get("session_id", "unknown")
-    state = get_context_by_session_id(session_id, project_root)
-
-    if not state:
-        log_warn("archive_plan", "Could not determine context for session")
-        return
-
-    context_id = state.id
-
-    # Archive the plan file (returns path, hash, signature)
-    archived_path, plan_hash, plan_signature = archive_plan(
-        str(plan_file), context_id, project_root
-    )
-
-    if archived_path:
-        # Clean up debug logs
-        try:
-            context_path = get_context_dir(context_id, project_root)
-            cleanup_debug_folder(context_path)
-        except Exception as e:
-            log_warn("archive_plan", f"could not clean debug folder: {e}")
-
-        log_info("archive_plan", f"SUCCESS: archived plan for {context_id}")
-        log_debug("archive_plan", f"Path: {archived_path}, hash: {plan_hash}")
-    else:
-        log_error("archive_plan", f"Could not archive plan for '{context_id}'")
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(on_plan_archive, "archive_plan")

package/dist/templates/_shared/hooks/context_monitor.py

@@ -1,270 +0,0 @@
-#!/usr/bin/env python3
-"""Context monitor hook for proactive handoff warnings.
-
-This hook runs on PostToolUse for context-heavy tools and monitors
-context window usage. When context drops below a threshold, it injects
-a system reminder instructing Claude to wrap up and create a handoff document.
-
-Unlike UserPromptSubmit hooks, this fires DURING Claude's work,
-allowing proactive intervention without waiting for user input.
-
-Monitored tools (configured via settings.json matcher):
-- Task: Subagent responses can be huge
-- Read: File content loads into context
-- Bash: Command output can be large
-- WebFetch: Web content loads into context
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "PostToolUse",
-    "tool_name": "Task",
-    "tool_input": {...},
-    "tool_result": {...},
-    "transcript_path": "/path/to/transcript.jsonl",
-    "session_id": "abc123",
-    "context_window": {
-        "current_usage": {
-            "cache_read_input_tokens": 0,
-            "input_tokens": 12345,
-            "cache_creation_input_tokens": 0,
-            "output_tokens": 6789
-        },
-        "context_window_size": 200000
-    },
-    ...
-}
-
-Hook output:
-- Outputs JSON with additionalContext if context is low
-- This injects a system reminder into Claude's context
-- Plain stdout from PostToolUse only goes to verbose mode, not Claude
-- Using additionalContext ensures Claude sees and responds to the warning
-
-KNOWN LIMITATION: Context percentage won't match /context exactly.
-Hook JSON excludes system prompt, tools, MCP tokens. We add a baseline
-to compensate (~22.6k tokens typical). See:
-https://github.com/anthropics/claude-code/issues/13783
-"""
-import sys
-from pathlib import Path
-from typing import Optional
-
-# Add parent directories to path for imports
-SCRIPT_DIR = Path(__file__).resolve().parent
-SHARED_LIB = SCRIPT_DIR.parent / "lib"
-sys.path.insert(0, str(SHARED_LIB.parent))
-
-from lib.base.hook_utils import emit_context, load_hook_input, get_context_percent_remaining, log_debug, log_info, log_warn, log_error, log_diagnostic
-from lib.base.utils import now_iso, project_dir
-from lib.context.context_store import (
-    get_all_contexts,
-    get_context_by_session_id,
-    maybe_activate,
-    save_state,
-)
-
-# Module-level flag: only save auto-state once per process lifetime
-_PROGRESSIVE_SAVE_MARKER = ".progressive-save-done"
-
-# Configuration
-SAVE_STATE_THRESHOLD = 60  # Silently save auto-state at 60% remaining
-HANDOFF_SUGGEST_THRESHOLD = 30  # Gentle nudge at 30% remaining (70% used)
-HANDOFF_PREPARE_THRESHOLD = 20  # Stronger warning at 20% remaining (80% used)
-CRITICAL_CONTEXT_THRESHOLD = 10  # Urgent warning at 10% remaining (90% used)
-
-
-def get_current_context_id(project_root: Path = None) -> Optional[str]:
-    """Determine the current active context (most recently active)."""
-    contexts = get_all_contexts(status="active", project_root=project_root)
-    if contexts:
-        return contexts[0].id
-    return None
-
-
-def get_context_warning(
-    percent_remaining: int,
-    tokens_used: Optional[int],
-    max_tokens: Optional[int],
-    context_id: Optional[str],
-    tool_name: str
-) -> str:
-    """Generate appropriate warning based on context level."""
-    if tokens_used is not None and max_tokens is not None:
-        tokens_used_k = tokens_used // 1000
-        max_tokens_k = max_tokens // 1000
-        usage_line = f"**Estimated usage**: ~{tokens_used_k}k / {max_tokens_k}k tokens"
-    else:
-        usage_line = f"**Estimated usage**: ~{percent_remaining}% remaining"
-
-    context_line = f"\nContext ID: `{context_id}`" if context_id else ""
-
-    if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD:
-        return f"""<system-reminder>
-## CRITICAL CONTEXT WARNING ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**CRITICAL: Run `/handoff` now before context is compacted.**
-{context_line}
-
-You are about to lose context. Stop all other work and run `/handoff` immediately.
-</system-reminder>"""
-
-    elif percent_remaining <= HANDOFF_PREPARE_THRESHOLD:
-        return f"""<system-reminder>
-## LOW CONTEXT WARNING ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**Context is getting low. Please finish your current task and run `/handoff`.**
-{context_line}
-
-**Actions:**
-1. Complete your current atomic task (if 1-2 steps away)
-2. Do NOT start new multi-step work
-3. Run `/handoff` to generate a handoff document
-</system-reminder>"""
-
-    else:
-        return f"""<system-reminder>
-## CONTEXT NOTICE ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**Consider preparing a handoff soon. When ready, run `/handoff` to generate a handoff document.**
-{context_line}
-
-Continue your current work, but avoid starting large new tasks.
-</system-reminder>"""
-
-
-def check_and_transition_mode(hook_input: dict) -> None:
-    """
-    Check if context mode needs to transition based on tool usage.
-
-    Handles:
-    - has_plan + implementation tool -> active (started implementing)
-    - idle + implementation tool -> active
-    """
-    project_root = project_dir(hook_input)
-    session_id = hook_input.get("session_id")
-
-    if not session_id:
-        return
-
-    state = get_context_by_session_id(session_id, project_root)
-    if not state:
-        return
-
-    # Implementation transitions only trigger on implementation tools
-    implementation_tools = {"Edit", "Write", "Bash", "NotebookEdit"}
-    tool_name = hook_input.get("tool_name", "")
-
-    if tool_name not in implementation_tools:
-        return
-
-    permission_mode = hook_input.get("permission_mode", "default")
-    maybe_activate(state.id, permission_mode, project_root=project_root, caller="context_monitor")
-
-
-def _try_progressive_save(hook_input: dict, percent_remaining: int) -> None:
-    """Silently save state at SAVE_STATE_THRESHOLD (60%)."""
-    try:
-        session_id = hook_input.get("session_id", "")
-        if not session_id:
-            return
-
-        project_root = project_dir(hook_input)
-        state = get_context_by_session_id(session_id, project_root)
-        if not state:
-            return
-
-        from lib.base.constants import get_context_dir
-        marker_path = get_context_dir(state.id, project_root) / _PROGRESSIVE_SAVE_MARKER
-        if marker_path.exists():
-            try:
-                saved_session = marker_path.read_text(encoding="utf-8").strip()
-                if saved_session == session_id:
-                    return
-            except OSError:
-                pass
-
-        log_info("context_monitor", f"Progressive save at {percent_remaining}% remaining")
-
-        # Just update last_active and save state
-        state.last_active = now_iso()
-        save_state(state, project_root)
-
-        try:
-            marker_path.write_text(session_id, encoding="utf-8")
-        except OSError:
-            pass
-
-    except Exception as e:
-        log_warn("context_monitor", f"Progressive save error (non-fatal): {e}")
-
-
-def check_context_level(hook_input: dict) -> Optional[str]:
-    """Check context level and return warning if low."""
-    tool_name = hook_input.get("tool_name", "Unknown")
-    percent_remaining, tokens_used, max_tokens = get_context_percent_remaining(hook_input)
-
-    log_diagnostic("context_monitor", "receive", f"tool={tool_name}, pct_remaining={percent_remaining}",
-                    inputs={"tool_name": tool_name, "percent_remaining": percent_remaining,
-                            "tokens_used": tokens_used, "max_tokens": max_tokens})
-
-    if percent_remaining is None:
-        return None
-
-    if percent_remaining > SAVE_STATE_THRESHOLD:
-        return None
-
-    if percent_remaining > HANDOFF_SUGGEST_THRESHOLD:
-        _try_progressive_save(hook_input, percent_remaining)
-        return None
-
-    if tokens_used is not None and max_tokens is not None:
-        log_info("context_monitor", f"Context: {percent_remaining}% remaining "
-                 f"(~{tokens_used//1000}k/{max_tokens//1000}k tokens)")
-    else:
-        log_info("context_monitor", f"Context: ~{percent_remaining}% remaining (from context.json)")
-
-    project_root = project_dir(hook_input)
-    context_id = get_current_context_id(project_root)
-
-    threshold = ("critical" if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD
-                 else "prepare" if percent_remaining <= HANDOFF_PREPARE_THRESHOLD
-                 else "suggest")
-    log_diagnostic("context_monitor", "decide", f"Threshold={threshold} at {percent_remaining}%",
-                    decision=threshold, reasoning=f"{percent_remaining}% remaining",
-                    inputs={"context_id": context_id, "percent_remaining": percent_remaining})
-
-    return get_context_warning(percent_remaining, tokens_used, max_tokens, context_id, tool_name)
-
-
-def main():
-    """Main entry point for PostToolUse hook."""
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        check_and_transition_mode(hook_input)
-
-        warning = check_context_level(hook_input)
-        if warning:
-            emit_context(warning)
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("context_monitor", e, "PostToolUse", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "context_monitor")

package/dist/templates/_shared/hooks/file-suggestion.py

@@ -1,215 +0,0 @@
-#!/usr/bin/env python3
-"""File suggestion hook for Claude Code.
-
-Suggests relevant files to include in context based on the current session:
-- Context file (context.json) for the active context
-- Plans from the active context's plans/ directory
-- Handoffs from the active context's handoffs/ directory
-- Reviews from the active context's reviews/ directory (including cc-native subdirectory)
-
-Hook input (from Claude Code):
-{
-    "session_id": "abc123",
-    "cwd": "/path/to/project",
-    ...
-}
-
-Hook output:
-JSON array of file paths to suggest, or empty array if no suggestions.
-["/path/to/file1.md", "/path/to/file2.md"]
-"""
-import json
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-# Add parent directories to path for imports
-SCRIPT_DIR = Path(__file__).resolve().parent
-SHARED_LIB = SCRIPT_DIR.parent / "lib"
-sys.path.insert(0, str(SHARED_LIB.parent))
-
-from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_error
-from lib.base.utils import project_dir
-from lib.base.constants import (
-    get_context_plans_dir,
-    get_context_handoffs_dir,
-    get_context_reviews_dir,
-    get_context_file_path,
-)
-from lib.context.context_store import (
-    get_context_by_session_id,
-    get_all_contexts,
-    get_context,
-)
-
-
-def get_context_files(context_id: str, project_root: Path) -> List[str]:
-    """
-    Get all relevant files for a context.
-
-    Collects:
-    - Context file (context.json)
-    - Plans (most recent first)
-    - Handoffs: index.md from subdirectories (folder-based) OR flat .md files (legacy)
-    - Reviews: index.md from subdirectories (folder-based) OR flat review.md (legacy)
-
-    Args:
-        context_id: Context identifier
-        project_root: Project root path
-
-    Returns:
-        List of absolute file paths, sorted by modification time (most recent first)
-    """
-    files = []
-
-    # Get context.json file first
-    context_file = get_context_file_path(context_id, project_root)
-    if context_file.exists():
-        files.append(str(context_file))
-        log_debug("file-suggestion", f"Found context file for {context_id}")
-
-    # Get plans directory
-    plans_dir = get_context_plans_dir(context_id, project_root)
-    if plans_dir.exists():
-        plan_files = list(plans_dir.glob("*.md"))
-        # Sort by modification time, most recent first
-        plan_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-        files.extend([str(p) for p in plan_files])
-        log_debug("file-suggestion", f"Found {len(plan_files)} plans in {context_id}")
-
-    # Get handoffs - prefer folder-based (index.md in subdirectories), fall back to legacy
-    handoffs_dir = get_context_handoffs_dir(context_id, project_root)
-    if handoffs_dir.exists():
-        # Find handoff folders (named like YYYY-MM-DD-HHMM or YYYY-MM-DD-HHMM-N)
-        handoff_folders = sorted(
-            [d for d in handoffs_dir.iterdir() if d.is_dir()],
-            key=lambda d: d.name,
-            reverse=True  # Most recent first (alphabetically sorts by date)
-        )
-
-        if handoff_folders:
-            # Use folder-based: get index.md from most recent folder only
-            index_file = handoff_folders[0] / "index.md"
-            if index_file.exists():
-                files.append(str(index_file))
-                log_debug("file-suggestion", f"Found handoff folder: {handoff_folders[0].name}")
-        else:
-            # Legacy support: flat .md files directly in handoffs/
-            legacy_handoffs = [f for f in handoffs_dir.glob("*.md") if f.is_file()]
-            legacy_handoffs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-            if legacy_handoffs:
-                files.append(str(legacy_handoffs[0]))  # Only most recent legacy
-                log_debug("file-suggestion", f"Found {len(legacy_handoffs)} legacy handoffs in {context_id}")
-
-    # Get reviews - prefer folder-based (index.md in subdirectories), fall back to legacy
-    reviews_dir = get_context_reviews_dir(context_id, project_root) / "cc-native"
-    if reviews_dir.exists():
-        # Find review folders (named like YYYY-MM-DD-HHMM-iteration-N)
-        review_folders = sorted(
-            [d for d in reviews_dir.iterdir() if d.is_dir()],
-            key=lambda d: d.name,
-            reverse=True  # Most recent first
-        )
-
-        if review_folders:
-            # Use folder-based: get index.md from most recent folder only
-            index_file = review_folders[0] / "index.md"
-            if index_file.exists():
-                files.append(str(index_file))
-                log_debug("file-suggestion", f"Found review folder: {review_folders[0].name}")
-        else:
-            # Legacy support: flat review.md directly in cc-native/
-            legacy_review = reviews_dir / "review.md"
-            if legacy_review.exists():
-                files.append(str(legacy_review))
-                log_debug("file-suggestion", f"Found legacy review.md in {context_id}")
-
-    return files
-
-
-def get_active_context_id(session_id: str, project_root: Path) -> Optional[str]:
-    """
-    Determine the active context for suggestions.
-
-    Priority:
-    1. Context bound to current session_id
-    2. Single in-flight context (if only one exists)
-    3. None (no suggestions if ambiguous)
-
-    Args:
-        session_id: Current session identifier
-        project_root: Project root path
-
-    Returns:
-        Context ID or None
-    """
-    # Try session_id lookup first
-    if session_id and session_id != "unknown":
-        context = get_context_by_session_id(session_id, project_root)
-        if context:
-            log_debug("file-suggestion", f"Found context by session: {context.id}")
-            return context.id
-
-    # Fall back to single active (non-idle) context
-    active = [c for c in get_all_contexts(status="active", project_root=project_root)
-              if c.mode != "idle"]
-    if len(active) == 1:
-        log_debug("file-suggestion", f"Using single active context: {active[0].id}")
-        return active[0].id
-
-    log_debug("file-suggestion", f"No unique context found (active: {len(active)})")
-    return None
-
-
-def main():
-    """
-    Main entry point for file suggestion hook.
-
-    Reads hook input from stdin, determines active context,
-    and outputs file suggestions as JSON array.
-    """
-    try:
-        # Read hook input using shared utility
-        hook_input = load_hook_input()
-
-        if not hook_input:
-            print("[]")
-            return
-
-        # Get project root and session ID
-        project_root = project_dir(hook_input)
-        session_id = hook_input.get("session_id", "unknown")
-
-        log_debug("file-suggestion", f"Session: {session_id[:8]}..., Project: {project_root}")
-
-        # Determine active context
-        context_id = get_active_context_id(session_id, project_root)
-
-        if not context_id:
-            print("[]")
-            return
-
-        # Collect file suggestions
-        suggestions = get_context_files(context_id, project_root)
-
-        # Limit suggestions to prevent overwhelming the context
-        MAX_SUGGESTIONS = 10
-        if len(suggestions) > MAX_SUGGESTIONS:
-            log_debug("file-suggestion", f"Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
-            suggestions = suggestions[:MAX_SUGGESTIONS]
-
-        # Output suggestions as JSON array
-        log_info("file-suggestion", f"Suggesting {len(suggestions)} files")
-        print(json.dumps(suggestions))
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("file-suggestion", e, "SessionStart", traceback_str=tb)
-        print("[]")
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "file_suggestion")