aiwcli 0.9.8 → 0.10.0

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

@@ -1,407 +0,0 @@
-"""Task synchronization utilities for Claude native task integration.
-
-Provides persistence for Claude Code native tasks:
-- Claude Code native TaskCreate/TaskUpdate/TaskList tools (ephemeral)
-- Persistent events.jsonl storage (source of truth)
-
-DURING SESSION (Persist):
-1. Claude uses native TaskCreate/TaskUpdate
-2. PostToolUse hooks capture events to events.jsonl
-3. Task state preserved for future reference
-
-SESSION END:
-- events.jsonl has complete task history
-- Can be queried for context summaries
-"""
-from pathlib import Path
-from typing import List, Optional
-
-from .event_log import (
-    get_current_state,
-    get_pending_tasks,
-    append_event,
-    read_events,
-    Task,
-    EVENT_TASK_ADDED,
-    EVENT_TASK_STARTED,
-    EVENT_TASK_COMPLETED,
-    EVENT_TASK_BLOCKED,
-    EVENT_TASK_DELETED,
-    EVENT_SESSION_STARTED,
-    EVENT_SESSION_ENDED,
-)
-from ..base.utils import eprint
-
-
-def generate_task_summary(context_id: str, project_root: Path = None) -> str:
-    """
-    Generate a session-aware summary of all tasks in a context.
-
-    Includes session boundary awareness: tasks left in_progress when a session
-    ended are marked as "interrupted" to distinguish from actively worked tasks.
-
-    Args:
-        context_id: Context identifier
-        project_root: Project root directory
-
-    Returns:
-        Formatted task summary with session context
-    """
-    state = get_current_state(context_id, project_root)
-
-    if not state.tasks:
-        return "No tasks in this context."
-
-    # Find the latest session_ended event to detect interrupted tasks
-    events = read_events(context_id, project_root)
-    interrupted_task_ids = set()
-    for event in reversed(events):
-        if event.get("event") == EVENT_SESSION_ENDED:
-            interrupted_task_ids = set(event.get("active_tasks", []))
-            break
-
-    completed = [t for t in state.tasks if t.status == "completed"]
-    interrupted = [t for t in state.tasks if t.status == "in_progress" and t.id in interrupted_task_ids]
-    in_progress = [t for t in state.tasks if t.status == "in_progress" and t.id not in interrupted_task_ids]
-    pending = [t for t in state.tasks if t.status == "pending"]
-    blocked = [t for t in state.tasks if t.status == "blocked"]
-
-    # Count sessions from session_ended events
-    session_count = sum(1 for e in events if e.get("event") == EVENT_SESSION_ENDED)
-
-    parts = []
-    if completed:
-        parts.append(f"{len(completed)} completed")
-    if interrupted:
-        parts.append(f"{len(interrupted)} interrupted")
-    if in_progress:
-        parts.append(f"{len(in_progress)} in progress")
-    if pending:
-        parts.append(f"{len(pending)} pending")
-    if blocked:
-        parts.append(f"{len(blocked)} blocked")
-
-    session_info = f" across {session_count} session{'s' if session_count != 1 else ''}" if session_count > 0 else ""
-
-    lines = [
-        f"### Previous Work ({len(state.tasks)} tasks{session_info})",
-        "",
-    ]
-
-    for t in completed:
-        work_info = ""
-        if t.work_summary:
-            work_info = f"\n  Work: {t.work_summary}"
-        lines.append(f"- [x] {t.id}: {t.subject}{work_info}")
-
-    for t in interrupted:
-        lines.append(f"- [~] {t.id}: {t.subject} (in progress when session ended)")
-
-    for t in in_progress:
-        lines.append(f"- [~] {t.id}: {t.subject}")
-
-    for t in pending:
-        lines.append(f"- [ ] {t.id}: {t.subject}")
-
-    for t in blocked:
-        lines.append(f"- [!] {t.id}: {t.subject}: {t.blocked_reason}")
-
-    return "\n".join(lines)
-
-
-def record_session_start(
-    context_id: str,
-    tasks_hydrated: Optional[List[str]] = None,
-    project_root: Path = None
-) -> bool:
-    """
-    Record a session_started event in the context's event log.
-
-    Called after SessionStart hook loads a context.
-
-    Args:
-        context_id: Context identifier
-        tasks_hydrated: List of task IDs that were restored
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {}
-    if tasks_hydrated:
-        event_data["tasks_hydrated"] = tasks_hydrated
-
-    return append_event(
-        context_id,
-        EVENT_SESSION_STARTED,
-        project_root,
-        **event_data
-    )
-
-
-def record_task_created(
-    context_id: str,
-    task_id: str,
-    subject: str,
-    description: str = "",
-    active_form: str = "",
-    session_id: str = "",
-    project_root: Path = None
-) -> bool:
-    """
-    Record a task_added event in the context's event log.
-
-    Called when Claude creates a new task via TaskCreate.
-
-    Args:
-        context_id: Context identifier
-        task_id: Persistent task ID (e.g., "aiw-1")
-        subject: Task subject (required)
-        description: Task description (optional)
-        active_form: Spinner text for in_progress status (optional)
-        session_id: Session ID where task was created (optional)
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {
-        "task_id": task_id,
-        "subject": subject,
-    }
-    if description:
-        event_data["description"] = description
-    if active_form:
-        event_data["activeForm"] = active_form
-    if session_id:
-        event_data["session_id"] = session_id
-
-    return append_event(
-        context_id,
-        EVENT_TASK_ADDED,
-        project_root,
-        **event_data
-    )
-
-
-def record_task_started(
-    context_id: str,
-    task_id: str,
-    session_id: str = "",
-    project_root: Path = None
-) -> bool:
-    """
-    Record a task_started event in the context's event log.
-
-    Called when Claude starts working on a task.
-
-    Args:
-        context_id: Context identifier
-        task_id: Persistent task ID
-        session_id: Session ID where task was started (optional)
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {"task_id": task_id}
-    if session_id:
-        event_data["session_id"] = session_id
-
-    return append_event(
-        context_id,
-        EVENT_TASK_STARTED,
-        project_root,
-        **event_data
-    )
-
-
-def record_task_completed(
-    context_id: str,
-    task_id: str,
-    evidence: str,
-    work_summary: str = "",
-    files_changed: Optional[List[str]] = None,
-    commit_ref: str = "",
-    session_id: str = "",
-    project_root: Path = None
-) -> bool:
-    """
-    Record a task_completed event in the context's event log.
-
-    Called when Claude completes a task.
-
-    Args:
-        context_id: Context identifier
-        task_id: Persistent task ID
-        evidence: Verification evidence (required)
-        work_summary: Summary of work done (optional)
-        files_changed: List of files modified (optional)
-        commit_ref: Git commit reference (optional)
-        session_id: Session ID where task was completed (optional)
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {
-        "task_id": task_id,
-        "evidence": evidence,
-    }
-    if work_summary:
-        event_data["work_summary"] = work_summary
-    if files_changed:
-        event_data["files_changed"] = files_changed
-    if commit_ref:
-        event_data["commit_ref"] = commit_ref
-    if session_id:
-        event_data["session_id"] = session_id
-
-    return append_event(
-        context_id,
-        EVENT_TASK_COMPLETED,
-        project_root,
-        **event_data
-    )
-
-
-def record_task_blocked(
-    context_id: str,
-    task_id: str,
-    reason: str,
-    session_id: str = "",
-    project_root: Path = None
-) -> bool:
-    """
-    Record a task_blocked event in the context's event log.
-
-    Called when a task becomes blocked.
-
-    Args:
-        context_id: Context identifier
-        task_id: Persistent task ID
-        reason: Reason for being blocked
-        session_id: Session ID where task was blocked (optional)
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {
-        "task_id": task_id,
-        "reason": reason,
-    }
-    if session_id:
-        event_data["session_id"] = session_id
-
-    return append_event(
-        context_id,
-        EVENT_TASK_BLOCKED,
-        project_root,
-        **event_data
-    )
-
-
-def record_task_deleted(
-    context_id: str,
-    task_id: str,
-    session_id: str = "",
-    project_root: Path = None
-) -> bool:
-    """
-    Record a task_deleted event in the context's event log.
-
-    Called when Claude deletes a task via TaskUpdate with status="deleted".
-
-    Args:
-        context_id: Context identifier
-        task_id: Persistent task ID
-        session_id: Session ID where task was deleted (optional)
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {"task_id": task_id}
-    if session_id:
-        event_data["session_id"] = session_id
-
-    return append_event(
-        context_id,
-        EVENT_TASK_DELETED,
-        project_root,
-        **event_data
-    )
-
-
-def record_session_ended(
-    context_id: str,
-    session_id: str,
-    reason: str = "other",
-    active_tasks: Optional[List[str]] = None,
-    pending_tasks: Optional[List[str]] = None,
-    project_root: Path = None
-) -> bool:
-    """
-    Record a session_ended event in the context's event log.
-
-    Creates a session boundary marker. Tasks left in_progress at session end
-    are recorded so they can be identified as "interrupted" during restore.
-
-    Args:
-        context_id: Context identifier
-        session_id: Session ID that ended
-        reason: Why session ended (prompt_input_exit, clear, logout, other)
-        active_tasks: Task IDs that were in_progress at session end
-        pending_tasks: Task IDs still pending at session end
-        project_root: Project root directory
-
-    Returns:
-        True if event was recorded successfully
-    """
-    event_data = {
-        "session_id": session_id,
-        "reason": reason,
-    }
-    if active_tasks:
-        event_data["active_tasks"] = active_tasks
-    if pending_tasks:
-        event_data["pending_tasks"] = pending_tasks
-
-    return append_event(
-        context_id,
-        EVENT_SESSION_ENDED,
-        project_root,
-        **event_data
-    )
-
-
-def generate_next_task_id(context_id: str, project_root: Path = None) -> str:
-    """
-    Generate the next sequential task ID for a context.
-
-    Task IDs follow the pattern: aiw-{n} where n starts at 1.
-    Accounts for deleted tasks by scanning all events, not just current state.
-
-    Args:
-        context_id: Context identifier
-        project_root: Project root directory
-
-    Returns:
-        Next available task ID (e.g., "aiw-3")
-    """
-    # Scan all events to find highest task ID ever used (including deleted)
-    events = read_events(context_id, project_root)
-
-    max_num = 0
-    for event in events:
-        if event.get("event") == EVENT_TASK_ADDED:
-            task_id = event.get("task_id", "")
-            if task_id.startswith("aiw-"):
-                try:
-                    num = int(task_id.split("-")[1])
-                    max_num = max(max_num, num)
-                except (IndexError, ValueError):
-                    pass
-
-    return f"aiw-{max_num + 1}"

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

@@ -1,113 +0,0 @@
-"""Persona-based question templates for plan clarification.
-
-Uses distinct reasoning lenses to surface hidden constraints and assumptions.
-"""
-
-from dataclasses import dataclass
-from typing import List, Dict
-
-
-@dataclass
-class PersonaQuestion:
-    """A clarifying question from a specific persona lens."""
-
-    persona: str
-    display_name: str
-    question: str
-    purpose: str
-
-
-CLARIFICATION_PERSONAS: Dict[str, List[PersonaQuestion]] = {
-    "problem_validator": [
-        PersonaQuestion(
-            persona="problem_validator",
-            display_name="Questioning the Problem",
-            question="Can you describe the problem you're trying to solve without mentioning the solution?",
-            purpose="Separates problem from solution to check alignment",
-        ),
-        PersonaQuestion(
-            persona="problem_validator",
-            display_name="Challenging the Approach",
-            question="What's the simplest possible way to achieve this outcome that we haven't considered?",
-            purpose="Identifies potential over-engineering",
-        ),
-    ],
-    "assumption_validator": [
-        PersonaQuestion(
-            persona="assumption_validator",
-            display_name="Surfacing Assumptions",
-            question="What must already be true about your users, systems, or constraints for this to succeed?",
-            purpose="Surfaces foundational assumptions that could invalidate the plan",
-        ),
-        PersonaQuestion(
-            persona="assumption_validator",
-            display_name="Hidden Dependencies",
-            question="What are you assuming 'everyone knows' about this problem that might not be documented?",
-            purpose="Uncovers implicit knowledge that needs to be made explicit",
-        ),
-    ],
-    "user_advocate": [
-        PersonaQuestion(
-            persona="user_advocate",
-            display_name="Understanding Users",
-            question="Who specifically will use this, and what problem does it solve for them today?",
-            purpose="Grounds the plan in actual user needs",
-        ),
-        PersonaQuestion(
-            persona="user_advocate",
-            display_name="Impact Assessment",
-            question="If we did nothing, what would happen? Who would be affected?",
-            purpose="Establishes urgency and stakes",
-        ),
-    ],
-    "tradeoff_illuminator": [
-        PersonaQuestion(
-            persona="tradeoff_illuminator",
-            display_name="Revealing Trade-offs",
-            question="What are you willing to sacrifice (scope, time, quality, features) to make this work?",
-            purpose="Forces explicit prioritization",
-        ),
-        PersonaQuestion(
-            persona="tradeoff_illuminator",
-            display_name="Foreclosed Options",
-            question="What becomes harder or impossible to do later if we proceed this way?",
-            purpose="Surfaces opportunity costs and lock-in risks",
-        ),
-    ],
-}
-
-
-def get_all_persona_questions() -> List[PersonaQuestion]:
-    """Get all persona questions as a flat list."""
-    questions = []
-    for persona_qs in CLARIFICATION_PERSONAS.values():
-        questions.extend(persona_qs)
-    return questions
-
-
-def format_questions_for_prompt() -> str:
-    """Format persona questions for injection into Claude prompt."""
-    lines = [
-        "### Persona-Based Clarifying Questions",
-        "",
-        "Ask 5-8 questions from these perspectives using AskUserQuestion:",
-        "",
-    ]
-
-    for persona_qs in CLARIFICATION_PERSONAS.values():
-        for q in persona_qs:
-            lines.append(f"**{q.display_name}**")
-            lines.append(f'- Q: "{q.question}"')
-            lines.append(f"- Purpose: {q.purpose}")
-            lines.append("")
-
-    lines.extend(
-        [
-            "**Guidance:**",
-            "- Select questions most relevant to THIS plan (skip if already answered)",
-            "- Ask one at a time with clear context",
-            "- Use answers to refine the plan before ExitPlanMode",
-        ]
-    )
-
-    return "\n".join(lines)

package/dist/templates/cc-native/_cc-native/lib/async_archive.py

@@ -1,68 +0,0 @@
-"""Async background archival to avoid blocking user workflow."""
-import threading
-import json
-from pathlib import Path
-from typing import Dict, Any, Callable, Optional
-try:
-    from .atomic_write import atomic_write
-    from .constants import ENABLE_ROBUST_PLAN_WRITES
-except ImportError:
-    # When imported directly via sys.path (not as a package)
-    from atomic_write import atomic_write
-    from constants import ENABLE_ROBUST_PLAN_WRITES
-
-def archive_plan_async(
-    out_path: Path,
-    header: str,
-    plan: str,
-    callback: Optional[Callable] = None
-) -> None:
-    """
-    Archive plan in background thread. Non-blocking.
-
-    Args:
-        out_path: Destination file path
-        header: Plan header with metadata
-        plan: Plan content
-        callback: Optional callback(success: bool, error: str) on completion
-    """
-    if not ENABLE_ROBUST_PLAN_WRITES:
-        # Legacy behavior - write directly
-        try:
-            out_path.write_text(header + plan + "\n", encoding="utf-8")
-            if callback:
-                callback(True, None)
-        except Exception as e:
-            if callback:
-                callback(False, str(e))
-        return
-
-    def _archive_worker():
-        success, error = atomic_write(out_path, header + plan + "\n")
-
-        if not success:
-            # Write sanitized error marker (no stack traces)
-            error_marker = out_path.with_suffix('.error')
-            error_content = f"Archive failed: {error}\n"
-
-            try:
-                # Use atomic write for error marker too
-                atomic_write(
-                    error_marker,
-                    error_content,
-                    max_attempts=1  # Don't retry error marker
-                )
-            except Exception:
-                pass  # Error marker is best-effort
-
-        if callback:
-            try:
-                callback(success, error)
-            except Exception as e:
-                # Log callback failures (daemon thread would otherwise swallow)
-                import sys
-                print(f"[async_archive] Callback failed: {e}", file=sys.stderr)
-
-    # Start background thread
-    thread = threading.Thread(target=_archive_worker, daemon=False)
-    thread.start()

package/dist/templates/cc-native/_cc-native/lib/atomic_write.py

@@ -1,98 +0,0 @@
-"""Cross-platform atomic file writes with security."""
-import os
-import sys
-import tempfile
-from pathlib import Path
-from typing import Optional
-
-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()
-            # Use ctypes.WinError for human-readable error messages
-            raise ctypes.WinError(error_code)
-
-def atomic_write(
-    path: Path,
-    content: str,
-    max_attempts: int = 2,
-    backoff_ms: list = None
-) -> tuple:
-    """
-    Write file atomically with retry logic.
-
-    Returns:
-        (success: bool, error_message: Optional[str])
-    """
-    import time
-
-    if backoff_ms is None:
-        backoff_ms = [500, 1000]
-
-    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)
-                os.chmod(temp_path, 0o600)
-
-                # 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 as e:
-                # 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")