antigravity-ai-kit 2.1.0 → 3.0.1

package/bin/ag-kit.js

@@ -4,7 +4,7 @@
  * Antigravity AI Kit CLI
  * 
  * Usage:
- *   npx @emredursun/antigravity-ai-kit init
+ *   npx antigravity-ai-kit init
  *   ag-kit init [options]
  * 
  * @author Emre Dursun
@@ -14,7 +14,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const VERSION = '2.1.0';
+const VERSION = '3.0.0';
 const AGENT_FOLDER = '.agent';
 
 // ANSI colors
@@ -49,8 +49,9 @@ ${colors.reset}
 ${colors.green}🚀 Antigravity AI Kit v${VERSION}${colors.reset}
 ${colors.yellow}   Transform Your IDE into an Autonomous Engineering Team${colors.reset}
 
-   • 19 AI Agents    • 27 Skills
-   • 31 Commands     • 11 Workflows
+   • 19 AI Agents    • 31 Skills
+   • 31 Commands     • 14 Workflows
+   • Runtime Engine  • Error Budget
 `);
 }
 
@@ -60,7 +61,16 @@ function showHelp() {
 ${colors.bright}Usage:${colors.reset}
   ag-kit init [options]     Install .agent folder to your project
   ag-kit update             Update to latest version
-  ag-kit status             Check installation status
+  ag-kit status             Check installation status (alias: dashboard)
+  ag-kit verify             Run manifest integrity checks
+  ag-kit scan               Run security scan
+  ag-kit plugin list        List installed plugins
+  ag-kit plugin install <p> Install plugin from directory
+  ag-kit plugin remove <n>  Remove installed plugin
+  ag-kit market search <q>  Search marketplace plugins
+  ag-kit market info <name> Get marketplace plugin details
+  ag-kit market install <n> Install from marketplace
+  ag-kit heal [--file <f>]  Detect and diagnose CI failures
   ag-kit --help             Show this help message
   ag-kit --version          Show version
 
@@ -69,11 +79,18 @@ ${colors.bright}Options:${colors.reset}
   --path <dir>              Install to specific directory
   --quiet                   Suppress output (for CI/CD)
   --dry-run                 Preview actions without executing
+  --apply                   Apply self-healing patches (default: dry-run)
+  --file <path>             CI log file for heal command
 
 ${colors.bright}Examples:${colors.reset}
   npx antigravity-ai-kit init
   ag-kit init --force
-  ag-kit init --path ./my-project
+  ag-kit scan
+  ag-kit plugin list
+
+${colors.bright}IDE Reference:${colors.reset}
+  Type ${colors.cyan}/help${colors.reset} in your AI-powered IDE for the full reference:
+  commands, workflows, agents, skills, rules, and checklists.
 `);
 }
 
@@ -169,6 +186,10 @@ ${colors.bright}Next steps:${colors.reset}
   2. Run ${colors.cyan}/status${colors.reset} to verify
   3. Use ${colors.cyan}/help${colors.reset} to see available commands
 
+${colors.bright}Validate your installation:${colors.reset}
+  ${colors.cyan}ag-kit verify${colors.reset}   Manifest integrity check
+  ${colors.cyan}ag-kit scan${colors.reset}     Security scan
+
 ${colors.bright}Quick start:${colors.reset}
   ${colors.cyan}/plan${colors.reset}       Create implementation plan
   ${colors.cyan}/implement${colors.reset}  Execute the plan
@@ -196,9 +217,298 @@ function statusCommand() {
   const commands = countItems(path.join(agentPath, 'commands'), 'file');
   const workflows = countItems(path.join(agentPath, 'workflows'), 'file');
   
+  log('   ═══ Capabilities ═══', 'cyan');
   console.log(`   📦 Skills:    ${skills}`);
   console.log(`   ⌨️  Commands:  ${commands}`);
-  console.log(`   🔄 Workflows: ${workflows}\n`);
+  console.log(`   🔄 Workflows: ${workflows}`);
+  
+  // Workflow phase + available transitions
+  try {
+    const workflowEngine = require('../lib/workflow-engine');
+    const phase = workflowEngine.getCurrentPhase(process.cwd());
+    const available = workflowEngine.getAvailableTransitions(process.cwd());
+    console.log(`   🔁 Phase:     ${phase}`);
+    if (available.length > 0) {
+      const nextPhases = available.map((t) => t.to).join(', ');
+      console.log(`   ➡️  Next:      ${nextPhases}`);
+    }
+  } catch {
+    // Engine not available, skip silently
+  }
+  
+  // Error budget
+  try {
+    const errorBudget = require('../lib/error-budget');
+    const report = errorBudget.getBudgetReport(process.cwd());
+    const statusIcon = report.status === 'HEALTHY' ? '🟢' : report.status === 'WARNING' ? '🟡' : '🔴';
+    console.log(`   ${statusIcon} Budget:   ${report.status}`);
+    if (report.violations.length > 0) {
+      log(`   ⚠️  Violations: ${report.violations.join(', ')}`, 'yellow');
+    }
+  } catch {
+    // Budget not available, skip silently
+  }
+  
+  // Task metrics
+  try {
+    const taskModel = require('../lib/task-model');
+    const metrics = taskModel.getTaskMetrics(process.cwd());
+    if (metrics.total > 0) {
+      console.log('');
+      log('   ═══ Tasks ═══', 'cyan');
+      console.log(`   📋 Open:        ${metrics.counts.open || 0}`);
+      console.log(`   🔨 In Progress: ${metrics.counts['in-progress'] || 0}`);
+      console.log(`   👁️  In Review:   ${metrics.counts.review || 0}`);
+      console.log(`   ✅ Done:        ${metrics.counts.done || 0}`);
+      console.log(`   🚫 Blocked:     ${metrics.counts.blocked || 0}`);
+      if (metrics.completionRate > 0) {
+        console.log(`   📊 Completion:  ${metrics.completionRate}%`);
+      }
+    }
+  } catch {
+    // Task model not available, skip silently
+  }
+  
+  // Hook readiness
+  try {
+    const hookSystem = require('../lib/hook-system');
+    const hookReport = hookSystem.getHookReport(process.cwd());
+    console.log('');
+    log('   ═══ Hooks ═══', 'cyan');
+    console.log(`   🪝 Events:    ${hookReport.events.length}`);
+    console.log(`   ✅ Ready:     ${hookReport.readyCount}/${hookReport.events.length}`);
+  } catch {
+    // Hook system not available, skip silently
+  }
+  
+  // Developer identity
+  try {
+    const identity = require('../lib/identity');
+    const current = identity.getCurrentIdentity(process.cwd());
+    if (current) {
+      console.log('');
+      log('   ═══ Identity ═══', 'cyan');
+      console.log(`   👤 Developer: ${current.name}`);
+      console.log(`   🔑 Role:      ${current.role}`);
+    }
+  } catch {
+    // Identity not available, skip silently
+  }
+  
+  // Plugins
+  try {
+    const pluginSystem = require('../lib/plugin-system');
+    const plugins = pluginSystem.listPlugins(process.cwd());
+    if (plugins.length > 0) {
+      console.log('');
+      log('   ═══ Plugins ═══', 'cyan');
+      console.log(`   🔌 Installed: ${plugins.length}`);
+      for (const plugin of plugins) {
+        console.log(`      • ${plugin.name} v${plugin.version}`);
+      }
+    }
+  } catch {
+    // Plugin system not available, skip silently
+  }
+  
+  // Phase 4 dashboard sections (D-5, E-5)
+  try {
+    const cliCommands = require('../lib/cli-commands');
+    cliCommands.renderDashboardSections(process.cwd());
+  } catch {
+    // Phase 4 modules not available, skip silently
+  }
+  
+  console.log('');
+}
+
+function verifyCommand() {
+  showBanner();
+  logStep('1/1', 'Running manifest integrity checks...\n');
+
+  try {
+    const verify = require('../lib/verify');
+    const report = verify.runAllChecks(process.cwd());
+
+    for (const result of report.results) {
+      const icon = result.status === 'pass' ? '✓' : result.status === 'fail' ? '✗' : '⚠';
+      const color = result.status === 'pass' ? 'green' : result.status === 'fail' ? 'red' : 'yellow';
+      log(`   ${icon} ${result.message}`, color);
+    }
+
+    console.log('');
+    log(`   Passed: ${report.passed}  Failed: ${report.failed}  Warnings: ${report.warnings}`, report.failed > 0 ? 'red' : 'green');
+    console.log('');
+
+    if (report.failed > 0) {
+      process.exit(1);
+    }
+  } catch (/** @type {any} */ error) {
+    log(`   ✗ Verification failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+function updateCommand(updateOptions) {
+  showBanner();
+
+  const agentPath = path.join(updateOptions.path || process.cwd(), '.agent');
+  if (!fs.existsSync(agentPath)) {
+    log('\n❌ No .agent/ folder found. Run: ag-kit init\n', 'red');
+    process.exit(1);
+  }
+
+  const sourceRoot = path.join(__dirname, '..');
+  const targetRoot = updateOptions.path || process.cwd();
+
+  try {
+    const updater = require('../lib/updater');
+    const isDryRun = updateOptions.dryRun;
+
+    if (isDryRun) {
+      log('\n🔍 Dry run mode — no changes will be made\n', 'cyan');
+    }
+
+    logStep('1/2', isDryRun ? 'Analyzing differences...' : 'Applying updates...');
+
+    const report = updater.applyUpdate(sourceRoot, targetRoot, isDryRun);
+
+    if (report.added.length > 0) {
+      log(`\n   📁 New files (${report.added.length}):`, 'green');
+      for (const file of report.added) {
+        log(`      + ${file}`, 'green');
+      }
+    }
+
+    if (report.updated.length > 0) {
+      log(`\n   📝 Updated files (${report.updated.length}):`, 'cyan');
+      for (const file of report.updated) {
+        log(`      ~ ${file}`, 'cyan');
+      }
+    }
+
+    if (report.skipped.length > 0) {
+      log(`\n   🔒 Preserved files (${report.skipped.length}):`, 'yellow');
+      for (const file of report.skipped) {
+        log(`      ○ ${file}`, 'yellow');
+      }
+    }
+
+    logStep('2/2', 'Summary');
+    console.log(`\n   Added: ${report.added.length}  Updated: ${report.updated.length}  Skipped: ${report.skipped.length}  Unchanged: ${report.unchanged.length}\n`);
+
+    if (report.added.length === 0 && report.updated.length === 0) {
+      log('   ✅ Already up to date!\n', 'green');
+    } else if (!isDryRun) {
+      log('   ✅ Update complete!\n', 'green');
+    }
+  } catch (/** @type {any} */ error) {
+    log(`   ✗ Update failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+function scanCommand() {
+  showBanner();
+  logStep('1/1', 'Running enhanced security scan...\n');
+
+  try {
+    const scanner = require('../lib/security-scanner');
+    const report = scanner.getSecurityReport(process.cwd());
+
+    log(`   📂 Files scanned: ${report.filesScanned}`, 'cyan');
+    console.log('');
+
+    if (report.findings.length === 0) {
+      log('   ✅ No security findings — all clear!\n', 'green');
+    } else {
+      for (const finding of report.findings) {
+        const icon = finding.severity === 'critical' ? '🔴' : finding.severity === 'high' ? '🟠' : finding.severity === 'medium' ? '🟡' : '⚪';
+        log(`   ${icon} [${finding.severity.toUpperCase()}] ${finding.detail}`, finding.severity === 'critical' ? 'red' : finding.severity === 'high' ? 'yellow' : 'reset');
+        console.log(`      File: ${finding.file}${finding.line ? `:${finding.line}` : ''}`);
+      }
+      console.log('');
+    }
+
+    log(`   🔴 Critical: ${report.criticalCount}  🟠 High: ${report.highCount}  🟡 Medium: ${report.mediumCount}  ⚪ Low: ${report.lowCount}`, report.clean ? 'green' : 'red');
+    console.log('');
+
+    if (!report.clean) {
+      process.exit(1);
+    }
+  } catch (/** @type {any} */ error) {
+    log(`   ✗ Security scan failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+function pluginCommand(subCommand, pluginArg) {
+  showBanner();
+
+  try {
+    const pluginSystem = require('../lib/plugin-system');
+
+    switch (subCommand) {
+      case 'list': {
+        const plugins = pluginSystem.listPlugins(process.cwd());
+        if (plugins.length === 0) {
+          log('   No plugins installed\n', 'yellow');
+        } else {
+          log(`   ═══ Installed Plugins (${plugins.length}) ═══\n`, 'cyan');
+          for (const plugin of plugins) {
+            console.log(`   🔌 ${plugin.name} v${plugin.version}`);
+            console.log(`      Author: ${plugin.author}`);
+            console.log(`      Installed: ${plugin.installedAt}`);
+            console.log('');
+          }
+        }
+        break;
+      }
+      case 'install': {
+        if (!pluginArg) {
+          log('   ✗ Usage: ag-kit plugin install <path>\n', 'red');
+          process.exit(1);
+        }
+        const pluginPath = path.resolve(pluginArg);
+        logStep('1/1', `Installing plugin from ${pluginPath}...`);
+        const result = pluginSystem.installPlugin(pluginPath, process.cwd());
+        if (result.success) {
+          log('\n   ✅ Plugin installed successfully!', 'green');
+          console.log(`      Agents: ${result.installed.agents}  Skills: ${result.installed.skills}  Workflows: ${result.installed.workflows}  Hooks: ${result.installed.hooks}\n`);
+        } else {
+          log('\n   ✗ Plugin installation failed:', 'red');
+          for (const error of result.errors) {
+            log(`      • ${error}`, 'red');
+          }
+          console.log('');
+          process.exit(1);
+        }
+        break;
+      }
+      case 'remove': {
+        if (!pluginArg) {
+          log('   ✗ Usage: ag-kit plugin remove <name>\n', 'red');
+          process.exit(1);
+        }
+        logStep('1/1', `Removing plugin: ${pluginArg}...`);
+        const result = pluginSystem.removePlugin(pluginArg, process.cwd());
+        if (result.success) {
+          log('\n   ✅ Plugin removed successfully!\n', 'green');
+        } else {
+          log(`\n   ✗ ${result.error}\n`, 'red');
+          process.exit(1);
+        }
+        break;
+      }
+      default:
+        log('   Usage: ag-kit plugin <list|install|remove>', 'yellow');
+        console.log('');
+        break;
+    }
+  } catch (/** @type {any} */ error) {
+    log(`   ✗ Plugin command failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
 }
 
 // Parse arguments
@@ -209,7 +519,9 @@ const options = {
   force: args.includes('--force'),
   quiet: args.includes('--quiet'),
   dryRun: args.includes('--dry-run'),
+  apply: args.includes('--apply'),
   path: null,
+  file: null,
 };
 
 // Parse --path option
@@ -218,21 +530,43 @@ if (pathIndex !== -1 && args[pathIndex + 1]) {
   options.path = args[pathIndex + 1];
 }
 
+// Parse --file option
+const fileIndex = args.indexOf('--file');
+if (fileIndex !== -1 && args[fileIndex + 1]) {
+  options.file = args[fileIndex + 1];
+}
+
 // Execute command
 switch (command) {
   case 'init':
     initCommand(options);
     break;
   case 'status':
+  case 'dashboard':
     statusCommand();
     break;
   case 'update':
-    log('🔄 Update not yet implemented - reinstall with: npx antigravity-ai-kit init --force', 'yellow');
+    updateCommand(options);
     break;
   case 'verify':
-    log('🔒 Manifest verification - coming in v2.2.0', 'cyan');
-    log('   This will validate the integrity of all .agent/ files\n', 'cyan');
+    verifyCommand();
     break;
+  case 'scan':
+    scanCommand();
+    break;
+  case 'plugin':
+    pluginCommand(args[1], args[2]);
+    break;
+  case 'market': {
+    const cliCommands = require('../lib/cli-commands');
+    cliCommands.marketCommand(process.cwd(), args[1], args[2], options);
+    break;
+  }
+  case 'heal': {
+    const cliCmd = require('../lib/cli-commands');
+    cliCmd.healCommand(process.cwd(), { file: options.file, apply: options.apply });
+    break;
+  }
   case '--version':
   case '-v':
     console.log(VERSION);

package/lib/agent-registry.js

@@ -0,0 +1,214 @@
+/**
+ * Antigravity AI Kit — Agent Registry
+ *
+ * Formalizes agent contracts by validating that every agent markdown
+ * file exposes required metadata structure.
+ *
+ * @module lib/agent-registry
+ * @author Emre Dursun
+ * @since v3.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENT_DIR = '.agent';
+const AGENTS_SUBDIR = 'agents';
+const MANIFEST_FILE = 'manifest.json';
+
+/** Minimum expected file size for a valid agent file (bytes) */
+const MIN_AGENT_SIZE = 100;
+/** Maximum expected file size for a valid agent file (bytes) */
+const MAX_AGENT_SIZE = 50000;
+
+/**
+ * @typedef {object} AgentValidation
+ * @property {string} name - Agent name
+ * @property {boolean} valid - Overall validity
+ * @property {string[]} errors - Validation errors
+ * @property {string[]} warnings - Validation warnings
+ * @property {object} metadata - Extracted metadata
+ */
+
+/**
+ * @typedef {object} RegistryReport
+ * @property {number} total - Total agents checked
+ * @property {number} valid - Number of valid agents
+ * @property {number} invalid - Number of invalid agents
+ * @property {AgentValidation[]} agents - Individual agent results
+ */
+
+/**
+ * Extracts metadata from an agent markdown file by parsing its structure.
+ *
+ * @param {string} content - Raw markdown content
+ * @returns {object} Extracted metadata
+ */
+function extractAgentMetadata(content) {
+  const lines = content.split('\n');
+  const metadata = {
+    hasTitle: false,
+    title: '',
+    hasRoleDescription: false,
+    hasCapabilities: false,
+    hasOutputFormat: false,
+    headingCount: 0,
+    lineCount: lines.length,
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Check for title (# heading)
+    if (trimmed.startsWith('# ') && !metadata.hasTitle) {
+      metadata.hasTitle = true;
+      metadata.title = trimmed.slice(2).trim();
+    }
+
+    // Count all headings
+    if (trimmed.startsWith('#')) {
+      metadata.headingCount += 1;
+    }
+
+    // Check for role/responsibility keywords
+    const roleLower = trimmed.toLowerCase();
+    if (roleLower.includes('role') || roleLower.includes('responsibility') || roleLower.includes('purpose') || roleLower.includes('identity')) {
+      metadata.hasRoleDescription = true;
+    }
+
+    // Check for capabilities/skills mentions
+    if (roleLower.includes('capabilit') || roleLower.includes('skill') || roleLower.includes('tool') || roleLower.includes('expertise')) {
+      metadata.hasCapabilities = true;
+    }
+
+    // Check for output format
+    if (roleLower.includes('output') || roleLower.includes('format') || roleLower.includes('deliver') || roleLower.includes('produce')) {
+      metadata.hasOutputFormat = true;
+    }
+  }
+
+  return metadata;
+}
+
+/**
+ * Validates a single agent file against contract requirements.
+ *
+ * @param {string} agentName - Name of the agent
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {AgentValidation}
+ */
+function validateAgent(agentName, projectRoot) {
+  const agentPath = path.join(projectRoot, AGENT_DIR, AGENTS_SUBDIR, `${agentName}.md`);
+  /** @type {string[]} */
+  const errors = [];
+  /** @type {string[]} */
+  const warnings = [];
+
+  if (!fs.existsSync(agentPath)) {
+    return { name: agentName, valid: false, errors: [`File not found: ${agentName}.md`], warnings: [], metadata: {} };
+  }
+
+  const stats = fs.statSync(agentPath);
+  const content = fs.readFileSync(agentPath, 'utf-8');
+  const metadata = extractAgentMetadata(content);
+
+  // Size checks
+  if (stats.size < MIN_AGENT_SIZE) {
+    errors.push(`File too small (${stats.size} bytes) — likely incomplete`);
+  }
+  if (stats.size > MAX_AGENT_SIZE) {
+    warnings.push(`File very large (${stats.size} bytes) — consider splitting`);
+  }
+
+  // Contract checks
+  if (!metadata.hasTitle) {
+    errors.push('Missing title header (# AgentName)');
+  }
+  if (!metadata.hasRoleDescription) {
+    warnings.push('No role/responsibility section detected');
+  }
+  if (!metadata.hasCapabilities) {
+    warnings.push('No capabilities/skills section detected');
+  }
+  if (metadata.headingCount < 2) {
+    warnings.push('Very few headings — agent file may lack structure');
+  }
+
+  return {
+    name: agentName,
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    metadata,
+  };
+}
+
+/**
+ * Validates all agents registered in the manifest.
+ *
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {RegistryReport}
+ */
+function validateAllAgents(projectRoot) {
+  const manifestPath = path.join(projectRoot, AGENT_DIR, MANIFEST_FILE);
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  const agents = manifest.capabilities?.agents?.items || [];
+
+  const results = agents.map((agent) => validateAgent(agent.name, projectRoot));
+  const validCount = results.filter((r) => r.valid).length;
+
+  return {
+    total: results.length,
+    valid: validCount,
+    invalid: results.length - validCount,
+    agents: results,
+  };
+}
+
+/**
+ * Loads the full agent registry from manifest + filesystem.
+ *
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {{ agents: object[], totalCount: number }}
+ */
+function loadRegistry(projectRoot) {
+  const manifestPath = path.join(projectRoot, AGENT_DIR, MANIFEST_FILE);
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  const agents = manifest.capabilities?.agents?.items || [];
+
+  return {
+    agents: agents.map((agent) => ({
+      name: agent.name,
+      file: agent.file,
+      domain: agent.domain,
+    })),
+    totalCount: agents.length,
+  };
+}
+
+/**
+ * Finds agents matching a domain keyword.
+ *
+ * @param {string} domain - Domain keyword to search for
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {object[]} Matching agents
+ */
+function getAgentByDomain(domain, projectRoot) {
+  const { agents } = loadRegistry(projectRoot);
+  const lowerDomain = domain.toLowerCase();
+
+  return agents.filter((agent) =>
+    agent.domain.toLowerCase().includes(lowerDomain) ||
+    agent.name.toLowerCase().includes(lowerDomain)
+  );
+}
+
+module.exports = {
+  validateAgent,
+  validateAllAgents,
+  loadRegistry,
+  getAgentByDomain,
+  extractAgentMetadata,
+};