aiwcli 0.9.1 → 0.9.4

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

@@ -27,47 +27,31 @@ Usage in .claude/settings.json:
 }
 """
 import json
+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
-lib_dir = script_dir.parent / "lib"
-sys.path.insert(0, str(lib_dir.parent))
+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.context.plan_archive import archive_plan_to_context
 from lib.context.context_manager import get_all_contexts
+from lib.context.context_extractor import extract_context_id_for_session
 from lib.base.utils import eprint, project_dir
+from lib.base.constants import get_context_dir
 
-
-def get_context_for_session(session_id: str, project_root: Path) -> Optional[str]:
-    """
-    Find context that matches this session_id.
-
-    Args:
-        session_id: Session ID to match
-        project_root: Project root directory
-
-    Returns:
-        Context ID or None if not found
-    """
-    contexts = get_all_contexts(status="active", project_root=project_root)
-
-    # Primary strategy: Find context with matching session_id
-    for ctx in contexts:
-        if ctx.in_flight and ctx.in_flight.session_ids and session_id in ctx.in_flight.session_ids:
-            eprint(f"[archive_plan] Found context by session: {ctx.id}")
-            return ctx.id
-
-    # Fallback: If only one context is planning, assume it's the one
-    planning_contexts = [c for c in contexts if c.in_flight and c.in_flight.mode == "planning"]
-    if len(planning_contexts) == 1:
-        eprint(f"[archive_plan] Fallback: Single planning context: {planning_contexts[0].id}")
-        return planning_contexts[0].id
-
-    eprint(f"[archive_plan] Could not find context for session {session_id}")
-    return None
+# 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  # Fallback if debug module not available
 
 
 def extract_plan_path_from_result(tool_result: str) -> Optional[str]:
@@ -76,7 +60,6 @@ def extract_plan_path_from_result(tool_result: str) -> Optional[str]:
 
     Looks for pattern: "Your plan has been saved to: <path>"
     """
-    import re
     match = re.search(r'Your plan has been saved to:\s*(.+\.md)', tool_result)
     if match:
         return match.group(1).strip()
@@ -90,10 +73,9 @@ def on_plan_archive():
     Called from PostToolUse on ExitPlanMode - extracts plan path from result
     and archives to the active context.
     """
-    # Read hook input from stdin
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
+    # Read hook input using shared utility
+    hook_input = load_hook_input()
+    if not hook_input:
         eprint("[archive_plan] No valid JSON input")
         return
 
@@ -220,9 +202,9 @@ def on_plan_archive():
         print(f"Plan archival skipped: file not found ({plan_path})")
         return
 
-    # Find context by session ID
+    # Find context by session ID using shared extractor
     session_id = hook_input.get("session_id", "unknown")
-    context_id = get_context_for_session(session_id, project_root)
+    context_id = extract_context_id_for_session(session_id, project_root, "archive_plan")
 
     if not context_id:
         eprint("[archive_plan] Could not determine context for session")
@@ -246,6 +228,14 @@ def on_plan_archive():
     )
 
     if archived_path:
+        # Clean up debug logs before completing archive
+        try:
+            context_path = get_context_dir(context_id, project_root)
+            cleanup_debug_folder(context_path)
+            print(f"[archive_plan] Cleaned up debug logs for context: {context_id}")
+        except Exception as e:
+            print(f"[archive_plan] Warning: could not clean debug folder: {e}")
+
         print(f"")
         print(f"[archive_plan] SUCCESS!")
         print(f"[archive_plan] Plan archived to context: {context_id}")

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

@@ -49,6 +49,7 @@ 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.subprocess_utils import is_internal_call
 from lib.context.context_manager import (
     Context,
@@ -65,7 +66,7 @@ from lib.context.discovery import (
     format_context_created,
     format_pending_plan_continuation,
     format_implementation_continuation,
-    _format_relative_time,
+    format_relative_time,
 )
 from lib.templates.formatters import get_mode_display
 from lib.base.utils import eprint, project_dir
@@ -251,7 +252,7 @@ def format_context_picker_stderr(contexts: List[Context]) -> str:
 
     implementing_count = 0
     for i, ctx in enumerate(contexts, 1):
-        time_str = _format_relative_time(ctx.last_active)
+        time_str = format_relative_time(ctx.last_active)
 
         # Check if context is in implementing mode (selectable)
         is_implementing = ctx.in_flight and ctx.in_flight.mode == "implementing"
@@ -299,13 +300,18 @@ def format_context_picker_stderr(contexts: List[Context]) -> str:
     return "\n".join(lines)
 
 
-def format_command_feedback(ended_contexts: List[Context], selected_context: Optional[Context]) -> str:
+def format_command_feedback(
+    ended_contexts: List[Context],
+    selected_context: Optional[Context],
+    remaining_prompt: Optional[str] = None
+) -> str:
     """
     Format feedback about what context operations were performed.
 
     Args:
         ended_contexts: Contexts that were ended/completed
         selected_context: Context that was selected (if any)
+        remaining_prompt: User's actual request after caret command (if any)
 
     Returns:
         Formatted feedback message
@@ -331,13 +337,21 @@ def format_command_feedback(ended_contexts: List[Context], selected_context: Opt
             if mode_str:
                 mode_display = mode_str.strip("[]")
 
-        time_str = _format_relative_time(selected_context.last_active)
+        time_str = format_relative_time(selected_context.last_active)
         lines.append(f"**Mode:** {mode_display}")
         lines.append(f"**Last Active:** {time_str}")
         lines.append("")
         lines.append(f'All work belongs to context "{selected_context.id}".')
         lines.append("Tasks created with TaskCreate will be persisted to this context.")
 
+    # Add user's actual request if provided after caret command
+    if remaining_prompt and remaining_prompt.strip():
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+        lines.append("**User's actual request:**")
+        lines.append(f"> {remaining_prompt}")
+
     return "\n".join(lines)
 
 
@@ -345,7 +359,7 @@ def determine_context(
     user_prompt: str,
     project_root: Path = None,
     session_id: str = None
-) -> Tuple[Optional[str], str, Optional[str]]:
+) -> Tuple[Optional[str], str, Optional[str], Optional[str]]:
     """
     Determine which context this prompt belongs to.
 
@@ -355,6 +369,7 @@ def determine_context(
         - method: How context was determined (session_match, in_flight, caret_select,
                   auto_created, single_context, blocked)
         - output: System reminder to inject, or None
+        - remaining_prompt: Actual user request after caret command, or None
 
     Raises:
         BlockRequest: When request should be blocked to show picker to user
@@ -362,7 +377,7 @@ def determine_context(
     # 0. Skip context creation for internal subprocess calls (orchestrator, agents)
     if is_internal_call():
         eprint("[context_enforcer] Skipping: internal subprocess call")
-        return (None, "skip_internal", None)
+        return (None, "skip_internal", None, None)
 
     # 1. Check if session already belongs to a context (HIGHEST PRIORITY)
     # This prevents context switching on subsequent prompts - one context per session
@@ -373,11 +388,20 @@ def determine_context(
             return (
                 session_context.id,
                 "session_match",
-                format_active_context_reminder(session_context)
+                format_active_context_reminder(session_context),
+                None
             )
 
     # 2. Check for bare "^" - show context picker
     if user_prompt.strip() == "^":
+        # Pre-transition: Move any pending_implementation contexts to implementing
+        # This ensures they appear selectable when user opens the picker
+        in_flight = get_all_in_flight_contexts(project_root)
+        for ctx in in_flight:
+            if ctx.in_flight and ctx.in_flight.mode == "pending_implementation":
+                update_plan_status(ctx.id, "implementing", project_root=project_root)
+                eprint(f"[context_enforcer] Pre-transitioned {ctx.id} to implementing (bare caret)")
+
         contexts = get_all_contexts(status="active", project_root=project_root)
         if not contexts:
             raise BlockRequest(
@@ -407,7 +431,7 @@ def determine_context(
 
         # Don't auto-create for greetings or help commands
         if any(prompt_lower.startswith(p) or prompt_lower == p for p in skip_patterns):
-            return (None, "no_context_needed", None)
+            return (None, "no_context_needed", None, None)
 
         # Auto-create context from prompt
         try:
@@ -419,11 +443,12 @@ def determine_context(
             return (
                 new_context.id,
                 "auto_created",
-                format_context_created(new_context)
+                format_context_created(new_context),
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
-            return (None, "creation_failed", None)
+            return (None, "creation_failed", None, None)
 
     elif len(in_flight_contexts) == 1:
         # Single in-flight context - auto-select it
@@ -431,6 +456,15 @@ def determine_context(
         mode = ctx.in_flight.mode if ctx.in_flight else "none"
         eprint(f"[context_enforcer] Auto-selected single in-flight context: {ctx.id} (mode={mode})")
 
+        # Auto-transition pending_implementation to implementing
+        # This ensures state updates immediately when context is selected,
+        # rather than waiting for _update_in_flight_status() which has conditions
+        if mode == "pending_implementation":
+            update_plan_status(ctx.id, "implementing", project_root=project_root)
+            ctx.in_flight.mode = "implementing"  # Update local copy for display
+            mode = "implementing"  # Update local var for formatter selection
+            eprint(f"[context_enforcer] Transitioned {ctx.id} to implementing")
+
         # Use mode-specific formatter for better continuation context
         if mode == "pending_implementation":
             output = format_pending_plan_continuation(ctx)
@@ -439,7 +473,7 @@ def determine_context(
         else:
             output = format_active_context_reminder(ctx)
 
-        return (ctx.id, "auto_selected", output)
+        return (ctx.id, "auto_selected", output, None)
 
     else:
         # Multiple in-flight contexts - block and show picker
@@ -455,7 +489,7 @@ def _handle_caret_command(
     user_prompt: str,
     contexts: List[Context],
     project_root: Path
-) -> Tuple[Optional[str], str, Optional[str]]:
+) -> Tuple[Optional[str], str, Optional[str], Optional[str]]:
     """
     Handle explicit caret commands (^E, ^S, ^0, ^N).
 
@@ -465,7 +499,7 @@ def _handle_caret_command(
         project_root: Project root directory
 
     Returns:
-        Tuple of (context_id, method, output)
+        Tuple of (context_id, method, output, remaining_prompt)
 
     Raises:
         BlockRequest: When command is invalid or selection needed
@@ -505,7 +539,8 @@ def _handle_caret_command(
             return (
                 new_context.id,
                 "caret_new",
-                format_context_created(new_context)
+                format_context_created(new_context),
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
@@ -542,7 +577,8 @@ def _handle_caret_command(
             return (
                 new_context.id,
                 "caret_new",
-                output
+                output,
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
@@ -552,11 +588,24 @@ def _handle_caret_command(
     if cmd.select:
         selected_ctx = contexts[cmd.select - 1]  # 1-indexed
         eprint(f"[context_enforcer] Caret-selected context: {selected_ctx.id}")
-        output = format_command_feedback(ended_contexts, selected_ctx)
+
+        # Auto-transition pending_implementation to implementing
+        mode = selected_ctx.in_flight.mode if selected_ctx.in_flight else "none"
+        if mode == "pending_implementation":
+            update_plan_status(selected_ctx.id, "implementing", project_root=project_root)
+            selected_ctx.in_flight.mode = "implementing"
+            eprint(f"[context_enforcer] Transitioned {selected_ctx.id} to implementing")
+
+        output = format_command_feedback(
+            ended_contexts,
+            selected_ctx,
+            cmd.remaining_prompt if cmd.remaining_prompt else None
+        )
         return (
             selected_ctx.id,
             "caret_select",
-            output
+            output,
+            cmd.remaining_prompt if cmd.remaining_prompt else None
         )
 
     # Only ended contexts, no selection - refresh context list and block
@@ -588,11 +637,10 @@ def main():
     In production, use user_prompt_submit.py as the unified entry point.
     """
     try:
-        input_data = sys.stdin.read().strip()
-        if not input_data:
+        hook_input = load_hook_input()
+        if not hook_input:
             return
 
-        hook_input = json.loads(input_data)
         user_prompt = hook_input.get("prompt", "")
         if not user_prompt:
             return
@@ -600,8 +648,10 @@ def main():
         project_root = project_dir(hook_input)
 
         try:
-            context_id, method, output = determine_context(user_prompt, project_root)
+            context_id, method, output, remaining_prompt = determine_context(user_prompt, project_root)
             eprint(f"[context_enforcer] Method: {method}, Context: {context_id}")
+            if remaining_prompt:
+                eprint(f"[context_enforcer] Remaining prompt: {remaining_prompt[:50]}...")
 
             if output:
                 print(output)

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

@@ -55,6 +55,7 @@ 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 (
     get_all_contexts,
@@ -301,15 +302,10 @@ def main():
     and prints system reminder if context is low.
     """
     try:
-        # Read hook input from stdin
-        input_data = sys.stdin.read().strip()
+        # Read hook input using shared utility
+        hook_input = load_hook_input()
 
-        if not input_data:
-            return
-
-        try:
-            hook_input = json.loads(input_data)
-        except json.JSONDecodeError:
+        if not hook_input:
             return
 
         # Always check for mode transitions on implementation tools

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

@@ -28,6 +28,7 @@ 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.constants import (
     get_context_plans_dir,
@@ -167,17 +168,10 @@ def main():
     and outputs file suggestions as JSON array.
     """
     try:
-        # Read hook input from stdin
-        input_data = sys.stdin.read().strip()
+        # Read hook input using shared utility
+        hook_input = load_hook_input()
 
-        if not input_data:
-            print("[]")
-            return
-
-        try:
-            hook_input = json.loads(input_data)
-        except json.JSONDecodeError:
-            eprint("[file-suggestion] Failed to parse input JSON")
+        if not hook_input:
             print("[]")
             return
 

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""SessionStart hook for mode transitions after /clear.
+
+This hook fires when a new session starts. It handles the critical transition
+from `pending_implementation` to `implementing` when a session starts after
+/clear with bypass permissions.
+
+The flow is:
+1. User approves plan (ExitPlanMode) -> mode = pending_implementation
+2. User clicks "yes and clear and bypass permissions"
+3. SessionStart fires with source="clear" and permission_mode="bypassPermissions"
+4. This hook transitions mode to "implementing"
+
+Without this hook, the mode stays stuck at pending_implementation because
+UserPromptSubmit may not receive the correct permission_mode after /clear.
+
+Hook input:
+{
+    "hook_event_name": "SessionStart",
+    "session_id": "abc123",
+    "source": "clear",  # or "startup", "resume", "compact"
+    "permission_mode": "bypassPermissions",
+    "model": "...",
+    ...
+}
+"""
+import sys
+from pathlib import Path
+
+# 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 (
+    get_all_in_flight_contexts,
+    update_plan_status,
+    update_context_session_id,
+)
+
+
+def main():
+    """
+    Handle mode transitions on session start.
+
+    When source is "clear" and permission_mode is "bypassPermissions" or "acceptEdits",
+    transition any pending_implementation context to implementing.
+    """
+    try:
+        # Read hook input using shared utility
+        hook_input = load_hook_input()
+
+        if not hook_input:
+            return
+
+        source = hook_input.get("source", "unknown")
+        permission_mode = hook_input.get("permission_mode", "default")
+        session_id = hook_input.get("session_id", "unknown")
+        project_root = project_dir(hook_input)
+
+        eprint(f"[session_start] source={source}, permission_mode={permission_mode}, session={session_id[:8]}...")
+
+        # Only handle /clear with bypass/accept permissions
+        if source != "clear":
+            eprint(f"[session_start] Skipping: source is '{source}', not 'clear'")
+            return
+
+        if permission_mode == "plan":
+            eprint(f"[session_start] Skipping: permission_mode is 'plan' (in planning mode)")
+            return
+
+        # Find contexts in pending_implementation mode
+        in_flight_contexts = get_all_in_flight_contexts(project_root)
+        pending_contexts = [
+            ctx for ctx in in_flight_contexts
+            if ctx.in_flight and ctx.in_flight.mode == "pending_implementation"
+        ]
+
+        if not pending_contexts:
+            eprint("[session_start] No pending_implementation contexts found")
+            return
+
+        # Transition each pending context to implementing
+        for ctx in pending_contexts:
+            eprint(f"[session_start] Transitioning {ctx.id} from pending_implementation to implementing")
+            update_plan_status(ctx.id, "implementing", project_root=project_root)
+
+            # Also bind this session to the context
+            update_context_session_id(ctx.id, session_id, project_root)
+            eprint(f"[session_start] Bound session {session_id[:8]}... to context {ctx.id}")
+
+        eprint(f"[session_start] Transitioned {len(pending_contexts)} context(s) to implementing")
+
+    except Exception as e:
+        eprint(f"[session_start] ERROR: {e}")
+        import traceback
+        eprint(traceback.format_exc())
+
+
+if __name__ == "__main__":
+    main()