aiwcli 0.9.8 → 0.10.0

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

@@ -1,177 +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 = """Assess whether a task description is self-contained enough for a subagent with zero conversation history to execute it.
-
-## What Makes a Good Task
-
-A well-specified task includes:
-- Explicit file paths: "Edit src/utils/parser.py"
-- Specific function/component names: "Modify validate_input()"
-- Clear expected behavior: "Return 404 when user not found"
-- Concrete error context: "TypeError on line 45 when input is None"
-
-## What Makes a Poor Task
-
-Watch for context-dependent references:
-- Dangling references: "the file above", "as discussed", "this bug"
-- Vague actions: "fix the bug", "update it", "finish the work"
-- Pronouns without antecedents: "it", "they", "the issue"
-- Missing specifics: which file? what function? what behavior?
-
-## Examples
-
-**Atomic** — Subject: "Fix null pointer in user lookup"
-Description: "In src/services/user.py, get_user_by_id() raises TypeError when user_id is None. Add null check at line 23 to return None instead of calling database.query()."
-Why: file path, function, error, fix location, expected behavior.
-
-**Not atomic** — Subject: "Fix the bug"
-Description: "The issue we discussed earlier needs to be resolved"
-Why: no file, no function, no error details, references conversation history.
-
-**Partially atomic** — Subject: "Add validation to form"
-Description: "Add email validation to the signup form. Return error if invalid."
-Why: missing which file, what validation rules, where to display error.
-
-## Output
-
-Respond with JSON only:
-{"atomic": true/false, "forkable": true/false, "issues": ["issue 1", "issue 2"], "recommendation": "actionable suggestion or 'Well-specified'"}"""
-
-ASSESSMENT_USER_TEMPLATE = """**Subject:** {subject}
-**Description:** {description}
-
-Could a subagent with zero conversation history execute this task?"""
-
-
-@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:
-        context_msg = "Task assessment: well-specified and ready for delegation."
-    else:
-        # Constructive guidance — what to add, not what's wrong
-        issues_text = "\n".join(f"- {issue}" for issue in issues) if issues else ""
-
-        context_msg = f"""**Enrich this task for subagent delegation**
-
-A subagent receiving this task will have no conversation history. To make it actionable:
-
-{issues_text}
-
-**Suggested enrichment:** {recommendation}"""
-
-    # Output hook response with additionalContext
-    out = {
-        "hookSpecificOutput": {
-            "additionalContext": context_msg
-        }
-    }
-    print(json.dumps(out, ensure_ascii=False))
-    return 0
-
-
-if __name__ == "__main__":
-    run_hook(main)

package/dist/templates/_shared/lib/context/auto_state.py

@@ -1,167 +0,0 @@
-"""Auto-state save/load module for session handoff.
-
-Captures structural session state (git state, transcript path, mode)
-for zero-friction session restoration. Does NOT capture Claude's
-subjective state — that comes from the manual /handoff flow.
-
-Auto-state file: _output/contexts/{context_id}/auto-state.json
-Overwritten each save. This is a cache — if corrupted, system degrades gracefully.
-"""
-import json
-import subprocess
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from ..base.atomic_write import atomic_write
-from ..base.constants import get_auto_state_path, get_context_dir
-from ..base.utils import eprint, now_iso
-
-
-AUTO_STATE_VERSION = 1
-
-
-def capture_git_state(project_root: Path = None) -> Dict[str, Any]:
-    """
-    Capture current git state for auto-state snapshot.
-
-    Returns:
-        Dict with branch, uncommitted_files, last_commit_short.
-        Empty dict on failure (non-git repo, git not available).
-    """
-    if project_root is None:
-        project_root = Path.cwd()
-
-    cwd = str(project_root)
-
-    try:
-        # Get current branch
-        branch_result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            capture_output=True, text=True, timeout=5, cwd=cwd
-        )
-        branch = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
-
-        # Get uncommitted files (modified + untracked, limited)
-        status_result = subprocess.run(
-            ["git", "status", "--porcelain", "--short"],
-            capture_output=True, text=True, timeout=5, cwd=cwd
-        )
-        uncommitted = []
-        if status_result.returncode == 0:
-            for line in status_result.stdout.strip().splitlines()[:20]:
-                # Format: "XY filename" — extract just filename
-                if len(line) > 3:
-                    uncommitted.append(line[3:].strip())
-
-        # Get last commit short hash + message
-        log_result = subprocess.run(
-            ["git", "log", "-1", "--oneline"],
-            capture_output=True, text=True, timeout=5, cwd=cwd
-        )
-        last_commit = log_result.stdout.strip() if log_result.returncode == 0 else ""
-
-        return {
-            "branch": branch,
-            "uncommitted_files": uncommitted,
-            "last_commit_short": last_commit,
-        }
-    except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
-        eprint(f"[auto_state] Git capture failed: {e}")
-        return {}
-
-
-def save_auto_state(
-    context_id: str,
-    session_id: str,
-    save_reason: str,
-    project_root: Path = None,
-    in_flight_mode: str = "none",
-    plan_path: Optional[str] = None,
-    handoff_path: Optional[str] = None,
-    transcript_path: Optional[str] = None,
-) -> bool:
-    """
-    Save auto-state.json for a context.
-
-    Captures structural state for session restoration. Overwrites
-    any existing auto-state file.
-
-    Args:
-        context_id: Context identifier
-        session_id: Current session ID
-        save_reason: Why state was saved (session_end, pre_compact, progressive)
-        project_root: Project root directory
-        in_flight_mode: Current in-flight mode (none, planning, implementing, etc.)
-        plan_path: Path to active plan file (if any)
-        handoff_path: Path to latest handoff (if any)
-        transcript_path: Path to transcript file (if available)
-
-    Returns:
-        True if saved successfully
-    """
-    auto_state_path = get_auto_state_path(context_id, project_root)
-
-    # Ensure parent directory exists
-    auto_state_path.parent.mkdir(parents=True, exist_ok=True)
-
-    git_state = capture_git_state(project_root)
-
-    state = {
-        "version": AUTO_STATE_VERSION,
-        "context_id": context_id,
-        "session_id": session_id,
-        "saved_at": now_iso(),
-        "save_reason": save_reason,
-        "in_flight_mode": in_flight_mode,
-        "plan_path": plan_path,
-        "latest_handoff_path": handoff_path,
-        "git_state": git_state,
-        "transcript_path": transcript_path,
-    }
-
-    try:
-        content = json.dumps(state, indent=2, ensure_ascii=False)
-        success, error = atomic_write(auto_state_path, content)
-        if success:
-            eprint(f"[auto_state] Saved auto-state for {context_id} (reason: {save_reason})")
-            return True
-        else:
-            eprint(f"[auto_state] Failed to save: {error}")
-            return False
-    except Exception as e:
-        eprint(f"[auto_state] Error saving auto-state: {e}")
-        return False
-
-
-def load_auto_state(context_id: str, project_root: Path = None) -> Optional[Dict[str, Any]]:
-    """
-    Load auto-state.json for a context.
-
-    Returns None if file doesn't exist or is corrupted.
-    Graceful degradation — callers should handle None.
-
-    Args:
-        context_id: Context identifier
-        project_root: Project root directory
-
-    Returns:
-        Auto-state dict or None
-    """
-    auto_state_path = get_auto_state_path(context_id, project_root)
-
-    if not auto_state_path.exists():
-        return None
-
-    try:
-        content = auto_state_path.read_text(encoding="utf-8")
-        state = json.loads(content)
-
-        # Version check
-        if state.get("version") != AUTO_STATE_VERSION:
-            eprint(f"[auto_state] Version mismatch: expected {AUTO_STATE_VERSION}, got {state.get('version')}")
-            return None
-
-        return state
-    except (json.JSONDecodeError, UnicodeDecodeError, OSError) as e:
-        eprint(f"[auto_state] Failed to load auto-state: {e}")
-        return None