aiwcli 0.9.2 → 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"
@@ -336,7 +337,7 @@ def format_command_feedback(
             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("")
@@ -636,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

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

@@ -24,7 +24,6 @@ Hook input:
     ...
 }
 """
-import json
 import sys
 from pathlib import Path
 
@@ -33,6 +32,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_in_flight_contexts,
@@ -49,15 +49,10 @@ def main():
     transition any pending_implementation context to implementing.
     """
     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
 
         source = hook_input.get("source", "unknown")

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

@@ -12,13 +12,20 @@ import sys
 from pathlib import Path
 
 # Path setup
-_hook_dir = Path(__file__).resolve().parent
-_shared_lib = _hook_dir.parent / "lib"
-sys.path.insert(0, str(_shared_lib))
-
-from base.utils import eprint
-from base.subprocess_utils import is_internal_call
-from base.inference import inference
+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,
+    validate_hook_event,
+    get_tool_input,
+    safe_hook_main,
+    run_hook,
+)
+from lib.base.utils import eprint
+from lib.base.subprocess_utils import is_internal_call
+from lib.base.inference import inference
 
 # Prompt engineered per Prompting/Standards.md:
 # - Markdown-only (no XML)
@@ -87,21 +94,25 @@ ASSESSMENT_USER_TEMPLATE = """Assess this task for atomicity and forkability:
 Evaluate whether a subagent with zero prior context could execute this task successfully."""
 
 
+@safe_hook_main("task_create_atomicity")
 def main() -> int:
     # Skip internal calls (prevents recursion from orchestrator/inference)
     if is_internal_call():
         return 0
 
-    try:
-        payload = json.load(sys.stdin)
-    except json.JSONDecodeError:
+    # Load and validate hook input
+    payload = load_hook_input()
+    if not payload:
         return 0
 
     # Only process TaskCreate
-    if payload.get("tool_name") != "TaskCreate":
+    if not validate_hook_event(payload, "PreToolUse", "TaskCreate"):
+        return 0
+
+    tool_input = get_tool_input(payload)
+    if not tool_input:
         return 0
 
-    tool_input = payload.get("tool_input", {})
     subject = tool_input.get("subject", "")
     description = tool_input.get("description", "")
 
@@ -110,66 +121,65 @@ def main() -> int:
         return 0
 
     # Call inference to assess atomicity and forkability
+    result = inference(
+        system_prompt=ASSESSMENT_SYSTEM_PROMPT,
+        user_prompt=ASSESSMENT_USER_TEMPLATE.format(
+            subject=subject,
+            description=description
+        ),
+        level="fast",  # Use Haiku for minimal latency (~1-2s)
+        timeout=12,    # Allow up to 12s for inference
+    )
+
+    if not result.success:
+        eprint(f"[task_create_atomicity] Inference failed: {result.error}")
+        return 0  # Non-blocking on failure
+
+    # Parse JSON response
     try:
-        result = inference(
-            system_prompt=ASSESSMENT_SYSTEM_PROMPT,
-            user_prompt=ASSESSMENT_USER_TEMPLATE.format(
-                subject=subject,
-                description=description
-            ),
-            level="fast",  # Use Haiku for minimal latency (~1-2s)
-            timeout=12,    # Allow up to 12s for inference
-        )
-
-        if not result.success:
-            eprint(f"[task-create-atomicity] Inference failed: {result.error}")
-            return 0  # Non-blocking on failure
-
-        # Parse JSON response
-        try:
-            # Handle potential markdown code blocks in response
-            output = result.output.strip()
-            if output.startswith("```"):
-                # Extract JSON from code block
-                lines = output.split("\n")
-                json_lines = []
-                in_block = False
-                for line in lines:
-                    if line.startswith("```") and not in_block:
-                        in_block = True
-                        continue
-                    elif line.startswith("```") and in_block:
-                        break
-                    elif in_block:
-                        json_lines.append(line)
-                output = "\n".join(json_lines)
-
-            assessment = json.loads(output)
-        except json.JSONDecodeError:
-            eprint(f"[task-create-atomicity] Failed to parse inference response: {result.output[:100]}")
-            return 0
-
-        # Extract assessment fields
-        atomic = assessment.get("atomic", True)
-        forkable = assessment.get("forkable", True)
-        issues = assessment.get("issues", [])
-        recommendation = assessment.get("recommendation", "")
-
-        # Build context message based on assessment
-        if atomic and forkable:
-            # Task is good - minimal positive feedback
-            context_msg = "Task Assessment: Well-specified and forkable."
-        else:
-            # Task has issues - inject detailed warning
-            status_parts = []
-            if not atomic:
-                status_parts.append("NOT ATOMIC")
-            if not forkable:
-                status_parts.append("NOT FORKABLE")
-
-            issues_text = "\n".join(f"- {issue}" for issue in issues) if issues else "- See recommendation below"
-
-            context_msg = f"""**TASK ATOMICITY WARNING** ({', '.join(status_parts)})
+        # Handle potential markdown code blocks in response
+        output = result.output.strip()
+        if output.startswith("```"):
+            # Extract JSON from code block
+            lines = output.split("\n")
+            json_lines = []
+            in_block = False
+            for line in lines:
+                if line.startswith("```") and not in_block:
+                    in_block = True
+                    continue
+                elif line.startswith("```") and in_block:
+                    break
+                elif in_block:
+                    json_lines.append(line)
+            output = "\n".join(json_lines)
+
+        assessment = json.loads(output)
+    except json.JSONDecodeError:
+        eprint(f"[task_create_atomicity] Failed to parse inference response: {result.output[:100]}")
+        return 0
+
+    # Extract assessment fields
+    atomic = assessment.get("atomic", True)
+    forkable = assessment.get("forkable", True)
+    issues = assessment.get("issues", [])
+    recommendation = assessment.get("recommendation", "")
+
+    # Build context message based on assessment
+    if atomic and forkable:
+        # Task is good - minimal positive feedback
+        context_msg = "Task Assessment: Well-specified and forkable."
+    else:
+        # Task has issues - inject detailed warning
+        status_parts = []
+        if not atomic:
+            status_parts.append("NOT ATOMIC")
+        if not forkable:
+            status_parts.append("NOT FORKABLE")
+
+        issues_text = "\n".join(f"- {issue}" for issue in issues) if issues else "- See recommendation below"
+
+        context_msg = f"""**TASK ATOMICITY WARNING** ({', '.join(status_parts)})
 
 This task may lack sufficient context for independent execution by a subagent.
 
@@ -180,20 +190,16 @@ This task may lack sufficient context for independent execution by a subagent.
 
 Consider adding specific file paths, function names, expected behaviors, or error details before creating this task."""
 
-        # Output hook response with additionalContext
-        out = {
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "additionalContext": context_msg
-            }
+    # Output hook response with additionalContext
+    out = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": context_msg
         }
-        print(json.dumps(out, ensure_ascii=False))
-        return 0
-
-    except Exception as e:
-        eprint(f"[task-create-atomicity] Error: {e}")
-        return 0  # Non-blocking on error
+    }
+    print(json.dumps(out, ensure_ascii=False))
+    return 0
 
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    run_hook(main)