anvil-dev-framework 0.1.6

package/scripts/test-statusline.sh

@@ -0,0 +1,248 @@
+#!/usr/bin/env bash
+# test-statusline.sh - Test statusline with various configurations
+#
+# Usage:
+#   ./scripts/test-statusline.sh           # Run all tests
+#   ./scripts/test-statusline.sh --live    # Watch live updates
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+STATUSLINE_SCRIPT="$PROJECT_ROOT/global/hooks/statusline.sh"
+CONFIG_FILE="$PROJECT_ROOT/.claude/anvil.config.json"
+
+# Colors for test output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+RESET='\033[0m'
+
+echo_header() {
+    echo ""
+    echo -e "${CYAN}═══════════════════════════════════════════════════${RESET}"
+    echo -e "${CYAN}$1${RESET}"
+    echo -e "${CYAN}═══════════════════════════════════════════════════${RESET}"
+}
+
+echo_test() {
+    echo -e "${YELLOW}▶ $1${RESET}"
+}
+
+echo_result() {
+    echo -e "  ${GREEN}→${RESET} $1"
+}
+
+# Create test JSON input for statusline
+# Uses the actual Claude Code input format
+create_test_input() {
+    local context_pct="${1:-50}"
+    local context_size="${2:-200000}"
+    local model="${3:-Claude Opus 4}"
+
+    # Calculate tokens based on percentage
+    local current_tokens=$((context_size * context_pct / 100))
+    local input_tokens=$((current_tokens * 80 / 100))
+    local cache_write=$((current_tokens * 20 / 100))
+    local cache_read=$((current_tokens / 2))
+
+    cat <<EOF
+{
+    "session_id": "test-session-123",
+    "model": {
+        "display_name": "$model"
+    },
+    "context_window": {
+        "context_window_size": $context_size,
+        "current_usage": {
+            "input_tokens": $input_tokens,
+            "cache_read_input_tokens": $cache_read,
+            "cache_creation_input_tokens": $cache_write
+        }
+    },
+    "cost": {
+        "total_cost_usd": 2.45
+    },
+    "workspace": {
+        "current_dir": "$PROJECT_ROOT"
+    },
+    "transcript_path": "/tmp/test-transcript.jsonl"
+}
+EOF
+}
+
+# Run statusline with test input
+run_statusline() {
+    create_test_input "$@" | bash "$STATUSLINE_SCRIPT"
+}
+
+# Test different config scenarios
+test_config_variants() {
+    echo_header "Testing Config Variants"
+
+    # Backup original config
+    local backup=""
+    if [[ -f "$CONFIG_FILE" ]]; then
+        backup=$(cat "$CONFIG_FILE")
+    fi
+
+    # Test 1: Default config (agent cost, never show project)
+    echo_test "Default config (costDisplay=agent, showProject=never)"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "full",
+        "costDisplay": "agent",
+        "showProject": "never"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Test 2: Total cost display
+    echo_test "Total cost display (costDisplay=total)"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "full",
+        "costDisplay": "total",
+        "showProject": "never"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Test 3: Both costs display
+    echo_test "Both costs display (costDisplay=both)"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "full",
+        "costDisplay": "both",
+        "showProject": "never"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Test 4: No cost display
+    echo_test "No cost display (costDisplay=none)"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "full",
+        "costDisplay": "none",
+        "showProject": "never"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Test 5: Always show project
+    echo_test "Always show project (showProject=always)"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "full",
+        "costDisplay": "agent",
+        "showProject": "always"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Test 6: Minimal variant
+    echo_test "Minimal variant"
+    cat > "$CONFIG_FILE" <<EOF
+{
+    "version": "1.3",
+    "statusline": {
+        "enabled": true,
+        "variant": "minimal",
+        "costDisplay": "agent",
+        "showProject": "never"
+    }
+}
+EOF
+    echo_result "$(run_statusline 50)"
+
+    # Restore original config
+    if [[ -n "$backup" ]]; then
+        echo "$backup" > "$CONFIG_FILE"
+    fi
+}
+
+# Test context thresholds (ANV-192: CCS L1/L2/L3 indicators)
+test_context_thresholds() {
+    echo_header "Testing Context Thresholds (CCS Levels)"
+
+    echo_test "L0 - Normal (50% context) - No level indicator"
+    echo_result "$(run_statusline 50)"
+
+    echo_test "L0 - Normal (65% context) - Still no indicator"
+    echo_result "$(run_statusline 65)"
+
+    echo_test "L1 - Warning (70% context) - ⚠️ L1 + [CKPT: Ready]"
+    echo_result "$(run_statusline 70)"
+
+    echo_test "L1 - Warning (75% context)"
+    echo_result "$(run_statusline 75)"
+
+    echo_test "L1 - Warning (84% context) - Upper L1 bound"
+    echo_result "$(run_statusline 84)"
+
+    echo_test "L2 - Critical (85% context) - 🔶 L2 + token breakdown"
+    echo_result "$(run_statusline 85)"
+
+    echo_test "L2 - Critical (90% context)"
+    echo_result "$(run_statusline 90)"
+
+    echo_test "L2 - Critical (94% context) - Upper L2 bound"
+    echo_result "$(run_statusline 94)"
+
+    echo_test "L3 - Emergency (95% context) - 🔴 L3 + [CKPT: URGENT]"
+    echo_result "$(run_statusline 95)"
+
+    echo_test "L3 - Emergency (98% context)"
+    echo_result "$(run_statusline 98)"
+}
+
+# Live mode - watch updates
+live_mode() {
+    echo_header "Live Mode - Press Ctrl+C to exit"
+    echo "Statusline will refresh every 2 seconds..."
+    echo ""
+
+    while true; do
+        # Clear line and print statusline
+        printf "\r\033[K"
+        run_statusline 50
+        sleep 2
+    done
+}
+
+# Main
+main() {
+    if [[ "${1:-}" == "--live" ]]; then
+        live_mode
+    else
+        test_config_variants
+        test_context_thresholds
+
+        echo_header "All Tests Complete"
+        echo -e "${GREEN}✓ Statusline configuration tests passed${RESET}"
+    fi
+}
+
+main "$@"

package/scripts/update_claude_md.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+Update CLAUDE.md with extracted patterns.
+
+Usage: python scripts/update_claude_md.py patterns.json [--claude-md PATH] [--dry-run]
+
+This script:
+1. Reads extracted patterns from JSON file
+2. Parses existing Project-Learned Patterns table in CLAUDE.md
+3. Merges new patterns (avoiding duplicates by name similarity)
+4. Updates the table with dates
+5. Writes the updated file (unless --dry-run)
+"""
+
+import sys
+import json
+import re
+import argparse
+from datetime import datetime
+from pathlib import Path
+from difflib import SequenceMatcher
+
+
+def read_file(path: str) -> str:
+    """Read file contents."""
+    return Path(path).read_text()
+
+
+def write_file(path: str, content: str) -> None:
+    """Write content to file."""
+    Path(path).write_text(content)
+
+
+def parse_patterns_table(content: str) -> list[dict]:
+    """Extract existing patterns from CLAUDE.md Project-Learned Patterns table."""
+    # Match the table after "### Project-Learned Patterns"
+    table_pattern = r'### Project-Learned Patterns.*?\n\| Pattern \| Evidence \| Added \|\n\|[-|]+\|\n((?:\|[^\n]+\|\n)*)'
+    match = re.search(table_pattern, content, re.DOTALL)
+
+    if not match:
+        return []
+
+    rows = match.group(1).strip().split('\n')
+    patterns = []
+
+    for row in rows:
+        if not row.strip():
+            continue
+        # Parse: | Pattern Name | Evidence | Date |
+        cols = [c.strip() for c in row.split('|')]
+        # Filter out empty strings from split
+        cols = [c for c in cols if c]
+
+        if len(cols) >= 3:
+            patterns.append({
+                'name': cols[0],
+                'evidence': cols[1],
+                'added': cols[2]
+            })
+
+    return patterns
+
+
+def similarity(a: str, b: str) -> float:
+    """Calculate string similarity ratio (0-1)."""
+    return SequenceMatcher(None, a.lower(), b.lower()).ratio()
+
+
+def is_duplicate(new_pattern: str, existing_patterns: list[dict], threshold: float = 0.7) -> bool:
+    """Check if a pattern name is too similar to existing ones."""
+    for existing in existing_patterns:
+        if similarity(new_pattern, existing['name']) >= threshold:
+            return True
+    return False
+
+
+def merge_patterns(existing: list[dict], new_patterns: list[dict]) -> tuple[list[dict], list[dict]]:
+    """
+    Merge new patterns with existing, avoiding duplicates.
+
+    Returns: (merged_list, added_patterns)
+    """
+    today = datetime.now().strftime('%Y-%m-%d')
+    merged = list(existing)
+    added = []
+
+    for pattern in new_patterns:
+        # Skip patterns that are too similar to existing ones
+        if is_duplicate(pattern['name'], existing):
+            continue
+
+        # Also skip if too similar to already-added patterns
+        if is_duplicate(pattern['name'], added):
+            continue
+
+        # Only include "learning" and "retro" type patterns (most valuable)
+        pattern_type = pattern.get('type', '')
+        if pattern_type not in ('learning', 'retro'):
+            continue
+
+        new_entry = {
+            'name': clean_pattern_name(pattern['name']),
+            'evidence': pattern.get('evidence', ''),
+            'added': today
+        }
+        merged.append(new_entry)
+        added.append(new_entry)
+
+    return merged, added
+
+
+def clean_pattern_name(name: str) -> str:
+    """Clean up pattern name for table display."""
+    # Remove markdown formatting
+    name = re.sub(r'\*\*([^*]+)\*\*', r'\1', name)
+    # Remove leading/trailing whitespace
+    name = name.strip()
+    # Truncate if too long
+    if len(name) > 50:
+        name = name[:47] + '...'
+    # Capitalize first letter
+    if name:
+        name = name[0].upper() + name[1:]
+    return name
+
+
+def format_table(patterns: list[dict]) -> str:
+    """Format patterns as markdown table."""
+    lines = [
+        '| Pattern | Evidence | Added |',
+        '|---------|----------|-------|'
+    ]
+    for p in patterns:
+        # Escape pipe characters in content
+        name = p['name'].replace('|', '\\|')
+        evidence = p['evidence'].replace('|', '\\|')
+        added = p['added']
+        lines.append(f'| {name} | {evidence} | {added} |')
+
+    return '\n'.join(lines)
+
+
+def update_claude_md(content: str, patterns: list[dict]) -> str:
+    """Replace the patterns table in CLAUDE.md content."""
+    format_table(patterns)
+
+    # Pattern to match the existing table
+    table_pattern = r'(### Project-Learned Patterns.*?\n\| Pattern \| Evidence \| Added \|\n\|[-|]+\|\n)((?:\|[^\n]+\|\n)*)'
+
+    def replacer(match):
+        header = match.group(1)
+        return header + '\n'.join(
+            f'| {p["name"]} | {p["evidence"]} | {p["added"]} |'
+            for p in patterns
+        ) + '\n'
+
+    updated = re.sub(table_pattern, replacer, content, flags=re.DOTALL)
+
+    return updated
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Update CLAUDE.md with extracted patterns')
+    parser.add_argument('patterns_file', help='JSON file with extracted patterns')
+    parser.add_argument('--claude-md', default='.claude/CLAUDE.md', help='Path to CLAUDE.md')
+    parser.add_argument('--dry-run', action='store_true', help='Show changes without writing')
+    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
+    args = parser.parse_args()
+
+    # Read patterns JSON
+    try:
+        with open(args.patterns_file) as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        print(f"Error: Pattern file not found: {args.patterns_file}", file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in {args.patterns_file}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    new_patterns = data.get('patterns', [])
+
+    # Read CLAUDE.md
+    claude_md_path = Path(args.claude_md)
+    if not claude_md_path.exists():
+        print(f"Error: CLAUDE.md not found: {args.claude_md}", file=sys.stderr)
+        sys.exit(1)
+
+    content = read_file(args.claude_md)
+    existing = parse_patterns_table(content)
+
+    if args.verbose:
+        print(f"Found {len(existing)} existing patterns", file=sys.stderr)
+        print(f"Processing {len(new_patterns)} new patterns", file=sys.stderr)
+
+    # Merge patterns
+    merged, added = merge_patterns(existing, new_patterns)
+
+    if not added:
+        print("No new patterns to add (all duplicates or non-learning types)")
+        sys.exit(0)
+
+    if args.verbose:
+        print(f"Adding {len(added)} new patterns:", file=sys.stderr)
+        for p in added:
+            print(f"  - {p['name']}", file=sys.stderr)
+
+    # Update content
+    updated = update_claude_md(content, merged)
+
+    if args.dry_run:
+        print("=== DRY RUN - Changes that would be made ===")
+        print(f"\nNew patterns to add ({len(added)}):")
+        for p in added:
+            print(f"  | {p['name']} | {p['evidence']} | {p['added']} |")
+        print(f"\nTotal patterns after merge: {len(merged)}")
+    else:
+        write_file(args.claude_md, updated)
+        print(f"Updated {args.claude_md} with {len(added)} new patterns")
+        print(f"Total patterns: {len(merged)}")
+
+
+if __name__ == '__main__':
+    main()