ccsetup 1.1.1 → 1.2.1

package/bin/lib/claudeInterface.js

@@ -0,0 +1,209 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+
+class ClaudeInterface {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+
+  /**
+   * Check if Claude Code CLI is available
+   */
+  async isAvailable() {
+    try {
+      await execAsync('claude --version');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Scan repository using Claude Code CLI
+   */
+  async scanRepository() {
+    const isAvailable = await this.isAvailable();
+    if (!isAvailable) {
+      throw new Error('Claude Code CLI is not available. Please install it first: npm install -g @anthropic-ai/claude-code');
+    }
+
+    console.log('🤖 Using Claude Code to analyze your repository...');
+    
+    try {
+      // Use Claude Code to analyze the repository
+      const projectInfo = await this.analyzeProject();
+      const dependencies = await this.analyzeDependencies();
+      const structure = await this.analyzeStructure();
+      const commands = await this.analyzeCommands();
+      const patterns = await this.analyzePatterns();
+      
+      return {
+        projectType: projectInfo.language || 'Unknown',
+        frameworks: projectInfo.frameworks || [],
+        purpose: projectInfo.description || '',
+        structure: structure.directories || [],
+        dependencies: dependencies,
+        commands: commands.scripts || [],
+        patterns: patterns,
+        scanDate: new Date().toISOString(),
+        scanMethod: 'claude-code'
+      };
+    } catch (error) {
+      throw new Error(`Claude Code analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Analyze project type and frameworks
+   */
+  async analyzeProject() {
+    const prompt = `Analyze this project and tell me:
+1. The main programming language
+2. Key frameworks being used
+3. A one-sentence description of what this project does
+
+Respond in this exact JSON format:
+{
+  "language": "the main language",
+  "frameworks": ["framework1", "framework2"],
+  "description": "one sentence description"
+}`;
+
+    const result = await this.executeCommand(prompt);
+    return this.parseJsonResponse(result);
+  }
+
+  /**
+   * Analyze project dependencies
+   */
+  async analyzeDependencies() {
+    const prompt = `List the key dependencies in this project. Look at package.json, requirements.txt, go.mod, etc.
+
+Respond in this exact JSON format:
+{
+  "runtime": ["dep1", "dep2"],
+  "dev": ["devDep1", "devDep2"]
+}`;
+
+    const result = await this.executeCommand(prompt);
+    const parsed = this.parseJsonResponse(result);
+    return {
+      runtime: parsed.runtime || [],
+      dev: parsed.dev || []
+    };
+  }
+
+  /**
+   * Analyze project structure
+   */
+  async analyzeStructure() {
+    const prompt = `List the most important directories in this project and their purpose.
+
+Respond in this exact JSON format:
+{
+  "directories": [
+    {"path": "/src", "purpose": "source code"},
+    {"path": "/tests", "purpose": "test files"}
+  ]
+}`;
+
+    const result = await this.executeCommand(prompt);
+    return this.parseJsonResponse(result);
+  }
+
+  /**
+   * Analyze available commands
+   */
+  async analyzeCommands() {
+    const prompt = `List all available commands from package.json scripts, Makefile, or other sources.
+
+Respond in this exact JSON format:
+{
+  "scripts": [
+    {"command": "npm run dev", "description": "start development server"},
+    {"command": "npm test", "description": "run tests"}
+  ]
+}`;
+
+    const result = await this.executeCommand(prompt);
+    return this.parseJsonResponse(result);
+  }
+
+  /**
+   * Analyze patterns and tools
+   */
+  async analyzePatterns() {
+    const prompt = `Identify architectural patterns, testing tools, and deployment methods used.
+
+Respond in this exact JSON format:
+{
+  "architecture": ["MVC", "REST API"],
+  "testing": ["Jest", "unit tests"],
+  "deployment": ["Docker", "CI/CD"]
+}`;
+
+    const result = await this.executeCommand(prompt);
+    return this.parseJsonResponse(result);
+  }
+
+  /**
+   * Execute Claude Code command
+   */
+  async executeCommand(prompt) {
+    // Create a temporary file to store the prompt to avoid shell escaping issues
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    const tmpFile = path.join(os.tmpdir(), `claude-prompt-${Date.now()}.txt`);
+    fs.writeFileSync(tmpFile, prompt);
+    
+    try {
+      const command = `cat "${tmpFile}" | claude --print`;
+      
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.projectPath,
+        maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+        timeout: 60000 // 60 second timeout
+      });
+
+      // Clean up temp file
+      fs.unlinkSync(tmpFile);
+
+      if (stderr && !stderr.includes('Warning')) {
+        throw new Error(`Claude Code error: ${stderr}`);
+      }
+
+      return stdout;
+    } catch (error) {
+      // Clean up temp file on error
+      if (fs.existsSync(tmpFile)) {
+        fs.unlinkSync(tmpFile);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Parse JSON from Claude's response
+   */
+  parseJsonResponse(response) {
+    try {
+      // Try to extract JSON from the response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      
+      // If no JSON found, return empty object
+      console.warn('Could not parse JSON from Claude response');
+      return {};
+    } catch (error) {
+      console.warn('JSON parsing failed:', error.message);
+      return {};
+    }
+  }
+}
+
+module.exports = ClaudeInterface;

package/lib/aiAgentSelector.js

@@ -0,0 +1,155 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class AIAgentSelector {
+  constructor(scanResults, agentMetadata) {
+    this.scanResults = scanResults;
+    this.agentMetadata = agentMetadata;
+    this.hasClaudeCode = this.checkClaudeCode();
+  }
+
+  checkClaudeCode() {
+    try {
+      execSync('which claude', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async recommendAgents(maxRecommendations = 5) {
+    if (!this.hasClaudeCode || !this.scanResults) {
+      return null;
+    }
+
+    const projectContext = this.buildProjectContext();
+    const agentList = this.getAgentSummary();
+
+    const prompt = `Analyze this project and recommend the ${maxRecommendations} most relevant agents:
+
+PROJECT DETAILS:
+${projectContext}
+
+AVAILABLE AGENTS:
+${agentList}
+
+Based on the project type, tech stack, and structure, recommend exactly ${maxRecommendations} agents that would be most valuable.
+For each agent, provide:
+1. Agent name (exact match from list)
+2. Why it's recommended (one sentence)
+3. Priority: HIGH, MEDIUM, or LOW
+
+Format as JSON array: [{"name": "agent-name", "reason": "why", "priority": "HIGH"}]`;
+
+    try {
+      const response = execSync(
+        `claude --print "${prompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 }
+      ).trim();
+
+      return this.parseRecommendations(response);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  buildProjectContext() {
+    const context = [];
+    
+    if (this.scanResults.projectType) {
+      context.push(`Type: ${this.scanResults.projectType}`);
+    }
+    
+    if (this.scanResults.languages && this.scanResults.languages.length > 0) {
+      context.push(`Languages: ${this.scanResults.languages.join(', ')}`);
+    }
+    
+    if (this.scanResults.frameworks && this.scanResults.frameworks.length > 0) {
+      context.push(`Frameworks: ${this.scanResults.frameworks.join(', ')}`);
+    }
+    
+    if (this.scanResults.dependencies) {
+      const deps = Object.keys(this.scanResults.dependencies).slice(0, 10);
+      if (deps.length > 0) {
+        context.push(`Key dependencies: ${deps.join(', ')}`);
+      }
+    }
+    
+    if (this.scanResults.structure) {
+      const dirs = Object.keys(this.scanResults.structure).filter(dir => !dir.startsWith('.'));
+      context.push(`Structure: ${dirs.join(', ')}`);
+    }
+
+    return context.join('\n');
+  }
+
+  getAgentSummary() {
+    return this.agentMetadata.agents
+      .map(agent => `- ${agent.name}: ${agent.purpose}`)
+      .join('\n');
+  }
+
+  parseRecommendations(response) {
+    try {
+      // Extract JSON from response
+      const jsonMatch = response.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) return null;
+      
+      const recommendations = JSON.parse(jsonMatch[0]);
+      
+      // Validate and enhance recommendations
+      return recommendations
+        .filter(rec => rec.name && rec.reason)
+        .map(rec => ({
+          name: rec.name,
+          reason: rec.reason,
+          priority: rec.priority || 'MEDIUM',
+          agent: this.agentMetadata.agents.find(a => a.name === rec.name)
+        }))
+        .filter(rec => rec.agent);
+    } catch {
+      return null;
+    }
+  }
+
+  async getWorkflowBasedRecommendations() {
+    if (!this.hasClaudeCode) return null;
+
+    const workflows = [
+      { name: 'api-development', agents: ['backend', 'api-documenter', 'database-optimizer'] },
+      { name: 'frontend-development', agents: ['frontend', 'shadcn', 'performance-engineer'] },
+      { name: 'full-stack', agents: ['backend', 'frontend', 'database-admin', 'deployment-engineer'] },
+      { name: 'data-science', agents: ['data-scientist', 'ml-engineer', 'python-pro'] },
+      { name: 'devops', agents: ['deployment-engineer', 'cloud-architect', 'terraform-specialist'] }
+    ];
+
+    const prompt = `Based on this project context, which development workflow best matches?
+
+${this.buildProjectContext()}
+
+Choose ONE from: ${workflows.map(w => w.name).join(', ')}
+Output only the workflow name.`;
+
+    try {
+      const workflow = execSync(
+        `claude --print "${prompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+      ).trim().toLowerCase();
+
+      const matched = workflows.find(w => w.name === workflow);
+      if (matched) {
+        return {
+          workflow: matched.name,
+          agents: matched.agents.map(name => 
+            this.agentMetadata.agents.find(a => a.name === name)
+          ).filter(Boolean)
+        };
+      }
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = AIAgentSelector;

package/lib/templates/README.md

@@ -0,0 +1,176 @@
+# Template Catalog System
+
+The template catalog system provides a powerful foundation for browsing, filtering, and selecting from ccsetup's collection of 8 core agent templates. This system implements Phase 1 of the template selection feature as outlined in PLAN-009.
+
+## Overview
+
+The template catalog system consists of:
+- **Metadata Extraction**: Automatically extracts metadata from agent frontmatter
+- **Template Catalog**: Provides filtering, search, and discovery capabilities  
+- **Category Management**: Organizes templates into logical categories
+- **Caching**: Efficient caching for fast template discovery
+
+## Components
+
+### MetadataExtractor (`metadata-extractor.js`)
+- Parses agent frontmatter to extract metadata
+- Automatically categorizes agents based on content analysis
+- Generates tags from descriptions and tools
+- Creates structured metadata JSON files
+
+### TemplateCatalog (`catalog.js`)
+- Template discovery and loading
+- Filtering by category, tags, and search queries
+- Template validation
+- Caching for performance
+
+### Generated Metadata (`metadata/agents.json`)
+- Contains metadata for all 8 agents
+- Organized by categories: Development, Backend, Planning, AI/ML, etc.
+- Includes tags, tools, examples, and workflows for each agent
+
+## Usage
+
+### Basic Catalog Operations
+```javascript
+const { TemplateCatalog } = require('./lib/templates');
+
+const catalog = new TemplateCatalog();
+
+// Load all templates
+const data = await catalog.load();
+
+// Get templates by category
+const planningAgents = await catalog.getTemplates('planning');
+const frontendAgents = await catalog.getTemplates('frontend');
+
+// Filter by tags
+const testingAgents = await catalog.getTemplates(null, ['testing']);
+
+// Search templates
+const reactAgents = await catalog.searchTemplates('react');
+
+// Get categories
+const categories = await catalog.getCategories();
+```
+
+### Template Filtering
+```javascript
+// Multiple filters can be combined
+const templates = await catalog.getTemplates(
+  'development',    // category
+  ['frontend', 'ui'], // tags
+  'react'           // search query
+);
+
+// Advanced search with options
+const results = await catalog.searchTemplates('API', {
+  category: 'backend',
+  tags: ['api'],
+  limit: 10,
+  sortBy: 'name'
+});
+```
+
+### Template Validation
+```javascript
+// Validate a template
+const validation = await catalog.validateTemplate(template);
+if (!validation.valid) {
+  console.log('Errors:', validation.errors);
+  console.log('Warnings:', validation.warnings);
+}
+```
+
+## Categories
+
+The system automatically categorizes agents into:
+
+- **Planning & Architecture** (8 agents) - Strategic planning and system design
+- **Development & Implementation** (26 agents) - Code implementation and development
+- **Frontend Development** (13 agents) - UI/UX and frontend frameworks
+- **Backend Development** (2 agents) - API design and server-side development
+- **Quality Assurance & Testing** (9 agents) - Testing and code review
+- **Security & Auditing** (5 agents) - Security analysis and auditing
+- **DevOps & Infrastructure** (2 agents) - Deployment and infrastructure
+- **Database & Data** (3 agents) - Database management and data analysis
+- **AI & Machine Learning** (5 agents) - AI/ML development and operations
+- **Mobile Development** (1 agent) - Mobile app development
+- **General Purpose** (4 agents) - Utility and general-purpose agents
+
+## Popular Tags
+
+Most common tags across all templates:
+- `development` (35 agents)
+- `implementation` (35 agents) 
+- `ml`, `ai` (19 agents each)
+- `performance` (19 agents)
+- `frontend`, `ui` (13 agents each)
+- `backend`, `api` (9 agents each)
+- `testing` (9 agents)
+
+## Scripts
+
+### Generate Metadata
+```bash
+npm run metadata:generate
+```
+Scans all agent templates and generates fresh metadata.
+
+### Test Catalog
+```bash
+npm run catalog:test
+```
+Runs comprehensive tests of catalog functionality.
+
+### Demo System
+```bash
+node scripts/demo-template-selection.js
+```
+Demonstrates browsing, filtering, and search capabilities.
+
+## Data Structure
+
+Each template has the following metadata:
+```json
+{
+  "id": "agent-planner",
+  "name": "Strategic Planner Agent",
+  "category": "agents",
+  "subcategory": "planning",
+  "description": "Strategic planning specialist...",
+  "tags": ["planning", "architecture", "roadmap"],
+  "tools": ["Read", "Grep", "Glob", "TodoWrite"],
+  "version": "1.0.0",
+  "dependencies": [],
+  "files": ["planner.md"],
+  "author": "ccsetup",
+  "examples": ["Breaking down feature implementations"],
+  "workflows": ["Feature Development", "Refactoring"]
+}
+```
+
+## Performance
+
+- **Caching**: 5-minute cache validity for fast repeated access
+- **Lazy Loading**: Metadata loaded only when needed
+- **Efficient Filtering**: Fast category and tag-based filtering
+- **Search Optimization**: Text search across name, description, tags, and examples
+
+## Future Enhancements
+
+Phase 1 provides the foundation for:
+- Interactive CLI template selection (Phase 2)
+- Browse command implementation (Phase 3)
+- Additional template categories (Phase 4)
+- Template marketplace features (Future)
+
+## Files
+
+- `metadata-extractor.js` - Extracts metadata from agent templates
+- `catalog.js` - Main catalog class with filtering and search
+- `index.js` - Public API exports
+- `metadata/agents.json` - Generated metadata for all agents
+- `README.md` - This documentation
+
+The template catalog system provides a robust foundation for the enhanced template selection system outlined in PLAN-009.