ccjk 7.0.0 → 7.0.2

package/agents/agent-router.md

@@ -1,135 +0,0 @@
-# Agent: Router
-
-> **Purpose**: Route research queries to appropriate information agents
-> **Key Feature**: Query classification + dispatch
-
-## 🎯 What This Agent Does
-
-Analyzes the user's information needs and routes to the most appropriate specialized research agent (doc-researcher, mcp-researcher, version-checker, or npm-researcher).
-
-## 📋 Query Classification
-
-```typescript
-type ResearchQuery = {
-  category: 'documentation' | 'mcp' | 'version' | 'package' | 'comparison'
-  keywords: string[]
-  agent: AgentType
-}
-```
-
-### Classification Rules
-
-**Documentation queries** → `doc-researcher`
-- "Latest Claude Code features"
-- "MCP specification"
-- "Claude Code API docs"
-
-**MCP server queries** → `mcp-researcher`
-- "@modelcontextprotocol/server-filesystem config"
-- "MCP servers for databases"
-- "How to install MCP server"
-
-**Version queries** → `version-checker`
-- "Latest ccjk version"
-- "CCR updates"
-- "CCUsage release notes"
-
-**NPM package queries** → `npm-researcher`
-- "vite package size"
-- "webpack vs vite"
-- "express dependencies"
-
-## 🔍 Query Examples
-
-```
-User: "How to configure filesystem MCP server"
-    ↓
-Router: Detect keywords ["MCP", "server", "filesystem", "config"]
-    ↓
-Classify: category = "mcp", agent = "mcp-researcher"
-    ↓
-Dispatch: mcp-researcher with query "filesystem MCP server configuration"
-    ↓
-Return: Server info + config template
-```
-
-## 🎯 Smart Routing
-
-### Single Agent Routing
-```typescript
-const routingMap = {
-  'documentation|Claude Code|MCP|docs': 'doc-researcher',
-  'MCP|server|@modelcontextprotocol|registry': 'mcp-researcher',
-  'version|update|release': 'version-checker',
-  'npm|package|bundle|bundlephobia': 'npm-researcher'
-}
-
-function routeQuery(query: string): string {
-  for (const [pattern, agent] of Object.entries(routingMap)) {
-    const regex = new RegExp(pattern, 'i')
-    if (regex.test(query)) {
-      return agent
-    }
-  }
-  return 'npm-researcher' // Default
-}
-```
-
-### Multi-Agent Routing
-```typescript
-// For complex queries, consult multiple agents
-const multiAgentQueries = [
-  "How to use MCP server with express",
-  "Vite vs webpack with latest features"
-]
-
-function routeMultiAgent(query: string): AgentType[] {
-  const agents: AgentType[] = []
-
-  if (query.includes('MCP')) agents.push('mcp-researcher')
-  if (query.includes('express')) agents.push('npm-researcher')
-  if (query.includes('vite') || query.includes('webpack')) agents.push('npm-researcher')
-
-  return agents
-}
-```
-
-## 📊 Agent Coordination
-
-```typescript
-// Single agent query
-async function routeToAgent(query: string): Promise<Result> {
-  const agent = routeQuery(query)
-  return await executeAgent(agent, query)
-}
-
-// Multi-agent query (combine results)
-async function routeToAgents(query: string): Promise<CombinedResult> {
-  const agents = routeMultiAgent(query)
-  const results = await Promise.all(
-    agents.map(agent => executeAgent(agent, query))
-  )
-
-  return combineResults(results)
-}
-
-function combineResults(results: AgentResult[]): CombinedResult {
-  return {
-    sources: results.map(r => r.source).join(', '),
-    information: results.map(r => r.data).join('\n---\n'),
-    confidence: Math.min(...results.map(r => r.confidence))
-  }
-}
-```
-
-## 🔗 Related Agents
-
-- **doc-researcher**: Documentation queries
-- **mcp-researcher**: MCP server queries
-- **version-checker**: Version queries
-- **npm-researcher**: NPM package queries
-
-## 📚 References
-
-- Agent implementation guide
-- Query classification patterns

package/agents/agents.json

@@ -1,6 +0,0 @@
-{
-  "name": "ccjk-info-agents",
-  "version": "1.0.0",
-  "description": "Background agents for fetching real-time CCJK information",
-  "agents": "./agents/"
-}

package/agents/cache-manager.ts

@@ -1,265 +0,0 @@
-/**
- * Cache Manager for CCJK Information Agents
- * Provides intelligent caching for doc-researcher, mcp-researcher, version-checker, npm-researcher
- */
-
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import process from 'node:process'
-
-export interface CacheConfig {
-  ttl: number
-  maxSize?: number
-}
-
-export interface CacheEntry<T> {
-  data: T
-  timestamp: number
-  source: string
-  cached: boolean
-}
-
-export class CacheManager {
-  private cacheDir: string
-  private defaultTtl: number
-  private maxSize: number
-
-  constructor(options: {
-    cacheDir: string
-    defaultTtl?: number
-    maxSize?: number
-  } = {}) {
-    this.cacheDir = options.cacheDir || join(process.env.HOME || '~', '.ccjk', 'cache')
-    this.defaultTtl = options.defaultTtl || 24 * 60 * 60 * 1000 // 24 hours
-    this.maxSize = options.maxSize || 100 * 1024 * 1024 // 100MB default
-
-    this.ensureCacheDir()
-  }
-
-  /**
-   * Ensure cache directory exists
-   */
-  private ensureCacheDir(): void {
-    if (!existsSync(this.cacheDir)) {
-      mkdirSync(this.cacheDir, { recursive: true })
-    }
-  }
-
-  /**
-   * Get cache path for key
-   */
-  private getCachePath(key: string): string {
-    const sanitizedKey = key.replace(/[^\w-]/g, '_')
-    return join(this.cacheDir, `${sanitizedKey}.json`)
-  }
-
-  /**
-   * Get cache size
-   */
-  getCacheSize(): number {
-    try {
-      const files = this.getCacheFiles()
-      return files.reduce((total, file) => {
-        const path = join(this.cacheDir, file)
-        const stats = statSync(path)
-        return total + stats.size
-      }, 0)
-    }
-    catch {
-      return 0
-    }
-  }
-
-  /**
-   * Clean old cache entries
-   */
-  clean(): void {
-    const files = this.getCacheFiles()
-    let totalCleaned = 0
-
-    for (const file of files) {
-      try {
-        const cachePath = join(this.cacheDir, file)
-        const content = JSON.parse(readFileSync(cachePath, 'utf8'))
-
-        const age = Date.now() - content.timestamp
-        if (age > this.defaultTtl) {
-          rmSync(cachePath)
-          totalCleaned++
-        }
-      }
-      catch {
-        // Skip invalid cache files
-        console.warn(`Invalid cache file: ${file}`)
-      }
-    }
-
-    console.log(`✅ Cleaned ${totalCleaned} expired cache entries`)
-  }
-
-  /**
-   * Get all cache files
-   */
-  private getCacheFiles(): string[] {
-    try {
-      return readdirSync(this.cacheDir).filter(f => f.endsWith('.json'))
-    }
-    catch {
-      return []
-    }
-  }
-
-  /**
-   * Clear entire cache
-   */
-  clear(): void {
-    const files = this.getCacheFiles()
-    for (const file of files) {
-      rmSync(join(this.cacheDir, file))
-    }
-    console.log(`✅ Cleared ${files.length} cache files`)
-  }
-
-  /**
-   * Check if cache entry is valid (not expired)
-   */
-  private isValid(entry: { timestamp: number }, ttl?: number): boolean {
-    const age = Date.now() - entry.timestamp
-    return age < (ttl || this.defaultTtl)
-  }
-
-  /**
-   * Get value from cache
-   */
-  get<T>(key: string, config?: { ttl?: number }): CacheEntry<T> | null {
-    const cachePath = this.getCachePath(key)
-
-    if (!existsSync(cachePath)) {
-      return null
-    }
-
-    try {
-      const content = readFileSync(cachePath, 'utf8')
-      const entry = JSON.parse(content) as CacheEntry<T>
-
-      if (this.isValid(entry, config?.ttl)) {
-        return { ...entry, cached: true }
-      }
-      else {
-        // Cache expired
-        rmSync(cachePath)
-        return null
-      }
-    }
-    catch {
-      // Invalid cache
-      rmSync(cachePath)
-      return null
-    }
-  }
-
-  /**
-   * Set value in cache
-   */
-  set<T>(key: string, data: T, options?: {
-    ttl?: number
-    source?: string
-  }): void {
-    const cachePath = this.getCachePath(key)
-
-    const entry: CacheEntry<T> = {
-      data,
-      timestamp: Date.now(),
-      source: options?.source || 'unknown',
-      cached: false,
-    }
-
-    writeFileSync(cachePath, JSON.stringify(entry, null, 2))
-  }
-
-  /**
-   * Get or fetch (with fallback)
-   */
-  async getOrFetch<T>(
-    key: string,
-    fetchFn: () => Promise<T>,
-    options?: {
-      ttl?: number
-      source?: string
-    },
-  ): Promise<CacheEntry<T>> {
-    // Try cache first
-    const cached = this.get<T>(key, options)
-    if (cached) {
-      return cached
-    }
-
-    // Cache miss or expired - fetch fresh data
-    try {
-      const data = await fetchFn()
-      this.set(key, data, options)
-      return {
-        data,
-        timestamp: Date.now(),
-        source: options?.source || 'fresh',
-        cached: false,
-      }
-    }
-    catch (error) {
-      throw new Error(`Failed to fetch and cache data: ${error.message}`)
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  stats(): {
-    totalEntries: number
-    cacheSize: string
-    latest: CacheEntry<any> | null
-    oldest: CacheEntry<any> | null
-  } {
-    const files = this.getCacheFiles()
-    const entries = files.map((file) => {
-      try {
-        const content = readFileSync(join(this.cacheDir, file), 'utf8')
-        return JSON.parse(content)
-      }
-      catch {
-        return null
-      }
-    }).filter(Boolean)
-
-    const size = this.getCacheSize()
-    const sorted = entries.sort((a, b) => a.timestamp - b.timestamp)
-
-    return {
-      totalEntries: entries.length,
-      cacheSize: `${(size / 1024 / 1024).toFixed(2)} MB`,
-      latest: sorted[sorted.length - 1] || null,
-      oldest: sorted[0] || null,
-    }
-  }
-}
-
-// Agent-specific cache configurations
-export const AGENT_CACHE_CONFIG = {
-  'doc-researcher': {
-    ttl: 72 * 60 * 60 * 1000, // 72 hours
-    description: 'Documentation (stable, 3 days)',
-  },
-  'mcp-researcher': {
-    ttl: 24 * 60 * 60 * 1000, // 24 hours
-    description: 'MCP servers (frequent updates, 1 day)',
-  },
-  'version-checker': {
-    ttl: 168 * 60 * 60 * 1000, // 168 hours (7 days)
-    description: 'Versions (stable, 1 week)',
-  },
-  'npm-researcher': {
-    ttl: 24 * 60 * 60 * 1000, // 24 hours
-    description: 'NPM packages (daily updates, 1 day)',
-  },
-}
-
-export default CacheManager

package/agents/doc-researcher.md

@@ -1,202 +0,0 @@
-# Agent: Doc Researcher
-
-> **Purpose**: Fetch latest Claude Code documentation
-> **Data Source**: https://docs.anthropic.com
-> **Cache TTL**: 72 hours (3 days)
-> **Run Mode**: Background
-
-## 🎯 What This Agent Does
-
-Researches and retrieves the latest Claude Code documentation to ensure CCJK skills and recommendations are based on current information.
-
-## 📚 Data Sources
-
-### Primary Sources
-- **Claude Code Docs**: https://docs.anthropic.com/claude/docs
-- **Claude API Docs**: https://docs.anthropic.com/claude/reference
-- **MCP Documentation**: https://modelcontextprotocol.io/
-- **Release Notes**: https://docs.anthropic.com/claude/docs/releases
-
-## 🔍 Research Queries
-
-### Common Queries
-```typescript
-// Latest Claude Code features
-"Claude Code latest features 2025"
-
-// MCP documentation
-"Model Context Protocol specification"
-
-// Skills documentation
-"Claude Code skills documentation"
-
-// API reference
-"Claude API messages parameters"
-```
-
-## 📊 Cache Strategy
-
-```typescript
-const CACHE_CONFIG = {
-  docs: {
-    ttl: 72 * 60 * 60 * 1000,  // 72 hours
-    key: (query) => `docs:${query}`
-  }
-}
-```
-
-**Rationale**: Documentation is relatively stable but updates occasionally. 72-hour balance ensures freshness without excessive API calls.
-
-## 🔄 Workflow
-
-```
-User Query: "Latest Claude Code features"
-    ↓
-1. Check Cache
-    ↓
-2. If Cache Hit (< 72h old)
-    → Return cached docs
-    ↓
-3. If Cache Miss or Expired
-    → Fetch from docs.anthropic.com
-    → Parse and extract relevant sections
-    → Store in cache
-    → Return to user
-```
-
-## 📋 Output Format
-
-```typescript
-interface DocResearchResult {
-  query: string
-  source: string
-  url: string
-  title: string
-  content: string
-  lastUpdated: Date
-  cacheHit: boolean
-}
-```
-
-## 🎯 Key Features
-
-### 1. Smart Caching
-- Check cache age before fetching
-- Return cached if fresh (< 72h)
-- Fetch and update if stale
-
-### 2. Relevant Extraction
-- Parse documentation HTML/Markdown
-- Extract relevant sections only
-- Format for easy reading
-
-### 3. Source Attribution
-- Always include source URL
-- Provide timestamp
-- Indicate if data is from cache
-
-## 🔗 Related Skills
-
-- **layer1-mcp**: Uses latest MCP docs
-- **layer2-best-practices**: Updated with latest standards
-- **All skills**: Benefit from current documentation
-
-## 📝 Usage Examples
-
-### Example 1: Fetch Latest MCP Docs
-```
-User: "What's the latest MCP specification?"
-    ↓
-Agent: doc-researcher
-    ↓
-Query: "Model Context Protocol specification 2025"
-    ↓
-Output:
-  - Latest MCP version
-  - New transport types
-  - Updated API format
-  - Source: modelcontextprotocol.io
-```
-
-### Example 2: Claude Code Features
-```
-User: "What's new in Claude Code?"
-    ↓
-Agent: doc-researcher
-    ↓
-Query: "Claude Code latest features"
-    ↓
-Output:
-  - New features list
-  - Updated workflows
-  - New skill formats
-  - Source: docs.anthropic.com
-```
-
-## ⚙️ Configuration
-
-```json
-{
-  "agent": "doc-researcher",
-  "runMode": "background",
-  "cache": {
-    "enabled": true,
-    "ttl": 259200000
-  },
-  "sources": [
-    "https://docs.anthropic.com",
-    "https://modelcontextprotocol.io"
-  ]
-}
-```
-
-## 🚫 Error Handling
-
-```typescript
-try {
-  const docs = await fetchDocs(query)
-  return docs
-} catch (error) {
-  // Fallback to cached data if available
-  const cached = await getFromCache(query)
-  if (cached) {
-    console.warn('Using cached docs (fetch failed)')
-    return { ...cached, source: 'cache (offline)' }
-  }
-
-  // If no cache, return error
-  throw new Error(`Failed to fetch docs: ${error.message}`)
-}
-```
-
-## 📈 Performance Metrics
-
-- **Average Fetch Time**: ~2 seconds
-- **Cache Hit Rate**: Target > 80%
-- **Success Rate**: Target > 95%
-
-## 🔐 Security & Privacy
-
-- ✅ No personal data sent
-- ✅ Only public documentation accessed
-- ✅ Cache stored locally
-- ✅ No tracking or analytics
-
-## 🔄 Update Strategy
-
-**When to Update Cache**:
-- Manual trigger: `/fetch-docs`
-- Automatic: If cache > 72h old
-- Before: Using docs in critical decisions
-
-## 📚 References
-
-- [Claude Code Documentation](https://docs.anthropic.com/claude/docs)
-- [MCP Specification](https://modelcontextprotocol.io/)
-- [Agent Implementation Guide](./AGENT-IMPLEMENTATION.md)
-
----
-
-**Status**: ✅ Ready for implementation
-**Priority**: 🔴 High
-**Dependencies**: None (can run independently)