aiwcli 0.9.8 → 0.10.1

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

@@ -45,369 +45,226 @@ 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 json
 import sys
 from pathlib import Path
-from typing import Optional, Tuple
+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
-from lib.base.utils import eprint, project_dir
-from lib.context.context_manager import (
+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,
-    update_plan_status,
+    maybe_activate,
+    save_state,
 )
-from lib.context.auto_state import save_auto_state
-from lib.context.event_log import EVENT_AUTO_STATE_SAVED, append_event
 
 # Module-level flag: only save auto-state once per process lifetime
-# Since hooks are separate processes per invocation, we use a file marker instead
 _PROGRESSIVE_SAVE_MARKER = ".progressive-save-done"
 
 # Configuration
 SAVE_STATE_THRESHOLD = 60  # Silently save auto-state at 60% remaining
-LOW_CONTEXT_THRESHOLD = 40  # Warn when below 40% remaining
-CRITICAL_CONTEXT_THRESHOLD = 25  # Urgent warning below 25%
-
-# Context baseline: preloaded tokens not visible to hooks (~22.6k typical)
-# This includes system prompt, tools, MCP tokens that aren't in hook data
-CONTEXT_BASELINE = 22_600
-
-# Default context window size (used when not provided in hook input)
-DEFAULT_CONTEXT_WINDOW = 200_000
-
-
-def get_context_tokens_from_hook(hook_input: dict) -> Tuple[Optional[int], Optional[int]]:
-    """
-    Extract actual token counts from Claude Code hook input.
-
-    Claude Code provides context_window data with actual token counts:
-    - cache_read_input_tokens: Tokens read from cache
-    - input_tokens: New input tokens
-    - cache_creation_input_tokens: Tokens written to cache
-    - output_tokens: Model output tokens
-
-    Args:
-        hook_input: Hook input data from Claude Code
-
-    Returns:
-        Tuple of (tokens_used, max_tokens) or (None, None) if not available
-    """
-    context_window = hook_input.get("context_window")
-    if not context_window:
-        return None, None
-
-    current_usage = context_window.get("current_usage")
-    if not current_usage:
-        return None, None
-
-    # Sum all token types
-    cache_read = current_usage.get("cache_read_input_tokens", 0) or 0
-    input_tokens = current_usage.get("input_tokens", 0) or 0
-    cache_creation = current_usage.get("cache_creation_input_tokens", 0) or 0
-    output_tokens = current_usage.get("output_tokens", 0) or 0
-
-    content_tokens = cache_read + input_tokens + cache_creation + output_tokens
-
-    # Add baseline for system prompt, tools, MCP tokens not in hook data
-    tokens_used = content_tokens + CONTEXT_BASELINE
-
-    # Get max context window from hook input
-    max_tokens = context_window.get("context_window_size") or DEFAULT_CONTEXT_WINDOW
-
-    return tokens_used, max_tokens
+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.
-
-    Falls back to most recently active context.
-
-    Returns:
-        Context ID or None if no active context
-    """
+    """Determine the current active context (most recently active)."""
     contexts = get_all_contexts(status="active", project_root=project_root)
     if contexts:
-        return contexts[0].id  # Sorted by last_active desc
+        return contexts[0].id
     return None
 
 
 def get_context_warning(
     percent_remaining: int,
-    tokens_used: int,
-    max_tokens: int,
+    tokens_used: Optional[int],
+    max_tokens: Optional[int],
     context_id: Optional[str],
     tool_name: str
 ) -> str:
-    """
-    Generate appropriate warning based on context level.
-
-    Args:
-        percent_remaining: Percentage of context remaining
-        tokens_used: Estimated tokens used
-        max_tokens: Maximum context window
-        context_id: Current context ID (if any)
-        tool_name: Tool that triggered this check
+    """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"
 
-    Returns:
-        System reminder markdown
-    """
-    # Format token counts
-    tokens_used_k = tokens_used // 1000
-    max_tokens_k = max_tokens // 1000
+    context_line = f"\nContext ID: `{context_id}`" if context_id else ""
 
     if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD:
-        urgency = "CRITICAL"
-        instruction = "You MUST wrap up immediately and create a handoff document."
-    else:
-        urgency = "LOW"
-        instruction = "Please wrap up your current task and prepare for handoff."
+        return f"""<system-reminder>
+## CRITICAL CONTEXT WARNING ({percent_remaining}% remaining)
+
+{usage_line}
+**Triggered by**: {tool_name} tool completion
 
-    context_info = ""
-    if context_id:
-        context_info = f"""
-To create a handoff document, use the /handoff command or describe:
-- What you were working on
-- What's completed
-- What still needs to be done
-- Any important decisions or context
+**CRITICAL: Run `/handoff` now before context is compacted.**
+{context_line}
 
-Context ID: `{context_id}`"""
+You are about to lose context. Stop all other work and run `/handoff` immediately.
+</system-reminder>"""
 
-    return f"""<system-reminder>
-## {urgency} CONTEXT WARNING ({percent_remaining}% remaining)
+    elif percent_remaining <= HANDOFF_PREPARE_THRESHOLD:
+        return f"""<system-reminder>
+## LOW CONTEXT WARNING ({percent_remaining}% remaining)
 
-**Estimated usage**: ~{tokens_used_k}k / {max_tokens_k}k tokens
+{usage_line}
 **Triggered by**: {tool_name} tool completion
 
-{instruction}
-{context_info}
+**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. Create a handoff document summarizing progress
-4. Ask user: "Context is getting low. I've summarized my progress. Should we continue in a new session?"
+3. Run `/handoff` to generate a handoff document
 </system-reminder>"""
 
+    else:
+        return f"""<system-reminder>
+## CONTEXT NOTICE ({percent_remaining}% remaining)
 
-def check_and_transition_mode(hook_input: dict) -> None:
-    """
-    Check if context needs to transition to implementing mode.
+{usage_line}
+**Triggered by**: {tool_name} tool completion
 
-    This handles two cases:
-    1. Plan was approved (pending_implementation) and implementation tools are used
-    2. Plan was in planning mode but permission_mode is no longer "plan"
-       (e.g., after /clear which clears permissions and pastes the plan)
+**Consider preparing a handoff soon. When ready, run `/handoff` to generate a handoff document.**
+{context_line}
 
-    If we're seeing tool usage (Edit, Write, Bash) and either:
-    - Context is in "pending_implementation", OR
-    - Context is in "planning" and permission_mode is not "plan"
-    We transition to "implementing".
+Continue your current work, but avoid starting large new tasks.
+</system-reminder>"""
 
-    Args:
-        hook_input: Hook input data from Claude Code
-    """
-    # Only transition on tools that indicate implementation work
-    implementation_tools = {"Edit", "Write", "Bash", "NotebookEdit"}
-    tool_name = hook_input.get("tool_name", "")
 
-    if tool_name not in implementation_tools:
-        return
+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
 
-    # Get context for this session
-    context = get_context_by_session_id(session_id, project_root)
-    if not context:
+    state = get_context_by_session_id(session_id, project_root)
+    if not state:
         return
 
-    if not context.in_flight:
+    # 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
 
-    current_mode = context.in_flight.mode
     permission_mode = hook_input.get("permission_mode", "default")
-
-    # Transition from pending_implementation to implementing
-    if current_mode == "pending_implementation":
-        eprint(f"[context_monitor] Transitioning {context.id} from pending_implementation to implementing")
-        update_plan_status(context.id, "implementing", project_root=project_root)
-
-    # Transition from planning to implementing if permission_mode is not "plan"
-    elif current_mode == "planning" and permission_mode != "plan":
-        eprint(f"[context_monitor] Transitioning {context.id} from planning to implementing (permission_mode={permission_mode})")
-        update_plan_status(context.id, "implementing", project_root=project_root)
+    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 auto-state at SAVE_STATE_THRESHOLD (60%).
-
-    Uses a marker file in the context folder to ensure this fires only
-    once per session. The marker is the session_id written to a file.
-
-    Args:
-        hook_input: Hook input data from Claude Code
-        percent_remaining: Current context percentage remaining
-    """
+    """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)
-        context = get_context_by_session_id(session_id, project_root)
-        if not context:
+        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(context.id, project_root) / _PROGRESSIVE_SAVE_MARKER
-        # Check if already saved for this session
+        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  # Already saved this session
+                    return
             except OSError:
                 pass
 
-        eprint(f"[context_monitor] Progressive save at {percent_remaining}% remaining")
-
-        in_flight_mode = context.in_flight.mode if context.in_flight else "none"
-        plan_path = context.in_flight.artifact_path if context.in_flight else None
-        handoff_path = context.in_flight.handoff_path if context.in_flight else None
-        transcript_path = hook_input.get("transcript_path")
-
-        saved = save_auto_state(
-            context_id=context.id,
-            session_id=session_id,
-            save_reason="progressive",
-            project_root=project_root,
-            in_flight_mode=in_flight_mode,
-            plan_path=plan_path,
-            handoff_path=handoff_path,
-            transcript_path=transcript_path,
-        )
-
-        if saved:
-            append_event(
-                context.id, EVENT_AUTO_STATE_SAVED, project_root,
-                session_id=session_id, save_reason="progressive",
-            )
-            # Write marker so we don't save again this session
-            try:
-                marker_path.write_text(session_id, encoding="utf-8")
-            except OSError:
-                pass
+        log_info("context_monitor", f"Progressive save at {percent_remaining}% remaining")
 
-    except Exception as e:
-        eprint(f"[context_monitor] Progressive save error (non-fatal): {e}")
+        # 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
 
-def check_context_level(hook_input: dict) -> Optional[str]:
-    """
-    Check context level and return warning if low.
-
-    Optimized for fail-fast: checks cheap conditions first before any file I/O.
+    except Exception as e:
+        log_warn("context_monitor", f"Progressive save error (non-fatal): {e}")
 
-    Args:
-        hook_input: Hook input data from Claude Code
 
-    Returns:
-        System reminder string if context is low, None otherwise
-    """
-    # === FAST PATH: No I/O, just dict lookups and math ===
+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)
 
-    # 1. Try to get context_window data (fast dict access)
-    tokens_used, max_tokens = get_context_tokens_from_hook(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})
 
-    # 2. If no context_window data, exit immediately - can't monitor accurately
-    if tokens_used is None or max_tokens is None:
-        # Only log if we want to debug
-        # eprint("[context_monitor] context_window data unavailable")
+    if percent_remaining is None:
         return None
 
-    # 3. Calculate percentage (fast math)
-    remaining = max_tokens - tokens_used
-    percent_remaining = max(0, min(100, int((remaining / max_tokens) * 100)))
-
-    # 4. Most common case: context is fine, exit early
     if percent_remaining > SAVE_STATE_THRESHOLD:
         return None
 
-    # === PROGRESSIVE SAVE: At 60% remaining, silently save auto-state ===
-    if percent_remaining > LOW_CONTEXT_THRESHOLD:
-        # Only save once per session (check marker file)
+    if percent_remaining > HANDOFF_SUGGEST_THRESHOLD:
         _try_progressive_save(hook_input, percent_remaining)
         return None
 
-    # === SLOW PATH: Only reached when context is low (rare) ===
-
-    # Log since we're in warning territory
-    eprint(f"[context_monitor] Context: {percent_remaining}% remaining "
-           f"(~{tokens_used//1000}k/{max_tokens//1000}k tokens)")
+    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)")
 
-    # Get current context for handoff info (file I/O)
     project_root = project_dir(hook_input)
     context_id = get_current_context_id(project_root)
 
-    tool_name = hook_input.get("tool_name", "Unknown")
+    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
-    )
+    return get_context_warning(percent_remaining, tokens_used, max_tokens, context_id, tool_name)
 
 
 def main():
-    """
-    Main entry point for PostToolUse hook.
-
-    Reads hook input from stdin, checks for mode transitions,
-    and prints system reminder if context is low.
-    """
+    """Main entry point for PostToolUse hook."""
     try:
-        # Read hook input using shared utility
         hook_input = load_hook_input()
-
         if not hook_input:
             return
 
-        # Always check for mode transitions on implementation tools
-        # This handles the case where /clear pastes the plan with non-plan permission mode
         check_and_transition_mode(hook_input)
 
-        # Check context level
         warning = check_context_level(hook_input)
-
         if warning:
-            # Output JSON with additionalContext so Claude sees the warning
-            # Plain stdout from PostToolUse only goes to verbose mode, not Claude's context
-            output = {
-                "hookSpecificOutput": {
-                    "additionalContext": warning
-                }
-            }
-            print(json.dumps(output))
+            emit_context(warning)
 
     except Exception as e:
-        eprint(f"[context_monitor] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        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__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "context_monitor")

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

@@ -28,17 +28,17 @@ 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
-from lib.base.utils import eprint, project_dir
+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_manager import (
+from lib.context.context_store import (
     get_context_by_session_id,
-    get_all_in_flight_contexts,
+    get_all_contexts,
     get_context,
 )
 
@@ -66,7 +66,7 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
     context_file = get_context_file_path(context_id, project_root)
     if context_file.exists():
         files.append(str(context_file))
-        eprint(f"[file-suggestion] Found context file for {context_id}")
+        log_debug("file-suggestion", f"Found context file for {context_id}")
 
     # Get plans directory
     plans_dir = get_context_plans_dir(context_id, project_root)
@@ -75,7 +75,7 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
         # 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])
-        eprint(f"[file-suggestion] Found {len(plan_files)} plans in {context_id}")
+        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)
@@ -92,14 +92,14 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
             index_file = handoff_folders[0] / "index.md"
             if index_file.exists():
                 files.append(str(index_file))
-                eprint(f"[file-suggestion] Found handoff folder: {handoff_folders[0].name}")
+                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
-                eprint(f"[file-suggestion] Found {len(legacy_handoffs)} legacy handoffs in {context_id}")
+                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"
@@ -116,13 +116,13 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
             index_file = review_folders[0] / "index.md"
             if index_file.exists():
                 files.append(str(index_file))
-                eprint(f"[file-suggestion] Found review folder: {review_folders[0].name}")
+                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))
-                eprint(f"[file-suggestion] Found legacy review.md in {context_id}")
+                log_debug("file-suggestion", f"Found legacy review.md in {context_id}")
 
     return files
 
@@ -147,16 +147,17 @@ def get_active_context_id(session_id: str, project_root: Path) -> Optional[str]:
     if session_id and session_id != "unknown":
         context = get_context_by_session_id(session_id, project_root)
         if context:
-            eprint(f"[file-suggestion] Found context by session: {context.id}")
+            log_debug("file-suggestion", f"Found context by session: {context.id}")
             return context.id
 
-    # Fall back to single in-flight context
-    in_flight = get_all_in_flight_contexts(project_root)
-    if len(in_flight) == 1:
-        eprint(f"[file-suggestion] Using single in-flight context: {in_flight[0].id}")
-        return in_flight[0].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
 
-    eprint(f"[file-suggestion] No unique context found (in-flight: {len(in_flight)})")
+    log_debug("file-suggestion", f"No unique context found (active: {len(active)})")
     return None
 
 
@@ -179,7 +180,7 @@ def main():
         project_root = project_dir(hook_input)
         session_id = hook_input.get("session_id", "unknown")
 
-        eprint(f"[file-suggestion] Session: {session_id[:8]}..., Project: {project_root}")
+        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)
@@ -194,19 +195,21 @@ def main():
         # Limit suggestions to prevent overwhelming the context
         MAX_SUGGESTIONS = 10
         if len(suggestions) > MAX_SUGGESTIONS:
-            eprint(f"[file-suggestion] Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
+            log_debug("file-suggestion", f"Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
             suggestions = suggestions[:MAX_SUGGESTIONS]
 
         # Output suggestions as JSON array
-        eprint(f"[file-suggestion] Suggesting {len(suggestions)} files")
+        log_info("file-suggestion", f"Suggesting {len(suggestions)} files")
         print(json.dumps(suggestions))
 
     except Exception as e:
-        eprint(f"[file-suggestion] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        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__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "file_suggestion")