aiwcli 0.10.2 → 0.11.0

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

@@ -1,318 +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 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",
-        "--no-hooks",
-        "-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."""
-    words = text.lower().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 (3-12 keyword tags for folder names)
-CONTEXT_ID_SLUG_PROMPT = """You are extracting keyword tags from a user's request to create a **folder name** for a work session.
-
-## Why This Matters
-
-These tags become part of a context ID like `260206-1959-refactor-webhook-retry-logic`. Users scan lists of 50-100+ such folder names to find past work sessions. Your job is to extract the 3-12 words that make THIS session instantly recognizable among hundreds of others.
-
-Think: "If someone had 100 folders and needed to find this one by scanning names, which words would make it jump out?"
-
-## First Word: Action Verb (REQUIRED)
-
-The first word MUST be a specific action verb. Choose the most precise verb available:
-
-Common: fix, add, implement, refactor, update, create, remove, replace, optimize, debug
-Specific (preferred when they fit): scaffold, instrument, serialize, throttle, migrate, integrate, extract, redesign, restructure, decouple, consolidate, parallelize, configure, deploy, benchmark, normalize, validate, document, deprecate, upstream
-
-## Word Selection: Rarity = Quality
-
-The less common a word is in everyday language, the better it is as an identifier. Apply this mental filter:
-
-BEST (+3):  Proper nouns, brand names, unique identifiers (PostgreSQL, Webpack, OAuth, JWT, CICD)
-GOOD (+2):  Domain-specific technical terms (middleware, pooling, webhook, serialization, throttle)
-OKAY (+1):  Specific common nouns (authentication, redirect, navbar, pagination, dropdown)
-WEAK (-1):  Generic nouns that appear in most prompts (code, file, app, feature, issue, project, stuff, thing)
-BANNED:     See banned list below — these must NEVER appear in output
-
-Select the 3-12 highest-value words. When choosing between two words that mean similar things, always pick the rarer/more specific one.
-
-## Banned Words (NEVER include these)
-
-Greetings/social: sure, okay, ok, hi, hello, hey, thanks, yeah, yes, no, well, right, um, uh
-Pronouns/articles: I, my, me, we, our, you, your, he, she, it, they, the, a, an, this, that, these, those
-Auxiliaries/modals: is, are, was, were, be, been, being, can, could, would, should, will, shall, may, might, must, do, does, did, have, has, had
-Prepositions: to, with, for, in, of, on, at, by, from, into, about, through, between, after, before, during
-Conjunctions: and, or, but, so, because, if, when, while, although, since
-Filler/hedging: want, need, help, try, think, know, look, going, trying, looking, basically, actually, really, just, some, also, please, maybe, probably, kind, sort, pretty, very, quite, like
-Generic: code, file, app, stuff, thing, feature, issue, problem, way, part, bit, lot, something
-
-## Bad vs Good Examples
-
-BAD:  sure help refactor code cleanup          -> starts with filler, "code" is generic
-GOOD: refactor database queries connection pooling
-
-BAD:  want add feature authentication          -> "want" is filler, "feature" is noise
-GOOD: add authentication Express JWT middleware
-
-BAD:  looking fix issue login page             -> gerund opener, "issue" is generic
-GOOD: fix login redirect blank page session
-
-BAD:  improve things make better setup         -> vague nouns, no technical specificity
-GOOD: improve CI pipeline GitHub Actions caching
-
-BAD:  help update documentation readme stuff   -> "help" opener, "stuff" is noise
-GOOD: update README API endpoints documentation
-
-BAD:  thinking about maybe changing prompt     -> hedging words, no specificity
-GOOD: optimize context ID extraction prompting Opus
-
-## Output
-
-Output ONLY the keyword tags separated by spaces. Nothing else. No reasoning, no labels, no punctuation, no quotes, no hyphens, no markdown."""
-
-
-def generate_context_id_slug(prompt: str, timeout: int = 3) -> Optional[str]:
-    """
-    Generate a 3-12 word context ID slug from a user prompt using AI inference.
-
-    Uses Haiku (fast tier) for low-latency keyword extraction within hook timeout budgets.
-    Returns a cleaned, validated slug or None on failure.
-
-    Args:
-        prompt: Raw user prompt to extract keywords from
-        timeout: Timeout in seconds (default 3, fits within 5-10s hook budget)
-
-    Returns:
-        Space-separated keyword slug (3-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
-
-    slug = result.output.strip()
-
-    # 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 3
-    if len(words) > 12:
-        words = words[:12]
-    if len(words) < 3:
-        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

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

@@ -1,291 +0,0 @@
-"""Unified logging for all hooks and libraries.
-
-Provides a single logging interface that replaces:
-- log_hook_error() from hook_utils.py (error-only, plain text)
-- debug.py from cc-native (per-context, plain text)
-- eprint() for diagnostic output (stderr-only, no persistence)
-
-Log format: JSONL (one JSON object per line)
-Log locations:
-- With context: _output/contexts/<context-id>/debug/hook-log.jsonl
-- Without context (fallback): _output/hook-log.jsonl
-
-Environment variables:
-- HOOK_LOG_DISABLE=1: Disable all file logging
-- HOOK_LOG_LEVEL=warn: Minimum level to log (default: debug)
-- HOOK_ERROR_LOG_DISABLE=1: Legacy alias for HOOK_LOG_DISABLE
-
-Never raises — all errors silently swallowed.
-No buffering — each call is one open+write+close.
-Stdlib only — json, os, sys, datetime, pathlib.
-"""
-
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-_LEVELS = {"debug": 0, "info": 1, "warn": 2, "error": 3}
-
-_MAX_LOG_SIZE = 1024 * 1024  # 1MB
-_TRUNCATE_TO = 512 * 1024    # 512KB
-
-# Module-level context path cache.
-# Set once per hook process via set_context_path() or auto-resolved on first use.
-_cached_context_path: Optional[Path] = None
-_context_resolved: bool = False
-
-
-def set_context_path(path: Optional[Path]) -> None:
-    """Set the context path for this process. All subsequent log calls use it.
-
-    Call this once in your hook after resolving the context:
-        from lib.base.logger import set_context_path
-        set_context_path(get_context_dir(context_id, project_root))
-
-    Args:
-        path: Path to context folder (e.g., _output/contexts/<context-id>/)
-              or None to force global-only logging.
-    """
-    global _cached_context_path, _context_resolved
-    _cached_context_path = path
-    _context_resolved = True
-
-
-def _auto_resolve_context_path() -> Optional[Path]:
-    """Try to auto-resolve context path from session_id. Called once per process.
-
-    Uses the context store to look up which context owns this session,
-    then returns its directory path. Falls back to None (global log).
-    """
-    global _cached_context_path, _context_resolved
-    _context_resolved = True  # Don't retry on failure
-
-    try:
-        from ..context.context_store import get_context_by_session_id
-        from .constants import get_context_dir
-
-        # Hook input isn't available here, but we can check if a recent
-        # context dir exists by scanning _output/contexts/ for one that
-        # has a state.json with a matching session
-        # This is too expensive for a logger. Instead, rely on set_context_path().
-    except Exception:
-        pass
-
-    return None
-
-
-def _get_context_path() -> Optional[Path]:
-    """Get the cached context path, auto-resolving on first call."""
-    global _context_resolved
-    if not _context_resolved:
-        _auto_resolve_context_path()
-    return _cached_context_path
-
-
-def _get_min_level() -> int:
-    """Get minimum log level from environment."""
-    env = os.environ.get("HOOK_LOG_LEVEL", "debug").lower()
-    return _LEVELS.get(env, 0)
-
-
-def _is_disabled() -> bool:
-    """Check if file logging is disabled."""
-    if os.environ.get("HOOK_LOG_DISABLE") == "1":
-        return True
-    if os.environ.get("HOOK_ERROR_LOG_DISABLE") == "1":
-        return True
-    return False
-
-
-def _get_project_root() -> Path:
-    """Get project root from environment or cwd."""
-    env_dir = os.environ.get("CLAUDE_PROJECT_DIR", "")
-    return Path(env_dir) if env_dir else Path.cwd()
-
-
-def hook_log(
-    level: str,
-    hook_name: str,
-    message: str,
-    *,
-    component: str = "",
-    data: Any = None,
-    traceback_str: str = "",
-    context_path: Optional[Path] = None,
-    stderr: bool = True,
-) -> None:
-    """Write a structured log entry.
-
-    Args:
-        level: "debug" | "info" | "warn" | "error"
-        hook_name: Hook or module name (e.g., "session_end")
-        message: Log message
-        component: Sub-component (e.g., "git", "parse")
-        data: Optional structured data (must be JSON-serializable)
-        traceback_str: Optional traceback string
-        context_path: If provided, logs to context debug dir
-        stderr: Also write to stderr (default: True)
-    """
-    try:
-        level_lower = level.lower()
-        level_num = _LEVELS.get(level_lower, 0)
-
-        # Write to stderr if requested
-        if stderr:
-            prefix = f"[{hook_name}]"
-            if component:
-                prefix = f"[{hook_name}:{component}]"
-            print(f"{prefix} {message}", file=sys.stderr)
-            if traceback_str:
-                print(traceback_str, file=sys.stderr)
-
-        # Check if file logging is enabled
-        if _is_disabled():
-            return
-
-        # Check minimum level
-        if level_num < _get_min_level():
-            return
-
-        # Build JSONL entry
-        ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3]
-        entry = {
-            "ts": ts,
-            "level": level_lower,
-            "hook": hook_name,
-            "msg": message,
-        }
-        if component:
-            entry["component"] = component
-        if data is not None:
-            try:
-                json.dumps(data, default=str)  # Validate serializable
-                entry["data"] = data
-            except (TypeError, ValueError):
-                entry["data"] = str(data)
-        if traceback_str:
-            entry["tb"] = traceback_str.rstrip()
-
-        line = json.dumps(entry, ensure_ascii=True, default=str) + "\n"
-
-        # Determine log path: explicit > cached > global
-        resolved_ctx = context_path or _get_context_path()
-        if resolved_ctx and resolved_ctx.exists():
-            log_path = resolved_ctx / "debug" / "hook-log.jsonl"
-        else:
-            project_root = _get_project_root()
-            log_path = project_root / "_output" / "hook-log.jsonl"
-
-        log_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Size guard (global log only, not per-context)
-        if not resolved_ctx and log_path.exists():
-            try:
-                if log_path.stat().st_size > _MAX_LOG_SIZE:
-                    file_data = log_path.read_bytes()
-                    log_path.write_bytes(file_data[-_TRUNCATE_TO:])
-            except OSError:
-                pass
-
-        with open(log_path, "a", encoding="utf-8") as f:
-            f.write(line)
-
-    except Exception:
-        pass  # Never crash
-
-
-def log_debug(hook_name: str, message: str, **kwargs: Any) -> None:
-    """Log a debug-level message."""
-    hook_log("debug", hook_name, message, **kwargs)
-
-
-def log_info(hook_name: str, message: str, **kwargs: Any) -> None:
-    """Log an info-level message."""
-    hook_log("info", hook_name, message, **kwargs)
-
-
-def log_warn(hook_name: str, message: str, **kwargs: Any) -> None:
-    """Log a warn-level message."""
-    hook_log("warn", hook_name, message, **kwargs)
-
-
-def log_error(hook_name: str, message: str, **kwargs: Any) -> None:
-    """Log an error-level message."""
-    hook_log("error", hook_name, message, **kwargs)
-
-
-def log_diagnostic(
-    hook_name: str,
-    phase: str,
-    summary: str,
-    *,
-    inputs: Any = None,
-    decision: Any = None,
-    reasoning: Any = None,
-    component: str = "diag",
-    data: Any = None,
-) -> None:
-    """Log a structured diagnostic entry at a hook decision point.
-
-    Emits a debug-level JSONL entry with tagged, filterable data.
-    Use at key decision points: receive (what came in), decide (what was chosen),
-    result (what happened).
-
-    Args:
-        hook_name: Hook or module name (e.g., "session_start")
-        phase: Decision phase — "receive", "decide", or "result"
-        summary: One-line description (e.g., "source=clear, session=a1b2c3d4")
-        inputs: Input data relevant to this phase
-        decision: The decision made (for "decide" phase)
-        reasoning: Why this decision was made
-        component: Log component tag (default: "diag")
-        data: Extra data to merge into the structured entry
-    """
-    diag_data: Dict[str, Any] = {"phase": phase}
-    if inputs is not None:
-        diag_data["inputs"] = inputs
-    if decision is not None:
-        diag_data["decision"] = decision
-    if reasoning is not None:
-        diag_data["reasoning"] = reasoning
-    if data is not None and isinstance(data, dict):
-        diag_data.update(data)
-    hook_log(
-        "debug",
-        hook_name,
-        f"[DIAG:{phase}] {summary}",
-        component=component,
-        data=diag_data,
-    )
-
-
-def log_hook_error(
-    hook_name: str,
-    error: Exception,
-    hook_event: str = "unknown",
-    traceback_str: str = "",
-) -> None:
-    """Backward-compatible wrapper matching the old hook_utils.log_hook_error signature.
-
-    Delegates to hook_log("error", ...) with the same behavior:
-    - Message capped at 200 chars, newlines stripped
-    - Never raises
-
-    Args:
-        hook_name: Name of the hook
-        error: The exception that occurred
-        hook_event: Hook event type (e.g., "PreToolUse")
-        traceback_str: Optional formatted traceback
-    """
-    msg = str(error).replace("\n", " ").replace("\r", "")[:200]
-    err_type = type(error).__name__
-    hook_log(
-        "error",
-        hook_name,
-        f"[{hook_event}] {err_type}: {msg}",
-        traceback_str=traceback_str,
-        stderr=True,
-    )