aiwcli 0.10.2 → 0.11.0

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

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook - captures TaskUpdate operations for persistence.
-
-This hook runs after Claude uses the TaskUpdate tool and automatically
-records the update in the context's state.json.
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "PostToolUse",
-    "tool_name": "TaskUpdate",
-    "tool_input": {
-        "taskId": "1",
-        "status": "completed",
-        "metadata": {"evidence": "...", "work_summary": "...", ...},
-        "addBlockedBy": ["2"],
-        ...
-    },
-    "tool_response": {...},
-    "session_id": "abc123",
-    "cwd": "/path/to/project"
-}
-
-Hook output:
-- Silent on success (no stdout output)
-- Logs to stderr for debugging
-"""
-import sys
-from pathlib import Path
-from typing import 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.base.hook_utils import (
-    load_hook_input,
-    validate_hook_event,
-    get_tool_input,
-    check_skip_persistence,
-    safe_hook_main,
-    run_hook,
-    log_debug,
-    log_info,
-    log_warn,
-    log_error,
-)
-from lib.base.utils import project_dir
-from lib.context.context_store import get_context_by_session_id
-from lib.context.task_tracker import update_task, delete_task
-
-
-def get_persistent_task_id(
-    claude_task_id: str,
-    tool_input: Dict[str, Any]
-) -> str:
-    """Convert Claude's ephemeral task ID to persistent task ID."""
-    metadata = tool_input.get("metadata", {})
-    if isinstance(metadata, dict):
-        persistent_id = metadata.get("persistent_id")
-        if persistent_id:
-            return persistent_id
-    return f"aiw-{claude_task_id}"
-
-
-@safe_hook_main("task_update_capture")
-def main() -> int:
-    """Main hook entry point."""
-    payload = load_hook_input()
-    if not payload:
-        return 0
-
-    if not validate_hook_event(payload, "PostToolUse", "TaskUpdate"):
-        return 0
-
-    tool_input = get_tool_input(payload)
-    if not tool_input:
-        log_warn("task_update_capture", "Invalid tool_input: not a dict")
-        return 0
-
-    if check_skip_persistence(payload, "task_update_capture"):
-        return 0
-
-    project_root = project_dir(payload)
-    session_id = payload.get("session_id", "")
-
-    # Find context by session ID
-    state = get_context_by_session_id(session_id, project_root)
-    if not state:
-        log_debug("task_update_capture", "No context available - skipping persistence")
-        return 0
-
-    context_id = state.id
-
-    # Extract task ID
-    claude_task_id = tool_input.get("taskId")
-    if not claude_task_id:
-        log_warn("task_update_capture", "Missing required field: taskId")
-        return 0
-
-    persistent_task_id = get_persistent_task_id(claude_task_id, tool_input)
-
-    status = tool_input.get("status")
-    metadata = tool_input.get("metadata", {})
-
-    events_recorded = []
-
-    if status == "deleted":
-        if delete_task(context_id, persistent_task_id, project_root):
-            events_recorded.append("task_deleted")
-    elif status:
-        # Extract completion metadata
-        evidence = ""
-        work_summary = ""
-        files_changed = None
-        if isinstance(metadata, dict):
-            evidence = metadata.get("evidence", "")
-            work_summary = metadata.get("work_summary", "")
-            files_changed = metadata.get("files_changed")
-            if files_changed and not isinstance(files_changed, list):
-                files_changed = None
-
-        success = update_task(
-            context_id=context_id,
-            task_id=persistent_task_id,
-            status=status,
-            evidence=evidence,
-            work_summary=work_summary,
-            files_changed=files_changed,
-            session_id=session_id,
-            project_root=project_root,
-        )
-        if success:
-            events_recorded.append(f"task_{status}")
-
-    if events_recorded:
-        log_info("task_update_capture", f"Recorded {', '.join(events_recorded)} for {persistent_task_id} in {context_id}")
-    else:
-        log_debug("task_update_capture", f"No relevant changes for {persistent_task_id}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    run_hook(main, "task_update_capture")

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

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""Unified UserPromptSubmit hook entry point.
-
-This hook runs on every UserPromptSubmit and handles:
-- Context enforcement - ensures all work happens in a tracked context
-
-Note: Context monitoring (handoff warnings) is handled separately by
-context_monitor.py on PostToolUse events, which fires during Claude's
-work rather than waiting for user input.
-
-Hook input (from Claude Code):
-{
-    "hook_type": "UserPromptSubmit",
-    "prompt": "user's message text",
-    "session_id": "abc123",
-    ...
-}
-
-Hook output:
-- Prints system reminders to stdout for context enforcement
-"""
-import sys
-from pathlib import Path
-from typing import List
-
-# 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, log_diagnostic
-from lib.base.utils import project_dir
-from lib.context.context_store import (
-    get_context,
-    get_context_by_session_id,
-    bind_session,
-    maybe_activate,
-    save_state,
-)
-from lib.context.context_selector import determine_context, BlockRequest
-
-
-def _update_in_flight_status(context_id: str, hook_input: dict, project_root: Path) -> None:
-    """
-    Update context mode based on permission mode.
-
-    - permission_mode == "plan": no-op (planning is runtime-only, not persisted)
-    - permission_mode != "plan" and mode == "idle": set to "active"
-    - permission_mode != "plan" and mode == "has_plan": set to "active" (plan was accepted)
-    """
-    permission_mode = hook_input.get("permission_mode", "default")
-    log_debug("user_prompt_submit", f"context_id={context_id}, permission_mode={permission_mode}")
-    maybe_activate(context_id, permission_mode, project_root=project_root, caller="user_prompt_submit")
-
-
-def main():
-    """
-    Main entry point for UserPromptSubmit hook.
-
-    Handles context enforcement for all user prompts.
-    Uses session_id to detect first prompt vs subsequent prompts.
-    """
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        user_prompt = hook_input.get("prompt", "")
-        project_root = project_dir(hook_input)
-        session_id = hook_input.get("session_id", "unknown")
-
-        log_diagnostic("user_prompt_submit", "receive", f"session={session_id[:8]}, prompt_len={len(user_prompt)}",
-                        inputs={"session_id": session_id[:12], "prompt_length": len(user_prompt)})
-
-        outputs: List[str] = []
-        active_context_id = None
-
-        # First-prompt detection: check if session_id is already bound to a context
-        existing_context = get_context_by_session_id(session_id, project_root)
-
-        if existing_context:
-            # NOT first prompt - session already bound to context
-            log_debug("user_prompt_submit", f"Session {session_id[:8]}... already bound to {existing_context.id}")
-            log_diagnostic("user_prompt_submit", "decide", f"Session already bound to {existing_context.id}",
-                            decision="session_match", reasoning="session_id found in existing context",
-                            inputs={"context_id": existing_context.id, "mode": existing_context.mode})
-            _update_in_flight_status(existing_context.id, hook_input, project_root)
-            active_context_id = existing_context.id
-        elif user_prompt:
-            # FIRST prompt - need context detection
-            try:
-                context_id, method, context_output = determine_context(user_prompt, session_id, project_root)
-                log_info("user_prompt_submit", f"Context: {method} -> {context_id}")
-                log_diagnostic("user_prompt_submit", "decide", f"Context detected via {method}: {context_id}",
-                                decision=method, reasoning=f"determine_context returned method={method}",
-                                inputs={"context_id": context_id, "has_output": bool(context_output)})
-
-                if context_id:
-                    # Bind session to context
-                    bind_session(context_id, session_id, project_root)
-                    log_info("user_prompt_submit", f"Bound session {session_id[:8]}... to context '{context_id}'")
-
-                    # Update mode based on permission mode
-                    _update_in_flight_status(context_id, hook_input, project_root)
-                    active_context_id = context_id
-
-                    # Clear handoff_path after it's been injected via context_selector
-                    try:
-                        ctx = get_context(context_id, project_root)
-                        if ctx and ctx.handoff_path:
-                            ctx.handoff_path = None
-                            save_state(ctx, project_root)
-                            log_debug("user_prompt_submit", f"Cleared handoff_path for {context_id}")
-                    except Exception as e:
-                        log_warn("user_prompt_submit", f"Failed to clear handoff_path: {e}")
-
-                if context_output:
-                    outputs.append(context_output)
-
-            except BlockRequest as e:
-                log_error("user_prompt_submit", e.message)
-                sys.exit(2)
-
-        log_diagnostic("user_prompt_submit", "result", f"context={active_context_id}, outputs={len(outputs)}",
-                        inputs={"active_context_id": active_context_id, "output_count": len(outputs)})
-
-        if outputs:
-            print("\n\n".join(outputs))
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("user_prompt_submit", e, "UserPromptSubmit", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "user_prompt_submit")

package/dist/templates/_shared/lib/__init__.py

@@ -1 +0,0 @@
-"""Shared library for AIW CLI templates."""

package/dist/templates/_shared/lib/base/__init__.py

@@ -1,65 +0,0 @@
-"""Base utilities for shared context management."""
-from .atomic_write import atomic_write, atomic_append
-from .constants import (
-    OUTPUT_DIR,
-    CONTEXTS_DIR,
-    INDEX_FILENAME,
-    validate_context_id,
-    get_output_dir,
-    get_contexts_dir,
-    get_context_dir,
-    get_context_plans_dir,
-    get_context_handoffs_dir,
-    get_index_path,
-    get_context_file_path,
-    get_events_file_path,
-)
-from .utils import (
-    eprint,
-    now_local,
-    now_iso,
-    project_dir,
-    sanitize_filename,
-    sanitize_title,
-    generate_context_id,
-)
-from .logger import (
-    hook_log,
-    log_debug,
-    log_info,
-    log_warn,
-    log_error,
-    log_hook_error,
-    set_context_path,
-)
-
-__all__ = [
-    "atomic_write",
-    "atomic_append",
-    "OUTPUT_DIR",
-    "CONTEXTS_DIR",
-    "INDEX_FILENAME",
-    "validate_context_id",
-    "get_output_dir",
-    "get_contexts_dir",
-    "get_context_dir",
-    "get_context_plans_dir",
-    "get_context_handoffs_dir",
-    "get_index_path",
-    "get_context_file_path",
-    "get_events_file_path",
-    "eprint",
-    "now_local",
-    "now_iso",
-    "project_dir",
-    "sanitize_filename",
-    "sanitize_title",
-    "generate_context_id",
-    "hook_log",
-    "log_debug",
-    "log_info",
-    "log_warn",
-    "log_error",
-    "log_hook_error",
-    "set_context_path",
-]

package/dist/templates/_shared/lib/base/atomic_write.py

@@ -1,180 +0,0 @@
-"""Cross-platform atomic file writes with security.
-
-Provides crash-safe file writes by writing to a temp file first,
-then atomically replacing the target. This prevents corrupted files
-if the process crashes mid-write.
-
-Note: This is for crash-safety, NOT for concurrent access.
-The shared context system assumes single-session-per-context.
-"""
-import os
-import sys
-import tempfile
-import time
-from pathlib import Path
-from typing import Optional, Tuple
-
-if sys.platform == 'win32':
-    import ctypes
-    from ctypes import wintypes
-
-    # Windows MoveFileEx flags
-    MOVEFILE_REPLACE_EXISTING = 0x1
-    MOVEFILE_WRITE_THROUGH = 0x8
-
-    def _atomic_replace_windows(src: Path, dst: Path) -> None:
-        """Atomic file replacement on Windows using MoveFileEx."""
-        kernel32 = ctypes.windll.kernel32
-
-        # Set proper function prototypes for 64-bit safety
-        kernel32.MoveFileExW.argtypes = [wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.DWORD]
-        kernel32.MoveFileExW.restype = wintypes.BOOL
-
-        result = kernel32.MoveFileExW(
-            str(src),
-            str(dst),
-            MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH
-        )
-        if not result:
-            error_code = kernel32.GetLastError()
-            raise ctypes.WinError(error_code)
-
-
-def atomic_write(
-    path: Path,
-    content: str,
-    max_attempts: int = 2,
-    backoff_ms: Optional[list] = None
-) -> Tuple[bool, Optional[str]]:
-    """
-    Write file atomically with retry logic.
-
-    Creates a temp file in the same directory, writes content,
-    then atomically replaces the target file. This ensures the
-    file is never left in a corrupted state.
-
-    Args:
-        path: Target file path
-        content: Content to write
-        max_attempts: Maximum retry attempts (default: 2)
-        backoff_ms: Retry backoff in milliseconds (default: [500, 1000])
-
-    Returns:
-        Tuple of (success: bool, error_message: Optional[str])
-    """
-    if backoff_ms is None:
-        backoff_ms = [500, 1000]
-
-    # Ensure parent directory exists
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    for attempt in range(max_attempts):
-        try:
-            # Create temp file in same directory for atomic rename
-            temp_fd, temp_path_str = tempfile.mkstemp(
-                dir=path.parent,
-                prefix=f".{path.stem}_",
-                suffix=".tmp"
-            )
-            temp_path = Path(temp_path_str)
-
-            try:
-                # Write content to temp file
-                with os.fdopen(temp_fd, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                    f.flush()
-                    os.fsync(f.fileno())  # Force write to disk
-
-                # Set restrictive permissions before rename (chmod 600)
-                try:
-                    os.chmod(temp_path, 0o600)
-                except OSError:
-                    pass  # chmod may fail on some filesystems
-
-                # Platform-specific atomic rename
-                if sys.platform == 'win32':
-                    _atomic_replace_windows(temp_path, path)
-                else:
-                    temp_path.replace(path)  # POSIX atomic
-
-                return (True, None)
-
-            except Exception:
-                # Clean up temp file on failure
-                try:
-                    temp_path.unlink()
-                except Exception:
-                    pass  # Cleanup is best-effort
-                raise
-
-        except Exception as e:
-            if attempt < max_attempts - 1:
-                # Bounds-safe backoff indexing
-                wait_ms = backoff_ms[min(attempt, len(backoff_ms) - 1)]
-                time.sleep(wait_ms / 1000.0)
-            else:
-                # Sanitize error message (no paths, no stack trace)
-                error_type = type(e).__name__
-                error_msg = str(e).split('\n')[0][:200]  # First line only, max 200 chars
-                return (False, f"{error_type}: {error_msg}")
-
-    return (False, "Max retry attempts exceeded")
-
-
-def atomic_append(
-    path: Path,
-    content: str,
-    max_attempts: int = 2,
-    backoff_ms: Optional[list] = None
-) -> Tuple[bool, Optional[str]]:
-    """
-    Append to file atomically with retry logic.
-
-    For JSONL files, this is safe because each line is independent.
-    If process crashes mid-append, only the last partial line is lost,
-    which read_events() handles gracefully.
-
-    Args:
-        path: Target file path
-        content: Content to append (should include newline if needed)
-        max_attempts: Maximum retry attempts (default: 2)
-        backoff_ms: Retry backoff in milliseconds (default: [500, 1000])
-
-    Returns:
-        Tuple of (success: bool, error_message: Optional[str])
-    """
-    if backoff_ms is None:
-        backoff_ms = [500, 1000]
-
-    # Ensure parent directory exists
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Check if file is being created (for permission setting)
-    is_new_file = not path.exists()
-
-    for attempt in range(max_attempts):
-        try:
-            with open(path, 'a', encoding='utf-8') as f:
-                f.write(content)
-                f.flush()
-                os.fsync(f.fileno())  # Force write to disk
-
-            # Set restrictive permissions on newly created files (chmod 600)
-            if is_new_file:
-                try:
-                    os.chmod(path, 0o600)
-                except OSError:
-                    pass  # chmod may fail on some filesystems
-
-            return (True, None)
-
-        except Exception as e:
-            if attempt < max_attempts - 1:
-                wait_ms = backoff_ms[min(attempt, len(backoff_ms) - 1)]
-                time.sleep(wait_ms / 1000.0)
-            else:
-                error_type = type(e).__name__
-                error_msg = str(e).split('\n')[0][:200]
-                return (False, f"{error_type}: {error_msg}")
-
-    return (False, "Max retry attempts exceeded")