aiwcli 0.10.2 → 0.11.0

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

@@ -1,104 +0,0 @@
-#!/usr/bin/env python3
-"""PreCompact hook - saves auto-state before context compaction.
-
-Critical: saves state before context compaction destroys token history.
-After compaction, SessionStart fires with source="compact" and the
-restored auto-state provides continuity context.
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "PreCompact",
-    "session_id": "abc123",
-    "transcript_path": "/path/to/transcript.jsonl",
-    "cwd": "/path/to/project",
-    ...
-}
-
-Hook output:
-- Silent (no stdout output needed)
-- Logs to stderr for debugging
-"""
-import sys
-from pathlib import Path
-
-# Add parent directories to path for imports
-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, log_debug, log_info, log_error
-from lib.base.utils import project_dir
-from lib.context.context_store import get_context_by_session_id, save_state
-
-
-def main():
-    """Save auto-state before compaction."""
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        session_id = hook_input.get("session_id", "")
-        transcript_path = hook_input.get("transcript_path")
-        project_root = project_dir(hook_input)
-
-        if not session_id:
-            log_debug("pre_compact", "No session_id, skipping")
-            return
-
-        log_info("pre_compact", f"Saving state before compaction: {session_id[:8]}...")
-
-        # Find context bound to this session
-        context = get_context_by_session_id(session_id, project_root)
-        if not context:
-            log_debug("pre_compact", "No context bound to this session, skipping")
-            return
-
-        # Save last_session snapshot directly to state.json
-        import subprocess
-        git_state = {}
-        try:
-            branch = subprocess.run(
-                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-                capture_output=True, text=True, timeout=5
-            )
-            git_state["branch"] = branch.stdout.strip() if branch.returncode == 0 else "unknown"
-
-            status = subprocess.run(
-                ["git", "status", "--short"],
-                capture_output=True, text=True, timeout=5
-            )
-            if status.returncode == 0 and status.stdout.strip():
-                git_state["uncommitted_files"] = [
-                    line.split(None, 1)[-1] for line in status.stdout.strip().split("\n")[:10]
-                ]
-
-            log = subprocess.run(
-                ["git", "log", "-1", "--format=%h %s"],
-                capture_output=True, text=True, timeout=5
-            )
-            if log.returncode == 0:
-                git_state["last_commit_short"] = log.stdout.strip()
-        except Exception:
-            pass
-
-        from lib.base.utils import now_iso
-        context.last_session = {
-            "session_id": session_id,
-            "saved_at": now_iso(),
-            "save_reason": "pre_compact",
-            "git_state": git_state,
-        }
-        save_state(context, project_root)
-        log_info("pre_compact", f"State saved for {context.id}")
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("pre_compact", e, "PreCompact", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "pre_compact")

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

@@ -1,173 +0,0 @@
-#!/usr/bin/env python3
-"""SessionEnd hook - saves session state to state.json.
-
-Fires when session terminates (quit, /clear, logout). Saves last_session
-data directly to state.json for restoration on next session.
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "SessionEnd",
-    "session_id": "abc123",
-    "source": "prompt_input_exit",  # or "clear", "logout", "compact"
-    "transcript_path": "/path/to/transcript.jsonl",
-    "cwd": "/path/to/project",
-    ...
-}
-
-Hook output:
-- Silent (no stdout output needed for SessionEnd)
-- Logs to stderr for debugging
-"""
-import hashlib
-import subprocess
-import sys
-from pathlib import Path
-
-# Add parent directories to path for imports
-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, log_debug, log_info, log_warn, log_error, log_diagnostic
-from lib.base.utils import now_iso, project_dir
-from lib.context.context_store import get_context_by_session_id, save_state
-from lib.context.plan_manager import find_latest_plan, normalize_plan_content, generate_plan_id, extract_plan_anchors
-
-
-def _get_git_state(project_root: Path) -> dict:
-    """Capture current git state for restoration."""
-    git_state = {}
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            capture_output=True, text=True, cwd=str(project_root), timeout=5,
-        )
-        if result.returncode == 0:
-            git_state["branch"] = result.stdout.strip()
-
-        result = subprocess.run(
-            ["git", "diff", "--name-only"],
-            capture_output=True, text=True, cwd=str(project_root), timeout=5,
-        )
-        if result.returncode == 0:
-            files = [f for f in result.stdout.strip().split("\n") if f]
-            git_state["uncommitted_files"] = files
-
-        result = subprocess.run(
-            ["git", "log", "-1", "--oneline"],
-            capture_output=True, text=True, cwd=str(project_root), timeout=5,
-        )
-        if result.returncode == 0:
-            git_state["last_commit_short"] = result.stdout.strip()
-    except Exception as e:
-        log_warn("session_end", f"Git state capture error (non-fatal): {e}")
-
-    return git_state
-
-
-def main():
-    """Save session state to state.json."""
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        session_id = hook_input.get("session_id", "")
-        source = hook_input.get("source", "other")
-        transcript_path = hook_input.get("transcript_path")
-        project_root = project_dir(hook_input)
-
-        if not session_id:
-            log_debug("session_end", "No session_id, skipping")
-            return
-
-        log_info("session_end", f"Session ending: {session_id[:8]}... reason={source}")
-        log_diagnostic("session_end", "receive", f"session={session_id[:8]}, source={source}",
-                        inputs={"session_id": session_id[:12], "source": source})
-
-        # Find context bound to this session
-        state = get_context_by_session_id(session_id, project_root)
-        if not state:
-            log_debug("session_end", "No context bound to this session, skipping")
-            return
-
-        log_info("session_end", f"Found context: {state.id}")
-
-        # Capture git state
-        git_state = _get_git_state(project_root)
-
-        # Save last_session directly to state.json
-        state.last_session = {
-            "session_id": session_id,
-            "save_reason": source,
-            "saved_at": now_iso(),
-            "transcript_path": transcript_path,
-            "git_state": git_state,
-        }
-        state.last_active = now_iso()
-
-        # Only assign plan fields and stage if NOT in plan mode.
-        # If permission_mode == "plan", ExitPlanMode was rejected (user pressed Escape),
-        # so we should not stage the archived plan for the next session.
-        permission_mode = hook_input.get("permission_mode", "default")
-
-        if permission_mode != "plan":
-            # Fallback: assign plan fields if PostToolUse:ExitPlanMode didn't fire.
-            # When ExitPlanMode triggers /clear, the session terminates before PostToolUse
-            # hooks can run, so plan_accepted.py never fires. Detect this by checking
-            # for an archived plan that hasn't been assigned yet.
-            if not state.plan_hash:
-                latest_plan_path = find_latest_plan(state.id, project_root)
-                if latest_plan_path:
-                    try:
-                        content = Path(latest_plan_path).read_text(encoding="utf-8")
-                        normalized = normalize_plan_content(content)
-                        state.plan_hash = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
-                        state.plan_path = latest_plan_path
-                        state.plan_signature = content[:200]
-                        state.plan_id = generate_plan_id()
-                        state.plan_anchors = extract_plan_anchors(content)
-                        state.plan_consumed = False
-                        log_info("session_end", f"Fallback: assigned archived plan for {state.id} (hash: {state.plan_hash})")
-                    except Exception as e:
-                        log_warn("session_end", f"Fallback plan assignment failed: {e}")
-
-            # If a plan is assigned, not yet consumed, and mode is active, stage it for next session
-            if state.plan_hash and state.mode == "active" and not state.plan_consumed:
-                state.mode = "has_plan"
-                log_info("session_end", f"Staged plan for next session: {state.id} -> has_plan")
-            elif state.plan_hash and state.mode == "active" and state.plan_consumed:
-                log_debug("session_end", f"Plan already consumed for {state.id}, not re-staging")
-                log_diagnostic("session_end", "decide", f"Skipping re-stage for {state.id}",
-                                decision="skip_restage", reasoning="plan_hash exists but plan_consumed=True",
-                                inputs={"plan_hash": state.plan_hash, "plan_consumed": True})
-        else:
-            log_info("session_end", f"Plan mode active (rejected), skipping plan staging for {state.id}")
-
-        # Handoff staging (mirrors plan staging above)
-        # Note: if plan already set has_plan, mode != "active" so handoff check skips (plan takes priority)
-        if state.handoff_path and state.mode == "active" and not state.handoff_consumed:
-            state.mode = "has_handoff"
-            log_info("session_end", f"Staged handoff for next session: {state.id} -> has_handoff")
-        elif state.handoff_path and state.mode == "active" and state.handoff_consumed:
-            log_debug("session_end", f"Handoff already consumed for {state.id}, not re-staging")
-
-        if save_state(state, project_root):
-            log_info("session_end", f"Saved last_session for {state.id}")
-            log_diagnostic("session_end", "result", f"Saved state for {state.id}",
-                            decision="saved", inputs={"context_id": state.id, "mode": state.mode,
-                                                       "has_plan_hash": bool(state.plan_hash),
-                                                       "git_files": len(git_state.get("uncommitted_files", []))})
-        else:
-            log_error("session_end", f"Failed to save state for {state.id}")
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("session_end", e, "SessionEnd", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "session_end")

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

@@ -1,206 +0,0 @@
-#!/usr/bin/env python3
-"""SessionStart hook for post-compaction and post-clear restore.
-
-This hook fires when a new session starts. It handles:
-
-1. Post-clear restore (source="clear"): After ExitPlanMode "clear context",
-   Claude Code runs /clear and auto-pastes the plan. The auto-paste bypasses
-   all hooks (UserPromptSubmit never fires), so this hook bridges the gap:
-   find the has_plan context (set by session_end moments ago), bind the new
-   session, transition has_plan → active, and inject restoration context.
-
-2. Post-compaction restore (source="compact"): The session is already bound
-   to a context. Load state and inject rich restoration context so Claude
-   can continue seamlessly after compaction.
-
-Hook input:
-{
-    "hook_event_name": "SessionStart",
-    "session_id": "abc123",
-    "source": "clear",  # or "startup", "resume", "compact"
-    "permission_mode": "bypassPermissions",
-    "model": "...",
-    ...
-}
-"""
-import sys
-from pathlib import Path
-
-# Add parent directories to path for imports
-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 emit_context, load_hook_input, log_debug, log_info, log_error, log_diagnostic
-from lib.base.utils import project_dir
-from lib.context.context_store import get_context_by_session_id, get_all_contexts, bind_session, update_mode
-from lib.context.context_formatter import _build_restore_sections, format_handoff_continuation
-
-
-def _handle_compact_restore(hook_input, session_id, project_root):
-    """
-    Handle post-compaction restore.
-
-    After compaction, the session is already bound to a context.
-    Load state and inject rich restoration context via additionalContext.
-    """
-    state = get_context_by_session_id(session_id, project_root)
-    if not state:
-        log_debug("session_start", "No context bound to session after compact")
-        return
-
-    log_info("session_start", f"Post-compaction restore for context: {state.id}")
-
-    # Build restoration context
-    mode_display = state.mode.replace("_", " ").title() if state.mode != "idle" else "Active"
-
-    lines = [
-        f"## Resuming Context After Compaction: {state.id}",
-        "",
-        f"**Summary:** {state.summary}",
-        f"**Mode:** {mode_display}",
-    ]
-
-    # Add restore sections (tasks, git state, plan content)
-    # inline_plan=True because plan content is NOT auto-pasted after compaction
-    restore = _build_restore_sections(state, project_root, inline_plan=True)
-    if restore:
-        lines.append(restore)
-
-    lines.extend([
-        "",
-        "---",
-        "",
-        "**Instructions:**",
-        "Context was compacted to free memory. Your previous conversation has been summarized.",
-        "1. Review the previous work above",
-        "2. Continue from where you left off",
-    ])
-
-    restore_context = "\n".join(lines)
-    emit_context(restore_context)
-    log_info("session_start", f"Injected post-compaction restore context for {state.id}")
-    log_diagnostic("session_start", "result", f"Compact restore complete for {state.id}",
-                    decision="injected", inputs={"context_id": state.id, "mode": state.mode})
-
-
-def _handle_clear_restore(hook_input, session_id, project_root):
-    """
-    Handle plan context restoration after /clear.
-
-    After ExitPlanMode "clear context", Claude Code auto-pastes the plan
-    but the auto-paste bypasses all hooks — UserPromptSubmit never fires.
-    This means the new session is never bound to a context.
-
-    Fix: find the has_plan context (set by session_end moments ago),
-    bind the new session to it, and inject restoration context.
-    """
-    # Find has_plan contexts (sorted by last_active descending)
-    has_plan = [
-        c for c in get_all_contexts(status="active", project_root=project_root)
-        if c.mode == "has_plan"
-    ]
-
-    if not has_plan:
-        # Check for has_handoff contexts (mirrors plan logic)
-        has_handoff = [
-            c for c in get_all_contexts(status="active", project_root=project_root)
-            if c.mode == "has_handoff"
-        ]
-        if has_handoff:
-            target = has_handoff[0]
-            log_info("session_start", f"Found has_handoff context after /clear: {target.id}")
-            bind_session(target.id, session_id, project_root)
-            log_info("session_start", f"Bound session {session_id[:8]}... to {target.id}")
-            update_mode(target.id, "active", project_root=project_root, handoff_consumed=True)
-            log_info("session_start", f"Transitioned {target.id}: has_handoff -> active (handoff_consumed=True)")
-            restore_context = format_handoff_continuation(target, project_root)
-            emit_context(restore_context)
-            log_info("session_start", f"Injected handoff-restore context for {target.id}")
-            return
-
-        log_debug("session_start", "No has_plan or has_handoff contexts found after /clear")
-        return
-
-    # Pick the most recently active one (first in list, already sorted)
-    target = has_plan[0]
-    log_info("session_start", f"Found has_plan context after /clear: {target.id}")
-
-    # Bind new session to this context
-    bind_session(target.id, session_id, project_root)
-    log_info("session_start", f"Bound session {session_id[:8]}... to {target.id}")
-
-    # Transition has_plan → active (consume the transient state)
-    update_mode(target.id, "active", project_root=project_root, plan_consumed=True)
-    log_info("session_start", f"Transitioned {target.id}: has_plan -> active (plan_consumed=True)")
-
-    # Inject restoration context (tasks, git state, plan path reference)
-    # Plan CONTENT is not injected — Claude Code auto-pastes it after /clear
-    mode_display = "Active (Plan Restored)"
-    lines = [
-        f"## Resuming Context After Plan Clear: {target.id}",
-        "",
-        f"**Summary:** {target.summary}",
-        f"**Mode:** {mode_display}",
-    ]
-
-    restore = _build_restore_sections(target, project_root)
-    if restore:
-        lines.append(restore)
-
-    lines.extend([
-        "",
-        "---",
-        "",
-        "**Instructions:**",
-        "Context was cleared for plan implementation. Your plan content has been pasted above.",
-        "1. Review the plan content above",
-        "2. Implement the plan step by step",
-    ])
-
-    restore_context = "\n".join(lines)
-    emit_context(restore_context)
-    log_info("session_start", f"Injected clear-restore context for {target.id}")
-    log_diagnostic("session_start", "result", f"Clear restore complete for {target.id}",
-                    decision="injected", inputs={"context_id": target.id, "mode_transition": "has_plan->active"})
-
-
-def main():
-    """Handle post-compaction and post-clear restore on session start."""
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        source = hook_input.get("source", "unknown")
-        permission_mode = hook_input.get("permission_mode", "default")
-        session_id = hook_input.get("session_id", "unknown")
-        project_root = project_dir(hook_input)
-
-        log_info("session_start", f"source={source}, permission_mode={permission_mode}, session={session_id[:8]}...")
-        log_diagnostic("session_start", "receive", f"source={source}, session={session_id[:8]}",
-                        inputs={"source": source, "session_id": session_id[:12], "permission_mode": permission_mode})
-
-        if source == "compact":
-            log_diagnostic("session_start", "decide", "Taking compact restore path",
-                            decision="compact_restore", reasoning="source=compact")
-            _handle_compact_restore(hook_input, session_id, project_root)
-        elif source == "clear":
-            log_diagnostic("session_start", "decide", "Taking clear restore path",
-                            decision="clear_restore", reasoning="source=clear, looking for has_plan context")
-            _handle_clear_restore(hook_input, session_id, project_root)
-        else:
-            log_diagnostic("session_start", "decide", f"No action for source={source}",
-                            decision="skip", reasoning=f"source={source} has no handler")
-            log_debug("session_start", f"No action for source='{source}'")
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("session_start", e, "SessionStart", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "session_start")

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

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook - captures TaskCreate operations for persistence.
-
-This hook runs after Claude uses the TaskCreate tool and automatically
-records the task in the context's state.json.
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "PostToolUse",
-    "tool_name": "TaskCreate",
-    "tool_input": {
-        "subject": "Task subject",
-        "description": "Task description",
-        "activeForm": "Present continuous form",
-        "metadata": {"context": "context-id", ...}
-    },
-    "tool_response": {"task": {"id": "1", "subject": "..."}},
-    "session_id": "abc123",
-    "cwd": "/path/to/project"
-}
-
-Hook output:
-- Silent on success (no stdout output)
-- Logs to stderr for debugging
-"""
-import sys
-from pathlib import Path
-
-# Add parent directories to path for imports
-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,
-    check_skip_persistence,
-    safe_hook_main,
-    run_hook,
-    log_debug,
-    log_info,
-    log_warn,
-    log_error,
-)
-from lib.base.utils import project_dir
-from lib.context.context_store import get_context_by_session_id
-from lib.context.task_tracker import add_task, generate_next_task_id
-
-
-@safe_hook_main("task_create_capture")
-def main() -> int:
-    """Main hook entry point."""
-    payload = load_hook_input()
-    if not payload:
-        return 0
-
-    if not validate_hook_event(payload, "PostToolUse", "TaskCreate"):
-        return 0
-
-    tool_input = get_tool_input(payload)
-    if not tool_input:
-        log_warn("task_create_capture", "Invalid tool_input: not a dict")
-        return 0
-
-    if check_skip_persistence(payload, "task_create_capture"):
-        return 0
-
-    project_root = project_dir(payload)
-    session_id = payload.get("session_id", "")
-
-    # Find context by session ID
-    state = get_context_by_session_id(session_id, project_root)
-    if not state:
-        log_debug("task_create_capture", "No context available - skipping persistence")
-        return 0
-
-    context_id = state.id
-
-    # Extract task data
-    subject = tool_input.get("subject", "")
-    if not subject:
-        log_warn("task_create_capture", "Missing required field: subject")
-        return 0
-
-    description = tool_input.get("description", "")
-    active_form = tool_input.get("activeForm", "")
-
-    # Add task to state.json
-    task = add_task(
-        context_id=context_id,
-        subject=subject,
-        description=description,
-        active_form=active_form,
-        session_id=session_id,
-        project_root=project_root,
-    )
-
-    if task:
-        log_info("task_create_capture", f"Recorded task: {task['id']} in {context_id}")
-    else:
-        log_error("task_create_capture", f"Failed to add task in {context_id}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    run_hook(main, "task_create_capture")