@agentskillkit/agent-skills 1.0.1 → 3.2.2

package/.agent/scripts-js/preflight-assessment.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+/**
+ * Pre-Flight Assessment Module
+ * 
+ * Integrates with impact-assessor agent for risk evaluation before execution.
+ * Used by /autopilot and other multi-phase workflows.
+ * 
+ * Usage:
+ *   import { PreFlightAssessment } from './preflight-assessment.js';
+ *   const assessment = new PreFlightAssessment(taskContext);
+ *   const result = await assessment.evaluate();
+ *   if (result.riskLevel === 'CRITICAL') { requireApproval(); }
+ * 
+ * @version 1.0.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Risk level thresholds
+const RISK_LEVELS = {
+    LOW: { min: 1.0, max: 2.0, action: 'PROCEED' },
+    MEDIUM: { min: 2.1, max: 3.5, action: 'PROCEED_WITH_CAUTION' },
+    HIGH: { min: 3.6, max: 4.5, action: 'EXTRA_CHECKPOINTS' },
+    CRITICAL: { min: 4.6, max: 5.0, action: 'REQUIRE_APPROVAL' }
+};
+
+// Trigger patterns that require assessment
+const ASSESSMENT_TRIGGERS = [
+    { pattern: /database|schema|migration|prisma/i, risk: 'CRITICAL', reason: 'Database changes' },
+    { pattern: /auth|login|password|jwt|token|security/i, risk: 'CRITICAL', reason: 'Auth system' },
+    { pattern: /api|endpoint|route/i, risk: 'HIGH', reason: 'API contract change' },
+    { pattern: /deploy|production|release/i, risk: 'HIGH', reason: 'Production deployment' },
+    { pattern: /refactor|restructure|reorganize/i, risk: 'MEDIUM', reason: 'Code restructuring' },
+    { pattern: /dependency|package|npm|upgrade/i, risk: 'MEDIUM', reason: 'Dependency changes' },
+    { pattern: /config|environment|env/i, risk: 'MEDIUM', reason: 'Configuration changes' }
+];
+
+/**
+ * Pre-Flight Assessment Class
+ */
+export class PreFlightAssessment {
+    constructor(taskContext) {
+        this.task = taskContext.task || '';
+        this.domains = taskContext.domains || [];
+        this.files = taskContext.files || [];
+        this.agents = taskContext.agents || [];
+        this.timestamp = Date.now();
+    }
+
+    /**
+     * Evaluate risk based on task context
+     */
+    evaluate() {
+        const triggers = this.detectTriggers();
+        const fileRisk = this.assessFileRisk();
+        const domainRisk = this.assessDomainRisk();
+
+        const overallScore = this.calculateOverallRisk(triggers, fileRisk, domainRisk);
+        const riskLevel = this.scoreToLevel(overallScore);
+
+        return {
+            timestamp: new Date().toISOString(),
+            task: this.task,
+
+            // Risk analysis
+            riskLevel,
+            riskScore: overallScore,
+            action: RISK_LEVELS[riskLevel].action,
+
+            // Triggers found
+            triggers: triggers.map(t => ({
+                pattern: t.reason,
+                risk: t.risk
+            })),
+
+            // Impact scope
+            impactScope: {
+                filesAffected: this.files.length,
+                domainsAffected: this.domains.length,
+                agentsInvolved: this.agents.length
+            },
+
+            // Recommendations
+            recommendations: this.generateRecommendations(riskLevel, triggers),
+
+            // Checkpoints required
+            checkpointsRequired: riskLevel === 'HIGH' || riskLevel === 'CRITICAL',
+
+            // User approval required
+            userApprovalRequired: riskLevel === 'CRITICAL'
+        };
+    }
+
+    /**
+     * Detect triggers from task description
+     */
+    detectTriggers() {
+        const found = [];
+        for (const trigger of ASSESSMENT_TRIGGERS) {
+            if (trigger.pattern.test(this.task)) {
+                found.push(trigger);
+            }
+        }
+        return found;
+    }
+
+    /**
+     * Assess risk based on file count
+     */
+    assessFileRisk() {
+        const count = this.files.length;
+        if (count > 20) return 5;
+        if (count > 10) return 4;
+        if (count > 5) return 3;
+        if (count > 2) return 2;
+        return 1;
+    }
+
+    /**
+     * Assess risk based on domains involved
+     */
+    assessDomainRisk() {
+        const criticalDomains = ['database', 'security', 'auth', 'payment'];
+        const hasCritical = this.domains.some(d =>
+            criticalDomains.some(cd => d.toLowerCase().includes(cd))
+        );
+
+        if (hasCritical) return 5;
+        if (this.domains.length > 3) return 4;
+        if (this.domains.length > 1) return 2;
+        return 1;
+    }
+
+    /**
+     * Calculate overall risk score
+     */
+    calculateOverallRisk(triggers, fileRisk, domainRisk) {
+        // If critical/high triggers detected, they dominate the score
+        if (triggers.length > 0) {
+            const hasCritical = triggers.some(t => t.risk === 'CRITICAL');
+            const hasHigh = triggers.some(t => t.risk === 'HIGH');
+            const hasMedium = triggers.some(t => t.risk === 'MEDIUM');
+
+            if (hasCritical) return 5.0;  // CRITICAL
+            if (hasHigh) return 4.0;      // HIGH
+            if (hasMedium) return 3.0;    // MEDIUM
+        }
+
+        // No triggers detected - use file and domain risk
+        const combinedRisk = (fileRisk * 0.5) + (domainRisk * 0.5);
+        return Math.min(5.0, Math.max(1.0, combinedRisk));
+    }
+
+    /**
+     * Convert score to risk level
+     */
+    scoreToLevel(score) {
+        for (const [level, config] of Object.entries(RISK_LEVELS)) {
+            if (score >= config.min && score <= config.max) {
+                return level;
+            }
+        }
+        return 'LOW';
+    }
+
+    /**
+     * Generate recommendations based on risk
+     */
+    generateRecommendations(riskLevel, triggers) {
+        const recommendations = [];
+
+        // Always recommend checkpoint for HIGH/CRITICAL
+        if (riskLevel === 'HIGH' || riskLevel === 'CRITICAL') {
+            recommendations.push({
+                priority: 'REQUIRED',
+                action: 'Create state checkpoint before execution',
+                agent: 'recovery'
+            });
+        }
+
+        // Specific trigger-based recommendations
+        for (const trigger of triggers) {
+            if (trigger.pattern.test(/database|schema/i)) {
+                recommendations.push({
+                    priority: 'REQUIRED',
+                    action: 'Backup database before migration',
+                    agent: 'recovery'
+                });
+            }
+            if (trigger.pattern.test(/auth|security/i)) {
+                recommendations.push({
+                    priority: 'RECOMMENDED',
+                    action: 'Run security scan before and after',
+                    agent: 'security-auditor'
+                });
+            }
+            if (trigger.pattern.test(/api|endpoint/i)) {
+                recommendations.push({
+                    priority: 'RECOMMENDED',
+                    action: 'Review API contract changes',
+                    agent: 'backend-specialist'
+                });
+            }
+        }
+
+        // Learning recommendation
+        recommendations.push({
+            priority: 'STANDARD',
+            action: 'Log outcome to lessons-learned after completion',
+            agent: 'learner'
+        });
+
+        return recommendations;
+    }
+
+    /**
+     * Format assessment for display
+     */
+    formatReport() {
+        const result = this.evaluate();
+
+        const statusIcon = {
+            LOW: '✅',
+            MEDIUM: '⚠️',
+            HIGH: '🔶',
+            CRITICAL: '🔴'
+        }[result.riskLevel];
+
+        return `
+## Pre-Flight Assessment ${statusIcon}
+
+**Task:** ${this.task}  
+**Risk Level:** ${result.riskLevel} (${result.riskScore.toFixed(1)}/5.0)  
+**Action:** ${result.action}
+
+### Impact Scope
+
+| Dimension | Count |
+|-----------|-------|
+| Files | ${result.impactScope.filesAffected} |
+| Domains | ${result.impactScope.domainsAffected} |
+| Agents | ${result.impactScope.agentsInvolved} |
+
+### Triggers Detected
+
+${result.triggers.length > 0
+                ? result.triggers.map(t => `- **${t.risk}**: ${t.pattern}`).join('\n')
+                : '- None detected'}
+
+### Recommendations
+
+${result.recommendations.map(r => `- **[${r.priority}]** ${r.action} → \`${r.agent}\``).join('\n')}
+
+${result.userApprovalRequired
+                ? '> 🔴 **User approval required before proceeding**'
+                : ''}
+${result.checkpointsRequired
+                ? '> 📸 **State checkpoint required before execution**'
+                : ''}
+`.trim();
+    }
+}
+
+/**
+ * Quick risk check for a task string
+ */
+export function quickRiskCheck(taskDescription) {
+    const assessment = new PreFlightAssessment({
+        task: taskDescription,
+        domains: [],
+        files: [],
+        agents: []
+    });
+
+    const result = assessment.evaluate();
+    return {
+        riskLevel: result.riskLevel,
+        requiresAssessment: result.riskLevel !== 'LOW',
+        requiresApproval: result.userApprovalRequired
+    };
+}
+
+/**
+ * CLI for testing
+ */
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+        console.log(`
+Pre-Flight Assessment Module
+
+Usage:
+  node preflight-assessment.js "<task description>"
+  node preflight-assessment.js --test
+
+Examples:
+  node preflight-assessment.js "refactor user authentication"
+  node preflight-assessment.js "add new button component"
+  node preflight-assessment.js "deploy to production"
+`);
+        return;
+    }
+
+    if (args[0] === '--test') {
+        runTests();
+        return;
+    }
+
+    const task = args.join(' ');
+    const assessment = new PreFlightAssessment({
+        task,
+        domains: ['frontend', 'backend'],
+        files: Array(5).fill('file.ts'),
+        agents: ['frontend-specialist', 'test-engineer']
+    });
+
+    console.log(assessment.formatReport());
+}
+
+function runTests() {
+    console.log('Running Pre-Flight Assessment Tests...\n');
+
+    const testCases = [
+        { task: 'add new button', expected: 'LOW' },
+        { task: 'update npm packages', expected: 'MEDIUM' },
+        { task: 'refactor API endpoints', expected: 'HIGH' },
+        { task: 'modify database schema', expected: 'CRITICAL' },
+        { task: 'fix login authentication bug', expected: 'CRITICAL' }
+    ];
+
+    for (const test of testCases) {
+        const check = quickRiskCheck(test.task);
+        const status = check.riskLevel === test.expected ? '✅' : '❌';
+        console.log(`${status} "${test.task}" → ${check.riskLevel} (expected: ${test.expected})`);
+    }
+}
+
+// Run if executed directly
+if (process.argv[1] === __filename) {
+    main().catch(console.error);
+}

package/.agent/scripts-js/scaffold-nextjs.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * scaffold-nextjs.js - Next.js Project Scaffolder
+ * 
+ * Purpose: Bundle multiple npx/npm commands into single script
+ * to minimize Accept prompts in autopilot mode.
+ * 
+ * Usage:
+ *   node .agent/scripts-js/scaffold-nextjs.js <project-name> [options]
+ * 
+ * Options:
+ *   --port <number>   Dev server port (default: 3000)
+ *   --deps <packages> Extra npm packages (comma-separated)
+ *   --no-install      Skip npm install
+ *   --start           Start dev server after creation
+ * 
+ * Example:
+ *   node .agent/scripts-js/scaffold-nextjs.js weather-app --port 3001 --deps zustand,framer-motion --start
+ */
+
+const { execSync, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Parse arguments
+const args = process.argv.slice(2);
+const projectName = args[0];
+
+if (!projectName) {
+  console.error('❌ Error: Project name required');
+  console.log('Usage: node scaffold-nextjs.js <project-name> [options]');
+  process.exit(1);
+}
+
+// Parse options
+const options = {
+  port: 3000,
+  deps: [],
+  install: true,
+  start: false
+};
+
+for (let i = 1; i < args.length; i++) {
+  if (args[i] === '--port' && args[i + 1]) {
+    options.port = parseInt(args[i + 1]);
+    i++;
+  } else if (args[i] === '--deps' && args[i + 1]) {
+    options.deps = args[i + 1].split(',').map(d => d.trim());
+    i++;
+  } else if (args[i] === '--no-install') {
+    options.install = false;
+  } else if (args[i] === '--start') {
+    options.start = true;
+  }
+}
+
+// Get target directory
+const targetDir = path.resolve(process.cwd(), projectName);
+
+console.log('');
+console.log('🚀 Next.js Scaffolder - Agent Skill Kit');
+console.log('========================================');
+console.log(`📁 Project: ${projectName}`);
+console.log(`📍 Path: ${targetDir}`);
+console.log(`🔌 Port: ${options.port}`);
+console.log(`📦 Extra deps: ${options.deps.length > 0 ? options.deps.join(', ') : 'none'}`);
+console.log('');
+
+// Check if directory exists
+if (fs.existsSync(targetDir)) {
+  console.error(`❌ Error: Directory "${projectName}" already exists`);
+  process.exit(1);
+}
+
+// Metrics tracking
+const startTime = Date.now();
+const metrics = {
+  createProject: 0,
+  installDeps: 0,
+  total: 0
+};
+
+try {
+  // Step 1: Create Next.js project
+  console.log('📦 Step 1/3: Creating Next.js project...');
+  const createStart = Date.now();
+  
+  execSync(
+    `npx -y create-next-app@latest ${projectName} --typescript --tailwind --eslint --app --no-src-dir --import-alias="@/*" --use-npm`,
+    { 
+      stdio: 'inherit',
+      cwd: process.cwd()
+    }
+  );
+  
+  metrics.createProject = Date.now() - createStart;
+  console.log(`✅ Project created in ${(metrics.createProject / 1000).toFixed(1)}s`);
+  console.log('');
+
+  // Step 2: Install extra dependencies
+  if (options.install && options.deps.length > 0) {
+    console.log(`📦 Step 2/3: Installing extra dependencies: ${options.deps.join(', ')}...`);
+    const installStart = Date.now();
+    
+    execSync(
+      `npm install ${options.deps.join(' ')}`,
+      { 
+        stdio: 'inherit',
+        cwd: targetDir
+      }
+    );
+    
+    metrics.installDeps = Date.now() - installStart;
+    console.log(`✅ Dependencies installed in ${(metrics.installDeps / 1000).toFixed(1)}s`);
+    console.log('');
+  } else {
+    console.log('⏭️ Step 2/3: Skipping extra dependencies');
+    console.log('');
+  }
+
+  // Step 3: Create common directories
+  console.log('📁 Step 3/3: Creating project structure...');
+  
+  const dirsToCreate = [
+    path.join(targetDir, 'components'),
+    path.join(targetDir, 'lib'),
+    path.join(targetDir, 'hooks'),
+    path.join(targetDir, 'types')
+  ];
+  
+  dirsToCreate.forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+  
+  // Create placeholder files
+  fs.writeFileSync(
+    path.join(targetDir, 'lib', 'utils.ts'),
+    `// Utility functions\n\nexport function cn(...classes: string[]) {\n  return classes.filter(Boolean).join(' ');\n}\n`
+  );
+  
+  fs.writeFileSync(
+    path.join(targetDir, 'types', 'index.ts'),
+    `// Type definitions\n\nexport interface AppConfig {\n  name: string;\n  version: string;\n}\n`
+  );
+  
+  console.log('✅ Project structure created');
+  console.log('');
+
+  // Calculate total time
+  metrics.total = Date.now() - startTime;
+
+  // Print summary
+  console.log('========================================');
+  console.log('✅ SCAFFOLD COMPLETE');
+  console.log('========================================');
+  console.log('');
+  console.log('📊 Metrics:');
+  console.log(`   Create project: ${(metrics.createProject / 1000).toFixed(1)}s`);
+  if (metrics.installDeps > 0) {
+    console.log(`   Install deps:   ${(metrics.installDeps / 1000).toFixed(1)}s`);
+  }
+  console.log(`   Total time:     ${(metrics.total / 1000).toFixed(1)}s`);
+  console.log('');
+  console.log('📁 Created directories:');
+  console.log('   - components/');
+  console.log('   - lib/');
+  console.log('   - hooks/');
+  console.log('   - types/');
+  console.log('');
+  console.log('🚀 Next steps:');
+  console.log(`   cd ${projectName}`);
+  console.log(`   npm run dev -- -p ${options.port}`);
+  console.log('');
+
+  // Start dev server if requested
+  if (options.start) {
+    console.log(`🌐 Starting dev server on port ${options.port}...`);
+    console.log('');
+    
+    const devServer = spawn('npm', ['run', 'dev', '--', '-p', options.port.toString()], {
+      cwd: targetDir,
+      stdio: 'inherit',
+      shell: true
+    });
+    
+    devServer.on('error', (err) => {
+      console.error('❌ Failed to start dev server:', err);
+    });
+  }
+
+} catch (error) {
+  console.error('');
+  console.error('❌ Scaffold failed:', error.message);
+  process.exit(1);
+}