claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-skill-management/src/cli/skill-loader.ts

@@ -0,0 +1,364 @@
+/**
+ * CFN Skill Loader
+ * High-performance contextual skill loading with LRU caching and SHA256 validation
+ */
+
+import { createHash } from 'crypto';
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import type { DatabaseService } from '../lib/database-service.js';
+import type { Logger } from '../../lib/propagation/src/types.js';
+
+export interface SkillLoadOptions {
+  agentType: string;
+  taskContext: string[];
+  maxSkills?: number;
+  includeBootstrap?: boolean;
+  phase?: 'loop1' | 'loop2' | 'loop3';
+  cacheKey?: string;
+}
+
+export interface SkillLoadResult {
+  skills: Array<{
+    name: string;
+    content: string;
+    metadata: SkillMetadata;
+    hash: string;
+  }>;
+  totalSkills: number;
+  loadTimeMs: number;
+  cacheHitCount: number;
+  cacheMissCount: number;
+  skippedCount: number;
+}
+
+export interface SkillMetadata {
+  name: string;
+  description: string;
+  version: string;
+  tags: string[];
+  status: 'active' | 'deprecated' | 'experimental';
+  namespace?: string;
+  priority?: number;
+  dependencies?: string[];
+  agentTypes?: string[];
+  phases?: string[];
+  lastModified: string;
+  contentHash?: string;
+  size: number;
+}
+
+export interface CacheEntry {
+  skill: any;
+  hash: string;
+  lastAccessed: number;
+  loadCount: number;
+}
+
+export class SkillLoader {
+  private cache = new Map<string, CacheEntry>();
+  private readonly maxCacheSize = 100;
+  private readonly skillsPath = '.claude/skills';
+
+  constructor(
+    private db: DatabaseService,
+    private logger: Logger
+  ) {}
+
+  /**
+   * Load skills based on agent type and task context
+   */
+  async loadContextualSkills(options: SkillLoadOptions): Promise<SkillLoadResult> {
+    const startTime = Date.now();
+    const result: SkillLoadResult = {
+      skills: [],
+      totalSkills: 0,
+      loadTimeMs: 0,
+      cacheHitCount: 0,
+      cacheMissCount: 0,
+      skippedCount: 0
+    };
+
+    try {
+      // Get available skills from database
+      const availableSkills = await this.db.getSkillsForAgent(options.agentType);
+      result.totalSkills = availableSkills.length;
+
+      // Filter and load relevant skills
+      for (const skillMeta of availableSkills) {
+        // Check relevance based on task context and phase
+        if (!this.isSkillRelevant(skillMeta, options)) {
+          result.skippedCount++;
+          continue;
+        }
+
+        // Try cache first
+        const cacheKey = `${skillMeta.name}:${skillMeta.version}`;
+        const cached = this.cache.get(cacheKey);
+
+        if (cached && this.validateSkillHash(skillMeta, cached.hash)) {
+          result.skills.push(cached.skill);
+          result.cacheHitCount++;
+          this.updateCacheAccess(cacheKey);
+        } else {
+          // Load from disk
+          const skill = await this.loadSkillFromDisk(skillMeta);
+          if (skill) {
+            result.skills.push(skill);
+            result.cacheMissCount++;
+            this.cache.set(cacheKey, {
+              skill,
+              hash: skill.hash,
+              lastAccessed: Date.now(),
+              loadCount: 1
+            });
+          }
+        }
+
+        // Respect maxSkills limit
+        if (options.maxSkills && result.skills.length >= options.maxSkills) {
+          break;
+        }
+      }
+
+      // Clean up old cache entries
+      this.cleanupCache();
+
+      result.loadTimeMs = Date.now() - startTime;
+      this.logger.debug(`Loaded ${result.skills.length} skills for ${options.agentType} in ${result.loadTimeMs}ms`);
+
+      return result;
+    } catch (error) {
+      this.logger.error('Failed to load contextual skills', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load a specific skill by name
+   */
+  async loadSkillByName(skillName: string): Promise<any | null> {
+    try {
+      const skillMeta = await this.db.getSkillByName(skillName);
+      if (!skillMeta) {
+        return null;
+      }
+
+      const cacheKey = `${skillMeta.name}:${skillMeta.version}`;
+      const cached = this.cache.get(cacheKey);
+
+      if (cached && this.validateSkillHash(skillMeta, cached.hash)) {
+        this.updateCacheAccess(cacheKey);
+        return cached.skill;
+      }
+
+      const skill = await this.loadSkillFromDisk(skillMeta);
+      if (skill) {
+        this.cache.set(cacheKey, {
+          skill,
+          hash: skill.hash,
+          lastAccessed: Date.now(),
+          loadCount: 1
+        });
+      }
+
+      return skill;
+    } catch (error) {
+      this.logger.error(`Failed to load skill: ${skillName}`, error as Error);
+      return null;
+    }
+  }
+
+  /**
+   * Validate skill content integrity using SHA256 hash
+   */
+  validateSkillHash(metadata: SkillMetadata, expectedHash: string): boolean {
+    try {
+      if (!metadata.contentHash) {
+        return false;
+      }
+      return metadata.contentHash === expectedHash;
+    } catch (error) {
+      this.logger.warn(`Hash validation failed for ${metadata.name}`, error as Error);
+      return false;
+    }
+  }
+
+  /**
+   * Clear the skill cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+    this.logger.debug('Skill cache cleared');
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxCacheSize,
+      entries: Array.from(this.cache.entries()).map(([key, entry]) => ({
+        key,
+        loadCount: entry.loadCount,
+        lastAccessed: entry.lastAccessed
+      }))
+    };
+  }
+
+  private isSkillRelevant(skill: SkillMetadata, options: SkillLoadOptions): boolean {
+    // Check agent type compatibility
+    if (skill.agentTypes && !skill.agentTypes.includes(options.agentType)) {
+      return false;
+    }
+
+    // Check phase compatibility
+    if (options.phase && skill.phases && !skill.phases.includes(options.phase)) {
+      return false;
+    }
+
+    // Check task context relevance
+    if (options.taskContext.length > 0 && skill.tags.length > 0) {
+      const hasRelevantTag = skill.tags.some(tag =>
+        options.taskContext.some(context =>
+          context.toLowerCase().includes(tag.toLowerCase()) ||
+          tag.toLowerCase().includes(context.toLowerCase())
+        )
+      );
+      if (!hasRelevantTag) {
+        return false;
+      }
+    }
+
+    // Check status
+    if (skill.status === 'deprecated' && !options.includeBootstrap) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private async loadSkillFromDisk(metadata: SkillMetadata): Promise<any | null> {
+    try {
+      const skillPath = this.findSkillPath(metadata.name);
+      if (!skillPath || !existsSync(skillPath)) {
+        this.logger.warn(`Skill file not found: ${metadata.name}`);
+        return null;
+      }
+
+      const content = readFileSync(skillPath, 'utf8');
+      const hash = this.calculateHash(content);
+
+      // Extract skill content from markdown
+      const skillContent = this.extractSkillContent(content);
+
+      return {
+        name: metadata.name,
+        content: skillContent,
+        metadata,
+        hash
+      };
+    } catch (error) {
+      this.logger.error(`Failed to load skill from disk: ${metadata.name}`, error as Error);
+      return null;
+    }
+  }
+
+  private findSkillPath(skillName: string): string | null {
+    const possiblePaths = [
+      join(this.skillsPath, skillName, 'SKILL.md'),
+      join(this.skillsPath, `cfn-${skillName}`, 'SKILL.md'),
+      join(this.skillsPath, skillName + '.md'),
+      join(this.skillsPath, `cfn-${skillName}.md`)
+    ];
+
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return path;
+      }
+    }
+
+    return null;
+  }
+
+  private extractSkillContent(markdownContent: string): string {
+    // Remove frontmatter
+    const withoutFrontmatter = markdownContent.replace(/^---\n.*?\n---\n/s, '');
+
+    // Extract only the main content, remove metadata sections
+    const lines = withoutFrontmatter.split('\n');
+    const contentLines: string[] = [];
+    let skipSection = false;
+
+    for (const line of lines) {
+      // Skip common metadata sections
+      if (line.startsWith('## ') && (
+        line.includes('Version History') ||
+        line.includes('Dependencies') ||
+        line.includes('Related Skills') ||
+        line.includes('Tags')
+      )) {
+        skipSection = true;
+        continue;
+      }
+
+      if (skipSection && line.startsWith('## ')) {
+        skipSection = false;
+      }
+
+      if (!skipSection) {
+        contentLines.push(line);
+      }
+    }
+
+    return contentLines.join('\n').trim();
+  }
+
+  private calculateHash(content: string): string {
+    return createHash('sha256').update(content).digest('hex');
+  }
+
+  private updateCacheAccess(key: string): void {
+    const entry = this.cache.get(key);
+    if (entry) {
+      entry.lastAccessed = Date.now();
+      entry.loadCount++;
+    }
+  }
+
+  private cleanupCache(): void {
+    if (this.cache.size <= this.maxCacheSize) {
+      return;
+    }
+
+    // Sort by last accessed time (LRU)
+    const entries = Array.from(this.cache.entries())
+      .sort(([, a], [, b]) => a.lastAccessed - b.lastAccessed);
+
+    // Remove oldest entries
+    const toRemove = entries.slice(0, entries.length - this.maxCacheSize);
+    for (const [key] of toRemove) {
+      this.cache.delete(key);
+    }
+
+    this.logger.debug(`Cache cleanup: removed ${toRemove.length} entries`);
+  }
+}
+
+// Global instance for convenience
+let globalLoader: SkillLoader | null = null;
+
+export function getGlobalLoader(db?: DatabaseService, logger?: Logger): SkillLoader {
+  if (!globalLoader) {
+    if (!db || !logger) {
+      throw new Error('Database service and logger required for first-time initialization');
+    }
+    globalLoader = new SkillLoader(db, logger);
+  }
+  return globalLoader;
+}
+
+export function resetGlobalLoader(): void {
+  globalLoader = null;
+}

package/.claude/skills/cfn-skill-management/src/lib/database-service.ts

@@ -0,0 +1,313 @@
+/**
+ * CFN Database Service
+ * Provides database operations for skill management
+ */
+
+import { Database } from 'sqlite3';
+import { open } from 'sqlite';
+import type { Logger } from '../propagation/src/types.js';
+
+export interface SkillRecord {
+  id: number;
+  name: string;
+  version: string;
+  namespace?: string;
+  description: string;
+  status: 'active' | 'deprecated' | 'experimental';
+  tags: string;
+  agent_types?: string;
+  phases?: string;
+  priority?: number;
+  dependencies?: string;
+  content_hash?: string;
+  file_path: string;
+  file_size: number;
+  last_modified: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SkillFilter {
+  agentType?: string;
+  phase?: string;
+  tags?: string[];
+  status?: string;
+  namespace?: string;
+}
+
+export class DatabaseService {
+  private db: any = null;
+  private initialized = false;
+
+  constructor(
+    private dbPath: string,
+    private logger: Logger
+  ) {}
+
+  /**
+   * Initialize database connection and create tables if needed
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      this.db = await open({
+        filename: this.dbPath,
+        driver: Database
+      });
+
+      await this.createTables();
+      this.initialized = true;
+      this.logger.info(`Database initialized: ${this.dbPath}`);
+    } catch (error) {
+      this.logger.error('Failed to initialize database', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Close database connection
+   */
+  async close(): Promise<void> {
+    if (this.db) {
+      await this.db.close();
+      this.db = null;
+      this.initialized = false;
+      this.logger.info('Database connection closed');
+    }
+  }
+
+  /**
+   * Get all skills suitable for a specific agent type
+   */
+  async getSkillsForAgent(agentType: string, filters?: SkillFilter): Promise<SkillRecord[]> {
+    await this.ensureInitialized();
+
+    try {
+      let query = `
+        SELECT * FROM skills
+        WHERE status = 'active'
+        AND (agent_types IS NULL OR agent_types LIKE '%' || ? || '%')
+      `;
+      const params: any[] = [agentType];
+
+      if (filters?.phase) {
+        query += ` AND (phases IS NULL OR phases LIKE '%' || ? || '%')`;
+        params.push(filters.phase);
+      }
+
+      if (filters?.tags && filters.tags.length > 0) {
+        const tagConditions = filters.tags.map(() => `tags LIKE '%' || ? || '%'`).join(' OR ');
+        query += ` AND (${tagConditions})`;
+        params.push(...filters.tags);
+      }
+
+      if (filters?.namespace) {
+        query += ` AND namespace = ?`;
+        params.push(filters.namespace);
+      }
+
+      query += ` ORDER BY priority DESC, name ASC`;
+
+      const skills = await this.db.all(query, params);
+      return skills.map(this.mapRowToSkill);
+    } catch (error) {
+      this.logger.error(`Failed to get skills for agent: ${agentType}`, error as Error);
+      return [];
+    }
+  }
+
+  /**
+   * Get a specific skill by name
+   */
+  async getSkillByName(name: string): Promise<SkillRecord | null> {
+    await this.ensureInitialized();
+
+    try {
+      const row = await this.db.get(
+        'SELECT * FROM skills WHERE name = ? ORDER BY version DESC LIMIT 1',
+        [name]
+      );
+
+      return row ? this.mapRowToSkill(row) : null;
+    } catch (error) {
+      this.logger.error(`Failed to get skill by name: ${name}`, error as Error);
+      return null;
+    }
+  }
+
+  /**
+   * Update or insert a skill record
+   */
+  async upsertSkill(skill: Partial<SkillRecord>): Promise<void> {
+    await this.ensureInitialized();
+
+    try {
+      const existing = await this.db.get(
+        'SELECT id FROM skills WHERE name = ? AND version = ?',
+        [skill.name, skill.version]
+      );
+
+      if (existing) {
+        await this.db.run(`
+          UPDATE skills SET
+            description = ?, status = ?, tags = ?, agent_types = ?, phases = ?,
+            priority = ?, dependencies = ?, content_hash = ?, file_path = ?,
+            file_size = ?, last_modified = ?, updated_at = datetime('now')
+          WHERE name = ? AND version = ?
+        `, [
+          skill.description, skill.status, skill.tags, skill.agent_types, skill.phases,
+          skill.priority, skill.dependencies, skill.content_hash, skill.file_path,
+          skill.file_size, skill.last_modified, skill.name, skill.version
+        ]);
+      } else {
+        await this.db.run(`
+          INSERT INTO skills (
+            name, version, namespace, description, status, tags, agent_types, phases,
+            priority, dependencies, content_hash, file_path, file_size, last_modified,
+            created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+        `, [
+          skill.name, skill.version, skill.namespace, skill.description, skill.status,
+          skill.tags, skill.agent_types, skill.phases, skill.priority, skill.dependencies,
+          skill.content_hash, skill.file_path, skill.file_size, skill.last_modified
+        ]);
+      }
+
+      this.logger.debug(`Skill upserted: ${skill.name} v${skill.version}`);
+    } catch (error) {
+      this.logger.error(`Failed to upsert skill: ${skill.name}`, error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a skill by name and version
+   */
+  async deleteSkill(name: string, version?: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    try {
+      let query = 'DELETE FROM skills WHERE name = ?';
+      const params: any[] = [name];
+
+      if (version) {
+        query += ' AND version = ?';
+        params.push(version);
+      }
+
+      const result = await this.db.run(query, params);
+      const deleted = result.changes > 0;
+
+      if (deleted) {
+        this.logger.debug(`Skill deleted: ${name}${version ? ` v${version}` : ''}`);
+      }
+
+      return deleted;
+    } catch (error) {
+      this.logger.error(`Failed to delete skill: ${name}`, error as Error);
+      return false;
+    }
+  }
+
+  /**
+   * Get skill statistics
+   */
+  async getStatistics(): Promise<{
+    totalSkills: number;
+    activeSkills: number;
+    deprecatedSkills: number;
+    experimentalSkills: number;
+    namespaces: string[];
+  }> {
+    await this.ensureInitialized();
+
+    try {
+      const [total, active, deprecated, experimental, namespaces] = await Promise.all([
+        this.db.get('SELECT COUNT(*) as count FROM skills'),
+        this.db.get('SELECT COUNT(*) as count FROM skills WHERE status = ?', ['active']),
+        this.db.get('SELECT COUNT(*) as count FROM skills WHERE status = ?', ['deprecated']),
+        this.db.get('SELECT COUNT(*) as count FROM skills WHERE status = ?', ['experimental']),
+        this.db.all('SELECT DISTINCT namespace FROM skills WHERE namespace IS NOT NULL')
+      ]);
+
+      return {
+        totalSkills: total.count,
+        activeSkills: active.count,
+        deprecatedSkills: deprecated.count,
+        experimentalSkills: experimental.count,
+        namespaces: namespaces.map((row: any) => row.namespace)
+      };
+    } catch (error) {
+      this.logger.error('Failed to get statistics', error as Error);
+      return {
+        totalSkills: 0,
+        activeSkills: 0,
+        deprecatedSkills: 0,
+        experimentalSkills: 0,
+        namespaces: []
+      };
+    }
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  private async createTables(): Promise<void> {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS skills (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        version TEXT NOT NULL,
+        namespace TEXT,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        tags TEXT,
+        agent_types TEXT,
+        phases TEXT,
+        priority INTEGER DEFAULT 0,
+        dependencies TEXT,
+        content_hash TEXT,
+        file_path TEXT,
+        file_size INTEGER,
+        last_modified TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(name, version)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
+      CREATE INDEX IF NOT EXISTS idx_skills_status ON skills(status);
+      CREATE INDEX IF NOT EXISTS idx_skills_namespace ON skills(namespace);
+      CREATE INDEX IF NOT EXISTS idx_skills_agent_types ON skills(agent_types);
+      CREATE INDEX IF NOT EXISTS idx_skills_priority ON skills(priority);
+    `);
+  }
+
+  private mapRowToSkill(row: any): SkillRecord {
+    return {
+      id: row.id,
+      name: row.name,
+      version: row.version,
+      namespace: row.namespace,
+      description: row.description,
+      status: row.status,
+      tags: row.tags || '',
+      agent_types: row.agent_types,
+      phases: row.phases,
+      priority: row.priority,
+      dependencies: row.dependencies,
+      content_hash: row.content_hash,
+      file_path: row.file_path,
+      file_size: row.file_size,
+      last_modified: row.last_modified,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+}