aiwcli 0.9.7 → 0.10.0

package/dist/templates/_shared/lib/base/utils.py

@@ -14,6 +14,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Optional
 
+from .logger import log_debug, log_info, log_warn, log_error
+
 
 def eprint(*args: Any) -> None:
     """Print to stderr."""
@@ -53,12 +55,12 @@ def project_dir(payload: Optional[Dict[str, Any]] = None) -> Path:
         # Validate that CLAUDE_PROJECT_DIR is an absolute path
         path = Path(p)
         if not path.is_absolute():
-            eprint(f"[utils] WARNING: CLAUDE_PROJECT_DIR is not absolute, using cwd instead")
+            log_warn("utils", "CLAUDE_PROJECT_DIR is not absolute, using cwd instead")
             p = None
         else:
             # Check for suspicious patterns
             if '..' in str(path):
-                eprint(f"[utils] WARNING: CLAUDE_PROJECT_DIR contains '..' pattern, using cwd instead")
+                log_warn("utils", "CLAUDE_PROJECT_DIR contains '..' pattern, using cwd instead")
                 p = None
 
     if not p and payload:
@@ -138,22 +140,58 @@ def generate_context_id(summary: str, existing_ids: Optional[set] = None) -> str
     """
     Generate a context ID from a summary string.
 
-    Filters stop words from the summary and slugifies the result.
+    Prepends a YYMMDD-HHMM local-time timestamp for visual
+    distinguishability, then filters stop words and slugifies.
 
     Args:
         summary: Context summary text
         existing_ids: Optional set of existing context IDs to avoid
 
     Returns:
-        Unique context ID string
+        Unique context ID string (e.g. '260205-1700-add-user-auth')
     """
-    if not summary or not summary.strip():
-        base_id = "context"
-    else:
-        # Use stop word filter, limit to 12 words
-        from .stop_words import STOP_WORDS
-        words = [w for w in summary.lower().split() if w not in STOP_WORDS and len(w) > 1][:12]
-        base_id = sanitize_title(' '.join(words), max_len=100)
+    # Timestamp prefix using local time, to the minute
+    timestamp = datetime.now().strftime("%y%m%d-%H%M")
+
+    try:
+        if not summary or not summary.strip():
+            base_id = f"{timestamp}-context"
+        else:
+            slug = None
+
+            # Tier 1: AI inference for high-quality keyword slugs
+            try:
+                from .inference import generate_context_id_slug
+                ai_slug = generate_context_id_slug(summary)
+                if ai_slug:
+                    # Post-inference stop-word filter: remove generic words the AI included
+                    from .stop_words import STOP_WORDS
+                    filtered_words = [w for w in ai_slug.split() if w.lower() not in STOP_WORDS and len(w) > 1]
+                    if len(filtered_words) >= 3:
+                        slug = sanitize_title(' '.join(filtered_words), max_len=100)
+                    else:
+                        log_debug("utils", f"AI slug too generic after stop-word filter ({len(filtered_words)} words remain), using fallback")
+            except Exception as e:
+                log_warn("utils", f"AI context ID slug failed, using fallback: {e}")
+
+            # Tier 2: Stop-word filtering
+            if not slug:
+                try:
+                    from .stop_words import STOP_WORDS
+                    words = [w for w in summary.lower().split() if w not in STOP_WORDS and len(w) > 1][:12]
+                    slug = sanitize_title(' '.join(words), max_len=50)
+                except Exception as e:
+                    log_warn("utils", f"Stop-word fallback failed: {e}")
+
+            # Tier 3: Simple word-length filter (no imports needed)
+            if not slug or slug == "unknown":
+                words = [w for w in summary.lower().split() if len(w) > 2][:6]
+                slug = sanitize_title(' '.join(words), max_len=50) if words else "context"
+
+            base_id = f"{timestamp}-{slug}"
+    except Exception as e:
+        log_error("utils", f"Context ID generation failed entirely, using timestamp: {e}")
+        base_id = f"{timestamp}-context"
 
     if not existing_ids:
         return base_id

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

@@ -1,110 +1,102 @@
-"""Context management for AIW CLI templates."""
-from .context_manager import (
-    Context,
-    InFlightState,
+"""Context management for AIW CLI templates.
+
+New 2-layer architecture:
+  context_store.py    — CRUD for state.json + index.json
+  context_selector.py — 5-case context selection (session match, caret, plan match, default)
+  context_formatter.py — All display formatting
+  plan_manager.py     — Plan archival, lookup, path extraction
+  task_tracker.py     — Direct state.json task CRUD
+"""
+from .context_store import (
+    ContextState,
     get_all_contexts,
     get_context,
+    get_context_by_session_id,
     create_context,
+    create_context_from_prompt,
     update_context,
     complete_context,
     reopen_context,
     archive_context,
-    update_plan_status,
-    get_context_with_pending_plan,
-    get_context_with_in_flight_work,
-)
-from .event_log import (
-    Task,
-    ContextState,
-    append_event,
-    read_events,
-    get_current_state,
-    are_all_tasks_completed,
-    get_pending_tasks,
+    bind_session,
+    update_mode,
+    maybe_activate,
+    load_state,
+    save_state,
 )
-from .cache import (
-    rebuild_index_from_folders,
-    rebuild_archive_index,
-    rebuild_context_from_events,
-    rebuild_all_caches,
-    verify_cache_integrity,
+from .context_selector import (
+    determine_context,
+    BlockRequest,
+    parse_chained_caret,
+    resolve_context_by_prefix,
 )
-from .discovery import (
-    discover_contexts_for_session,
-    get_in_flight_context,
+from .context_formatter import (
     format_context_list,
-    format_pending_plan_continuation,
-    format_implementation_continuation,
-    format_context_picker_prompt,
-    format_ready_for_new_work,
+    format_context_created,
+    format_context_picker_stderr,
+    format_active_context_reminder,
+    format_handoff_continuation,
+    format_plan_continuation,
+    format_active_continuation,
+    format_command_feedback,
     format_relative_time,
 )
-from .task_sync import (
+from .plan_manager import (
+    archive_plan,
+    find_latest_plan,
+    extract_plan_path_from_result,
+)
+from .task_tracker import (
+    add_task,
+    update_task,
+    delete_task,
+    get_tasks,
     generate_task_summary,
-    record_session_start,
-    record_task_created,
-    record_task_started,
-    record_task_completed,
-    record_task_blocked,
     generate_next_task_id,
 )
-from .plan_archive import (
-    archive_plan_to_context,
-)
-from .context_extractor import (
-    extract_context_id,
-    extract_context_id_for_session,
-)
 
 __all__ = [
-    # Data Classes
-    "Context",
-    "InFlightState",
-    "Task",
+    # Data model
     "ContextState",
-    # Context Manager
+    # Context store (CRUD)
     "get_all_contexts",
     "get_context",
+    "get_context_by_session_id",
     "create_context",
+    "create_context_from_prompt",
     "update_context",
     "complete_context",
     "reopen_context",
     "archive_context",
-    "update_plan_status",
-    "get_context_with_pending_plan",
-    "get_context_with_in_flight_work",
-    # Event Log
-    "append_event",
-    "read_events",
-    "get_current_state",
-    "are_all_tasks_completed",
-    "get_pending_tasks",
-    # Cache
-    "rebuild_index_from_folders",
-    "rebuild_archive_index",
-    "rebuild_context_from_events",
-    "rebuild_all_caches",
-    "verify_cache_integrity",
-    # Discovery
-    "discover_contexts_for_session",
-    "get_in_flight_context",
+    "bind_session",
+    "update_mode",
+    "maybe_activate",
+    "load_state",
+    "save_state",
+    # Context selector
+    "determine_context",
+    "BlockRequest",
+    "parse_chained_caret",
+    "resolve_context_by_prefix",
+    # Formatting
     "format_context_list",
-    "format_pending_plan_continuation",
-    "format_implementation_continuation",
-    "format_context_picker_prompt",
-    "format_ready_for_new_work",
+    "format_context_created",
+    "format_context_picker_stderr",
+    "format_active_context_reminder",
+    "format_handoff_continuation",
+    "format_plan_continuation",
+    "format_active_continuation",
+    "format_command_feedback",
     "format_relative_time",
-    # Task Sync
+    # Plan manager
+    "archive_plan",
+    "find_latest_plan",
+    "extract_plan_path_from_result",
+    # Task tracker
+    "add_task",
+    "update_task",
+    "delete_task",
+    "get_tasks",
     "generate_task_summary",
-    "record_session_start",
-    "record_task_created",
-    "record_task_started",
-    "record_task_completed",
-    "record_task_blocked",
     "generate_next_task_id",
-    # Plan Archive
-    "archive_plan_to_context",
-    # Context Extractor
-    "extract_context_id",
-    "extract_context_id_for_session",
 ]

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

@@ -0,0 +1,316 @@
+"""Formatting module for context display output.
+
+Consolidates output formatting previously in discovery.py and context_enforcer.py (both now deleted).
+All functions accept a ContextState (from context_store.py) with fields:
+    id, summary, mode, last_active, plan_path, handoff_path,
+    tasks[], last_session, session_ids, status, method, tags
+"""
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ..base.utils import parse_iso_timestamp
+
+MAX_PLAN_INLINE_CHARS = 30_000
+
+
+def _read_plan_content(plan_path: str) -> Tuple[Optional[str], bool, int]:
+    """Read plan content from disk for inline injection.
+    Returns (content, truncated, total_chars) or (None, False, 0) on error."""
+    try:
+        pf = Path(plan_path)
+        if not pf.exists():
+            return None, False, 0
+        content = pf.read_text(encoding="utf-8")
+        total = len(content)
+        if total > MAX_PLAN_INLINE_CHARS:
+            return content[:MAX_PLAN_INLINE_CHARS], True, total
+        return content, False, total
+    except Exception:
+        return None, False, 0
+
+MODE_DISPLAY_MAP = {
+    "idle": "",
+    "has_plan": "[Plan Ready]",
+    "active": "[Active]",
+}
+
+
+def get_mode_display(mode: str) -> str:
+    """Get bracketed display string for mode, or empty for idle."""
+    return MODE_DISPLAY_MAP.get(mode, "")
+
+
+def format_relative_time(iso_timestamp: Optional[str]) -> str:
+    """Format ISO timestamp as '2 hours ago', 'yesterday', etc."""
+    if not iso_timestamp:
+        return "unknown"
+    dt = parse_iso_timestamp(iso_timestamp)
+    if not dt:
+        return iso_timestamp[:16]
+    now = datetime.now()
+    if dt.tzinfo is not None:
+        try:
+            dt = dt.replace(tzinfo=None)
+        except Exception:
+            return iso_timestamp[:16]
+    diff = now - dt
+    if diff.days == 0:
+        hours = diff.seconds // 3600
+        if hours == 0:
+            minutes = diff.seconds // 60
+            if minutes == 0:
+                return "just now"
+            return "1 minute ago" if minutes == 1 else f"{minutes} minutes ago"
+        return "1 hour ago" if hours == 1 else f"{hours} hours ago"
+    if diff.days == 1:
+        return "yesterday"
+    if diff.days < 7:
+        return f"{diff.days} days ago"
+    return dt.strftime("%Y-%m-%d")
+
+
+# ── Internal helpers ───────────────────────────────────────────────
+
+def _task_attr(task, key: str, default: str = "") -> str:
+    """Extract attribute from a task (dict or object)."""
+    return task.get(key, default) if isinstance(task, dict) else getattr(task, key, default)
+
+
+def _build_restore_sections(ctx, project_root: Path = None, inline_plan: bool = False) -> str:
+    """Build restore sections from last_session, tasks, and plan_path.
+
+    Args:
+        inline_plan: If True, read and inline plan file content (for compact restore
+            where plan is NOT auto-pasted). If False, just reference the path (for
+            clear restore where Claude Code auto-pastes the plan).
+    """
+    sections = []
+    last_session = getattr(ctx, "last_session", None) or {}
+
+    if last_session:
+        saved_at = last_session.get("saved_at", "")
+        if saved_at:
+            reason = last_session.get("save_reason", "")
+            reason_display = reason.replace("_", " ") if reason else "unknown"
+            sections.append(f"**Last session ended:** {format_relative_time(saved_at)} ({reason_display})")
+
+    tasks = getattr(ctx, "tasks", None) or []
+    if tasks:
+        buckets = {"completed": [], "in_progress": [], "pending": [], "blocked": []}
+        for t in tasks:
+            s = _task_attr(t, "status", "pending")
+            if s in buckets:
+                buckets[s].append(_task_attr(t, "subject"))
+        if any(buckets.values()):
+            sections.extend(["", f"### Previous Work ({len(tasks)} tasks)", ""])
+            marks = {"completed": "[x]", "in_progress": "[~]", "pending": "[ ]", "blocked": "[!]"}
+            for status, mark in marks.items():
+                for subj in buckets[status]:
+                    sections.append(f"- {mark} {subj}")
+
+    plan_path = getattr(ctx, "plan_path", None)
+    if plan_path:
+        if inline_plan:
+            content, truncated, total_chars = _read_plan_content(plan_path)
+            if content:
+                header = f"Plan loaded from: `{plan_path}`"
+                if truncated:
+                    header += f" (truncated, {total_chars} chars total)"
+                sections.extend(["", "### Plan", header, "", content])
+                if truncated:
+                    sections.append(f"\n*Plan truncated at {MAX_PLAN_INLINE_CHARS} characters. Full plan at: `{plan_path}`*")
+            else:
+                sections.extend(["", "### Plan", f"*Plan file not found at `{plan_path}`.*"])
+        else:
+            sections.extend(["", "### Plan", f"Read the plan at: `{plan_path}`"])
+
+    git_state = last_session.get("git_state", {}) if last_session else {}
+    if git_state:
+        branch = git_state.get("branch", "unknown")
+        uncommitted = git_state.get("uncommitted_files", [])
+        last_commit = git_state.get("last_commit_short", "")
+        unc_str = ", ".join(uncommitted[:5]) if uncommitted else "none"
+        if len(uncommitted) > 5:
+            unc_str += f" (+{len(uncommitted) - 5} more)"
+        sections.extend(["", "### Git State", f"Branch: {branch} | Uncommitted: {unc_str}"])
+        if last_commit:
+            sections.append(f"Last commit: {last_commit}")
+
+    return "\n".join(sections)
+
+
+def _mode_label(ctx) -> str:
+    """Get unbracketed mode label for inline display, defaulting to 'Active'."""
+    d = get_mode_display(getattr(ctx, "mode", "idle"))
+    return d.strip("[]") if d else "Active"
+
+
+def _resume_block(ctx, project_root, mode_text, instructions):
+    """Common pattern: resume header + restore + instructions."""
+    lines = [f"## Resuming Context: {ctx.id}", "", f"**Summary:** {ctx.summary}", f"**Mode:** {mode_text}"]
+    restore = _build_restore_sections(ctx, project_root, inline_plan=True)
+    if restore:
+        lines.append(restore)
+    lines.extend(["", "---", "", "**Instructions:**"])
+    lines.extend(instructions)
+    return "\n".join(lines)
+
+
+# ── Public formatters ──────────────────────────────────────────────
+
+def format_handoff_continuation(ctx, project_root: Path = None) -> str:
+    """Format output when resuming a context with a pending handoff."""
+    handoff_path = getattr(ctx, "handoff_path", None) or ""
+    lines = [
+        f"## Resuming Context: {ctx.id} (Handoff Available)", "",
+        f"**Summary:** {ctx.summary}",
+        f"**Mode:** Implementing (handoff from previous session)", "",
+    ]
+    try:
+        hf = Path(handoff_path)
+        if hf.exists():
+            lines.extend(["### Previous Session Handoff", "", hf.read_text(encoding="utf-8"), ""])
+        else:
+            lines.extend([f"*Handoff document not found at `{handoff_path}`*", ""])
+    except Exception as e:
+        lines.extend([f"*Handoff document at `{handoff_path}` could not be read: {e}*", ""])
+    restore = _build_restore_sections(ctx, project_root, inline_plan=True)
+    if restore:
+        lines.append(restore)
+    lines.extend(["", "---", "", "**Instructions:**",
+        "1. Review the handoff document above - especially dead ends",
+        "2. Check the plan file for remaining tasks",
+        "3. Continue implementation from where the previous session left off"])
+    return "\n".join(lines)
+
+
+def format_plan_continuation(ctx, project_root: Path = None) -> str:
+    """Format output for pending plan implementation (mode=has_plan)."""
+    return _resume_block(ctx, project_root, "Pending Implementation", [
+        "1. Review the plan and previous work above",
+        "2. Continue from where the previous session left off"])
+
+
+def format_active_continuation(ctx, project_root: Path = None) -> str:
+    """Format output for ongoing implementation (mode=active)."""
+    return _resume_block(ctx, project_root, "Implementing", [
+        "1. Review the plan and previous work above",
+        "2. Continue from where the previous session left off"])
+
+
+def format_context_list(contexts: list) -> str:
+    """Format list of contexts for display."""
+    if not contexts:
+        return "No active contexts found."
+    lines = ["## Active Contexts\n"]
+    for i, ctx in enumerate(contexts, 1):
+        time_str = format_relative_time(ctx.last_active)
+        md = get_mode_display(getattr(ctx, "mode", "idle"))
+        si = f" {md}" if md else ""
+        lines.append(f"**{i}. {ctx.id}**{si}")
+        lines.append(f"   {ctx.summary}")
+        if ctx.method:
+            lines.append(f"   Method: {ctx.method} | Last active: {time_str}")
+        else:
+            lines.append(f"   Last active: {time_str}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def format_context_created(ctx) -> str:
+    """Format notification for a newly created context."""
+    return "\n".join([
+        f"## Context Created: {ctx.id}", "", f"**Summary:** {ctx.summary}", "",
+        "A new context has been created for this work.",
+        "Tasks created with TaskCreate will be persisted to this context."])
+
+
+def format_active_context_reminder(ctx, project_root: Path = None, include_restore: bool = False) -> str:
+    """Format system reminder: lightweight (per-prompt) or rich (first-bind restore)."""
+    time_str = format_relative_time(ctx.last_active)
+    label = _mode_label(ctx)
+    if include_restore:
+        lines = [f"## Resuming Context: {ctx.id}", "", f"**Summary:** {ctx.summary}", f"**Mode:** {label}"]
+        restore = _build_restore_sections(ctx, project_root, inline_plan=True)
+        if restore:
+            lines.append(restore)
+        lines.extend(["", "---", "", "**Instructions:**",
+            "1. Review the previous work above",
+            "2. Continue from where the previous session left off"])
+    else:
+        lines = [
+            f"## Active Context: {ctx.id}", "", f"**Summary:** {ctx.summary}",
+            f"**Mode:** {label}", f"**Last Active:** {time_str}", "",
+            f'All work belongs to context "{ctx.id}".',
+            "Tasks created with TaskCreate will be persisted to this context."]
+    return "\n".join(lines)
+
+
+# ── Picker / command feedback ──────────────────────────────────────
+
+def format_context_picker_stderr(contexts: list) -> str:
+    """Format the boxed picker shown on stderr when blocking for selection."""
+    lines = ["",
+        "+----------------------------------------------------------------+",
+        "|                   CONTEXT SELECTION REQUIRED                   |",
+        "+----------------------------------------------------------------+"]
+    selectable_count = 0
+    for i, ctx in enumerate(contexts, 1):
+        time_str = format_relative_time(ctx.last_active)
+        mode = getattr(ctx, "mode", "idle")
+        is_selectable = mode == "active" or getattr(ctx, "handoff_path", None)
+        if is_selectable:
+            selectable_count += 1
+        status = ""
+        if getattr(ctx, "handoff_path", None):
+            status = " [Handoff Ready]"
+        elif get_mode_display(mode):
+            status = f" {get_mode_display(mode)}"
+        summary = ctx.summary[:45] + "..." if len(ctx.summary) > 48 else ctx.summary
+        sel_tag = " [selectable]" if is_selectable else " [end only]"
+        lines.append(f"|  ^{i}  {ctx.id}{status}{sel_tag}")
+        lines.append(f"|       {summary}")
+        lines.append(f"|       [{time_str}]")
+        lines.append("|")
+    lines.extend([
+        "+----------------------------------------------------------------+",
+        "|  Usage:                                                        |",
+        "|    ^S<N>                 - Select context by number            |",
+        "|    ^E<N>                 - End/complete context by number      |",
+        "|    ^S:query              - Select by ID match (race-safe)       |",
+        "|    ^E:query              - End by ID match (race-safe)         |",
+        "|    ^E<N>+                - End context N and all after         |",
+        "|    ^E*                   - End ALL contexts                    |",
+        "|    ^E1E2S3               - End #1 and #2, select #3           |",
+        "|    ^E:fooS:bar           - End 'foo...', select 'bar...'       |",
+        "|    ^0 work description   - Create new context (10+ chars)     |",
+        "+----------------------------------------------------------------+"])
+    if selectable_count == 0:
+        lines.extend([
+            "|  NOTE: No selectable contexts.                                |",
+            "|        Use ^E<N> to end old contexts, then ^0 to create new.  |",
+            "+----------------------------------------------------------------+"])
+    lines.append("")
+    return "\n".join(lines)
+
+
+def format_command_feedback(ended_contexts: list, selected_context=None) -> str:
+    """Format feedback about caret command operations performed."""
+    lines = []
+    if ended_contexts:
+        lines.extend(["## Contexts Ended", ""])
+        for ctx in ended_contexts:
+            s = ctx.summary[:50] + "..." if len(ctx.summary) > 50 else ctx.summary
+            lines.append(f"- **{ctx.id}**: {s}")
+        lines.append("")
+    if selected_context:
+        label = _mode_label(selected_context)
+        time_str = format_relative_time(selected_context.last_active)
+        lines.extend([
+            f"## Active Context: {selected_context.id}", "",
+            f"**Summary:** {selected_context.summary}",
+            f"**Mode:** {label}", f"**Last Active:** {time_str}", "",
+            f'All work belongs to context "{selected_context.id}".',
+            "Tasks created with TaskCreate will be persisted to this context."])
+    return "\n".join(lines)