aiwcli 0.10.3 → 0.11.1

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

@@ -1,303 +0,0 @@
-"""Plan lifecycle management — archival, lookup, and path extraction.
-
-Provides pure-data operations on plan files:
-- archive_plan: copy plan to context plans/ folder, compute hash + signature
-- find_latest_plan: locate the most relevant plan for a context
-- extract_plan_path_from_result: parse plan path from ExitPlanMode output
-
-This module does NOT modify mode or state.json.  The calling hook
-(e.g. archive_plan.py) is responsible for updating mode via
-context_store.update_mode() after archival succeeds.
-"""
-import hashlib
-import json
-import re
-import uuid
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional, Tuple
-
-from ..base.atomic_write import atomic_write
-from ..base.constants import get_context_dir, get_context_plans_dir
-from ..base.logger import log_debug, log_info, log_warn, log_error
-from ..base.utils import sanitize_title
-
-
-# ---------------------------------------------------------------------------
-# Plan archival
-# ---------------------------------------------------------------------------
-
-def archive_plan(
-    plan_path: str,
-    context_id: str,
-    project_root: Path = None,
-) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-    """Archive a plan file to the context's plans/ folder.
-
-    Copies the plan content to:
-        _output/contexts/{context_id}/plans/{date}-{slug}.md
-
-    Computes a content hash and signature for change detection and
-    fallback matching after /clear.
-
-    Does NOT modify state.json or mode — the calling hook handles that
-    via context_store.update_mode().
-
-    Args:
-        plan_path: Path to the source plan file.
-        context_id: Target context identifier.
-        project_root: Project root directory (default: from env / cwd).
-
-    Returns:
-        (archived_path, plan_hash, plan_signature) on success.
-        (None, None, None) on any error.
-    """
-    plan_file = Path(plan_path)
-    if not plan_file.exists():
-        log_warn("plan_manager", f"Plan file not found: {plan_path}")
-        return None, None, None
-
-    # Read plan content
-    try:
-        content = plan_file.read_text(encoding="utf-8")
-    except Exception as e:
-        log_error("plan_manager", f"Failed to read plan: {e}")
-        return None, None, None
-
-    # Compute hash and signature
-    plan_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()[:12]
-    plan_signature = content[:200]
-
-    # Ensure plans directory exists
-    plans_dir = get_context_plans_dir(context_id, project_root)
-    plans_dir.mkdir(parents=True, exist_ok=True)
-
-    # Generate archive filename: YYYY-MM-DD-<slug>.md
-    date_str = datetime.now().strftime("%Y-%m-%d-%H%M")
-
-    # Try AI inference for a descriptive slug from plan content
-    slug = None
-    try:
-        from ..base.inference import generate_context_id_slug
-        ai_slug = generate_context_id_slug(content[:500], timeout=5)
-        if ai_slug:
-            slug = sanitize_title(ai_slug, max_len=60)
-    except Exception as e:
-        log_warn("plan_manager", f"Plan slug inference failed: {e}")
-
-    # Fallback: use plan filename
-    if not slug:
-        slug = sanitize_title(plan_file.stem, max_len=30)
-
-    archive_name = f"{date_str}-{slug}.md"
-    archive_path = plans_dir / archive_name
-
-    # Handle filename collisions with counter suffix
-    counter = 2
-    while archive_path.exists():
-        archive_name = f"{date_str}-{slug}-{counter}.md"
-        archive_path = plans_dir / archive_name
-        counter += 1
-
-    # Write archived plan atomically
-    success, error = atomic_write(archive_path, content)
-    if not success:
-        log_error("plan_manager", f"Failed to write archive: {error}")
-        return None, None, None
-
-    log_info("plan_manager", f"Archived plan to: {archive_path}")
-    return str(archive_path), plan_hash, plan_signature
-
-
-# ---------------------------------------------------------------------------
-# Plan lookup
-# ---------------------------------------------------------------------------
-
-def find_latest_plan(
-    context_id: str,
-    project_root: Path = None,
-) -> Optional[str]:
-    """Find the most relevant plan file for a context.
-
-    Priority:
-    1. state.json plan_path — if the file still exists on disk.
-    2. Most recent .md in plans/ directory by modification time.
-    3. None if no plans found.
-
-    Args:
-        context_id: Context identifier.
-        project_root: Project root directory (default: from env / cwd).
-
-    Returns:
-        Absolute path string to the plan file, or None.
-    """
-    # 1. Check state.json plan_path first
-    try:
-        from .context_store import load_state
-        state = load_state(context_id, project_root)
-        if state and state.plan_path:
-            plan_path = Path(state.plan_path)
-            if plan_path.exists():
-                return str(plan_path)
-    except Exception as e:
-        log_warn("plan_manager", f"Failed to check state.json plan_path: {e}")
-
-    # 2. Fall back to most recent .md in plans/ dir by mtime
-    plans_dir = get_context_plans_dir(context_id, project_root)
-    if plans_dir.exists():
-        plans = sorted(
-            plans_dir.glob("*.md"),
-            key=lambda p: p.stat().st_mtime,
-            reverse=True,
-        )
-        if plans:
-            return str(plans[0])
-
-    # 3. No plan found
-    return None
-
-
-# ---------------------------------------------------------------------------
-# Plan identification and normalization
-# ---------------------------------------------------------------------------
-
-def generate_plan_id() -> str:
-    """Generate a short unique plan identifier (8 hex chars)."""
-    return uuid.uuid4().hex[:8]
-
-
-def normalize_plan_content(text: str) -> str:
-    """Aggressively normalize plan content for hashing.
-
-    Strips all XML/HTML tags and collapses whitespace so that
-    wrapper variations (e.g. <system-reminder>) don't affect the hash.
-    """
-    text = re.sub(r'<[^>]+>', '', text)
-    text = re.sub(r'\s+', ' ', text).strip()
-    return text
-
-
-def extract_plan_anchors(content: str, max_anchors: int = 5) -> List[str]:
-    """Extract structural anchors from plan content.
-
-    Returns markdown headings + first substantial paragraph as short strings.
-    Used for fuzzy matching when hash-based matching fails.
-    """
-    anchors = []
-    for line in content.splitlines():
-        line = line.strip()
-        if line.startswith('#') and len(line) > 3:
-            anchors.append(line[:80])
-        elif not anchors and len(line) > 20:
-            anchors.append(line[:80])
-        if len(anchors) >= max_anchors:
-            break
-    return anchors
-
-
-# ---------------------------------------------------------------------------
-# Transcript-based plan path extraction
-# ---------------------------------------------------------------------------
-
-_MAX_TRANSCRIPT_SIZE = 50 * 1024 * 1024  # 50 MB
-
-def find_plan_path_in_transcript(transcript_path: str) -> Optional[str]:
-    """Find the plan file path by parsing the session transcript JSONL.
-
-    Searches the transcript in reverse for the most recent Write tool call
-    whose file_path targets a .claude/plans/ directory. This is deterministic:
-    exact structural match on Path.parts, no fuzzy matching.
-
-    Args:
-        transcript_path: Absolute path to the transcript JSONL file.
-
-    Returns:
-        The file_path string from the Write tool call, or None.
-    """
-    if not transcript_path:
-        return None
-
-    tp = Path(transcript_path)
-    if not tp.exists():
-        log_debug("plan_manager", f"Transcript not found: {transcript_path}")
-        return None
-
-    try:
-        size = tp.stat().st_size
-    except OSError:
-        return None
-
-    if size > _MAX_TRANSCRIPT_SIZE:
-        log_warn("plan_manager", f"Transcript too large ({size} bytes), skipping")
-        return None
-
-    try:
-        lines = tp.read_text(encoding="utf-8").splitlines()
-    except Exception as e:
-        log_warn("plan_manager", f"Failed to read transcript: {e}")
-        return None
-
-    for line in reversed(lines):
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            data = json.loads(line)
-        except (json.JSONDecodeError, ValueError):
-            continue
-
-        content = None
-        try:
-            content = data["message"]["content"]
-        except (KeyError, TypeError):
-            continue
-
-        if not isinstance(content, list):
-            continue
-
-        for block in content:
-            if not isinstance(block, dict):
-                continue
-            if block.get("type") != "tool_use" or block.get("name") != "Write":
-                continue
-            file_path = None
-            try:
-                file_path = block["input"]["file_path"]
-            except (KeyError, TypeError):
-                continue
-            if not file_path:
-                continue
-
-            # Check if path contains .claude/plans/ as consecutive parts
-            parts = Path(file_path).parts
-            for i in range(len(parts) - 1):
-                if parts[i] == ".claude" and parts[i + 1] == "plans":
-                    log_info("plan_manager", f"Extracted plan path from transcript: {file_path}")
-                    return file_path
-
-    log_debug("plan_manager", "No plan Write found in transcript")
-    return None
-
-
-# ---------------------------------------------------------------------------
-# Path extraction from tool output
-# ---------------------------------------------------------------------------
-
-def extract_plan_path_from_result(tool_result: str) -> Optional[str]:
-    """Extract plan file path from ExitPlanMode tool result.
-
-    Parses the pattern: "Your plan has been saved to: <path>"
-    from the tool_result string returned by ExitPlanMode.
-
-    Args:
-        tool_result: Raw text output from the ExitPlanMode tool.
-
-    Returns:
-        Plan file path string (stripped), or None if not found.
-    """
-    if not tool_result:
-        return None
-    match = re.search(r"Your plan has been saved to:\s*(.+\.md)", tool_result)
-    if match:
-        return match.group(1).strip()
-    return None

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

@@ -1,188 +0,0 @@
-"""Task tracker — direct state.json CRUD for tasks.
-
-Writes tasks directly to the tasks[] array in state.json,
-bypassing events.jsonl for faster, simpler task operations.
-
-All functions do their own I/O to avoid circular imports with
-context_store.py.
-"""
-import json
-import re
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from ..base.atomic_write import atomic_write
-from ..base.constants import get_context_dir
-from ..base.logger import log_warn
-from ..base.utils import now_iso
-
-
-# ---------------------------------------------------------------------------
-# Internal I/O (avoids circular import with context_store)
-# ---------------------------------------------------------------------------
-
-def _state_path(context_id: str, project_root: Path = None) -> Path:
-    return get_context_dir(context_id, project_root) / "state.json"
-
-
-def _load_state(context_id: str, project_root: Path = None) -> Optional[dict]:
-    sp = _state_path(context_id, project_root)
-    if not sp.exists():
-        return None
-    try:
-        return json.loads(sp.read_text(encoding="utf-8"))
-    except Exception as e:
-        log_warn("task_tracker", f"Failed to read state.json: {e}")
-        return None
-
-
-def _save_state(context_id: str, state_data: dict, project_root: Path = None) -> bool:
-    sp = _state_path(context_id, project_root)
-    content = json.dumps(state_data, indent=2, ensure_ascii=False)
-    success, error = atomic_write(sp, content)
-    if not success:
-        log_warn("task_tracker", f"Failed to write state.json: {error}")
-    return success
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def generate_next_task_id(context_id: str, project_root: Path = None) -> str:
-    """Scan tasks[] for highest aiw-N, return aiw-(N+1)."""
-    state = _load_state(context_id, project_root)
-    tasks = state.get("tasks", []) if state else []
-
-    max_num = 0
-    for t in tasks:
-        tid = t.get("id", "")
-        m = re.match(r"^aiw-(\d+)$", tid)
-        if m:
-            max_num = max(max_num, int(m.group(1)))
-
-    return f"aiw-{max_num + 1}"
-
-
-def add_task(
-    context_id: str,
-    subject: str,
-    description: str = "",
-    active_form: str = "",
-    session_id: str = "",
-    project_root: Path = None,
-) -> Optional[dict]:
-    """Add a new task to state.json tasks[] and return the task dict."""
-    state = _load_state(context_id, project_root)
-    if state is None:
-        return None
-
-    task_id = generate_next_task_id(context_id, project_root)
-    task = {
-        "id": task_id,
-        "subject": subject,
-        "description": description,
-        "active_form": active_form,
-        "status": "pending",
-        "created_at": now_iso(),
-        "completed_at": None,
-        "evidence": "",
-        "work_summary": "",
-        "files_changed": [],
-        "session_id": session_id,
-    }
-
-    state.setdefault("tasks", []).append(task)
-    state["last_active"] = now_iso()
-
-    if _save_state(context_id, state, project_root):
-        return task
-    return None
-
-
-def update_task(
-    context_id: str,
-    task_id: str,
-    status: str = None,
-    evidence: str = "",
-    work_summary: str = "",
-    files_changed: List[str] = None,
-    session_id: str = "",
-    project_root: Path = None,
-) -> bool:
-    """Find task by task_id in tasks[], update fields, return True on success."""
-    state = _load_state(context_id, project_root)
-    if state is None:
-        return False
-
-    for task in state.get("tasks", []):
-        if task.get("id") == task_id:
-            if status is not None:
-                task["status"] = status
-                if status == "completed":
-                    task["completed_at"] = now_iso()
-            if evidence:
-                task["evidence"] = evidence
-            if work_summary:
-                task["work_summary"] = work_summary
-            if files_changed is not None:
-                task["files_changed"] = files_changed
-            if session_id:
-                task["session_id"] = session_id
-            state["last_active"] = now_iso()
-            return _save_state(context_id, state, project_root)
-
-    log_warn("task_tracker", f"Task '{task_id}' not found in context '{context_id}'")
-    return False
-
-
-def delete_task(context_id: str, task_id: str, project_root: Path = None) -> bool:
-    """Remove task from tasks[] and return True on success."""
-    state = _load_state(context_id, project_root)
-    if state is None:
-        return False
-
-    tasks = state.get("tasks", [])
-    original_len = len(tasks)
-    state["tasks"] = [t for t in tasks if t.get("id") != task_id]
-
-    if len(state["tasks"]) == original_len:
-        log_warn("task_tracker", f"Task '{task_id}' not found in context '{context_id}'")
-        return False
-
-    state["last_active"] = now_iso()
-    return _save_state(context_id, state, project_root)
-
-
-def get_tasks(context_id: str, project_root: Path = None) -> List[dict]:
-    """Return tasks[] from state.json."""
-    state = _load_state(context_id, project_root)
-    if state is None:
-        return []
-    return state.get("tasks", [])
-
-
-def generate_task_summary(context_id: str, project_root: Path = None) -> str:
-    """Partition tasks and format as markdown checklist."""
-    tasks = get_tasks(context_id, project_root)
-    if not tasks:
-        return "No tasks in this context."
-
-    completed = [t for t in tasks if t.get("status") == "completed"]
-    in_progress = [t for t in tasks if t.get("status") == "in_progress"]
-    pending = [t for t in tasks if t.get("status") == "pending"]
-    blocked = [t for t in tasks if t.get("status") == "blocked"]
-
-    lines = [f"### Tasks ({len(tasks)} total)", ""]
-
-    for t in completed:
-        ws = f"\n  Work: {t['work_summary']}" if t.get("work_summary") else ""
-        lines.append(f"- [x] {t['id']}: {t['subject']}{ws}")
-    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']}")
-
-    return "\n".join(lines)

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

@@ -1,22 +0,0 @@
-"""Handoff utilities for context-aware session management.
-
-This module provides graceful context degradation when Claude's
-context window fills up. Instead of rushing or losing work,
-it creates a handoff document and facilitates clean session continuation.
-
-Components:
-- document_generator: Creates handoff documents with work state
-- context_monitor hook: Monitors context during tool use and triggers warnings
-"""
-
-from .document_generator import (
-    generate_handoff_document,
-    get_handoff_continuation_prompt,
-    HandoffDocument,
-)
-
-__all__ = [
-    "generate_handoff_document",
-    "get_handoff_continuation_prompt",
-    "HandoffDocument",
-]