aiwcli 0.9.1 → 0.9.4

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

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""PreToolUse hook for TaskCreate - assesses atomicity and forkability via inference.
+
+Ensures tasks contain sufficient self-contained context for independent execution,
+especially when delegated to subagents with zero conversation history.
+
+Non-blocking: Warns but allows creation even if atomicity is poor.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Path setup
+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)
+# - Positive framing (tell what TO do)
+# - 1-3 clear examples matching desired output
+# - Direct imperative instructions
+# - Explicit JSON output format
+
+ASSESSMENT_SYSTEM_PROMPT = """You assess task descriptions for atomicity and forkability.
+
+## Definitions
+
+**Atomic Task:** Contains ALL context needed for independent execution without reading prior conversation.
+
+**Forkable Task:** Can be delegated to a subagent with ZERO conversation history and still be completed successfully.
+
+## Signs of Non-Atomic Tasks
+
+Look for these indicators:
+- Contextual references: "the file above", "as discussed", "the mentioned function", "this bug"
+- Vague descriptions assuming prior knowledge: "fix the bug", "update it", "finish the work"
+- Missing specifics: which file? what function? what expected behavior? what error?
+- Pronouns without antecedents: "it", "they", "the issue" without explicit definition
+
+## Signs of Atomic Tasks
+
+Well-specified tasks include:
+- Explicit file paths: "Edit src/utils/parser.py"
+- Specific function names: "Modify the validate_input() function"
+- Clear expected behavior: "Should return 404 when user not found"
+- Complete error context: "TypeError on line 45 when input is None"
+
+## Examples
+
+**Example 1: Non-Atomic Task**
+Subject: "Fix the bug"
+Description: "The issue we discussed earlier needs to be resolved"
+Assessment: NOT atomic (no file, no function, no error details, references "discussed earlier")
+
+**Example 2: Atomic Task**
+Subject: "Fix null pointer in user lookup"
+Description: "In src/services/user.py, the get_user_by_id() function raises TypeError when user_id is None. Add null check at line 23 that returns None early instead of calling database.query()."
+Assessment: Atomic (file path, function name, specific error, exact fix location, expected behavior)
+
+**Example 3: Partially Atomic Task**
+Subject: "Add validation to form"
+Description: "Add email validation to the signup form. Return error message if invalid."
+Assessment: NOT fully atomic (missing: which file contains the form? what validation rules? where to display error?)
+
+## Output Format
+
+Respond with valid JSON only:
+{
+  "atomic": true/false,
+  "forkable": true/false,
+  "issues": ["specific issue 1", "specific issue 2"],
+  "recommendation": "brief actionable suggestion if issues exist, or 'Task is well-specified' if good"
+}"""
+
+ASSESSMENT_USER_TEMPLATE = """Assess this task for atomicity and forkability:
+
+**Subject:** {subject}
+
+**Description:** {description}
+
+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
+
+    # Load and validate hook input
+    payload = load_hook_input()
+    if not payload:
+        return 0
+
+    # Only process TaskCreate
+    if not validate_hook_event(payload, "PreToolUse", "TaskCreate"):
+        return 0
+
+    tool_input = get_tool_input(payload)
+    if not tool_input:
+        return 0
+
+    subject = tool_input.get("subject", "")
+    description = tool_input.get("description", "")
+
+    # Skip very short tasks (likely intentionally brief or simple acknowledgments)
+    if len(description.strip()) < 15:
+        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:
+        # 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.
+
+**Issues detected:**
+{issues_text}
+
+**Recommendation:** {recommendation}
+
+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
+        }
+    }
+    print(json.dumps(out, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    run_hook(main)

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

@@ -23,83 +23,28 @@ Hook output:
 - Silent on success (no stdout output)
 - Logs to stderr for debugging
 """
-import json
 import sys
 from pathlib import Path
-from typing import Optional, Dict, Any
 
 # 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.context.task_sync import record_task_created, generate_next_task_id
-from lib.context.context_manager import get_all_contexts, get_context_by_session_id
+from lib.base.hook_utils import (
+    load_hook_input,
+    validate_hook_event,
+    get_tool_input,
+    check_skip_persistence,
+    safe_hook_main,
+    run_hook,
+)
 from lib.base.utils import eprint, project_dir
+from lib.context.context_extractor import extract_context_id
+from lib.context.task_sync import record_task_created, generate_next_task_id
 
 
-def extract_context_id(
-    tool_input: Dict[str, Any],
-    project_root: Path,
-    session_id: Optional[str] = None
-) -> Optional[str]:
-    """
-    Extract context ID from tool input metadata, session, or active contexts.
-
-    Priority:
-    1. metadata.context field
-    2. Session ID lookup (session bound to context)
-    3. metadata.persistent_id prefix (e.g., "ctx-123-task-1" -> "ctx-123")
-    4. Single active context
-    5. None (will trigger auto-creation)
-
-    Args:
-        tool_input: Tool input from TaskCreate
-        project_root: Project root directory
-        session_id: Session ID from hook payload
-
-    Returns:
-        Context ID or None if cannot determine
-    """
-    # Check metadata.context field
-    metadata = tool_input.get("metadata", {})
-    if isinstance(metadata, dict):
-        context = metadata.get("context")
-        if context:
-            return context
-
-    # Check session ID - session may be bound to a context
-    if session_id:
-        try:
-            session_context = get_context_by_session_id(session_id, project_root)
-            if session_context:
-                eprint(f"[task_create_capture] Found context via session_id: {session_context.id}")
-                return session_context.id
-        except Exception as e:
-            eprint(f"[task_create_capture] Failed to lookup context by session: {e}")
-
-    # Check persistent_id for context hint
-    if isinstance(metadata, dict):
-        persistent_id = metadata.get("persistent_id", "")
-        if persistent_id and "-" in persistent_id:
-            # Format: "context-id-task-1" or similar
-            parts = persistent_id.split("-")
-            if len(parts) >= 2:
-                # Reconstruct context ID (everything before last two parts)
-                context_parts = parts[:-2] if len(parts) > 2 else parts[:1]
-                return "-".join(context_parts)
-
-    # Check for single active context
-    try:
-        contexts = get_all_contexts(status="active", project_root=project_root)
-        if len(contexts) == 1:
-            return contexts[0].id
-    except Exception as e:
-        eprint(f"[task_create_capture] Failed to get active contexts: {e}")
-
-    return None
-
-
+@safe_hook_main("task_create_capture")
 def main() -> int:
     """
     Main hook entry point.
@@ -107,88 +52,80 @@ def main() -> int:
     Returns:
         0 on success, non-zero on failure (but hook is non-blocking)
     """
-    try:
-        # Parse hook input
-        payload = json.load(sys.stdin)
-
-        # Validate hook type
-        if payload.get("hook_event_name") != "PostToolUse":
-            return 0
-
-        # Validate tool name
-        if payload.get("tool_name") != "TaskCreate":
-            return 0
-
-        # Extract tool input
-        tool_input = payload.get("tool_input", {})
-        if not isinstance(tool_input, dict):
-            eprint("[task_create_capture] Invalid tool_input: not a dict")
-            return 0
-
-        # Check for skip_persistence flag (used during hydration to avoid duplicates)
-        metadata = tool_input.get("metadata", {})
-        if isinstance(metadata, dict) and metadata.get("skip_persistence"):
-            eprint("[task_create_capture] Skipping persistence (hydration mode)")
-            return 0
-
-        # Extract tool response (contains task ID assigned by Claude)
-        tool_response = payload.get("tool_response", {})
-        if not isinstance(tool_response, dict):
-            eprint("[task_create_capture] Invalid tool_response: not a dict")
-            return 0
-
-        # Get project root and session ID
-        project_root = project_dir(payload)
-        session_id = payload.get("session_id")
-
-        # Extract context ID
-        context_id = extract_context_id(tool_input, project_root, session_id)
-        if not context_id:
-            eprint("[task_create_capture] No context available - skipping persistence")
-            eprint("[task_create_capture] Task will be ephemeral until context is created")
-            return 0
-
-        # Extract task data
-        subject = tool_input.get("subject", "")
-        if not subject:
-            eprint("[task_create_capture] Missing required field: subject")
-            return 0
-
-        description = tool_input.get("description", "")
-        active_form = tool_input.get("activeForm", "")
-
-        # Generate persistent task ID
-        # Claude's native ID is ephemeral (1, 2, 3...)
-        # We need a persistent ID that survives sessions
-        persistent_task_id = generate_next_task_id(context_id, project_root)
-
-        # Record the task creation event
-        success = record_task_created(
-            context_id=context_id,
-            task_id=persistent_task_id,
-            subject=subject,
-            description=description,
-            active_form=active_form,
-            project_root=project_root
-        )
-
-        if success:
-            eprint(f"[task_create_capture] Recorded task_added: {persistent_task_id} in {context_id}")
-        else:
-            eprint(f"[task_create_capture] Failed to record task_added: {persistent_task_id}")
-
-        # Silent success (no stdout output)
+    # Parse hook input
+    payload = load_hook_input()
+    if not payload:
+        return 0
+
+    # Validate hook type and tool name
+    if not validate_hook_event(payload, "PostToolUse", "TaskCreate"):
+        return 0
+
+    # Extract tool input
+    tool_input = get_tool_input(payload)
+    if not tool_input:
+        eprint("[task_create_capture] Invalid tool_input: not a dict")
+        return 0
+
+    # Check for skip_persistence flag
+    if check_skip_persistence(payload, "task_create_capture"):
+        return 0
+
+    # Extract tool response (contains task ID assigned by Claude)
+    tool_response = payload.get("tool_response", {})
+    if not isinstance(tool_response, dict):
+        eprint("[task_create_capture] Invalid tool_response: not a dict")
+        return 0
+
+    # Get project root and session ID
+    project_root = project_dir(payload)
+    session_id = payload.get("session_id")
+
+    # Extract context ID using unified extractor
+    context_id = extract_context_id(
+        tool_input,
+        project_root,
+        session_id=session_id,
+        hook_name="task_create_capture",
+        check_persistent_id=True  # TaskCreate uses persistent_id for context hints
+    )
+    if not context_id:
+        eprint("[task_create_capture] No context available - skipping persistence")
+        eprint("[task_create_capture] Task will be ephemeral until context is created")
         return 0
 
-    except json.JSONDecodeError as e:
-        eprint(f"[task_create_capture] JSON decode error: {e}")
-        return 0  # Non-blocking
-    except Exception as e:
-        eprint(f"[task_create_capture] Unexpected error: {e}")
-        import traceback
-        eprint(traceback.format_exc())
-        return 0  # Non-blocking
+    # Extract task data
+    subject = tool_input.get("subject", "")
+    if not subject:
+        eprint("[task_create_capture] Missing required field: subject")
+        return 0
+
+    description = tool_input.get("description", "")
+    active_form = tool_input.get("activeForm", "")
+
+    # Generate persistent task ID
+    # Claude's native ID is ephemeral (1, 2, 3...)
+    # We need a persistent ID that survives sessions
+    persistent_task_id = generate_next_task_id(context_id, project_root)
+
+    # Record the task creation event
+    success = record_task_created(
+        context_id=context_id,
+        task_id=persistent_task_id,
+        subject=subject,
+        description=description,
+        active_form=active_form,
+        project_root=project_root
+    )
+
+    if success:
+        eprint(f"[task_create_capture] Recorded task_added: {persistent_task_id} in {context_id}")
+    else:
+        eprint(f"[task_create_capture] Failed to record task_added: {persistent_task_id}")
+
+    # Silent success (no stdout output)
+    return 0
 
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    run_hook(main)