aiwcli 0.9.7 → 0.10.0

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

@@ -1,205 +0,0 @@
-#!/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/lib/context/cache.py

@@ -1,444 +0,0 @@
-"""Cache rebuild utilities for context management.
-
-These functions allow recovery from corrupted cache files
-by rebuilding from the source of truth (events.jsonl).
-
-Data hierarchy:
-  events.jsonl (source of truth)
-    → context.json (L1 cache) - can be rebuilt
-      → index.json (L2 cache) - can be rebuilt
-"""
-import json
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from ..base.atomic_write import atomic_write
-from ..base.constants import (
-    get_contexts_dir,
-    get_context_file_path,
-    get_events_file_path,
-    get_index_path,
-    get_archive_dir,
-    get_archive_index_path,
-    ARCHIVE_DIR,
-)
-from ..base.utils import eprint, now_iso
-from .event_log import read_events
-
-
-def rebuild_context_from_events(context_dir: Path, project_root: Path = None) -> Optional['Context']:
-    """
-    Rebuild context.json by replaying events.jsonl.
-
-    This is the recovery mechanism when context.json is
-    corrupted or out of sync.
-
-    Args:
-        context_dir: Path to context directory
-        project_root: Project root directory (if known, avoids fragile path calculation)
-
-    Returns:
-        Rebuilt Context object, or None if events file doesn't exist
-    """
-    # Import here to avoid circular dependency
-    from .context_manager import Context, InFlightState
-
-    events_path = context_dir / "events.jsonl"
-    if not events_path.exists():
-        return None
-
-    context_id = context_dir.name
-
-    # Calculate project_root if not provided
-    # Structure: project_root/_output/contexts/{id}
-    if project_root is None:
-        # Traverse up: context_dir -> contexts -> _output -> project_root
-        project_root = context_dir.parent.parent.parent
-
-    events = read_events(context_id, project_root)
-
-    if not events:
-        return None
-
-    # Initialize context with defaults
-    context = Context(
-        id=context_id,
-        status="active",
-        folder=str(context_dir),
-        in_flight=InFlightState()
-    )
-
-    # Replay events to derive current state
-    for event in events:
-        event_type = event.get("event")
-        timestamp = event.get("timestamp")
-
-        # Update last_active for any event
-        context.last_active = timestamp
-
-        if event_type == "context_created":
-            context.summary = event.get("summary", "")
-            context.method = event.get("method")
-            context.tags = event.get("tags", [])
-            context.created_at = timestamp
-
-        elif event_type == "context_completed":
-            context.status = "completed"
-
-        elif event_type == "context_reopened":
-            context.status = "active"
-
-        elif event_type == "metadata_updated":
-            if "summary" in event:
-                context.summary = event["summary"]
-            if "tags" in event:
-                context.tags = event["tags"]
-            if "method" in event:
-                context.method = event["method"]
-
-        elif event_type == "planning_started":
-            context.in_flight.mode = "planning"
-
-        elif event_type == "plan_created":
-            context.in_flight.mode = "pending_implementation"
-            context.in_flight.artifact_path = event.get("path")
-            context.in_flight.artifact_hash = event.get("hash")
-            context.in_flight.started_at = timestamp
-
-        elif event_type == "plan_implementation_started":
-            context.in_flight.mode = "implementing"
-
-        elif event_type == "plan_completed":
-            context.in_flight.mode = "none"
-            context.in_flight.artifact_path = None
-            context.in_flight.artifact_hash = None
-            context.in_flight.started_at = None
-
-        elif event_type == "handoff_created":
-            # Handoff events are informational only - no mode change
-            context.in_flight.handoff_path = event.get("path")
-
-        elif event_type == "handoff_cleared":
-            # Legacy event - just clear handoff_path, no mode change
-            context.in_flight.handoff_path = None
-
-    return context
-
-
-def rebuild_index_from_folders(project_root: Path = None) -> Dict[str, Any]:
-    """
-    Rebuild index.json by scanning context folders.
-
-    This is the recovery mechanism when index.json is
-    corrupted or out of sync.
-
-    Note: Skips the archive/ folder - archived contexts are not included
-    in the main index.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        Rebuilt index dictionary
-    """
-    index = {
-        "version": "2.0",
-        "updated_at": now_iso(),
-        "contexts": {}
-    }
-
-    contexts_dir = get_contexts_dir(project_root)
-    if not contexts_dir.exists():
-        return index
-
-    for ctx_dir in contexts_dir.iterdir():
-        if not ctx_dir.is_dir():
-            continue
-
-        # Skip archive folder - archived contexts have their own index
-        if ctx_dir.name == ARCHIVE_DIR:
-            continue
-
-        # Try to read context.json first
-        context_file = ctx_dir / "context.json"
-        if context_file.exists():
-            try:
-                ctx_data = json.loads(context_file.read_text(encoding='utf-8'))
-                in_flight = ctx_data.get("in_flight", {})
-                index["contexts"][ctx_data["id"]] = {
-                    "id": ctx_data["id"],
-                    "status": ctx_data.get("status", "active"),
-                    "method": ctx_data.get("method"),
-                    "summary": ctx_data.get("summary", ""),
-                    "created_at": ctx_data.get("created_at"),
-                    "last_active": ctx_data.get("last_active"),
-                    "folder": str(ctx_dir),
-                    "in_flight_mode": in_flight.get("mode", "none")
-                }
-                continue
-            except Exception as e:
-                eprint(f"[cache] Failed to read {context_file}, rebuilding from events: {e}")
-
-        # Fallback: rebuild from events
-        context = rebuild_context_from_events(ctx_dir)
-        if context:
-            index["contexts"][context.id] = context.to_index_entry()
-
-    return index
-
-
-def rebuild_archive_index(project_root: Path = None) -> Dict[str, Any]:
-    """
-    Rebuild archive/index.json by scanning archive folder.
-
-    This is the recovery mechanism when archive index is
-    corrupted or out of sync.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        Rebuilt archive index dictionary
-    """
-    archive_index = {
-        "version": "2.0",
-        "updated_at": now_iso(),
-        "contexts": {}
-    }
-
-    archive_dir = get_archive_dir(project_root)
-    if not archive_dir.exists():
-        return archive_index
-
-    for ctx_dir in archive_dir.iterdir():
-        if not ctx_dir.is_dir():
-            continue
-
-        # Skip index.json file itself
-        if ctx_dir.name == "index.json":
-            continue
-
-        # Try to read context.json first
-        context_file = ctx_dir / "context.json"
-        if context_file.exists():
-            try:
-                ctx_data = json.loads(context_file.read_text(encoding='utf-8'))
-                in_flight = ctx_data.get("in_flight", {})
-                archive_index["contexts"][ctx_data["id"]] = {
-                    "id": ctx_data["id"],
-                    "status": ctx_data.get("status", "completed"),
-                    "method": ctx_data.get("method"),
-                    "summary": ctx_data.get("summary", ""),
-                    "created_at": ctx_data.get("created_at"),
-                    "last_active": ctx_data.get("last_active"),
-                    "folder": str(ctx_dir),
-                    "in_flight_mode": in_flight.get("mode", "none")
-                }
-                continue
-            except Exception as e:
-                eprint(f"[cache] Failed to read {context_file}, rebuilding from events: {e}")
-
-        # Fallback: rebuild from events
-        context = rebuild_context_from_events(ctx_dir)
-        if context:
-            archive_index["contexts"][context.id] = context.to_index_entry()
-
-    return archive_index
-
-
-def rebuild_all_caches(project_root: Path = None) -> bool:
-    """
-    Rebuild all cache files from events.jsonl files.
-
-    Useful for recovery after corruption or version migration.
-    Rebuilds both active context caches and archive index.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        True if all caches were rebuilt successfully
-    """
-    success = True
-    contexts_dir = get_contexts_dir(project_root)
-
-    if not contexts_dir.exists():
-        eprint("[cache] No contexts directory found, nothing to rebuild")
-        return True
-
-    # Rebuild each active context's cache (skip archive folder)
-    for ctx_dir in contexts_dir.iterdir():
-        if not ctx_dir.is_dir():
-            continue
-
-        # Skip archive folder - handled separately
-        if ctx_dir.name == ARCHIVE_DIR:
-            continue
-
-        events_path = ctx_dir / "events.jsonl"
-        if not events_path.exists():
-            continue
-
-        eprint(f"[cache] Rebuilding context: {ctx_dir.name}")
-        context = rebuild_context_from_events(ctx_dir)
-
-        if context:
-            context_file = ctx_dir / "context.json"
-            content = json.dumps(context.to_dict(), indent=2, ensure_ascii=False)
-            ok, error = atomic_write(context_file, content)
-            if not ok:
-                eprint(f"[cache] Failed to write {context_file}: {error}")
-                success = False
-        else:
-            eprint(f"[cache] Failed to rebuild context: {ctx_dir.name}")
-            success = False
-
-    # Rebuild archived context caches
-    archive_dir = get_archive_dir(project_root)
-    if archive_dir.exists():
-        for ctx_dir in archive_dir.iterdir():
-            if not ctx_dir.is_dir():
-                continue
-
-            events_path = ctx_dir / "events.jsonl"
-            if not events_path.exists():
-                continue
-
-            eprint(f"[cache] Rebuilding archived context: {ctx_dir.name}")
-            context = rebuild_context_from_events(ctx_dir)
-
-            if context:
-                context_file = ctx_dir / "context.json"
-                content = json.dumps(context.to_dict(), indent=2, ensure_ascii=False)
-                ok, error = atomic_write(context_file, content)
-                if not ok:
-                    eprint(f"[cache] Failed to write {context_file}: {error}")
-                    success = False
-            else:
-                eprint(f"[cache] Failed to rebuild archived context: {ctx_dir.name}")
-                success = False
-
-    # Rebuild global index
-    eprint("[cache] Rebuilding global index")
-    index = rebuild_index_from_folders(project_root)
-    index_path = get_index_path(project_root)
-
-    content = json.dumps(index, indent=2, ensure_ascii=False)
-    ok, error = atomic_write(index_path, content)
-    if not ok:
-        eprint(f"[cache] Failed to write index: {error}")
-        success = False
-
-    # Rebuild archive index
-    eprint("[cache] Rebuilding archive index")
-    archive_index = rebuild_archive_index(project_root)
-    archive_index_path = get_archive_index_path(project_root)
-
-    if archive_index["contexts"]:  # Only write if there are archived contexts
-        content = json.dumps(archive_index, indent=2, ensure_ascii=False)
-        ok, error = atomic_write(archive_index_path, content)
-        if not ok:
-            eprint(f"[cache] Failed to write archive index: {error}")
-            success = False
-
-    total_contexts = len(index['contexts']) + len(archive_index['contexts'])
-    eprint(f"[cache] Rebuild complete. {len(index['contexts'])} active, {len(archive_index['contexts'])} archived contexts indexed.")
-    return success
-
-
-def verify_cache_integrity(project_root: Path = None) -> Dict[str, Any]:
-    """
-    Verify integrity of cache files against events.
-
-    Returns a report of any discrepancies found.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        Dictionary with verification results
-    """
-    report = {
-        "ok": True,
-        "issues": [],
-        "contexts_checked": 0,
-        "contexts_with_issues": 0
-    }
-
-    contexts_dir = get_contexts_dir(project_root)
-    if not contexts_dir.exists():
-        return report
-
-    for ctx_dir in contexts_dir.iterdir():
-        if not ctx_dir.is_dir():
-            continue
-
-        # Skip archive folder - archived contexts verified separately
-        if ctx_dir.name == ARCHIVE_DIR:
-            continue
-
-        report["contexts_checked"] += 1
-        context_id = ctx_dir.name
-
-        # Check events.jsonl exists
-        events_path = ctx_dir / "events.jsonl"
-        if not events_path.exists():
-            report["issues"].append({
-                "context": context_id,
-                "issue": "Missing events.jsonl (source of truth)",
-                "severity": "critical"
-            })
-            report["contexts_with_issues"] += 1
-            report["ok"] = False
-            continue
-
-        # Check context.json exists
-        context_file = ctx_dir / "context.json"
-        if not context_file.exists():
-            report["issues"].append({
-                "context": context_id,
-                "issue": "Missing context.json (cache)",
-                "severity": "warning",
-                "action": "Run rebuild_all_caches()"
-            })
-            report["contexts_with_issues"] += 1
-            continue
-
-        # Compare cache with events-derived state
-        try:
-            cached = json.loads(context_file.read_text(encoding='utf-8'))
-            derived = rebuild_context_from_events(ctx_dir)
-
-            if derived:
-                has_issue = False
-                if cached.get("status") != derived.status:
-                    report["issues"].append({
-                        "context": context_id,
-                        "issue": f"Status mismatch: cache={cached.get('status')}, events={derived.status}",
-                        "severity": "warning"
-                    })
-                    has_issue = True
-
-                cached_mode = cached.get("in_flight", {}).get("mode", "none")
-                if cached_mode != derived.in_flight.mode:
-                    report["issues"].append({
-                        "context": context_id,
-                        "issue": f"in_flight.mode mismatch: cache={cached_mode}, events={derived.in_flight.mode}",
-                        "severity": "warning"
-                    })
-                    has_issue = True
-
-                if has_issue:
-                    report["contexts_with_issues"] += 1
-                    report["ok"] = False
-
-        except Exception as e:
-            report["issues"].append({
-                "context": context_id,
-                "issue": f"Verification error: {e}",
-                "severity": "error"
-            })
-            report["contexts_with_issues"] += 1
-            report["ok"] = False
-
-    return report