aiwcli 0.9.7 → 0.10.0

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

@@ -0,0 +1,204 @@
+"""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 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")
+    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
+
+
+# ---------------------------------------------------------------------------
+# 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

@@ -0,0 +1,188 @@
+"""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/document_generator.py

@@ -18,14 +18,10 @@ from typing import Any, Dict, List, Optional
 
 from ..base.atomic_write import atomic_write
 from ..base.constants import get_context_handoffs_dir, get_context_dir
-from ..base.utils import eprint, now_iso
-from ..context.event_log import (
-    append_event,
-    get_current_state,
-    get_pending_tasks,
-    Task,
-    EVENT_HANDOFF_CREATED,
-)
+from ..base.logger import log_info, log_error
+from ..base.utils import now_iso
+from ..context.context_store import get_context as _get_context_state, save_state as _save_state
+from ..context.task_tracker import get_tasks
 from ..templates.formatters import render_task_list, format_continuation_header, format_reason
 
 
@@ -83,19 +79,17 @@ def generate_handoff_document(
     Returns:
         HandoffDocument with file_path set, or None on failure
     """
-    from ..context.context_manager import get_context
-
-    context = get_context(context_id, project_root)
+    context = _get_context_state(context_id, project_root)
     if not context:
-        eprint(f"[handoff] ERROR: Context '{context_id}' not found")
+        log_error("handoff", f"Context '{context_id}' not found")
         return None
 
     # Generate session ID
     session_id = str(uuid.uuid4())[:8]
 
-    # Get current state
-    state = get_current_state(context_id, project_root)
-    pending_tasks = get_pending_tasks(context_id, project_root)
+    # Get pending tasks from state.json
+    all_tasks = get_tasks(context_id, project_root)
+    pending_tasks = [t for t in all_tasks if t.get("status") in ("pending", "in_progress", "blocked")]
 
     # Build document
     now = now_iso()
@@ -107,10 +101,10 @@ def generate_handoff_document(
         session_id=session_id,
         reason=reason,
         created_at=now,
-        plan_path=context.in_flight.artifact_path if context.in_flight else None,
+        plan_path=context.plan_path,
         context_folder=str(context_dir),
-        events_log_path=str(context_dir / "events.jsonl"),
-        active_tasks=[_task_to_dict(t) for t in pending_tasks],
+        events_log_path=str(context_dir / "state.json"),
+        active_tasks=pending_tasks,
         completed_tasks_this_session=[
             {"subject": s} for s in (completed_this_session or [])
         ],
@@ -138,33 +132,13 @@ def generate_handoff_document(
 
     success, error = atomic_write(file_path, markdown)
     if not success:
-        eprint(f"[handoff] ERROR: Failed to write handoff document: {error}")
+        log_error("handoff", f"Failed to write handoff document: {error}")
         return None
 
-    # Record event (informational only - no mode change)
-    append_event(
-        context_id,
-        EVENT_HANDOFF_CREATED,
-        project_root,
-        path=str(file_path),
-        reason=reason,
-        session_id=session_id
-    )
-
-    eprint(f"[handoff] Created handoff document: {file_path}")
+    log_info("handoff", f"Created handoff document: {file_path}")
     return doc
 
 
-def _task_to_dict(task: Task) -> Dict[str, Any]:
-    """Convert Task to dictionary for handoff document."""
-    return {
-        "id": task.id,
-        "subject": task.subject,
-        "status": task.status,
-        "description": task.description,
-    }
-
-
 def _render_handoff_markdown(doc: HandoffDocument) -> str:
     """Render handoff document as markdown."""
     lines = [

package/dist/templates/_shared/lib/templates/README.md

@@ -1,6 +1,6 @@
 # Shared Templates Module
 
-Centralized templates and formatters for consistent context management output across discovery, handoff, and hooks.
+Centralized templates and formatters for consistent context management output across context formatting, handoff, and hooks.
 
 ## Purpose
 
@@ -115,10 +115,6 @@ Plan context templates for the add_plan_context hook.
 
 Returns the evaluation context reminder template that prompts Claude to add evaluation context to plans.
 
-**`get_questions_offer_template() -> str`**
-
-Returns the clarifying questions offer template shown on first plan write.
-
 ## Usage
 
 ### In Discovery Functions
@@ -158,28 +154,24 @@ reason_text = format_reason(doc.reason)
 ### In Hooks
 
 ```python
-from templates.plan_context import (
-    get_evaluation_context_reminder,
-    get_questions_offer_template,
-)
+from templates.plan_context import get_evaluation_context_reminder
 
-# Get plan context templates
+# Get plan context template
 CONTEXT_REMINDER = get_evaluation_context_reminder()
-QUESTIONS_OFFER = get_questions_offer_template()
 ```
 
 ## Dependent Files
 
 Files that import from this module:
 
-- `.aiwcli/_shared/lib/context/discovery.py`
+- `.aiwcli/_shared/lib/context/context_formatter.py`
   - Uses: `get_mode_display`, `get_status_icon`, `format_continuation_header`
 
 - `.aiwcli/_shared/lib/handoff/document_generator.py`
   - Uses: `render_task_list`, `format_continuation_header`, `format_reason`
 
 - `.aiwcli/_cc-native/hooks/add_plan_context.py`
-  - Uses: `get_evaluation_context_reminder`, `get_questions_offer_template`
+  - Uses: `get_evaluation_context_reminder`
 
 ## Design Principles
 

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

@@ -6,7 +6,7 @@ This module provides centralized templates for:
 - Task rendering
 - Context continuation headers
 
-Used by discovery.py, document_generator.py, and hooks.
+Used by context_formatter.py, document_generator.py, and hooks.
 """
 
 from .formatters import (
@@ -20,10 +20,7 @@ from .formatters import (
     format_continuation_header,
     format_reason,
 )
-from .plan_context import (
-    get_evaluation_context_reminder,
-    get_questions_offer_template,
-)
+from .plan_context import get_evaluation_context_reminder
 
 __all__ = [
     "MODE_DISPLAY_MAP",
@@ -36,5 +33,4 @@ __all__ = [
     "format_continuation_header",
     "format_reason",
     "get_evaluation_context_reminder",
-    "get_questions_offer_template",
 ]