create-universal-ai-context 2.0.0

package/lib/adapters/claude.js

@@ -0,0 +1,122 @@
+/**
+ * Claude Adapter
+ *
+ * Generates AI_CONTEXT.md and .ai-context/ directory structure.
+ * This is the primary/universal format.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { renderTemplateByName, buildContext } = require('../template-renderer');
+
+/**
+ * Adapter metadata
+ */
+const adapter = {
+  name: 'claude',
+  displayName: 'Claude Code',
+  description: 'Universal AI context format for Claude Code and other AI assistants',
+  outputType: 'single-file',
+  outputPath: 'AI_CONTEXT.md'
+};
+
+/**
+ * Get output path for Claude context file
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Output file path
+ */
+function getOutputPath(projectRoot) {
+  return path.join(projectRoot, 'AI_CONTEXT.md');
+}
+
+/**
+ * Check if Claude output already exists
+ * @param {string} projectRoot - Project root directory
+ * @returns {boolean}
+ */
+function exists(projectRoot) {
+  return fs.existsSync(getOutputPath(projectRoot));
+}
+
+/**
+ * Generate Claude context file
+ * @param {object} analysis - Analysis results from static analyzer
+ * @param {object} config - Configuration from CLI
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Generation result
+ */
+async function generate(analysis, config, projectRoot) {
+  const result = {
+    success: false,
+    adapter: adapter.name,
+    files: [],
+    errors: []
+  };
+
+  try {
+    // Build context from analysis
+    const context = buildContext(analysis, config);
+
+    // Render template
+    const content = renderTemplateByName('claude', context);
+
+    // Write output file
+    const outputPath = getOutputPath(projectRoot);
+    fs.writeFileSync(outputPath, content, 'utf-8');
+
+    result.success = true;
+    result.files.push({
+      path: outputPath,
+      relativePath: 'AI_CONTEXT.md',
+      size: content.length
+    });
+  } catch (error) {
+    result.errors.push({
+      message: error.message,
+      stack: error.stack
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Validate Claude output
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Validation result
+ */
+function validate(projectRoot) {
+  const outputPath = getOutputPath(projectRoot);
+
+  if (!fs.existsSync(outputPath)) {
+    return {
+      valid: false,
+      error: 'AI_CONTEXT.md not found'
+    };
+  }
+
+  const content = fs.readFileSync(outputPath, 'utf-8');
+
+  // Check for unreplaced placeholders
+  const placeholderMatch = content.match(/\{\{[A-Z_]+\}\}/g);
+  if (placeholderMatch && placeholderMatch.length > 0) {
+    return {
+      valid: false,
+      error: `Found ${placeholderMatch.length} unreplaced placeholders`,
+      placeholders: placeholderMatch
+    };
+  }
+
+  return {
+    valid: true,
+    size: content.length
+  };
+}
+
+module.exports = {
+  ...adapter,
+  getOutputPath,
+  exists,
+  generate,
+  validate
+};

package/lib/adapters/cline.js

@@ -0,0 +1,111 @@
+/**
+ * Cline Adapter
+ *
+ * Generates .clinerules file for Cline VS Code extension.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { renderTemplateByName, buildContext } = require('../template-renderer');
+
+/**
+ * Adapter metadata
+ */
+const adapter = {
+  name: 'cline',
+  displayName: 'Cline',
+  description: 'Rules file for Cline VS Code extension',
+  outputType: 'single-file',
+  outputPath: '.clinerules'
+};
+
+/**
+ * Get output path for Cline rules file
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Output file path
+ */
+function getOutputPath(projectRoot) {
+  return path.join(projectRoot, '.clinerules');
+}
+
+/**
+ * Check if Cline output already exists
+ * @param {string} projectRoot - Project root directory
+ * @returns {boolean}
+ */
+function exists(projectRoot) {
+  return fs.existsSync(getOutputPath(projectRoot));
+}
+
+/**
+ * Generate Cline rules file
+ * @param {object} analysis - Analysis results from static analyzer
+ * @param {object} config - Configuration from CLI
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Generation result
+ */
+async function generate(analysis, config, projectRoot) {
+  const result = {
+    success: false,
+    adapter: adapter.name,
+    files: [],
+    errors: []
+  };
+
+  try {
+    // Build context from analysis
+    const context = buildContext(analysis, config);
+
+    // Render template
+    const content = renderTemplateByName('cline', context);
+
+    // Write output file
+    const outputPath = getOutputPath(projectRoot);
+    fs.writeFileSync(outputPath, content, 'utf-8');
+
+    result.success = true;
+    result.files.push({
+      path: outputPath,
+      relativePath: '.clinerules',
+      size: content.length
+    });
+  } catch (error) {
+    result.errors.push({
+      message: error.message,
+      stack: error.stack
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Validate Cline output
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Validation result
+ */
+function validate(projectRoot) {
+  const outputPath = getOutputPath(projectRoot);
+
+  if (!fs.existsSync(outputPath)) {
+    return {
+      valid: false,
+      error: '.clinerules not found'
+    };
+  }
+
+  const content = fs.readFileSync(outputPath, 'utf-8');
+
+  return {
+    valid: true,
+    size: content.length
+  };
+}
+
+module.exports = {
+  ...adapter,
+  getOutputPath,
+  exists,
+  generate,
+  validate
+};

package/lib/adapters/copilot.js

@@ -0,0 +1,117 @@
+/**
+ * GitHub Copilot Adapter
+ *
+ * Generates .github/copilot-instructions.md file.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { renderTemplateByName, buildContext } = require('../template-renderer');
+
+/**
+ * Adapter metadata
+ */
+const adapter = {
+  name: 'copilot',
+  displayName: 'GitHub Copilot',
+  description: 'Context file for GitHub Copilot VS Code extension',
+  outputType: 'single-file',
+  outputPath: '.github/copilot-instructions.md'
+};
+
+/**
+ * Get output path for Copilot instructions file
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Output file path
+ */
+function getOutputPath(projectRoot) {
+  return path.join(projectRoot, '.github', 'copilot-instructions.md');
+}
+
+/**
+ * Check if Copilot output already exists
+ * @param {string} projectRoot - Project root directory
+ * @returns {boolean}
+ */
+function exists(projectRoot) {
+  return fs.existsSync(getOutputPath(projectRoot));
+}
+
+/**
+ * Generate Copilot instructions file
+ * @param {object} analysis - Analysis results from static analyzer
+ * @param {object} config - Configuration from CLI
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Generation result
+ */
+async function generate(analysis, config, projectRoot) {
+  const result = {
+    success: false,
+    adapter: adapter.name,
+    files: [],
+    errors: []
+  };
+
+  try {
+    // Build context from analysis
+    const context = buildContext(analysis, config);
+
+    // Render template
+    const content = renderTemplateByName('copilot', context);
+
+    // Ensure .github directory exists
+    const outputPath = getOutputPath(projectRoot);
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Write output file
+    fs.writeFileSync(outputPath, content, 'utf-8');
+
+    result.success = true;
+    result.files.push({
+      path: outputPath,
+      relativePath: '.github/copilot-instructions.md',
+      size: content.length
+    });
+  } catch (error) {
+    result.errors.push({
+      message: error.message,
+      stack: error.stack
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Validate Copilot output
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Validation result
+ */
+function validate(projectRoot) {
+  const outputPath = getOutputPath(projectRoot);
+
+  if (!fs.existsSync(outputPath)) {
+    return {
+      valid: false,
+      error: 'copilot-instructions.md not found'
+    };
+  }
+
+  const content = fs.readFileSync(outputPath, 'utf-8');
+
+  return {
+    valid: true,
+    size: content.length
+  };
+}
+
+module.exports = {
+  ...adapter,
+  getOutputPath,
+  exists,
+  generate,
+  validate
+};

package/lib/adapters/index.js

@@ -0,0 +1,69 @@
+/**
+ * AI Context Adapters
+ *
+ * Exports all available AI tool adapters.
+ */
+
+const claude = require('./claude');
+const copilot = require('./copilot');
+const cline = require('./cline');
+const antigravity = require('./antigravity');
+
+/**
+ * All available adapters
+ */
+const adapters = {
+  claude,
+  copilot,
+  cline,
+  antigravity
+};
+
+/**
+ * Get adapter by name
+ * @param {string} name - Adapter name
+ * @returns {object|null} Adapter or null if not found
+ */
+function getAdapter(name) {
+  return adapters[name] || null;
+}
+
+/**
+ * Get all adapter names
+ * @returns {string[]} Array of adapter names
+ */
+function getAdapterNames() {
+  return Object.keys(adapters);
+}
+
+/**
+ * Get adapters by names
+ * @param {string[]} names - Array of adapter names
+ * @returns {object[]} Array of adapters
+ */
+function getAdapters(names) {
+  return names
+    .map(name => adapters[name])
+    .filter(Boolean);
+}
+
+/**
+ * Get all adapters
+ * @returns {object[]} Array of all adapters
+ */
+function getAllAdapters() {
+  return Object.values(adapters);
+}
+
+module.exports = {
+  adapters,
+  getAdapter,
+  getAdapterNames,
+  getAdapters,
+  getAllAdapters,
+  // Export individual adapters
+  claude,
+  copilot,
+  cline,
+  antigravity
+};

package/lib/ai-context-generator.js

@@ -0,0 +1,234 @@
+/**
+ * AI Context Generator
+ *
+ * Orchestrates context generation for multiple AI tools.
+ * Uses adapters to generate tool-specific output files.
+ */
+
+const path = require('path');
+const { getAdapters, getAllAdapters, getAdapterNames } = require('./adapters');
+const { initialize: initTemplateRenderer, buildContext } = require('./template-renderer');
+
+/**
+ * Default AI tools to generate for
+ */
+const DEFAULT_AI_TOOLS = ['claude', 'copilot', 'cline', 'antigravity'];
+
+/**
+ * Initialize the generator
+ */
+function initialize() {
+  initTemplateRenderer();
+}
+
+/**
+ * Generate context files for selected AI tools
+ * @param {object} analysis - Analysis results from static analyzer
+ * @param {object} config - Configuration from CLI
+ * @param {string} projectRoot - Project root directory
+ * @param {object} options - Generation options
+ * @returns {object} Generation results
+ */
+async function generateAll(analysis, config, projectRoot, options = {}) {
+  const {
+    aiTools = config.aiTools || DEFAULT_AI_TOOLS,
+    verbose = false,
+    dryRun = false
+  } = options;
+
+  const results = {
+    success: true,
+    generated: [],
+    skipped: [],
+    errors: [],
+    summary: {
+      total: 0,
+      successful: 0,
+      failed: 0,
+      files: 0
+    }
+  };
+
+  // Initialize template renderer
+  initialize();
+
+  // Get adapters for selected tools
+  const adapters = getAdapters(aiTools);
+
+  if (adapters.length === 0) {
+    results.success = false;
+    results.errors.push({
+      message: `No valid adapters found for: ${aiTools.join(', ')}`,
+      validAdapters: getAdapterNames()
+    });
+    return results;
+  }
+
+  // Generate for each adapter
+  for (const adapter of adapters) {
+    results.summary.total++;
+
+    if (verbose) {
+      console.log(`Generating ${adapter.displayName} context...`);
+    }
+
+    if (dryRun) {
+      results.skipped.push({
+        adapter: adapter.name,
+        reason: 'dry-run mode',
+        outputPath: adapter.outputPath
+      });
+      continue;
+    }
+
+    try {
+      const result = await adapter.generate(analysis, config, projectRoot);
+
+      if (result.success) {
+        results.summary.successful++;
+        results.summary.files += result.files.length;
+        results.generated.push({
+          adapter: adapter.name,
+          displayName: adapter.displayName,
+          files: result.files,
+          outputType: adapter.outputType
+        });
+      } else {
+        results.summary.failed++;
+        results.errors.push({
+          adapter: adapter.name,
+          errors: result.errors
+        });
+      }
+    } catch (error) {
+      results.summary.failed++;
+      results.errors.push({
+        adapter: adapter.name,
+        message: error.message,
+        stack: error.stack
+      });
+    }
+  }
+
+  // Update overall success
+  results.success = results.summary.failed === 0;
+
+  return results;
+}
+
+/**
+ * Generate context for a single AI tool
+ * @param {string} toolName - AI tool name (claude, copilot, cline, antigravity)
+ * @param {object} analysis - Analysis results from static analyzer
+ * @param {object} config - Configuration from CLI
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Generation result
+ */
+async function generateSingle(toolName, analysis, config, projectRoot) {
+  initialize();
+
+  const adapters = getAdapters([toolName]);
+
+  if (adapters.length === 0) {
+    return {
+      success: false,
+      error: `Unknown AI tool: ${toolName}`,
+      validTools: getAdapterNames()
+    };
+  }
+
+  const adapter = adapters[0];
+  return adapter.generate(analysis, config, projectRoot);
+}
+
+/**
+ * Validate generated context files
+ * @param {string} projectRoot - Project root directory
+ * @param {string[]} aiTools - AI tools to validate
+ * @returns {object} Validation results
+ */
+function validateAll(projectRoot, aiTools = DEFAULT_AI_TOOLS) {
+  const adapters = getAdapters(aiTools);
+  const results = {
+    valid: true,
+    validations: []
+  };
+
+  for (const adapter of adapters) {
+    const validation = adapter.validate(projectRoot);
+    results.validations.push({
+      adapter: adapter.name,
+      displayName: adapter.displayName,
+      ...validation
+    });
+
+    if (!validation.valid) {
+      results.valid = false;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check which AI tool outputs exist
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Existence check results
+ */
+function checkExisting(projectRoot) {
+  const adapters = getAllAdapters();
+  const existing = {};
+
+  for (const adapter of adapters) {
+    existing[adapter.name] = {
+      exists: adapter.exists(projectRoot),
+      path: adapter.outputPath
+    };
+  }
+
+  return existing;
+}
+
+/**
+ * Get context information for display
+ * @param {object} analysis - Analysis results
+ * @param {object} config - Configuration
+ * @returns {object} Context info for display
+ */
+function getContextInfo(analysis, config) {
+  const context = buildContext(analysis, config);
+
+  return {
+    projectName: context.project.name,
+    techStack: context.project.tech_stack,
+    workflowCount: context.workflows.length,
+    entryPointCount: context.key_files.entry_points.length,
+    gotchaCount: context.gotchas.length,
+    constraintCount: context.critical_constraints.length
+  };
+}
+
+/**
+ * Get supported AI tools
+ * @returns {object[]} Array of tool info objects
+ */
+function getSupportedTools() {
+  return getAllAdapters().map(adapter => ({
+    name: adapter.name,
+    displayName: adapter.displayName,
+    description: adapter.description,
+    outputType: adapter.outputType,
+    outputPath: adapter.outputPath
+  }));
+}
+
+module.exports = {
+  generateAll,
+  generateSingle,
+  validateAll,
+  checkExisting,
+  getContextInfo,
+  getSupportedTools,
+  initialize,
+  DEFAULT_AI_TOOLS
+};