claude-dev-kit 2.1.0

package/.claude/hooks/skill-activation-prompt/skill-activation-prompt.ts

@@ -0,0 +1,135 @@
+#!/usr/bin/env tsx
+import * as fs from "fs";
+import * as path from "path";
+
+interface HookInput {
+  session_id?: string;
+  prompt?: string;
+  transcript_path?: string;
+  hook_event_name?: string;
+}
+
+interface SkillRule {
+  skill: string;
+  priority: "critical" | "high" | "medium" | "low";
+  alwaysActive?: boolean;
+  triggers?: string[];
+  message: string;
+}
+
+interface SessionState {
+  [sessionId: string]: {
+    skills: string[];
+    timestamp: number;
+  };
+}
+
+const SESSION_STATE_DIR = "/tmp/.claude-session-state";
+const STATE_FILE = path.join(SESSION_STATE_DIR, "suggested-skills.json");
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+function getSessionState(sessionId: string): Set<string> {
+  try {
+    if (!fs.existsSync(STATE_FILE)) return new Set();
+    const raw = fs.readFileSync(STATE_FILE, "utf-8");
+    const data: SessionState = JSON.parse(raw);
+    const now = Date.now();
+    // Prune stale sessions
+    for (const key of Object.keys(data)) {
+      if (data[key].timestamp < now - MAX_AGE_MS) {
+        delete data[key];
+      }
+    }
+    return new Set(data[sessionId]?.skills ?? []);
+  } catch {
+    return new Set();
+  }
+}
+
+function saveSessionState(sessionId: string, suggested: Set<string>): void {
+  try {
+    fs.mkdirSync(SESSION_STATE_DIR, { recursive: true });
+    let data: SessionState = {};
+    try {
+      if (fs.existsSync(STATE_FILE)) {
+        data = JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+      }
+    } catch {
+      // start fresh
+    }
+    data[sessionId] = { skills: [...suggested], timestamp: Date.now() };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+  } catch {
+    // non-fatal
+  }
+}
+
+function main(): void {
+  let input: HookInput = {};
+  try {
+    const stdin = fs.readFileSync("/dev/stdin", "utf-8").trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch {
+    process.exit(0);
+  }
+
+  const prompt = (input.prompt ?? "").toLowerCase();
+  const sessionId = input.session_id ?? "default";
+
+  const rulesPath = path.join(__dirname, "skill-rules.json");
+  let rules: SkillRule[] = [];
+  try {
+    rules = JSON.parse(fs.readFileSync(rulesPath, "utf-8"));
+  } catch {
+    process.exit(0);
+  }
+
+  const alreadySuggested = getSessionState(sessionId);
+
+  const priorityOrder: Record<string, number> = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+  };
+
+  const toSuggest: SkillRule[] = [];
+  for (const rule of rules) {
+    if (alreadySuggested.has(rule.skill)) continue;
+
+    if (rule.alwaysActive) {
+      toSuggest.push(rule);
+      continue;
+    }
+
+    if (rule.triggers) {
+      for (const trigger of rule.triggers) {
+        if (prompt.includes(trigger.toLowerCase())) {
+          toSuggest.push(rule);
+          break;
+        }
+      }
+    }
+  }
+
+  if (toSuggest.length === 0) {
+    process.exit(0);
+  }
+
+  toSuggest.sort(
+    (a, b) => (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9)
+  );
+
+  const lines = toSuggest.map((r) => `- [${r.priority.toUpperCase()}] ${r.message}`);
+  const reminder = `SKILL ACTIVATION SUGGESTIONS:\n${lines.join("\n")}`;
+
+  for (const r of toSuggest) {
+    alreadySuggested.add(r.skill);
+  }
+  saveSessionState(sessionId, alreadySuggested);
+
+  process.stdout.write(reminder);
+  process.exit(0);
+}
+
+main();

package/.claude/hooks/skill-activation-prompt/skill-rules.json

@@ -0,0 +1,50 @@
+[
+  {
+    "skill": "verification-before-completion",
+    "priority": "critical",
+    "triggers": ["done", "complete", "finished", "implemented", "fixed", "ready", "working", "resolved"],
+    "message": "Use /verification-before-completion before claiming work is done or creating PRs — run verification commands and confirm output first."
+  },
+  {
+    "skill": "code-investigator",
+    "priority": "high",
+    "triggers": ["investigate", "how does", "how do", "trace", "debug", "understand", "look into", "explore", "find the", "why is", "what is", "where is", "call hierarchy", "who calls", "find all", "go to definition", "find references", "refactor", "reorganize", "understand the flow", "walk me through"],
+    "message": "Use /code-investigator for efficient targeted code investigation — saves tokens via precise searches."
+  },
+  {
+    "skill": "build-and-fix",
+    "priority": "high",
+    "triggers": ["build", "lint", "compile", "type error", "type check", "tsc", "bun run build", "fix errors", "format"],
+    "message": "Use /build-and-fix to auto-detect project type, run build, and fix simple errors (formatting/linting)."
+  },
+  {
+    "skill": "ai-router",
+    "priority": "high",
+    "triggers": ["use gemini", "use codex", "use grok", "use kimi", "use ollama", "ask grok", "ask gemini", "ask ollama", "route to", "which ai", "best ai for", "delegate to", "run with", "send to gemini", "let codex", "opencode", "other ai", "different model", "another model", "local model", "local llm"],
+    "message": "Use /ai:route to route this task to the best available AI CLI tool. Run /ai:detect first to see what's installed."
+  },
+  {
+    "skill": "ai-router",
+    "priority": "high",
+    "triggers": ["private", "confidential", "sensitive data", "don't send to cloud", "local only", "air-gapped", "offline mode", "no cloud", "keep it local"],
+    "message": "Use /ai:route for privacy-sensitive tasks — it will route to Ollama (local LLM) if available, keeping data on your machine."
+  },
+  {
+    "skill": "ai-router",
+    "priority": "medium",
+    "triggers": ["entire codebase", "full project scan", "scan everything", "whole repo", "all files in"],
+    "message": "For large codebase scans, use /ai:route — Gemini's 1M token context may be better suited than Claude's 200k."
+  },
+  {
+    "skill": "improve",
+    "priority": "medium",
+    "triggers": ["improve the kit", "make the kit better", "kit is slow", "skill not triggering", "agent keeps failing", "optimize agents", "feedback", "what can be improved", "kit improvements"],
+    "message": "Use /improve to analyze session learning data and propose concrete improvements to agents, skills, and commands."
+  },
+  {
+    "skill": "self-improve",
+    "priority": "low",
+    "triggers": ["self-improve", "critique the kit", "improve itself", "meta-improve", "kit self-improvement", "have ais review"],
+    "message": "Use /self-improve to have multiple AI models critique and improve the kit's own prompts and configurations."
+  }
+]

package/.claude/hooks/stop/context_monitor.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Context monitor - warns when context usage is high."""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+from pathlib import Path
+
+THRESHOLD_WARN = 65
+THRESHOLD_STOP = 85
+CONTEXT_LIMIT = 200000
+
+CACHE_DIR = Path("/tmp/.claude_context_cache")
+CACHE_TTL = 30
+
+RED = "\033[0;31m"
+YELLOW = "\033[0;33m"
+NC = "\033[0m"
+
+
+def get_current_session_id() -> str:
+    """Get current session ID from history."""
+    history = Path.home() / ".claude" / "history.jsonl"
+    if not history.exists():
+        return ""
+    try:
+        with history.open() as f:
+            lines = f.readlines()
+            if lines:
+                return json.loads(lines[-1]).get("sessionId", "")
+    except (json.JSONDecodeError, OSError):
+        pass
+    return ""
+
+
+def find_session_file(session_id: str) -> Path | None:
+    """Find session file for given session ID."""
+    projects_dir = Path.home() / ".claude" / "projects"
+    if not projects_dir.exists():
+        return None
+    for project_dir in projects_dir.iterdir():
+        if project_dir.is_dir():
+            session_file = project_dir / f"{session_id}.jsonl"
+            if session_file.exists():
+                return session_file
+    return None
+
+
+def get_actual_token_count(session_file: Path) -> int | None:
+    """Get actual token count from the most recent API usage data."""
+    last_usage = None
+
+    try:
+        with session_file.open() as f:
+            for line in f:
+                try:
+                    msg = json.loads(line)
+                    if msg.get("type") != "assistant":
+                        continue
+
+                    message = msg.get("message", {})
+                    if not isinstance(message, dict):
+                        continue
+
+                    usage = message.get("usage")
+                    if usage:
+                        last_usage = usage
+                except (json.JSONDecodeError, KeyError):
+                    continue
+    except OSError:
+        return None
+
+    if not last_usage:
+        return None
+
+    input_tokens = last_usage.get("input_tokens", 0)
+    cache_creation = last_usage.get("cache_creation_input_tokens", 0)
+    cache_read = last_usage.get("cache_read_input_tokens", 0)
+
+    return input_tokens + cache_creation + cache_read
+
+
+def get_cache_file(session_id: str) -> Path:
+    """Get cache file path for a session."""
+    return CACHE_DIR / f"{session_id}.json"
+
+
+def get_cached_context(session_id: str) -> tuple[int, bool]:
+    """Get cached context value if fresh enough."""
+    cache_file = get_cache_file(session_id)
+    if cache_file.exists():
+        try:
+            with cache_file.open() as f:
+                cache = json.load(f)
+                if time.time() - cache.get("timestamp", 0) < CACHE_TTL:
+                    return cache.get("tokens", 0), True
+        except (json.JSONDecodeError, OSError):
+            pass
+    return 0, False
+
+
+def save_cache(session_id: str, tokens: int) -> None:
+    """Save context calculation to cache."""
+    try:
+        CACHE_DIR.mkdir(exist_ok=True)
+        cache_file = get_cache_file(session_id)
+        with cache_file.open("w") as f:
+            json.dump({"tokens": tokens, "timestamp": time.time()}, f)
+    except OSError:
+        pass
+
+
+def run_context_monitor() -> int:
+    """Run context monitoring and return exit code."""
+    session_id = get_current_session_id()
+    if not session_id:
+        return 0
+
+    cached_tokens, is_cached = get_cached_context(session_id)
+    if is_cached:
+        total_tokens = cached_tokens
+    else:
+        session_file = find_session_file(session_id)
+        if not session_file:
+            return 0
+
+        actual_tokens = get_actual_token_count(session_file)
+        if actual_tokens is None:
+            return 0
+
+        total_tokens = actual_tokens
+        save_cache(session_id, total_tokens)
+
+    percentage = (total_tokens / CONTEXT_LIMIT) * 100
+
+    if percentage >= THRESHOLD_STOP:
+        print("", file=sys.stderr)
+        print(f"{RED}CONTEXT LIMIT: {percentage:.0f}% ({total_tokens:,}/{CONTEXT_LIMIT//1000}k){NC}", file=sys.stderr)
+        print(f"{RED}Ask user to run /clear to reset context.{NC}", file=sys.stderr)
+        return 2
+
+    if percentage >= THRESHOLD_WARN:
+        print("", file=sys.stderr)
+        print(f"{YELLOW}Context: {percentage:.0f}% ({total_tokens:,}/{CONTEXT_LIMIT//1000}k){NC}", file=sys.stderr)
+        print(f"{YELLOW}   Complete current task, wrap up at {THRESHOLD_STOP}% maximum{NC}", file=sys.stderr)
+        # Return 0 for warning - shows info without "error" label
+        # Only return 2 at THRESHOLD_STOP for actual blocking
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(run_context_monitor())

package/.claude/hooks/stop/learning_logger.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Learning Logger - Stop hook that captures session data for self-improvement.
+
+After each session ends, this hook:
+1. Reads the session transcript from ~/.claude/projects/
+2. Extracts: commands used, agents spawned, tools called, token usage, errors
+3. Appends a structured entry to .claude/learning/sessions/YYYY-MM-DD.jsonl
+
+This data feeds the /improve command for pattern analysis and kit evolution.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+
+LEARNING_DIR = Path(".claude/learning/sessions")
+MAX_SESSIONS_PER_FILE = 50
+
+
+def get_current_session_id() -> str:
+    """Get current session ID from history."""
+    history = Path.home() / ".claude" / "history.jsonl"
+    if not history.exists():
+        return ""
+    try:
+        with history.open() as f:
+            lines = f.readlines()
+            if lines:
+                return json.loads(lines[-1]).get("sessionId", "")
+    except (json.JSONDecodeError, OSError):
+        pass
+    return ""
+
+
+def find_session_file(session_id: str) -> Path | None:
+    """Find session file for given session ID."""
+    projects_dir = Path.home() / ".claude" / "projects"
+    if not projects_dir.exists():
+        return None
+    for project_dir in projects_dir.iterdir():
+        if project_dir.is_dir():
+            session_file = project_dir / f"{session_id}.jsonl"
+            if session_file.exists():
+                return session_file
+    return None
+
+
+def extract_session_data(session_file: Path) -> dict:
+    """Extract structured data from a session transcript."""
+    commands_used: list[str] = []
+    agents_spawned: list[str] = []
+    tools_called: Counter = Counter()
+    errors: list[str] = []
+    total_input_tokens = 0
+    total_output_tokens = 0
+    turn_count = 0
+    user_prompts: list[str] = []
+
+    try:
+        with session_file.open() as f:
+            for line in f:
+                try:
+                    msg = json.loads(line)
+                    msg_type = msg.get("type", "")
+
+                    # Count turns
+                    if msg_type == "user":
+                        turn_count += 1
+                        # Capture user prompt text (truncated for privacy)
+                        content = msg.get("message", {}).get("content", "")
+                        if isinstance(content, str) and len(content) > 10:
+                            user_prompts.append(content[:200])
+                        elif isinstance(content, list):
+                            for block in content:
+                                if isinstance(block, dict) and block.get("type") == "text":
+                                    text = block.get("text", "")
+                                    if text:
+                                        user_prompts.append(text[:200])
+                                        break
+
+                    # Track assistant tool usage
+                    if msg_type == "assistant":
+                        message = msg.get("message", {})
+                        usage = message.get("usage", {})
+                        total_input_tokens += usage.get("input_tokens", 0)
+                        total_output_tokens += usage.get("output_tokens", 0)
+
+                        content = message.get("content", [])
+                        if isinstance(content, list):
+                            for block in content:
+                                if isinstance(block, dict) and block.get("type") == "tool_use":
+                                    tool_name = block.get("name", "unknown")
+                                    tools_called[tool_name] += 1
+
+                                    # Detect slash commands from user prompts
+                                    tool_input = block.get("input", {})
+
+                                    # Detect agent spawning
+                                    if tool_name == "Task":
+                                        agent = tool_input.get("subagent_type", "unknown")
+                                        agents_spawned.append(agent)
+
+                                    # Detect bash commands for pattern learning
+                                    if tool_name == "Bash":
+                                        cmd = tool_input.get("command", "")
+                                        if cmd.startswith("git "):
+                                            commands_used.append("git")
+                                        elif cmd.startswith("gh "):
+                                            commands_used.append("gh")
+                                        elif "gemini" in cmd:
+                                            commands_used.append("gemini")
+                                        elif "opencode" in cmd:
+                                            commands_used.append("opencode")
+
+                    # Capture tool result errors
+                    if msg_type == "tool":
+                        result = msg.get("content", "")
+                        if isinstance(result, str) and ("error" in result.lower() or "failed" in result.lower()):
+                            errors.append(result[:300])
+
+                except (json.JSONDecodeError, KeyError, TypeError):
+                    continue
+
+    except OSError:
+        return {}
+
+    # Detect slash commands from user prompts
+    slash_commands = []
+    for prompt in user_prompts:
+        # Look for /command patterns
+        words = prompt.split()
+        for word in words:
+            if word.startswith("/") and len(word) > 1 and not word.startswith("//"):
+                slash_commands.append(word.lower())
+
+    return {
+        "turn_count": turn_count,
+        "tools_called": dict(tools_called.most_common(20)),
+        "agents_spawned": agents_spawned,
+        "commands_used": list(set(commands_used)),
+        "slash_commands": slash_commands,
+        "errors": errors[:5],  # Cap at 5 error samples
+        "tokens": {
+            "input": total_input_tokens,
+            "output": total_output_tokens,
+            "total": total_input_tokens + total_output_tokens,
+        },
+        "user_prompts_preview": [p[:100] for p in user_prompts[:3]],
+    }
+
+
+def write_learning_entry(session_id: str, data: dict) -> None:
+    """Write a learning entry to the daily log file."""
+    try:
+        LEARNING_DIR.mkdir(parents=True, exist_ok=True)
+        today = datetime.now().strftime("%Y-%m-%d")
+        log_file = LEARNING_DIR / f"{today}.jsonl"
+
+        entry = {
+            "ts": int(time.time()),
+            "session_id": session_id[:16],  # Truncate for privacy
+            "date": today,
+            **data,
+        }
+
+        with log_file.open("a") as f:
+            f.write(json.dumps(entry) + "\n")
+
+    except OSError:
+        pass  # Non-fatal — never block the session from ending
+
+
+def check_and_prune_old_logs() -> None:
+    """Remove learning logs older than 90 days to keep storage bounded."""
+    try:
+        if not LEARNING_DIR.exists():
+            return
+        cutoff = time.time() - (90 * 24 * 3600)
+        for log_file in LEARNING_DIR.glob("*.jsonl"):
+            try:
+                if log_file.stat().st_mtime < cutoff:
+                    log_file.unlink()
+            except OSError:
+                pass
+    except OSError:
+        pass
+
+
+def run_learning_logger() -> int:
+    """Main entry point — extract session data and write learning log."""
+    session_id = get_current_session_id()
+    if not session_id:
+        return 0
+
+    session_file = find_session_file(session_id)
+    if not session_file:
+        return 0
+
+    data = extract_session_data(session_file)
+    if not data or data.get("turn_count", 0) < 2:
+        return 0  # Skip trivially short sessions
+
+    write_learning_entry(session_id, data)
+    check_and_prune_old_logs()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(run_learning_logger())

package/.claude/skills/ai-router/SKILL.md

@@ -0,0 +1,119 @@
+---
+version: 1.0.0
+name: ai-router
+description: Routes tasks to the best available AI CLI tool based on task type and provider strengths. Triggered when user asks to "use gemini for", "run with codex", "ask grok", "route to best AI", "which AI should", or "delegate to".
+---
+
+# AI Router
+
+**Notification:** At skill start, output: "Using ai-router to select optimal AI provider..."
+
+## When to Use
+
+- User wants to run a task with a specific non-Claude AI
+- Task requires large context (> 100k tokens) → route to Gemini
+- Task requires speed over depth → route to Grok
+- Task is a coding challenge → consider Codex or Kimi
+- User wants multi-AI perspective without full brainstorm
+- Routing delegation for specific sub-tasks in a pipeline
+
+## When NOT to Use
+
+- Standard Claude Code tasks (just let Claude handle normally)
+- When `/bs:brainstorm_full` is more appropriate (full multi-AI synthesis)
+- When the user hasn't asked for a different AI
+
+## Routing Logic
+
+### Decision Tree
+
+```
+Is context > 100k tokens OR task = "scan entire codebase"?
+  → YES: Use gemini (1M context window)
+  → NO: Continue...
+
+Is task = "private", "confidential", "local only", "don't send to cloud", "offline", "sensitive"?
+  → YES: Use ollama if available (stays on machine), otherwise warn + use claude
+  → NO: Continue...
+
+Is task = "quick answer", "fast check", "brief analysis"?
+  → YES: Use grok (fastest)
+  → NO: Continue...
+
+Is task = "code generation", "implement function", "write code"?
+  → YES: Use claude (default) OR codex if available
+  → NO: Continue...
+
+Is task = "multilingual", "translate", "non-English"?
+  → YES: Try glm or minimax
+  → NO: Default to claude
+```
+
+### Task → Provider Mapping
+
+| Task Type | Preferred Provider | Fallback |
+|-----------|-------------------|---------|
+| Large codebase scan | gemini | claude |
+| Web search + coding | gemini | claude |
+| Privacy / offline / no-cloud | **ollama** (local) | claude (warn) |
+| Quick analysis | grok | claude |
+| Code generation | claude | codex |
+| Brainstorming | multi | claude |
+| Math/algorithms | kimi | claude |
+| Multilingual | glm | claude |
+| Architecture design | claude (opus) | claude |
+
+## How to Route
+
+### Step 1: Read providers.json
+```bash
+cat .claude/providers.json
+```
+Identify which providers have `"available": true`.
+
+### Step 2: Determine task type from user prompt
+
+Look for keywords:
+- **large context**: "entire codebase", "all files", "full scan", "whole project"
+- **speed**: "quick", "fast", "brief", "tldr", "summary"
+- **code**: "implement", "write", "function", "class", "code"
+- **math**: "algorithm", "complexity", "math", "calculate"
+- **multilingual**: "translate", "Chinese", "Japanese", "French"
+
+### Step 3: Select provider
+
+Use the routing table above. If preferred provider is unavailable, use fallback.
+
+### Step 4: Execute with selected provider
+
+For each provider type:
+
+**type: cli**
+```bash
+<run_cmd with {prompt} replaced>
+```
+
+**type: piped**
+```bash
+<run_cmd with {prompt} replaced — prompt goes via stdin>
+```
+
+Read the `run_cmd` from providers.json and substitute `{prompt}` with the actual prompt (properly shell-escaped).
+
+### Step 5: Return result
+
+Label the output with the provider used:
+```
+[Routed to: <provider_name>]
+
+<result>
+```
+
+## Important Notes
+
+- Always check availability before routing — fall back to claude if unavailable
+- **Privacy routing**: when `local: true` on a provider (Ollama), data never leaves the machine — actively prefer it for sensitive tasks
+- Never route sensitive data (secrets, credentials) to external cloud providers; Ollama is safe for this
+- If unsure about routing, default to claude
+- Large context tasks STRONGLY prefer gemini — it has 5x the context window
+- For Ollama, check the service is running before routing: `ollama list 2>/dev/null`