@agentskillkit/agent-skills 1.0.1 → 3.2.2

package/.agent/scripts-js/autopilot-runner.js

@@ -0,0 +1,455 @@
+#!/usr/bin/env node
+/**
+ * Autopilot Runner with Full Integration
+ * 
+ * Central runner for /autopilot that integrates:
+ * - Pre-flight assessment (risk evaluation)
+ * - State management (checkpoints)
+ * - Adaptive workflow (optimization)
+ * - Metrics collection (tracking)
+ * - Learning (lessons)
+ * 
+ * Usage:
+ *   node autopilot-runner.js --task "build todo app" --domains frontend,backend
+ *   node autopilot-runner.js --status
+ *   node autopilot-runner.js --last
+ * 
+ * @version 1.0.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Import integrated modules
+import { AutopilotMetrics } from './autopilot-metrics.js';
+import { PreFlightAssessment, quickRiskCheck } from './preflight-assessment.js';
+import { AdaptiveWorkflow } from './adaptive-workflow.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Paths
+const RUN_LOG = path.join(__dirname, '..', 'knowledge', 'autopilot-runs.json');
+
+/**
+ * Autopilot Runner Class
+ */
+export class AutopilotRunner {
+    constructor(config = {}) {
+        this.task = config.task || '';
+        this.domains = config.domains || [];
+        this.files = config.files || [];
+        this.agents = config.agents || [];
+        this.complexity = config.complexity || 'standard';
+
+        this.metrics = null;
+        this.assessment = null;
+        this.optimization = null;
+        this.checkpointId = null;
+    }
+
+    /**
+     * Run full pre-flight checks
+     */
+    async preFlight() {
+        console.log('🛫 Running pre-flight checks...\n');
+
+        // 1. Risk Assessment
+        this.assessment = new PreFlightAssessment({
+            task: this.task,
+            domains: this.domains,
+            files: this.files,
+            agents: this.agents
+        }).evaluate();
+
+        console.log(`Risk Level: ${this.getRiskIcon(this.assessment.riskLevel)} ${this.assessment.riskLevel}`);
+        console.log(`Action: ${this.assessment.action}`);
+
+        // 2. Workflow Optimization
+        const workflow = new AdaptiveWorkflow({
+            steps: this.getDefaultSteps()
+        });
+
+        this.optimization = await workflow.optimize({
+            complexity: this.complexity,
+            domains: this.domains,
+            type: this.detectTaskType(),
+            files: this.files
+        });
+
+        console.log(`\nOptimization: ${this.optimization.original} → ${this.optimization.optimized} steps`);
+        console.log(`Time saved: ${this.optimization.estimatedTimeSaving.formatted}`);
+
+        // 3. Initialize Metrics
+        this.metrics = new AutopilotMetrics(null, {
+            task: this.task,
+            domains: this.domains,
+            complexity: this.complexity,
+            riskLevel: this.assessment.riskLevel
+        });
+
+        return {
+            assessment: this.assessment,
+            optimization: this.optimization,
+            requiresApproval: this.assessment.userApprovalRequired,
+            requiresCheckpoint: this.assessment.checkpointsRequired
+        };
+    }
+
+    /**
+     * Start execution with metrics tracking
+     */
+    startExecution() {
+        if (!this.metrics) {
+            throw new Error('Run preFlight() first');
+        }
+
+        this.metrics.start();
+        console.log(`\n🚀 Execution started: ${this.metrics.taskId}`);
+
+        return this.metrics.taskId;
+    }
+
+    /**
+     * Record phase completion
+     */
+    recordPhase(phaseName, durationMs, status, details = {}) {
+        if (!this.metrics) {
+            throw new Error('Execution not started');
+        }
+
+        this.metrics.recordPhase(phaseName, durationMs, status, details);
+
+        const icon = status === 'success' ? '✅' : status === 'error' ? '❌' : '⏳';
+        console.log(`${icon} Phase: ${phaseName} (${(durationMs / 1000).toFixed(1)}s)`);
+    }
+
+    /**
+     * Record error
+     */
+    recordError(error, wasAutoFixed = false) {
+        if (!this.metrics) return;
+
+        this.metrics.recordError(error, wasAutoFixed);
+
+        const icon = wasAutoFixed ? '🔧' : '❌';
+        console.log(`${icon} Error: ${error.message || error}`);
+    }
+
+    /**
+     * Record human intervention
+     */
+    recordIntervention(reason) {
+        if (!this.metrics) return;
+
+        this.metrics.recordIntervention(reason);
+        console.log(`👤 Intervention: ${reason}`);
+    }
+
+    /**
+     * Set checkpoint ID
+     */
+    setCheckpoint(checkpointId) {
+        this.checkpointId = checkpointId;
+        if (this.metrics) {
+            this.metrics.recordCheckpoint(checkpointId, this.files);
+        }
+        console.log(`📸 Checkpoint: ${checkpointId}`);
+    }
+
+    /**
+     * Finalize and get report
+     */
+    finalize() {
+        if (!this.metrics) {
+            throw new Error('Execution not started');
+        }
+
+        const report = this.metrics.finalize();
+
+        // Save run to log
+        this.saveRunLog(report);
+
+        // Generate formatted report
+        const formattedReport = this.formatReport(report);
+
+        return {
+            raw: report,
+            formatted: formattedReport
+        };
+    }
+
+    /**
+     * Get default workflow steps
+     */
+    getDefaultSteps() {
+        return [
+            'explorer-agent',
+            'design-system-generation',
+            'database-architect',
+            'security-auditor',
+            'backend-specialist',
+            'frontend-specialist',
+            'test-engineer',
+            'documentation-writer',
+            'security-audit',
+            'e2e-tests',
+            'staging-deploy'
+        ];
+    }
+
+    /**
+     * Detect task type from description
+     */
+    detectTaskType() {
+        const task = this.task.toLowerCase();
+        if (task.includes('refactor')) return 'refactor';
+        if (task.includes('fix') || task.includes('bug')) return 'fix';
+        if (task.includes('add') || task.includes('create') || task.includes('build')) return 'feature';
+        return 'feature';
+    }
+
+    /**
+     * Get risk level icon
+     */
+    getRiskIcon(level) {
+        return {
+            LOW: '✅',
+            MEDIUM: '⚠️',
+            HIGH: '🔶',
+            CRITICAL: '🔴'
+        }[level] || '❓';
+    }
+
+    /**
+     * Save run to log
+     */
+    saveRunLog(report) {
+        try {
+            let runs = [];
+            if (fs.existsSync(RUN_LOG)) {
+                runs = JSON.parse(fs.readFileSync(RUN_LOG, 'utf-8'));
+            }
+
+            runs.unshift({
+                taskId: report.taskId,
+                task: this.task,
+                timestamp: report.timestamp,
+                riskLevel: this.assessment?.riskLevel,
+                duration: report.metrics.totalDuration,
+                success: report.metrics.firstTimeSuccess,
+                interventions: report.metrics.humanInterventions
+            });
+
+            // Keep last 50 runs
+            if (runs.length > 50) {
+                runs = runs.slice(0, 50);
+            }
+
+            const dir = path.dirname(RUN_LOG);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            fs.writeFileSync(RUN_LOG, JSON.stringify(runs, null, 2));
+        } catch (error) {
+            console.error('Failed to save run log:', error.message);
+        }
+    }
+
+    /**
+     * Format final report
+     */
+    formatReport(report) {
+        const m = report.metrics;
+
+        return `
+## 🎼 Autopilot Execution Report
+
+**Task ID:** ${report.taskId}  
+**Task:** ${this.task}  
+**Duration:** ${(m.totalDuration / 1000).toFixed(1)}s
+
+### Pre-Flight Assessment
+
+| Dimension | Value |
+|-----------|-------|
+| Risk Level | ${this.assessment?.riskLevel || 'N/A'} |
+| Checkpoints | ${report.checkpoints.length} |
+| Optimization | ${this.optimization?.original || 0} → ${this.optimization?.optimized || 0} steps |
+
+### Execution Metrics
+
+| Metric | Value | Target | Status |
+|--------|-------|--------|--------|
+| Duration | ${(m.totalDuration / 1000).toFixed(1)}s | <300s | ${m.totalDuration < 300000 ? '✅' : '⚠️'} |
+| Interventions | ${m.humanInterventions} | 0 | ${m.humanInterventions === 0 ? '✅' : '⚠️'} |
+| First-Time Success | ${m.firstTimeSuccess ? 'Yes' : 'No'} | Yes | ${m.firstTimeSuccess ? '✅' : '❌'} |
+| Auto-Fix Rate | ${m.autoFixRate.toFixed(0)}% | >85% | ${m.autoFixRate >= 85 ? '✅' : '⚠️'} |
+| Phases | ${m.successfulPhases}/${m.totalPhases} | 100% | ${m.failedPhases === 0 ? '✅' : '❌'} |
+
+### Phase Breakdown
+
+| Phase | Duration | Status |
+|-------|----------|--------|
+${report.phases.map(p => `| ${p.name} | ${(p.duration / 1000).toFixed(1)}s | ${p.status === 'success' ? '✅' : '❌'} |`).join('\n')}
+
+${report.comparison?.hasBaseline ? `
+### Comparison to Baseline
+
+${this.formatComparison(report.comparison)}` : ''}
+`.trim();
+    }
+
+    /**
+     * Format comparison section
+     */
+    formatComparison(comparison) {
+        if (!comparison.hasBaseline) return '';
+
+        const c = comparison.changes;
+        const lines = [];
+
+        if (c.duration) {
+            const icon = c.duration.improved ? '🎉' : '';
+            lines.push(`- Duration: ${c.duration.baseline}ms → ${c.duration.current}ms (${c.duration.change}%) ${icon}`);
+        }
+
+        if (c.interventions) {
+            const icon = c.interventions.improved ? '🎉' : '';
+            lines.push(`- Interventions: ${c.interventions.baseline} → ${c.interventions.current} ${icon}`);
+        }
+
+        return lines.join('\n');
+    }
+}
+
+/**
+ * Show last run
+ */
+function showLastRun() {
+    if (!fs.existsSync(RUN_LOG)) {
+        console.log('No runs recorded yet.');
+        return;
+    }
+
+    const runs = JSON.parse(fs.readFileSync(RUN_LOG, 'utf-8'));
+    if (runs.length === 0) {
+        console.log('No runs recorded yet.');
+        return;
+    }
+
+    const last = runs[0];
+    console.log(`
+Last Autopilot Run
+==================
+Task ID: ${last.taskId}
+Task: ${last.task}
+Timestamp: ${last.timestamp}
+Risk Level: ${last.riskLevel}
+Duration: ${(last.duration / 1000).toFixed(1)}s
+Success: ${last.success ? 'Yes' : 'No'}
+Interventions: ${last.interventions}
+`);
+}
+
+/**
+ * Show run status
+ */
+function showStatus() {
+    if (!fs.existsSync(RUN_LOG)) {
+        console.log('No runs recorded yet.');
+        return;
+    }
+
+    const runs = JSON.parse(fs.readFileSync(RUN_LOG, 'utf-8'));
+
+    console.log(`
+Autopilot Status
+================
+Total Runs: ${runs.length}
+Successful: ${runs.filter(r => r.success).length}
+Failed: ${runs.filter(r => !r.success).length}
+Avg Duration: ${(runs.reduce((s, r) => s + r.duration, 0) / runs.length / 1000).toFixed(1)}s
+Avg Interventions: ${(runs.reduce((s, r) => s + r.interventions, 0) / runs.length).toFixed(1)}
+`);
+}
+
+/**
+ * CLI
+ */
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.includes('--status')) {
+        showStatus();
+        return;
+    }
+
+    if (args.includes('--last')) {
+        showLastRun();
+        return;
+    }
+
+    if (args.includes('--task')) {
+        const taskIdx = args.indexOf('--task');
+        const task = args[taskIdx + 1];
+
+        const domainsIdx = args.indexOf('--domains');
+        const domains = domainsIdx >= 0 ? args[domainsIdx + 1].split(',') : ['frontend'];
+
+        // Demo execution
+        const runner = new AutopilotRunner({
+            task,
+            domains,
+            complexity: 'standard'
+        });
+
+        // Pre-flight
+        const preflight = await runner.preFlight();
+
+        if (preflight.requiresApproval) {
+            console.log('\n🔴 CRITICAL risk - would require explicit approval');
+            return;
+        }
+
+        // Start
+        runner.startExecution();
+
+        // Simulate phases
+        const phases = ['planning', 'setup', 'execution', 'verification'];
+        for (const phase of phases) {
+            await new Promise(r => setTimeout(r, 100));
+            runner.recordPhase(phase, 100 + Math.random() * 200, 'success');
+        }
+
+        // Finalize
+        const result = runner.finalize();
+        console.log('\n' + result.formatted);
+        return;
+    }
+
+    console.log(`
+Autopilot Runner with Full Integration
+
+Usage:
+  node autopilot-runner.js --task "your task" --domains frontend,backend
+  node autopilot-runner.js --status
+  node autopilot-runner.js --last
+
+Programmatic usage:
+  import { AutopilotRunner } from './autopilot-runner.js';
+  
+  const runner = new AutopilotRunner({ task, domains, complexity });
+  await runner.preFlight();
+  runner.startExecution();
+  runner.recordPhase('phase-name', durationMs, 'success');
+  const report = runner.finalize();
+`);
+}
+
+// Run if executed directly
+if (process.argv[1] === __filename) {
+    main().catch(console.error);
+}

package/.agent/scripts-js/batch-skill-update.cjs

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * Batch Skill Frontmatter Updater
+ * Adds trigger phrases, categories, and metrics to skills missing them
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const skillsDir = path.join(__dirname, '..', 'skills');
+
+// Skills to update with their metadata
+const skillUpdates = {
+  'agent-modes': {
+    description: 'AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task context.',
+    triggers: 'mode, brainstorm, implement, debug, review, teach, ship',
+    category: 'core',
+    metrics: 'correct mode selected, behavior adapted',
+    coordinates: 'smart-router, context-optimizer'
+  },
+  'debug-pro': {
+    description: 'Advanced debugging techniques and root cause analysis.',
+    triggers: 'debug, bug, error, crash, exception, root cause',
+    category: 'core',
+    metrics: 'bug fixed, root cause identified',
+    coordinates: 'debug-toolkit, test-architect'
+  },
+  'diagram-kit': {
+    description: 'Create diagrams and visualizations using Mermaid, PlantUML, and other tools.',
+    triggers: 'diagram, mermaid, flowchart, sequence diagram, architecture diagram',
+    category: 'specialized',
+    metrics: 'diagram generated, syntax valid',
+    coordinates: 'doc-processor, system-design'
+  },
+  'doc-templates': {
+    description: 'Documentation templates for README, API docs, and project documentation.',
+    triggers: 'template, README, documentation, API docs',
+    category: 'specialized',
+    metrics: 'template applied, documentation complete',
+    coordinates: 'doc-processor, project-planner'
+  },
+  'game-engine': {
+    description: 'Game development patterns for web and mobile games.',
+    triggers: 'game, Unity, Godot, Phaser, game engine, 2D, 3D',
+    category: 'framework',
+    metrics: 'game runs, no crashes',
+    coordinates: 'perf-optimizer, mobile-first'
+  },
+  'geo-spatial': {
+    description: 'Geographic and spatial data processing, mapping, and location services.',
+    triggers: 'map, GPS, geolocation, spatial, coordinates, GeoJSON',
+    category: 'specialized',
+    metrics: 'location accurate, map renders',
+    coordinates: 'data-modeler, api-architect'
+  },
+  'globalization-kit': {
+    description: 'Internationalization (i18n) and localization (l10n) implementation.',
+    triggers: 'i18n, l10n, translation, localization, internationalization, language',
+    category: 'specialized',
+    metrics: 'translations complete, RTL handled',
+    coordinates: 'web-core, mobile-first'
+  },
+  'mcp-server': {
+    description: 'Model Context Protocol server integration and development.',
+    triggers: 'MCP, Model Context Protocol, server, integration',
+    category: 'framework',
+    metrics: 'MCP server running, tools connected',
+    coordinates: 'api-architect, context-optimizer'
+  },
+  'mobile-first': {
+    description: 'Mobile-first design and development patterns for responsive UI.',
+    triggers: 'mobile, responsive, touch, React Native, Flutter',
+    category: 'framework',
+    metrics: 'mobile audit passed, responsive design',
+    coordinates: 'design-system, perf-optimizer'
+  },
+  'nextjs-pro': {
+    description: 'Advanced Next.js patterns including App Router, RSC, and server actions.',
+    triggers: 'Next.js, App Router, RSC, server actions, SSR, SSG',
+    category: 'framework',
+    metrics: 'build passes, pages render',
+    coordinates: 'web-core, react-architect'
+  },
+  'nodejs-pro': {
+    description: 'Node.js best practices, patterns, and performance optimization.',
+    triggers: 'Node.js, Express, backend, server, API',
+    category: 'framework',
+    metrics: 'server runs, no memory leaks',
+    coordinates: 'api-architect, data-modeler'
+  },
+  'offensive-sec': {
+    description: 'Penetration testing and offensive security techniques.',
+    triggers: 'pentest, red team, exploit, vulnerability, hacking',
+    category: 'devops',
+    metrics: 'vulnerabilities found, report complete',
+    coordinates: 'security-scanner, code-review'
+  },
+  'python-pro': {
+    description: 'Python best practices, patterns, and tooling.',
+    triggers: 'Python, pip, FastAPI, Django, Flask',
+    category: 'framework',
+    metrics: 'tests pass, type hints complete',
+    coordinates: 'test-architect, api-architect'
+  },
+  'react-architect': {
+    description: 'React architecture patterns, component design, and state management.',
+    triggers: 'React, component, hooks, state management, Redux, Zustand',
+    category: 'architecture',
+    metrics: 'components render, no prop drilling',
+    coordinates: 'web-core, design-system'
+  },
+  'seo-optimizer': {
+    description: 'SEO optimization for web applications.',
+    triggers: 'SEO, meta tags, sitemap, search ranking, OpenGraph',
+    category: 'specialized',
+    metrics: 'SEO score improved, meta tags complete',
+    coordinates: 'web-core, perf-optimizer'
+  },
+  'server-ops': {
+    description: 'Server operations, deployment, and infrastructure management.',
+    triggers: 'server, DevOps, infrastructure, deployment, hosting',
+    category: 'devops',
+    metrics: 'server running, uptime maintained',
+    coordinates: 'cicd-pipeline, security-scanner'
+  },
+  'shell-script': {
+    description: 'Shell scripting patterns for automation and DevOps.',
+    triggers: 'shell, bash, script, automation, CLI',
+    category: 'framework',
+    metrics: 'script runs, no errors',
+    coordinates: 'cicd-pipeline, server-ops'
+  },
+  'system-design': {
+    description: 'System architecture and design patterns for scalable applications.',
+    triggers: 'architecture, system design, scalability, microservices',
+    category: 'architecture',
+    metrics: 'architecture documented, scalability validated',
+    coordinates: 'api-architect, data-modeler'
+  },
+  'tailwind-kit': {
+    description: 'Tailwind CSS patterns, utilities, and component styling.',
+    triggers: 'Tailwind, CSS, styling, utility classes',
+    category: 'architecture',
+    metrics: 'styles applied, design consistent',
+    coordinates: 'design-system, web-core'
+  },
+  'test-driven-dev': {
+    description: 'Test-driven development methodology and practices.',
+    triggers: 'TDD, test first, red-green-refactor',
+    category: 'testing',
+    metrics: 'tests written before code, coverage high',
+    coordinates: 'test-architect, code-craft'
+  },
+  'visual-excellence': {
+    description: 'Visual design excellence and aesthetic quality standards.',
+    triggers: 'visual, aesthetic, design quality, polish',
+    category: 'architecture',
+    metrics: 'design polished, visual consistency',
+    coordinates: 'design-system, tailwind-kit'
+  }
+};
+
+function updateSkill(skillName, updates) {
+  const skillPath = path.join(skillsDir, skillName, 'SKILL.md');
+  
+  if (!fs.existsSync(skillPath)) {
+    console.log(`Skip: ${skillName} (no SKILL.md)`);
+    return false;
+  }
+
+  let content = fs.readFileSync(skillPath, 'utf-8');
+  
+  // Check if already has triggers
+  if (content.includes('Triggers on:')) {
+    console.log(`Skip: ${skillName} (already has triggers)`);
+    return false;
+  }
+
+  // Find and update the frontmatter
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    console.log(`Error: ${skillName} (no frontmatter)`);
+    return false;
+  }
+
+  const frontmatter = frontmatterMatch[1];
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  
+  if (!descMatch) {
+    console.log(`Error: ${skillName} (no description)`);
+    return false;
+  }
+
+  // Build new description
+  const newDesc = `description: >-
+  ${updates.description}
+  Triggers on: ${updates.triggers}.
+  Coordinates with: ${updates.coordinates}.`;
+
+  // Build new metadata
+  const newMetadata = `metadata:
+  category: "${updates.category}"
+  success_metrics: "${updates.metrics}"
+  coordinates_with: "${updates.coordinates}"`;
+
+  // Replace description line
+  let newContent = content.replace(
+    /description:\s*.+(\n|$)/,
+    newDesc + '\n'
+  );
+
+  // Add or update metadata
+  if (newContent.includes('metadata:')) {
+    // Has existing metadata - replace
+    newContent = newContent.replace(
+      /metadata:\n(  .+\n)*/,
+      newMetadata + '\n'
+    );
+  } else {
+    // No metadata - add before ---
+    newContent = newContent.replace(
+      /\n---\n/,
+      '\n' + newMetadata + '\n---\n'
+    );
+  }
+
+  fs.writeFileSync(skillPath, newContent);
+  console.log(`Updated: ${skillName}`);
+  return true;
+}
+
+// Main execution
+console.log('Batch Skill Update Script');
+console.log('='.repeat(40));
+
+let updated = 0;
+let skipped = 0;
+
+for (const [skillName, updates] of Object.entries(skillUpdates)) {
+  if (updateSkill(skillName, updates)) {
+    updated++;
+  } else {
+    skipped++;
+  }
+}
+
+console.log('='.repeat(40));
+console.log(`Updated: ${updated}, Skipped: ${skipped}`);