aiwcli 0.10.3 → 0.11.1

package/dist/templates/_shared/hooks/file-suggestion.py

@@ -1,215 +0,0 @@
-#!/usr/bin/env python3
-"""File suggestion hook for Claude Code.
-
-Suggests relevant files to include in context based on the current session:
-- Context file (context.json) for the active context
-- Plans from the active context's plans/ directory
-- Handoffs from the active context's handoffs/ directory
-- Reviews from the active context's reviews/ directory (including cc-native subdirectory)
-
-Hook input (from Claude Code):
-{
-    "session_id": "abc123",
-    "cwd": "/path/to/project",
-    ...
-}
-
-Hook output:
-JSON array of file paths to suggest, or empty array if no suggestions.
-["/path/to/file1.md", "/path/to/file2.md"]
-"""
-import json
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-# 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.base.constants import (
-    get_context_plans_dir,
-    get_context_handoffs_dir,
-    get_context_reviews_dir,
-    get_context_file_path,
-)
-from lib.context.context_store import (
-    get_context_by_session_id,
-    get_all_contexts,
-    get_context,
-)
-
-
-def get_context_files(context_id: str, project_root: Path) -> List[str]:
-    """
-    Get all relevant files for a context.
-
-    Collects:
-    - Context file (context.json)
-    - Plans (most recent first)
-    - Handoffs: index.md from subdirectories (folder-based) OR flat .md files (legacy)
-    - Reviews: index.md from subdirectories (folder-based) OR flat review.md (legacy)
-
-    Args:
-        context_id: Context identifier
-        project_root: Project root path
-
-    Returns:
-        List of absolute file paths, sorted by modification time (most recent first)
-    """
-    files = []
-
-    # Get context.json file first
-    context_file = get_context_file_path(context_id, project_root)
-    if context_file.exists():
-        files.append(str(context_file))
-        log_debug("file-suggestion", f"Found context file for {context_id}")
-
-    # Get plans directory
-    plans_dir = get_context_plans_dir(context_id, project_root)
-    if plans_dir.exists():
-        plan_files = list(plans_dir.glob("*.md"))
-        # Sort by modification time, most recent first
-        plan_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-        files.extend([str(p) for p in plan_files])
-        log_debug("file-suggestion", f"Found {len(plan_files)} plans in {context_id}")
-
-    # Get handoffs - prefer folder-based (index.md in subdirectories), fall back to legacy
-    handoffs_dir = get_context_handoffs_dir(context_id, project_root)
-    if handoffs_dir.exists():
-        # Find handoff folders (named like YYYY-MM-DD-HHMM or YYYY-MM-DD-HHMM-N)
-        handoff_folders = sorted(
-            [d for d in handoffs_dir.iterdir() if d.is_dir()],
-            key=lambda d: d.name,
-            reverse=True  # Most recent first (alphabetically sorts by date)
-        )
-
-        if handoff_folders:
-            # Use folder-based: get index.md from most recent folder only
-            index_file = handoff_folders[0] / "index.md"
-            if index_file.exists():
-                files.append(str(index_file))
-                log_debug("file-suggestion", f"Found handoff folder: {handoff_folders[0].name}")
-        else:
-            # Legacy support: flat .md files directly in handoffs/
-            legacy_handoffs = [f for f in handoffs_dir.glob("*.md") if f.is_file()]
-            legacy_handoffs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-            if legacy_handoffs:
-                files.append(str(legacy_handoffs[0]))  # Only most recent legacy
-                log_debug("file-suggestion", f"Found {len(legacy_handoffs)} legacy handoffs in {context_id}")
-
-    # Get reviews - prefer folder-based (index.md in subdirectories), fall back to legacy
-    reviews_dir = get_context_reviews_dir(context_id, project_root) / "cc-native"
-    if reviews_dir.exists():
-        # Find review folders (named like YYYY-MM-DD-HHMM-iteration-N)
-        review_folders = sorted(
-            [d for d in reviews_dir.iterdir() if d.is_dir()],
-            key=lambda d: d.name,
-            reverse=True  # Most recent first
-        )
-
-        if review_folders:
-            # Use folder-based: get index.md from most recent folder only
-            index_file = review_folders[0] / "index.md"
-            if index_file.exists():
-                files.append(str(index_file))
-                log_debug("file-suggestion", f"Found review folder: {review_folders[0].name}")
-        else:
-            # Legacy support: flat review.md directly in cc-native/
-            legacy_review = reviews_dir / "review.md"
-            if legacy_review.exists():
-                files.append(str(legacy_review))
-                log_debug("file-suggestion", f"Found legacy review.md in {context_id}")
-
-    return files
-
-
-def get_active_context_id(session_id: str, project_root: Path) -> Optional[str]:
-    """
-    Determine the active context for suggestions.
-
-    Priority:
-    1. Context bound to current session_id
-    2. Single in-flight context (if only one exists)
-    3. None (no suggestions if ambiguous)
-
-    Args:
-        session_id: Current session identifier
-        project_root: Project root path
-
-    Returns:
-        Context ID or None
-    """
-    # Try session_id lookup first
-    if session_id and session_id != "unknown":
-        context = get_context_by_session_id(session_id, project_root)
-        if context:
-            log_debug("file-suggestion", f"Found context by session: {context.id}")
-            return context.id
-
-    # Fall back to single active (non-idle) context
-    active = [c for c in get_all_contexts(status="active", project_root=project_root)
-              if c.mode != "idle"]
-    if len(active) == 1:
-        log_debug("file-suggestion", f"Using single active context: {active[0].id}")
-        return active[0].id
-
-    log_debug("file-suggestion", f"No unique context found (active: {len(active)})")
-    return None
-
-
-def main():
-    """
-    Main entry point for file suggestion hook.
-
-    Reads hook input from stdin, determines active context,
-    and outputs file suggestions as JSON array.
-    """
-    try:
-        # Read hook input using shared utility
-        hook_input = load_hook_input()
-
-        if not hook_input:
-            print("[]")
-            return
-
-        # Get project root and session ID
-        project_root = project_dir(hook_input)
-        session_id = hook_input.get("session_id", "unknown")
-
-        log_debug("file-suggestion", f"Session: {session_id[:8]}..., Project: {project_root}")
-
-        # Determine active context
-        context_id = get_active_context_id(session_id, project_root)
-
-        if not context_id:
-            print("[]")
-            return
-
-        # Collect file suggestions
-        suggestions = get_context_files(context_id, project_root)
-
-        # Limit suggestions to prevent overwhelming the context
-        MAX_SUGGESTIONS = 10
-        if len(suggestions) > MAX_SUGGESTIONS:
-            log_debug("file-suggestion", f"Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
-            suggestions = suggestions[:MAX_SUGGESTIONS]
-
-        # Output suggestions as JSON array
-        log_info("file-suggestion", f"Suggesting {len(suggestions)} files")
-        print(json.dumps(suggestions))
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("file-suggestion", e, "SessionStart", traceback_str=tb)
-        print("[]")
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "file_suggestion")

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")