@iservu-inc/adf-cli 0.10.0 → 0.12.0

package/lib/generators/antigravity-generator.js

@@ -0,0 +1,140 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for Google Antigravity configurations
+ * Creates .antigravity/agents.yaml that mounts AGENTS.md
+ * Provides file system access to .context/ directory
+ */
+class AntigravityGenerator extends ToolConfigGenerator {
+  /**
+   * Generate Antigravity configurations
+   * @returns {Object} Generated file paths
+   */
+  async generate() {
+    await this.initialize();
+
+    const antigravityDir = path.join(this.projectPath, '.antigravity');
+    await fs.ensureDir(antigravityDir);
+
+    const generated = {
+      agents: null
+    };
+
+    // Generate agents.yaml
+    generated.agents = await this.generateAgentsYaml(antigravityDir);
+
+    return generated;
+  }
+
+  /**
+   * Generate .antigravity/agents.yaml
+   */
+  async generateAgentsYaml(antigravityDir) {
+    const agentsPath = path.join(antigravityDir, 'agents.yaml');
+
+    const agentName = this.getAgentName();
+    const model = this.getModelForFramework();
+
+    // Generate YAML content
+    const yamlContent = `# Antigravity Agent Configuration
+# Generated by ADF CLI v${this.getADFVersion()}
+# Framework: ${this.getFrameworkName()}
+
+agents:
+  - name: "${agentName}"
+    model: "${model}"
+    capabilities:
+      - file_system:
+          read_only:
+            - "AGENTS.md"
+            - ".context"
+            - ".adf/sessions"
+          exclude:
+            - ".adf/.env"
+            - "node_modules"
+            - ".git"
+    system_prompt: |
+      You are ${agentName}, an expert AI coding assistant.
+
+      CRITICAL INSTRUCTIONS:
+      1. Read "AGENTS.md" IMMEDIATELY upon startup to understand project rules and structure
+      2. Consult ".context/memory/architecture.md" for system design decisions
+      3. Follow all operational rules defined in AGENTS.md (they are NON-NEGOTIABLE)
+      4. Never output secrets from .env files or expose API keys
+      5. All code changes must pass the test suite defined in AGENTS.md
+
+      WORKFLOW:
+      - Before any code change, read AGENTS.md and .context/memory/architecture.md
+      - Follow the build & test commands specified in AGENTS.md
+      - Adhere to the project structure and workflow directives
+      - Ask clarifying questions if requirements are unclear
+
+      PROJECT CONTEXT:
+      - Framework: ${this.getFrameworkName()}
+      - Session: ${this.getSessionId()}
+      - Complete requirements: .adf/sessions/${this.getSessionId()}/outputs/
+
+      Remember: AGENTS.md is your single source of truth. Read it first, follow it always.
+`;
+
+    await fs.writeFile(agentsPath, yamlContent, 'utf-8');
+    return agentsPath;
+  }
+
+  /**
+   * Get agent name based on framework
+   */
+  getAgentName() {
+    const projectName = this.getProjectName();
+
+    const roleMap = {
+      'rapid': 'Developer',
+      'balanced': 'Project Architect',
+      'comprehensive': 'Solutions Architect'
+    };
+
+    const role = roleMap[this.framework] || 'Developer';
+    return `${projectName} ${role}`;
+  }
+
+  /**
+   * Get appropriate model for framework complexity
+   */
+  getModelForFramework() {
+    const modelMap = {
+      'rapid': 'gemini-2.0-flash-exp',
+      'balanced': 'gemini-2.0-flash-thinking-exp',
+      'comprehensive': 'gemini-exp-1206'
+    };
+
+    return modelMap[this.framework] || 'gemini-2.0-flash-exp';
+  }
+
+  /**
+   * Get framework display name
+   */
+  getFrameworkName() {
+    const names = {
+      'rapid': 'Rapid Development (PRP)',
+      'balanced': 'Balanced (Specification-Driven)',
+      'comprehensive': 'BMAD Comprehensive (Enterprise)'
+    };
+    return names[this.framework] || this.framework;
+  }
+
+  /**
+   * Get ADF CLI version
+   */
+  getADFVersion() {
+    try {
+      const packageJson = require('../../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '0.11.0';
+    }
+  }
+}
+
+module.exports = AntigravityGenerator;

package/lib/generators/index.js

@@ -7,6 +7,8 @@ const AgentsMdGenerator = require('./agents-md-generator');
 const WindsurfGenerator = require('./windsurf-generator');
 const CursorGenerator = require('./cursor-generator');
 const VSCodeGenerator = require('./vscode-generator');
+const ZedGenerator = require('./zed-generator');
+const AntigravityGenerator = require('./antigravity-generator');
 const ToolConfigGenerator = require('./tool-config-generator');
 
 /**
@@ -84,15 +86,35 @@ async function generateVSCode(sessionPath, projectPath, framework) {
   return await generator.generate();
 }
 
+/**
+ * Generate Zed Editor configurations
+ */
+async function generateZed(sessionPath, projectPath, framework) {
+  const generator = new ZedGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Google Antigravity configurations
+ */
+async function generateAntigravity(sessionPath, projectPath, framework) {
+  const generator = new AntigravityGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
 module.exports = {
   generateAll,
   generateAgentsMd,
   generateWindsurf,
   generateCursor,
   generateVSCode,
+  generateZed,
+  generateAntigravity,
   AgentsMdGenerator,
   WindsurfGenerator,
   CursorGenerator,
   VSCodeGenerator,
+  ZedGenerator,
+  AntigravityGenerator,
   ToolConfigGenerator
 };

package/lib/generators/zed-generator.js

@@ -0,0 +1,252 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for Zed Editor configurations
+ * Creates .zed/settings.json with MCP integration and agent configuration
+ * Creates .zed/keymap.json for agent switching shortcuts
+ * Creates symlink .zed/rules -> ../AGENTS.md (or copies on Windows)
+ */
+class ZedGenerator extends ToolConfigGenerator {
+  /**
+   * Generate Zed Editor configurations
+   * @returns {Object} Generated file paths
+   */
+  async generate() {
+    await this.initialize();
+
+    const zedDir = path.join(this.projectPath, '.zed');
+    await fs.ensureDir(zedDir);
+
+    const generated = {
+      settings: null,
+      keymap: null,
+      rules: null
+    };
+
+    // Generate settings.json
+    generated.settings = await this.generateSettings(zedDir);
+
+    // Generate keymap.json
+    generated.keymap = await this.generateKeymap(zedDir);
+
+    // Create symlink or copy AGENTS.md
+    generated.rules = await this.linkAgentsMd(zedDir);
+
+    return generated;
+  }
+
+  /**
+   * Generate .zed/settings.json with MCP and agent configuration
+   */
+  async generateSettings(zedDir) {
+    const settingsPath = path.join(zedDir, 'settings.json');
+
+    // Determine model configuration based on framework
+    const modelConfig = this.getModelConfiguration();
+
+    const settings = {
+      agent: {
+        default_model: modelConfig.default,
+        feature_specific_models: modelConfig.featureSpecific,
+        model_parameters: modelConfig.parameters,
+        always_allow_tool_actions: true,
+        single_file_review: true
+      },
+      context_servers: this.getMCPContextServers(),
+      terminal: {
+        env: this.getTerminalEnvironment()
+      }
+    };
+
+    await fs.writeJson(settingsPath, settings, { spaces: 2 });
+    return settingsPath;
+  }
+
+  /**
+   * Get model configuration based on framework complexity
+   */
+  getModelConfiguration() {
+    const configs = {
+      rapid: {
+        default: {
+          provider: 'anthropic',
+          model: 'claude-3-5-sonnet-20241022'
+        },
+        featureSpecific: {
+          thread_summary_model: {
+            provider: 'google',
+            model: 'gemini-2.0-flash-exp'
+          },
+          commit_message_model: {
+            provider: 'google',
+            model: 'gemini-2.0-flash-exp'
+          },
+          inline_assistant_model: {
+            provider: 'anthropic',
+            model: 'claude-3-5-sonnet-20241022'
+          }
+        },
+        parameters: [
+          { provider: 'anthropic', temperature: 0.1 },
+          { provider: 'google', temperature: 0.2 }
+        ]
+      },
+      balanced: {
+        default: {
+          provider: 'anthropic',
+          model: 'claude-3-5-sonnet-20241022'
+        },
+        featureSpecific: {
+          thread_summary_model: {
+            provider: 'google',
+            model: 'gemini-2.0-flash-exp'
+          },
+          commit_message_model: {
+            provider: 'google',
+            model: 'gemini-2.0-flash-exp'
+          },
+          inline_assistant_model: {
+            provider: 'anthropic',
+            model: 'claude-3-5-sonnet-20241022'
+          }
+        },
+        parameters: [
+          { provider: 'anthropic', temperature: 0.1 },
+          { provider: 'google', temperature: 0.2 }
+        ]
+      },
+      comprehensive: {
+        default: {
+          provider: 'anthropic',
+          model: 'claude-3-5-sonnet-20241022'
+        },
+        featureSpecific: {
+          thread_summary_model: {
+            provider: 'anthropic',
+            model: 'claude-3-5-sonnet-20241022'
+          },
+          commit_message_model: {
+            provider: 'anthropic',
+            model: 'claude-3-5-sonnet-20241022'
+          },
+          inline_assistant_model: {
+            provider: 'anthropic',
+            model: 'claude-3-5-sonnet-20241022'
+          }
+        },
+        parameters: [
+          { provider: 'anthropic', temperature: 0.05 }
+        ]
+      }
+    };
+
+    return configs[this.framework] || configs.balanced;
+  }
+
+  /**
+   * Get MCP context servers configuration
+   */
+  getMCPContextServers() {
+    const servers = {
+      project_context: {
+        command: 'npx',
+        args: ['@modelcontextprotocol/server-filesystem', '.context']
+      }
+    };
+
+    // Add Archon if configured
+    const archonUrl = process.env.ARCHON_MCP_URL || this.metadata?.archonUrl;
+    if (archonUrl) {
+      servers.archon = {
+        url: archonUrl
+      };
+    }
+
+    return servers;
+  }
+
+  /**
+   * Get terminal environment variables
+   */
+  getTerminalEnvironment() {
+    const env = {};
+
+    // Add ARCHON_MCP_PORT if configured
+    if (process.env.ARCHON_MCP_URL) {
+      const url = new URL(process.env.ARCHON_MCP_URL);
+      if (url.port) {
+        env.ARCHON_MCP_PORT = url.port;
+      }
+    }
+
+    return env;
+  }
+
+  /**
+   * Generate .zed/keymap.json with agent switching shortcuts
+   */
+  async generateKeymap(zedDir) {
+    const keymapPath = path.join(zedDir, 'keymap.json');
+
+    const keymap = [
+      {
+        context: 'Editor',
+        bindings: {
+          'ctrl-shift-a': 'assistant::Toggle',
+          'ctrl-shift-c': 'assistant::CycleMessageRole',
+          'ctrl-shift-r': 'assistant::Restart'
+        }
+      },
+      {
+        context: 'AssistantPanel',
+        bindings: {
+          'ctrl-enter': 'assistant::Assist',
+          'escape': 'assistant::Hide',
+          'ctrl-shift-n': 'assistant::NewConversation'
+        }
+      }
+    ];
+
+    await fs.writeJson(keymapPath, keymap, { spaces: 2 });
+    return keymapPath;
+  }
+
+  /**
+   * Create symlink .zed/rules -> ../AGENTS.md
+   * Falls back to file copy on Windows if symlink fails
+   */
+  async linkAgentsMd(zedDir) {
+    const rulesPath = path.join(zedDir, 'rules');
+    const agentsMdPath = path.join(this.projectPath, 'AGENTS.md');
+
+    // Remove existing link/file if present
+    if (await fs.pathExists(rulesPath)) {
+      await fs.remove(rulesPath);
+    }
+
+    // Check if AGENTS.md exists
+    if (!await fs.pathExists(agentsMdPath)) {
+      console.warn('AGENTS.md not found, skipping Zed rules link');
+      return null;
+    }
+
+    try {
+      // Try to create symlink (Unix/Mac/modern Windows)
+      await fs.symlink('../AGENTS.md', rulesPath, 'file');
+      return { type: 'symlink', path: rulesPath };
+    } catch (error) {
+      // Symlink failed (older Windows or permissions), copy file instead
+      try {
+        await fs.copy(agentsMdPath, rulesPath);
+        return { type: 'copy', path: rulesPath };
+      } catch (copyError) {
+        console.warn(`Failed to create Zed rules link: ${copyError.message}`);
+        return null;
+      }
+    }
+  }
+}
+
+module.exports = ZedGenerator;

package/lib/learning/analytics-exporter.js

@@ -0,0 +1,241 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Learning Analytics Exporter
+ *
+ * Handles exporting analytics data in multiple formats:
+ * - JSON: Single comprehensive file with all analytics
+ * - CSV: Multiple files for different metrics
+ */
+
+/**
+ * Export analytics data
+ * @param {Object} analyticsData - Complete analytics data
+ * @param {string} projectPath - Project root path
+ * @param {string} format - Export format ('json' or 'csv')
+ * @returns {Promise<Object>} Export result with file paths
+ */
+async function exportAnalytics(analyticsData, projectPath, format = 'json') {
+  const learningPath = path.join(projectPath, '.adf', 'learning');
+  const exportsPath = path.join(learningPath, 'exports');
+
+  // Ensure exports directory exists
+  await fs.ensureDir(exportsPath);
+
+  if (format === 'json') {
+    return await exportJSON(analyticsData, exportsPath);
+  } else if (format === 'csv') {
+    return await exportCSV(analyticsData, exportsPath);
+  } else {
+    throw new Error(`Unsupported export format: ${format}`);
+  }
+}
+
+/**
+ * Export analytics as JSON
+ * @param {Object} analyticsData - Analytics data
+ * @param {string} exportsPath - Exports directory path
+ * @returns {Promise<Object>} Export result
+ */
+async function exportJSON(analyticsData, exportsPath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const filename = `analytics-${timestamp}.json`;
+  const filePath = path.join(exportsPath, filename);
+
+  // Write JSON file
+  await fs.writeJSON(filePath, analyticsData, { spaces: 2 });
+
+  // Get file size
+  const stats = await fs.stat(filePath);
+  const sizeKB = (stats.size / 1024).toFixed(2);
+
+  return {
+    file: filePath,
+    size: `${sizeKB} KB`,
+    format: 'json'
+  };
+}
+
+/**
+ * Export analytics as CSV (multiple files)
+ * @param {Object} analyticsData - Analytics data
+ * @param {string} exportsPath - Exports directory path
+ * @returns {Promise<Object>} Export result
+ */
+async function exportCSV(analyticsData, exportsPath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const files = [];
+
+  // Export overview
+  const overviewFile = path.join(exportsPath, `analytics-overview-${timestamp}.csv`);
+  await fs.writeFile(overviewFile, generateOverviewCSV(analyticsData.overview));
+  files.push(overviewFile);
+
+  // Export skip trends
+  const trendsFile = path.join(exportsPath, `analytics-skip-trends-${timestamp}.csv`);
+  await fs.writeFile(trendsFile, generateSkipTrendsCSV(analyticsData.skipTrends));
+  files.push(trendsFile);
+
+  // Export category preferences
+  const categoriesFile = path.join(exportsPath, `analytics-categories-${timestamp}.csv`);
+  await fs.writeFile(categoriesFile, generateCategoriesCSV(analyticsData.categoryPreferences));
+  files.push(categoriesFile);
+
+  // Export patterns
+  const patternsFile = path.join(exportsPath, `analytics-patterns-${timestamp}.csv`);
+  await fs.writeFile(patternsFile, generatePatternsCSV(analyticsData.patternDistribution, analyticsData.decayStatus));
+  files.push(patternsFile);
+
+  // Export effectiveness
+  const effectivenessFile = path.join(exportsPath, `analytics-effectiveness-${timestamp}.csv`);
+  await fs.writeFile(effectivenessFile, generateEffectivenessCSV(analyticsData.effectiveness));
+  files.push(effectivenessFile);
+
+  return {
+    files,
+    format: 'csv'
+  };
+}
+
+/**
+ * Generate overview CSV
+ * @param {Object} overview - Overview data
+ * @returns {string} CSV content
+ */
+function generateOverviewCSV(overview) {
+  const rows = [
+    ['Metric', 'Value', 'Unit'],
+    ['Total Sessions', overview.totalSessions, 'sessions'],
+    ['Total Skips', overview.totalSkips, 'questions'],
+    ['Manual Skips', overview.manualSkips, 'questions'],
+    ['Filtered Skips', overview.filteredSkips, 'questions'],
+    ['Total Answers', overview.totalAnswers, 'questions'],
+    ['Active Patterns', overview.activePatterns, 'patterns'],
+    ['Active Rules', overview.activeRules, 'rules'],
+    ['Learning Age', overview.learningAge, 'days']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate skip trends CSV
+ * @param {Array} skipTrends - Skip trends data
+ * @returns {string} CSV content
+ */
+function generateSkipTrendsCSV(skipTrends) {
+  const rows = [
+    ['Week', 'Week Number', 'Manual Skips', 'Filtered Skips', 'Total Skips', 'Skip Rate (%)']
+  ];
+
+  for (const trend of skipTrends) {
+    rows.push([
+      trend.week,
+      trend.weekNumber,
+      trend.manualSkips,
+      trend.filteredSkips,
+      trend.totalSkips,
+      trend.skipRate
+    ]);
+  }
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate categories CSV
+ * @param {Array} categories - Category preferences data
+ * @returns {string} CSV content
+ */
+function generateCategoriesCSV(categories) {
+  const rows = [
+    ['Category', 'Skips', 'Answers', 'Total', 'Skip Rate (%)', 'Level']
+  ];
+
+  for (const cat of categories) {
+    rows.push([
+      escapeCSV(cat.category),
+      cat.skips,
+      cat.answers,
+      cat.total,
+      cat.skipRate,
+      cat.level
+    ]);
+  }
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate patterns CSV
+ * @param {Object} patternDistribution - Pattern distribution data
+ * @param {Object} decayStatus - Decay status data
+ * @returns {string} CSV content
+ */
+function generatePatternsCSV(patternDistribution, decayStatus) {
+  const dist = patternDistribution.distribution || { high: 0, medium: 0, low: 0, veryLow: 0 };
+  const decay = decayStatus || { healthy: 0, warning: 0, critical: 0, recentlyRenewed: 0, avgAge: 0 };
+
+  const rows = [
+    ['Metric', 'Value', 'Description'],
+    ['Total Patterns', patternDistribution.totalPatterns || 0, 'All patterns'],
+    ['High Confidence (90%+)', dist.high, 'Very strong patterns'],
+    ['Medium Confidence (75-89%)', dist.medium, 'Strong patterns'],
+    ['Low Confidence (50-74%)', dist.low, 'Weak patterns'],
+    ['Very Low Confidence (<50%)', dist.veryLow, 'Very weak patterns'],
+    ['Average Confidence', (patternDistribution.avgConfidence || 0) + '%', 'Mean confidence score'],
+    ['At Risk', patternDistribution.atRiskCount || 0, 'Patterns at risk of removal'],
+    ['', '', ''],
+    ['Decay Status', '', ''],
+    ['Healthy Patterns', decay.healthy, 'Active and strong'],
+    ['Warning Patterns', decay.warning, 'Needs attention'],
+    ['Critical Patterns', decay.critical, 'May be removed soon'],
+    ['Recently Renewed', decay.recentlyRenewed, 'Last 30 days'],
+    ['Average Age', decay.avgAge + ' days', 'Mean pattern age']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate effectiveness CSV
+ * @param {Object} effectiveness - Effectiveness data
+ * @returns {string} CSV content
+ */
+function generateEffectivenessCSV(effectiveness) {
+  const rows = [
+    ['Metric', 'Value', 'Unit'],
+    ['Time Saved', effectiveness.timeSavedMinutes, 'minutes'],
+    ['Time Saved (Hours)', effectiveness.timeSavedHours, 'hours'],
+    ['Questions Filtered', effectiveness.questionsFiltered, 'questions'],
+    ['False Positives', effectiveness.falsePositives, 'questions'],
+    ['False Positive Rate', effectiveness.falsePositiveRate, '%'],
+    ['Pattern Accuracy', effectiveness.patternAccuracy, '%'],
+    ['Total Rule Applications', effectiveness.totalRuleApplications, 'applications'],
+    ['Avg Applications Per Rule', effectiveness.avgApplicationsPerRule, 'applications'],
+    ['Overall Effectiveness', effectiveness.overallEffectiveness, '%']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Escape CSV value
+ * @param {string} value - Value to escape
+ * @returns {string} Escaped value
+ */
+function escapeCSV(value) {
+  if (typeof value !== 'string') return value;
+
+  // Escape quotes and wrap in quotes if contains special chars
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return '"' + value.replace(/"/g, '""') + '"';
+  }
+
+  return value;
+}
+
+module.exports = {
+  exportAnalytics
+};