aiwcli 0.10.3 → 0.11.1

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

@@ -1,339 +0,0 @@
-"""Common utilities for hook scripts.
-
-Provides standardized boilerplate for:
-- Path setup for imports
-- JSON parsing from stdin
-- Hook payload validation
-- Error handling decorators
-"""
-
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from functools import wraps
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional, TypeVar
-
-from .logger import log_hook_error, hook_log, log_debug, log_info, log_warn, log_error, log_diagnostic, set_context_path, set_session_id
-
-
-# Context window baseline: tokens not visible in hook data
-# (system prompt, tools, MCP tokens)
-# See: https://github.com/anthropics/claude-code/issues/13783
-CONTEXT_BASELINE_TOKENS = 22_600
-DEFAULT_CONTEXT_WINDOW_SIZE = 200_000
-
-
-def parse_context_window(hook_input: dict) -> tuple:
-    """Parse context window from hook input.
-
-    Returns (tokens_used, max_tokens) or (None, None).
-    tokens_used includes baseline offset for system prompt/tools.
-    """
-    context_window = hook_input.get("context_window")
-    if not context_window:
-        return None, None
-    current_usage = context_window.get("current_usage")
-    if not current_usage:
-        return None, None
-    cache_read = current_usage.get("cache_read_input_tokens", 0) or 0
-    input_tokens = current_usage.get("input_tokens", 0) or 0
-    cache_creation = current_usage.get("cache_creation_input_tokens", 0) or 0
-    output_tokens = current_usage.get("output_tokens", 0) or 0
-    content_tokens = cache_read + input_tokens + cache_creation + output_tokens
-    tokens_used = content_tokens + CONTEXT_BASELINE_TOKENS
-    max_tokens = context_window.get("context_window_size") or DEFAULT_CONTEXT_WINDOW_SIZE
-    return tokens_used, max_tokens
-
-
-def get_context_percent_remaining(hook_input: dict) -> tuple:
-    """Get context percentage remaining with context.json fallback.
-
-    Tries two sources in order:
-    1. Hook input context_window data (most accurate, real-time)
-    2. context.json remaining_percentage (written by status_line.py)
-
-    Returns:
-        (percent_remaining, tokens_used, max_tokens) where tokens_used and
-        max_tokens may be None if data came from context.json fallback.
-        Returns (None, None, None) if no data available from either source.
-    """
-    # Source 1: Hook input (most accurate)
-    tokens_used, max_tokens = parse_context_window(hook_input)
-    if tokens_used is not None and max_tokens is not None and max_tokens > 0:
-        remaining = max_tokens - tokens_used
-        percent_remaining = max(0, min(100, int((remaining / max_tokens) * 100)))
-        return percent_remaining, tokens_used, max_tokens
-
-    # Source 2: context.json fallback (written by status_line.py)
-    try:
-        from .utils import project_dir
-        from ..context.context_store import get_context_by_session_id
-
-        session_id = hook_input.get("session_id")
-        if session_id:
-            project_root = project_dir(hook_input)
-            context = get_context_by_session_id(session_id, project_root)
-            if context and context.last_session:
-                pct = context.last_session.get("context_remaining_pct")
-                if pct is not None:
-                    return pct, None, None
-    except Exception:
-        pass  # Fallback failed — degrade gracefully
-
-    return None, None, None
-
-
-# Type variable for generic decorators
-F = TypeVar('F', bound=Callable[..., Any])
-
-# Event metadata stash — populated by load_hook_input(), read by run_hook()
-_last_hook_event: Optional[str] = None
-_last_tool_name: Optional[str] = None
-_last_session_id: Optional[str] = None
-
-
-def load_hook_input() -> Optional[Dict[str, Any]]:
-    """
-    Load and parse JSON from stdin.
-
-    Returns:
-        Parsed JSON dict, or None if stdin is empty or invalid JSON
-    """
-    global _last_hook_event, _last_tool_name, _last_session_id
-    try:
-        input_data = sys.stdin.read().strip()
-        if not input_data:
-            return None
-        result = json.loads(input_data)
-        if isinstance(result, dict):
-            _last_hook_event = result.get("hook_event_name")
-            _last_tool_name = result.get("tool_name")
-            _last_session_id = result.get("session_id")
-        return result
-    except json.JSONDecodeError:
-        return None
-
-
-def validate_hook_event(
-    payload: Dict[str, Any],
-    expected_event: str,
-    expected_tool: Optional[str] = None
-) -> bool:
-    """
-    Validate hook event type and optional tool name.
-
-    Args:
-        payload: Hook payload from stdin
-        expected_event: Expected hook_event_name (e.g., "PostToolUse", "PreToolUse")
-        expected_tool: Optional expected tool_name (e.g., "TaskCreate")
-
-    Returns:
-        True if payload matches expected event/tool, False otherwise
-    """
-    if payload.get("hook_event_name") != expected_event:
-        return False
-    if expected_tool and payload.get("tool_name") != expected_tool:
-        return False
-    return True
-
-
-def get_tool_input(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """
-    Extract and validate tool_input from payload.
-
-    Args:
-        payload: Hook payload from stdin
-
-    Returns:
-        tool_input dict, or None if missing/invalid
-    """
-    tool_input = payload.get("tool_input", {})
-    return tool_input if isinstance(tool_input, dict) else None
-
-
-def check_skip_persistence(payload: Dict[str, Any], hook_name: str = "hook") -> bool:
-    """
-    Check if persistence should be skipped based on metadata flags.
-
-    Args:
-        payload: Hook payload from stdin
-        hook_name: Name of hook for logging
-
-    Returns:
-        True if skip_persistence flag is set, False otherwise
-    """
-    tool_input = get_tool_input(payload)
-    if not tool_input:
-        return False
-
-    metadata = tool_input.get("metadata", {})
-    if isinstance(metadata, dict) and metadata.get("skip_persistence"):
-        log_debug(hook_name, "Skipping persistence (skip_persistence flag set)")
-        return True
-    return False
-
-
-def safe_hook_main(hook_name: str) -> Callable[[F], F]:
-    """
-    Decorator for hook main functions with standard error handling.
-
-    Catches exceptions, logs them to stderr, and returns 0 (non-blocking).
-
-    Args:
-        hook_name: Name of hook for error messages
-
-    Returns:
-        Decorator function
-
-    Example:
-        @safe_hook_main("my_hook")
-        def main() -> int:
-            # ... hook logic ...
-            return 0
-    """
-    def decorator(func: F) -> F:
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except json.JSONDecodeError as e:
-                import traceback
-                tb = traceback.format_exc()
-                log_hook_error(hook_name, e, traceback_str=tb)
-                log_error(hook_name, f"JSON decode error: {e}")
-                return 0
-            except Exception as e:
-                import traceback
-                tb = traceback.format_exc()
-                log_hook_error(hook_name, e, traceback_str=tb)
-                log_error(hook_name, f"Unexpected error: {e}", traceback_str=tb)
-                return 0
-        return wrapper  # type: ignore
-    return decorator
-
-
-def emit_context(additional_context: str, ensure_ascii: bool = False) -> None:
-    """Emit hookSpecificOutput with additionalContext to stdout.
-
-    Args:
-        additional_context: Context string to inject into Claude's context
-        ensure_ascii: If True, escape non-ASCII characters in JSON output
-    """
-    out = {
-        "hookSpecificOutput": {
-            "additionalContext": additional_context,
-        }
-    }
-    print(json.dumps(out, ensure_ascii=ensure_ascii))
-
-
-def emit_context_and_block(
-    additional_context: str,
-    reason: str,
-    ensure_ascii: bool = True,
-) -> None:
-    """Emit hookSpecificOutput that denies the tool call with context and reason.
-
-    Args:
-        additional_context: Context string to inject into Claude's context
-        reason: Reason shown to Claude for why the tool call was denied
-        ensure_ascii: If True, escape non-ASCII characters in JSON output
-    """
-    out = {
-        "hookSpecificOutput": {
-            "additionalContext": additional_context,
-            "permissionDecision": "deny",
-            "permissionDecisionReason": reason,
-        }
-    }
-    print(json.dumps(out, ensure_ascii=ensure_ascii))
-
-
-def _detect_template(script_path: str = "") -> str:
-    """Auto-detect template origin from the hook script path.
-
-    Returns "shared", a template name (e.g., "cc-native"), or "unknown".
-    """
-    import re
-    path = (script_path or (sys.argv[0] if sys.argv else "")).replace("\\", "/")
-    if "/_shared/hooks/" in path or path.startswith("_shared/hooks/"):
-        return "shared"
-    match = re.search(r'_([a-z][a-z0-9-]*)/hooks/', path)
-    if match:
-        return match.group(1)  # e.g., "cc-native"
-    return "unknown"
-
-
-def run_hook(main_func: Callable[[], int], hook_name: str = "unknown") -> None:
-    """
-    Standard hook entry point wrapper with lifecycle logging.
-
-    Logs HOOK_START before calling main, HOOK_END after completion.
-    Catches unhandled exceptions and logs them before exiting cleanly.
-
-    Args:
-        main_func: Hook main function that returns exit code
-        hook_name: Name of the hook for error logging
-
-    Example:
-        if __name__ == "__main__":
-            run_hook(main, "my_hook")
-    """
-    import time
-    start_time = time.monotonic()
-    template = _detect_template()
-    event = _last_hook_event or "unknown"
-    tool = _last_tool_name
-
-    # Wire session_id into logger so all log entries carry it
-    if _last_session_id:
-        set_session_id(_last_session_id)
-
-    # HOOK_START
-    start_data: Dict[str, Any] = {"lifecycle": "start", "template": template, "event": event}
-    if tool:
-        start_data["tool"] = tool
-    log_info(hook_name, "HOOK_START", data=start_data)
-
-    exit_code = 0
-    status = "success"
-    error_info = None
-
-    try:
-        result = main_func()
-        exit_code = result if isinstance(result, int) else 0
-        status = "blocked" if exit_code != 0 else "success"
-    except SystemExit as e:
-        exit_code = e.code if isinstance(e.code, int) else (1 if e.code else 0)
-        status = "blocked" if exit_code != 0 else "success"
-    except Exception as e:
-        import traceback
-        exit_code = 0  # Non-blocking
-        status = "error"
-        error_info = (e, traceback.format_exc())
-
-    # HOOK_END
-    duration_ms = round((time.monotonic() - start_time) * 1000, 1)
-    end_data: Dict[str, Any] = {
-        "lifecycle": "end", "status": status,
-        "duration_ms": duration_ms, "exit_code": exit_code,
-        "template": template,
-    }
-    end_event = _last_hook_event or event  # Re-read after main() populated it
-    end_tool = _last_tool_name or tool
-    end_data["event"] = end_event
-    if end_tool:
-        end_data["tool"] = end_tool
-    if error_info:
-        e, tb = error_info
-        end_data["error_type"] = type(e).__name__
-        log_hook_error(hook_name, e, traceback_str=tb)
-        log_error(hook_name, f"HOOK_END: {e}", data=end_data, traceback_str=tb)
-    elif status == "blocked":
-        log_warn(hook_name, "HOOK_END", data=end_data)
-    else:
-        log_info(hook_name, "HOOK_END", data=end_data)
-
-    raise SystemExit(exit_code)

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

@@ -1,307 +0,0 @@
-"""Inference utility for AI-powered text processing.
-
-Provides a unified interface for Claude API calls using the claude CLI.
-Supports multiple model tiers: fast (Haiku), standard (Sonnet), smart (Opus).
-"""
-import json
-import re
-import subprocess
-import sys
-import os
-from typing import Optional
-
-from .logger import log_debug, log_info, log_warn, log_error
-from dataclasses import dataclass
-
-
-@dataclass
-class InferenceResult:
-    """Result from an inference call."""
-    success: bool
-    output: str
-    error: Optional[str] = None
-    latency_ms: int = 0
-
-
-# Model configurations
-MODELS = {
-    "fast": "claude-3-haiku-20240307",
-    "standard": "claude-sonnet-4-20250514",
-    "smart": "claude-opus-4-20250514",
-}
-
-TIMEOUTS = {
-    "fast": 15,      # 15 seconds
-    "standard": 30,  # 30 seconds
-    "smart": 90,     # 90 seconds
-}
-
-
-def inference(
-    system_prompt: str,
-    user_prompt: str,
-    level: str = "fast",
-    timeout: Optional[int] = None,
-) -> InferenceResult:
-    """
-    Run inference using the claude CLI.
-
-    Args:
-        system_prompt: System instructions for the model
-        user_prompt: User message to process
-        level: Model level - "fast" (Haiku), "standard" (Sonnet), "smart" (Opus)
-        timeout: Custom timeout in seconds (uses level default if not specified)
-
-    Returns:
-        InferenceResult with success status, output, and any error
-    """
-    import time
-    start_time = time.time()
-
-    model = MODELS.get(level, MODELS["fast"])
-    timeout_sec = timeout or TIMEOUTS.get(level, TIMEOUTS["fast"])
-
-    # Combine prompts
-    full_prompt = f"{system_prompt}\n\n{user_prompt}"
-
-    # Build command
-    cmd = [
-        "claude",
-        "--model", model,
-        "--print",
-        "--setting-sources", "",
-        "-p", full_prompt,
-    ]
-
-    # Remove ANTHROPIC_API_KEY to force subscription auth
-    env = os.environ.copy()
-    env.pop("ANTHROPIC_API_KEY", None)
-
-    try:
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout_sec,
-            env=env,
-            # Windows needs shell=True for command resolution
-            shell=(sys.platform == "win32"),
-        )
-
-        latency_ms = int((time.time() - start_time) * 1000)
-
-        if result.returncode != 0:
-            return InferenceResult(
-                success=False,
-                output=result.stdout.strip() if result.stdout else "",
-                error=result.stderr.strip() if result.stderr else f"Exit code: {result.returncode}",
-                latency_ms=latency_ms,
-            )
-
-        return InferenceResult(
-            success=True,
-            output=result.stdout.strip(),
-            latency_ms=latency_ms,
-        )
-
-    except subprocess.TimeoutExpired:
-        latency_ms = int((time.time() - start_time) * 1000)
-        return InferenceResult(
-            success=False,
-            output="",
-            error=f"Timeout after {timeout_sec}s",
-            latency_ms=latency_ms,
-        )
-    except FileNotFoundError:
-        latency_ms = int((time.time() - start_time) * 1000)
-        return InferenceResult(
-            success=False,
-            output="",
-            error="claude CLI not found",
-            latency_ms=latency_ms,
-        )
-    except Exception as e:
-        latency_ms = int((time.time() - start_time) * 1000)
-        return InferenceResult(
-            success=False,
-            output="",
-            error=str(e),
-            latency_ms=latency_ms,
-        )
-
-
-# Stop words for filtering (from corpus analysis of 1,424 documents)
-from .stop_words import STOP_WORDS
-
-
-def filter_stop_words(text: str) -> str:
-    """Remove stop words from text, keeping only content keywords."""
-    from .utils import clean_text_for_slug
-    cleaned = clean_text_for_slug(text)
-    words = cleaned.split()
-    filtered = [w for w in words if w not in STOP_WORDS and len(w) > 1]
-    return ' '.join(filtered)
-
-
-# System prompt for generating context ID summaries (keyword extraction for recognition)
-CONTEXT_ID_SYSTEM_PROMPT = """Extract 6-12 keywords from what the user wants to do.
-
-Rules:
-- Output 6-12 keywords only
-- Keywords: nouns, verbs, adjectives, technical terms, proper names
-- NO function words: the, to, with, for, in, a, an, of, on, is, it, and, or, that, this, be, as, at, by, from
-- Most important/specific words preferred
-- No punctuation, no quotes
-
-Examples:
-- "I want to add user authentication" -> "add user authentication login security JWT tokens webapp service"
-- "Fix the bug in the login flow" -> "fix bug login flow validation error redirect session auth handler"
-- "Can you help me refactor this code" -> "refactor code cleanup architecture maintainability legacy modules structure patterns"
-- "Update the README with new instructions" -> "update README documentation instructions setup configuration install guide steps"
-
-Output ONLY the keywords separated by spaces, nothing else."""
-
-
-def generate_semantic_summary(prompt: str, timeout: int = 15) -> Optional[str]:
-    """
-    Generate a keyword summary of a user prompt.
-
-    Uses Sonnet for quality inference. Returns None if inference fails.
-
-    Args:
-        prompt: User prompt to summarize
-        timeout: Timeout in seconds (default 15)
-
-    Returns:
-        Keyword summary string (5-10 words) or None if failed
-    """
-    result = inference(
-        system_prompt=CONTEXT_ID_SYSTEM_PROMPT,
-        user_prompt=prompt,
-        level="standard",
-        timeout=timeout,
-    )
-
-    if not result.success or not result.output:
-        return None
-
-    # Clean up the output
-    summary = result.output.strip()
-    # Remove any quotes
-    summary = summary.strip('"\'')
-    # Remove trailing punctuation
-    summary = summary.rstrip('.!?')
-
-    # Filter stop words
-    summary = filter_stop_words(summary)
-
-    # Validate 6-12 words for sufficient context
-    words = summary.split()
-    if len(words) < 6 or len(words) > 12:
-        return None
-
-    return summary
-
-
-# System prompt for generating context ID slugs (8-12 word summary phrases for folder names)
-CONTEXT_ID_SLUG_PROMPT = """You generate short title phrases for work sessions. These become folder names like `260206-1959-fix-auth-middleware-redirect-loop-session-timeout`.
-
-Users scan 100+ such names to find past sessions. Your title must make THIS session instantly recognizable.
-
-Rules:
-- Exactly 8-12 lowercase words
-- First word is an action verb (fix, add, implement, refactor, update, create, remove, optimize, debug, migrate, integrate, configure, deploy, scaffold, restructure)
-- Coherent phrase, not disjointed keywords — reads like a short task description
-- Prefer specific technical terms over generic words
-- No articles (the, a, an), no pronouns, no filler words, no punctuation, no quotes
-- Input may come from speech-to-text with filler words (uh, um, like, you know, basically, so) — ignore them entirely
-
-Examples:
-
-Input: "um so basically I need to like fix the auth bug in the login page"
-{"slug": "fix authentication bug login page redirect session handling flow"}
-
-Input: "hey uh can we add dark mode to the settings page"
-{"slug": "add dark mode toggle settings page user preference storage"}
-
-Input: "the context ids are bad can we change how we generate them towards a summary"
-{"slug": "improve context id generation use prompt summary slugs"}
-
-Input: "I want to refactor the database connection pooling for PostgreSQL"
-{"slug": "refactor postgresql database connection pooling optimize query performance"}
-
-Input: "so like you know the webhook retry logic is broken and stuff"
-{"slug": "fix webhook retry logic broken error handling recovery mechanism"}
-
-Input: "update the CI pipeline to cache node modules between runs"
-{"slug": "update ci pipeline cache node modules between workflow runs"}
-
-Respond with ONLY a JSON object: {"slug": "your 8-12 word phrase here"}"""
-
-
-def generate_context_id_slug(prompt: str, timeout: int = 5) -> Optional[str]:
-    """
-    Generate a 5-12 word context ID slug from a user prompt using AI inference.
-
-    Uses Haiku (fast tier) for low-latency summary generation within hook timeout budgets.
-    Prompts for JSON output {"slug": "..."} with fallback to raw text parsing.
-
-    Args:
-        prompt: Raw user prompt to summarize (may include STT filler words)
-        timeout: Timeout in seconds (default 3, fits within 5-10s hook budget)
-
-    Returns:
-        Space-separated summary slug (5-12 words) or None if failed
-    """
-    # Truncate input to 500 chars to keep inference fast
-    truncated = prompt[:500] if len(prompt) > 500 else prompt
-
-    result = inference(
-        system_prompt=CONTEXT_ID_SLUG_PROMPT,
-        user_prompt=truncated,
-        level="fast",
-        timeout=timeout,
-    )
-
-    if not result.success or not result.output:
-        log_warn("inference", f"Context ID slug inference failed: {result.error}")
-        return None
-
-    raw = result.output.strip()
-
-    # Parse JSON response {"slug": "..."}, fall back to raw text
-    slug = None
-    try:
-        parsed = json.loads(raw)
-        if isinstance(parsed, dict) and "slug" in parsed:
-            slug = parsed["slug"]
-    except (json.JSONDecodeError, TypeError):
-        pass
-
-    if not slug:
-        # Fallback: treat entire output as raw text
-        slug = raw
-
-    # Clean: strip quotes, punctuation, hyphens
-    slug = slug.strip('"\'`')
-    slug = slug.rstrip('.!?')
-    slug = slug.replace('-', ' ')
-
-    # Remove non-alphanumeric chars (except spaces)
-    slug = re.sub(r'[^a-zA-Z0-9 ]', '', slug)
-
-    # Normalize whitespace
-    slug = re.sub(r'\s+', ' ', slug).strip()
-
-    words = slug.split()
-
-    # Validate word count: truncate if over 12, reject if under 5
-    if len(words) > 12:
-        words = words[:12]
-    if len(words) < 5:
-        log_debug("inference", f"Context ID slug too short ({len(words)} words): '{slug}'")
-        return None
-
-    result_slug = ' '.join(words)
-    log_debug("inference", f"Generated context ID slug: '{result_slug}' ({result.latency_ms}ms)")
-    return result_slug