ccsetup 1.1.1 → 1.2.1

package/lib/templates/metadata-extractor.js

@@ -0,0 +1,329 @@
+const fs = require('fs');
+const path = require('path');
+
+class MetadataExtractor {
+  static parseFrontmatter(content) {
+    const lines = content.split('\n');
+    
+    if (lines[0] !== '---') {
+      return null;
+    }
+    
+    const frontmatter = {};
+    let inFrontmatter = true;
+    let lineIndex = 1;
+    
+    while (lineIndex < lines.length && inFrontmatter) {
+      const line = lines[lineIndex];
+      if (line === '---') {
+        inFrontmatter = false;
+      } else if (line.includes(':')) {
+        const [key, ...valueParts] = line.split(':');
+        const value = valueParts.join(':').trim();
+        frontmatter[key.trim()] = value;
+      }
+      lineIndex++;
+    }
+    
+    return frontmatter;
+  }
+  
+  static extractTagsFromContent(frontmatter) {
+    const tags = [];
+    
+    if (frontmatter.tools) {
+      const tools = frontmatter.tools.split(',').map(t => t.trim().toLowerCase());
+      tags.push(...tools);
+    }
+    
+    if (frontmatter.description) {
+      const desc = frontmatter.description.toLowerCase();
+      
+      if (desc.includes('planning') || desc.includes('roadmap') || desc.includes('architecture')) {
+        tags.push('planning', 'architecture');
+      }
+      if (desc.includes('implement') || desc.includes('code') || desc.includes('develop')) {
+        tags.push('development', 'implementation');
+      }
+      if (desc.includes('test') || desc.includes('qa') || desc.includes('quality')) {
+        tags.push('testing', 'qa');
+      }
+      if (desc.includes('security') || desc.includes('audit')) {
+        tags.push('security');
+      }
+      if (desc.includes('frontend') || desc.includes('ui') || desc.includes('react')) {
+        tags.push('frontend', 'ui');
+      }
+      if (desc.includes('backend') || desc.includes('api') || desc.includes('server')) {
+        tags.push('backend', 'api');
+      }
+      if (desc.includes('database') || desc.includes('sql')) {
+        tags.push('database');
+      }
+      if (desc.includes('performance') || desc.includes('optimization')) {
+        tags.push('performance');
+      }
+      if (desc.includes('mobile') || desc.includes('ios') || desc.includes('android')) {
+        tags.push('mobile');
+      }
+      if (desc.includes('devops') || desc.includes('deployment') || desc.includes('ci/cd')) {
+        tags.push('devops', 'deployment');
+      }
+      if (desc.includes('blockchain') || desc.includes('web3') || desc.includes('smart contract')) {
+        tags.push('blockchain', 'web3');
+      }
+      if (desc.includes('ml') || desc.includes('machine learning') || desc.includes('ai')) {
+        tags.push('ml', 'ai');
+      }
+    }
+    
+    return [...new Set(tags)];
+  }
+  
+  static categorizeAgent(name, description, tags) {
+    const nameLower = name.toLowerCase();
+    const descLower = description.toLowerCase();
+    
+    if (nameLower.includes('planner') || nameLower.includes('architect') || 
+        descLower.includes('planning') || descLower.includes('architecture')) {
+      return 'planning';
+    }
+    
+    if (nameLower.includes('coder') || nameLower.includes('developer') || 
+        descLower.includes('implement') || descLower.includes('code')) {
+      return 'development';
+    }
+    
+    if (nameLower.includes('checker') || nameLower.includes('test') || nameLower.includes('qa') ||
+        descLower.includes('testing') || descLower.includes('quality') || descLower.includes('review')) {
+      return 'qa';
+    }
+    
+    if (nameLower.includes('frontend') || nameLower.includes('ui') || 
+        descLower.includes('frontend') || descLower.includes('react') || descLower.includes('vue')) {
+      return 'frontend';
+    }
+    
+    if (nameLower.includes('backend') || nameLower.includes('api') || 
+        descLower.includes('backend') || descLower.includes('server') || descLower.includes('api')) {
+      return 'backend';
+    }
+    
+    if (nameLower.includes('security') || nameLower.includes('audit') ||
+        descLower.includes('security') || descLower.includes('audit')) {
+      return 'security';
+    }
+    
+    if (nameLower.includes('devops') || nameLower.includes('deploy') ||
+        descLower.includes('devops') || descLower.includes('deployment') || descLower.includes('infrastructure')) {
+      return 'devops';
+    }
+    
+    if (nameLower.includes('database') || nameLower.includes('sql') ||
+        descLower.includes('database') || descLower.includes('sql')) {
+      return 'database';
+    }
+    
+    if (nameLower.includes('blockchain') || nameLower.includes('web3') ||
+        descLower.includes('blockchain') || descLower.includes('web3') || descLower.includes('smart contract')) {
+      return 'blockchain';
+    }
+    
+    if (nameLower.includes('ml') || nameLower.includes('ai') || nameLower.includes('data') ||
+        descLower.includes('machine learning') || descLower.includes('data science') || descLower.includes('ai')) {
+      return 'ai-ml';
+    }
+    
+    if (nameLower.includes('mobile') || descLower.includes('mobile') || 
+        descLower.includes('ios') || descLower.includes('android')) {
+      return 'mobile';
+    }
+    
+    return 'general';
+  }
+  
+  static formatName(name) {
+    return name.split('-').map(word => 
+      word.charAt(0).toUpperCase() + word.slice(1)
+    ).join(' ') + ' Agent';
+  }
+  
+  static extractFromAgent(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const frontmatter = this.parseFrontmatter(content);
+      
+      if (!frontmatter || !frontmatter.name) {
+        return null;
+      }
+      
+      const tags = this.extractTagsFromContent(frontmatter);
+      const category = this.categorizeAgent(frontmatter.name, frontmatter.description || '', tags);
+      
+      return {
+        id: `agent-${frontmatter.name}`,
+        name: this.formatName(frontmatter.name),
+        category: 'agents',
+        subcategory: category,
+        description: frontmatter.description || 'No description available',
+        tags: tags,
+        tools: frontmatter.tools ? frontmatter.tools.split(',').map(t => t.trim()) : [],
+        version: '1.0.0',
+        dependencies: [],
+        files: [path.basename(filePath)],
+        author: 'ccsetup',
+        examples: this.extractExamplesFromDescription(frontmatter.description || ''),
+        workflows: this.extractWorkflowsFromContent(content)
+      };
+    } catch (error) {
+      console.warn(`Warning: Could not extract metadata from ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+  
+  static extractExamplesFromDescription(description) {
+    const examples = [];
+    
+    if (description.includes('planning')) {
+      examples.push('Breaking down feature implementations', 'Creating technical roadmaps');
+    }
+    if (description.includes('implement') || description.includes('code')) {
+      examples.push('Feature implementation', 'Bug fixes and optimizations');
+    }
+    if (description.includes('test') || description.includes('qa')) {
+      examples.push('Test automation', 'Quality assurance reviews');
+    }
+    if (description.includes('frontend') || description.includes('ui')) {
+      examples.push('UI component development', 'Responsive design implementation');
+    }
+    if (description.includes('backend') || description.includes('api')) {
+      examples.push('API development', 'Server-side optimization');
+    }
+    
+    return examples.length > 0 ? examples : ['General development tasks'];
+  }
+  
+  static extractWorkflowsFromContent(content) {
+    const workflows = [];
+    
+    if (content.includes('feature') || content.includes('implement')) {
+      workflows.push('Feature Development');
+    }
+    if (content.includes('bug') || content.includes('fix')) {
+      workflows.push('Bug Fix');
+    }
+    if (content.includes('refactor') || content.includes('optimization')) {
+      workflows.push('Refactoring');
+    }
+    if (content.includes('test') || content.includes('qa')) {
+      workflows.push('QA');
+    }
+    if (content.includes('api') || content.includes('backend')) {
+      workflows.push('API Development');
+    }
+    if (content.includes('ui') || content.includes('frontend') || content.includes('component')) {
+      workflows.push('UI Component');
+    }
+    if (content.includes('blockchain') || content.includes('web3') || content.includes('smart contract')) {
+      workflows.push('Blockchain Development');
+    }
+    
+    return workflows.length > 0 ? workflows : ['General'];
+  }
+  
+  static generateCatalogFromAgents(agentsDir = null) {
+    if (!agentsDir) {
+      agentsDir = path.join(__dirname, '../../template/.claude/agents');
+    }
+    
+    const agents = [];
+    
+    try {
+      const files = fs.readdirSync(agentsDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.md') && file !== 'README.md') {
+          const filePath = path.join(agentsDir, file);
+          const metadata = this.extractFromAgent(filePath);
+          
+          if (metadata) {
+            agents.push(metadata);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error generating catalog from agents:', error.message);
+      return { agents: [] };
+    }
+    
+    return {
+      agents: agents.sort((a, b) => a.name.localeCompare(b.name)),
+      categories: this.generateCategories(agents),
+      stats: {
+        totalAgents: agents.length,
+        categories: [...new Set(agents.map(a => a.subcategory))].length,
+        lastUpdated: new Date().toISOString()
+      }
+    };
+  }
+  
+  static generateCategories(agents) {
+    const categories = {};
+    
+    for (const agent of agents) {
+      if (!categories[agent.subcategory]) {
+        categories[agent.subcategory] = {
+          name: agent.subcategory,
+          displayName: this.formatCategoryName(agent.subcategory),
+          count: 0,
+          agents: []
+        };
+      }
+      
+      categories[agent.subcategory].count++;
+      categories[agent.subcategory].agents.push(agent.id);
+    }
+    
+    return categories;
+  }
+  
+  static formatCategoryName(category) {
+    const categoryNames = {
+      'planning': 'Planning & Architecture',
+      'development': 'Development & Implementation', 
+      'qa': 'Quality Assurance & Testing',
+      'frontend': 'Frontend Development',
+      'backend': 'Backend Development',
+      'security': 'Security & Auditing',
+      'devops': 'DevOps & Infrastructure',
+      'database': 'Database & Data',
+      'blockchain': 'Blockchain & Web3',
+      'ai-ml': 'AI & Machine Learning',
+      'mobile': 'Mobile Development',
+      'general': 'General Purpose'
+    };
+    
+    return categoryNames[category] || category.charAt(0).toUpperCase() + category.slice(1);
+  }
+  
+  static saveCatalogToFile(catalog, outputPath = null) {
+    if (!outputPath) {
+      outputPath = path.join(__dirname, 'metadata/agents.json');
+    }
+    
+    try {
+      const dir = path.dirname(outputPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      fs.writeFileSync(outputPath, JSON.stringify(catalog, null, 2), 'utf8');
+      return true;
+    } catch (error) {
+      console.error('Error saving catalog to file:', error.message);
+      return false;
+    }
+  }
+}
+
+module.exports = MetadataExtractor;

package/lib/templates/search.js

@@ -0,0 +1,356 @@
+class TemplateSearch {
+  constructor(templates = []) {
+    this.templates = templates;
+  }
+  
+  setTemplates(templates) {
+    this.templates = templates;
+    return this;
+  }
+  
+  search(query, options = {}) {
+    if (!query || typeof query !== 'string' || query.trim() === '') {
+      return new TemplateSearch(this.templates);
+    }
+    
+    const {
+      fields = ['name', 'description', 'tags', 'examples'],
+      caseSensitive = false,
+      exactMatch = false,
+      minScore = 0,
+      fuzzy = false,
+      fuzzyThreshold = 0.6
+    } = options;
+    
+    const searchQuery = caseSensitive ? query.trim() : query.toLowerCase().trim();
+    const searchResults = [];
+    
+    for (const template of this.templates) {
+      const score = this.calculateScore(template, searchQuery, fields, {
+        caseSensitive,
+        exactMatch,
+        fuzzy,
+        fuzzyThreshold
+      });
+      
+      if (score >= minScore) {
+        searchResults.push({
+          template,
+          score,
+          matches: this.getMatches(template, searchQuery, fields, caseSensitive)
+        });
+      }
+    }
+    
+    const sortedResults = searchResults
+      .sort((a, b) => b.score - a.score)
+      .map(result => ({
+        ...result.template,
+        _searchScore: result.score,
+        _searchMatches: result.matches
+      }));
+    
+    return new TemplateSearch(sortedResults);
+  }
+  
+  calculateScore(template, query, fields, options) {
+    let totalScore = 0;
+    let maxPossibleScore = 0;
+    
+    for (const field of fields) {
+      const fieldValue = this.getFieldValue(template, field);
+      if (!fieldValue) continue;
+      
+      const fieldWeight = this.getFieldWeight(field);
+      maxPossibleScore += fieldWeight;
+      
+      const fieldScore = this.scoreField(fieldValue, query, options);
+      totalScore += fieldScore * fieldWeight;
+    }
+    
+    return maxPossibleScore > 0 ? totalScore / maxPossibleScore : 0;
+  }
+  
+  getFieldValue(template, field) {
+    if (field === 'tags' && Array.isArray(template.tags)) {
+      return template.tags.join(' ');
+    }
+    if (field === 'examples' && Array.isArray(template.examples)) {
+      return template.examples.join(' ');
+    }
+    return template[field] || '';
+  }
+  
+  getFieldWeight(field) {
+    const weights = {
+      name: 3,
+      description: 2,
+      tags: 1.5,
+      examples: 1,
+      subcategory: 1,
+      category: 0.5
+    };
+    return weights[field] || 1;
+  }
+  
+  scoreField(fieldValue, query, options) {
+    if (!fieldValue || typeof fieldValue !== 'string') {
+      return 0;
+    }
+    
+    const text = options.caseSensitive ? fieldValue : fieldValue.toLowerCase();
+    
+    if (options.exactMatch) {
+      return text === query ? 1 : 0;
+    }
+    
+    if (options.fuzzy) {
+      return this.fuzzyMatch(text, query, options.fuzzyThreshold);
+    }
+    
+    if (text.includes(query)) {
+      if (text === query) return 1;
+      if (text.startsWith(query)) return 0.9;
+      if (text.endsWith(query)) return 0.8;
+      
+      const queryLength = query.length;
+      const textLength = text.length;
+      return 0.5 + (queryLength / textLength) * 0.3;
+    }
+    
+    const words = query.split(/\s+/);
+    const matchedWords = words.filter(word => text.includes(word));
+    
+    if (matchedWords.length > 0) {
+      return (matchedWords.length / words.length) * 0.4;
+    }
+    
+    return 0;
+  }
+  
+  fuzzyMatch(text, query, threshold) {
+    const distance = this.levenshteinDistance(text, query);
+    const maxLength = Math.max(text.length, query.length);
+    const similarity = 1 - (distance / maxLength);
+    
+    return similarity >= threshold ? similarity : 0;
+  }
+  
+  levenshteinDistance(str1, str2) {
+    const matrix = [];
+    
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+    
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+    
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    
+    return matrix[str2.length][str1.length];
+  }
+  
+  getMatches(template, query, fields, caseSensitive) {
+    const matches = [];
+    const searchQuery = caseSensitive ? query : query.toLowerCase();
+    
+    for (const field of fields) {
+      const fieldValue = this.getFieldValue(template, field);
+      if (!fieldValue) continue;
+      
+      const text = caseSensitive ? fieldValue : fieldValue.toLowerCase();
+      
+      if (text.includes(searchQuery)) {
+        const startIndex = text.indexOf(searchQuery);
+        matches.push({
+          field,
+          value: fieldValue,
+          matchStart: startIndex,
+          matchEnd: startIndex + searchQuery.length,
+          matchText: fieldValue.substring(startIndex, startIndex + searchQuery.length)
+        });
+      }
+    }
+    
+    return matches;
+  }
+  
+  searchByName(query, options = {}) {
+    return this.search(query, { ...options, fields: ['name'] });
+  }
+  
+  searchByDescription(query, options = {}) {
+    return this.search(query, { ...options, fields: ['description'] });
+  }
+  
+  searchByTags(query, options = {}) {
+    return this.search(query, { ...options, fields: ['tags'] });
+  }
+  
+  searchByMultipleTerms(terms, options = {}) {
+    if (!Array.isArray(terms) || terms.length === 0) {
+      return new TemplateSearch(this.templates);
+    }
+    
+    const {
+      matchMode = 'any',
+      ...searchOptions
+    } = options;
+    
+    if (matchMode === 'all') {
+      let results = this.templates;
+      for (const term of terms) {
+        results = new TemplateSearch(results).search(term, searchOptions).getResults();
+      }
+      return new TemplateSearch(results);
+    } else {
+      const allResults = new Map();
+      
+      for (const term of terms) {
+        const termResults = this.search(term, searchOptions).getResults();
+        for (const result of termResults) {
+          const existingResult = allResults.get(result.id);
+          if (existingResult) {
+            existingResult._searchScore = Math.max(
+              existingResult._searchScore || 0,
+              result._searchScore || 0
+            );
+          } else {
+            allResults.set(result.id, result);
+          }
+        }
+      }
+      
+      const combinedResults = Array.from(allResults.values())
+        .sort((a, b) => (b._searchScore || 0) - (a._searchScore || 0));
+      
+      return new TemplateSearch(combinedResults);
+    }
+  }
+  
+  highlight(text, query, options = {}) {
+    if (!text || !query) return text;
+    
+    const {
+      caseSensitive = false,
+      highlightTag = 'mark',
+      className = 'search-highlight'
+    } = options;
+    
+    const searchText = caseSensitive ? text : text.toLowerCase();
+    const searchQuery = caseSensitive ? query : query.toLowerCase();
+    
+    if (!searchText.includes(searchQuery)) {
+      return text;
+    }
+    
+    const startTag = className 
+      ? `<${highlightTag} class="${className}">`
+      : `<${highlightTag}>`;
+    const endTag = `</${highlightTag}>`;
+    
+    const regex = new RegExp(
+      this.escapeRegExp(query),
+      caseSensitive ? 'g' : 'gi'
+    );
+    
+    return text.replace(regex, `${startTag}$&${endTag}`);
+  }
+  
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+  
+  getSuggestions(query, options = {}) {
+    const {
+      maxSuggestions = 5,
+      minLength = 2,
+      includePartialMatches = true
+    } = options;
+    
+    if (!query || query.length < minLength) {
+      return [];
+    }
+    
+    const suggestions = new Set();
+    const queryLower = query.toLowerCase();
+    
+    for (const template of this.templates) {
+      if (template.name && template.name.toLowerCase().startsWith(queryLower)) {
+        suggestions.add(template.name);
+      }
+      
+      if (template.tags && Array.isArray(template.tags)) {
+        for (const tag of template.tags) {
+          if (tag.toLowerCase().startsWith(queryLower)) {
+            suggestions.add(tag);
+          }
+        }
+      }
+      
+      if (includePartialMatches) {
+        if (template.description && template.description.toLowerCase().includes(queryLower)) {
+          const words = template.description.split(/\s+/);
+          for (const word of words) {
+            if (word.toLowerCase().startsWith(queryLower) && word.length >= minLength) {
+              suggestions.add(word);
+            }
+          }
+        }
+      }
+      
+      if (suggestions.size >= maxSuggestions) {
+        break;
+      }
+    }
+    
+    return Array.from(suggestions).slice(0, maxSuggestions);
+  }
+  
+  getResults() {
+    return [...this.templates];
+  }
+  
+  getCount() {
+    return this.templates.length;
+  }
+  
+  first() {
+    return this.templates.length > 0 ? this.templates[0] : null;
+  }
+  
+  isEmpty() {
+    return this.templates.length === 0;
+  }
+  
+  sortByRelevance() {
+    const sorted = [...this.templates].sort((a, b) => {
+      const scoreA = a._searchScore || 0;
+      const scoreB = b._searchScore || 0;
+      return scoreB - scoreA;
+    });
+    
+    return new TemplateSearch(sorted);
+  }
+  
+  static createFromCatalog(catalog) {
+    const templates = catalog?.agents || [];
+    return new TemplateSearch(templates);
+  }
+}
+
+module.exports = TemplateSearch;