aios-core 1.0.0

package/.aios-core/infrastructure/scripts/documentation-integrity/config-generator.js

@@ -0,0 +1,368 @@
+/**
+ * Config Generator Module
+ *
+ * Generates project-specific core-config.yaml from templates.
+ * Supports greenfield and brownfield modes with deployment configuration.
+ *
+ * @module documentation-integrity/config-generator
+ * @version 1.0.0
+ * @story 6.9
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+// Template directory
+const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates', 'core-config');
+
+/**
+ * Template file names
+ * @enum {string}
+ */
+const ConfigTemplates = {
+  GREENFIELD: 'core-config-greenfield.tmpl.yaml',
+  BROWNFIELD: 'core-config-brownfield.tmpl.yaml',
+};
+
+/**
+ * Deployment workflow types
+ * @enum {string}
+ */
+const DeploymentWorkflow = {
+  STAGING_FIRST: 'staging-first',
+  DIRECT_TO_MAIN: 'direct-to-main',
+};
+
+/**
+ * Deployment platform options
+ * @enum {string}
+ */
+const DeploymentPlatform = {
+  RAILWAY: 'Railway',
+  VERCEL: 'Vercel',
+  AWS: 'AWS',
+  DOCKER: 'Docker',
+  NONE: 'None',
+};
+
+/**
+ * Default deployment configuration
+ * @type {Object}
+ */
+const DEFAULT_DEPLOYMENT_CONFIG = {
+  workflow: DeploymentWorkflow.STAGING_FIRST,
+  stagingBranch: 'staging',
+  productionBranch: 'main',
+  defaultTarget: 'staging',
+  stagingEnvName: 'Staging',
+  productionEnvName: 'Production',
+  platform: DeploymentPlatform.NONE,
+  qualityGates: {
+    lint: true,
+    typecheck: true,
+    tests: true,
+    securityScan: false,
+    minCoverage: 50,
+  },
+};
+
+/**
+ * Escapes a string for use in YAML double-quoted strings
+ *
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string safe for YAML
+ */
+function escapeYamlString(str) {
+  return String(str)
+    .replace(/\\/g, '\\\\') // Escape backslashes first
+    .replace(/"/g, '\\"') // Escape double quotes
+    .replace(/\n/g, '\\n') // Escape newlines
+    .replace(/\r/g, '\\r') // Escape carriage returns
+    .replace(/\t/g, '\\t'); // Escape tabs
+}
+
+/**
+ * Formats an array as YAML list string for template substitution
+ *
+ * @param {Array} arr - Array to format
+ * @param {number} [indent=4] - Number of spaces for indentation
+ * @returns {string} YAML-formatted array string
+ */
+function formatArrayAsYaml(arr, indent = 4) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return '[]';
+  }
+  const spaces = ' '.repeat(indent);
+  const items = arr.map((item) => `\n${spaces}- "${escapeYamlString(item)}"`).join('');
+  return items;
+}
+
+/**
+ * Builds config context from project info and deployment settings
+ *
+ * @param {string} projectName - Project name
+ * @param {string} mode - Installation mode (greenfield/brownfield)
+ * @param {Object} deploymentConfig - Deployment configuration
+ * @param {Object} [analysisResults] - Brownfield analysis results (if applicable)
+ * @returns {Object} Config context for template rendering
+ */
+function buildConfigContext(projectName, mode, deploymentConfig = {}, analysisResults = {}) {
+  const config = { ...DEFAULT_DEPLOYMENT_CONFIG, ...deploymentConfig };
+  const isStaging = config.workflow === DeploymentWorkflow.STAGING_FIRST;
+
+  const context = {
+    // Basic info
+    PROJECT_NAME: projectName,
+    GENERATED_DATE: new Date().toISOString().split('T')[0],
+    PROJECT_VERSION: analysisResults.version || '0.1.0',
+
+    // Deployment workflow
+    DEPLOYMENT_WORKFLOW: config.workflow,
+
+    // Branch configuration
+    STAGING_BRANCH: isStaging ? config.stagingBranch : 'null',
+    PRODUCTION_BRANCH: config.productionBranch,
+    // Use symbolic name ('staging'/'production') - deployment-config-loader resolves to actual branch
+    DEFAULT_TARGET: isStaging ? 'staging' : 'production',
+
+    // Environment names
+    STAGING_ENV_NAME: config.stagingEnvName,
+    PRODUCTION_ENV_NAME: config.productionEnvName,
+
+    // Platform
+    DEPLOYMENT_PLATFORM: config.platform,
+
+    // Quality gates
+    QUALITY_LINT: config.qualityGates.lint,
+    QUALITY_TYPECHECK: config.qualityGates.typecheck,
+    QUALITY_TESTS: config.qualityGates.tests,
+    QUALITY_SECURITY: config.qualityGates.securityScan || false,
+    MIN_COVERAGE: config.qualityGates.minCoverage || 50,
+
+    // Brownfield specific (defaults for greenfield)
+    HAS_EXISTING_STRUCTURE: analysisResults.hasExistingStructure || false,
+    HAS_EXISTING_WORKFLOWS: analysisResults.hasExistingWorkflows || false,
+    HAS_EXISTING_STANDARDS: analysisResults.hasExistingStandards || false,
+    MERGE_STRATEGY: analysisResults.mergeStrategy || 'parallel',
+
+    // Detected configs (brownfield)
+    DETECTED_TECH_STACK: JSON.stringify(analysisResults.techStack || []),
+    DETECTED_FRAMEWORKS: JSON.stringify(analysisResults.frameworks || []),
+    DETECTED_LINTING: analysisResults.linting || 'none',
+    DETECTED_FORMATTING: analysisResults.formatting || 'none',
+    DETECTED_TESTING: analysisResults.testing || 'none',
+
+    // Auto deploy settings
+    STAGING_AUTO_DEPLOY: config.stagingAutoDeploy !== false,
+    PRODUCTION_AUTO_DEPLOY: config.productionAutoDeploy !== false,
+
+    // PR settings
+    AUTO_ASSIGN_REVIEWERS: config.autoAssignReviewers || false,
+    DRAFT_BY_DEFAULT: config.draftByDefault || false,
+
+    // Existing config paths (brownfield)
+    ESLINT_CONFIG_PATH: analysisResults.eslintPath || 'null',
+    PRETTIER_CONFIG_PATH: analysisResults.prettierPath || 'null',
+    TSCONFIG_PATH: analysisResults.tsconfigPath || 'null',
+    FLAKE8_CONFIG_PATH: analysisResults.flake8Path || 'null',
+    GITHUB_WORKFLOWS_PATH: analysisResults.githubWorkflowsPath || 'null',
+    GITLAB_CI_PATH: analysisResults.gitlabCiPath || 'null',
+    PACKAGE_JSON_PATH: analysisResults.packageJsonPath || 'null',
+    REQUIREMENTS_PATH: analysisResults.requirementsPath || 'null',
+    GO_MOD_PATH: analysisResults.goModPath || 'null',
+
+    // Merge settings
+    MERGE_WORKFLOWS: analysisResults.mergeWorkflows || false,
+
+    // Migration notes (brownfield)
+    MIGRATION_SUMMARY: analysisResults.summary || 'No analysis performed',
+    MANUAL_REVIEW_ITEMS: analysisResults.manualReviewItems || [],
+    CONFLICTS: analysisResults.conflicts || [],
+    RECOMMENDATIONS: analysisResults.recommendations || [],
+
+    // Pre-formatted YAML arrays for template substitution (avoids Handlebars #each)
+    MANUAL_REVIEW_ITEMS_YAML: formatArrayAsYaml(analysisResults.manualReviewItems || []),
+    CONFLICTS_YAML: formatArrayAsYaml(analysisResults.conflicts || []),
+    RECOMMENDATIONS_YAML: formatArrayAsYaml(analysisResults.recommendations || []),
+  };
+
+  return context;
+}
+
+/**
+ * Renders a YAML template with context
+ *
+ * @param {string} template - Template content
+ * @param {Object} context - Context object
+ * @returns {string} Rendered YAML content
+ */
+function renderConfigTemplate(template, context) {
+  let result = template;
+
+  // Process {{#each}} blocks
+  result = processEachBlocks(result, context);
+
+  // Replace simple variables {{variable}}
+  result = result.replace(/\{\{([^#/}][^}]*)\}\}/g, (match, key) => {
+    const value = context[key.trim()];
+    if (value === undefined) return match;
+    if (typeof value === 'boolean') return value.toString();
+    if (typeof value === 'number') return value.toString();
+    return String(value);
+  });
+
+  return result;
+}
+
+/**
+ * Process {{#each array}}...{{/each}} blocks
+ *
+ * @param {string} template - Template string
+ * @param {Object} context - Context object
+ * @returns {string} Processed template
+ */
+function processEachBlocks(template, context) {
+  const eachRegex = /\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g;
+
+  return template.replace(eachRegex, (match, arrayName, content) => {
+    const array = context[arrayName];
+    if (!Array.isArray(array) || array.length === 0) {
+      return '';
+    }
+
+    return array
+      .map((item) => {
+        return content.replace(/\{\{this\}\}/g, String(item));
+      })
+      .join('');
+  });
+}
+
+/**
+ * Loads a config template
+ *
+ * @param {string} templateName - Template file name
+ * @returns {string} Template content
+ * @throws {Error} If template not found
+ */
+function loadConfigTemplate(templateName) {
+  const templatePath = path.join(TEMPLATES_DIR, templateName);
+
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Config template not found: ${templatePath}`);
+  }
+
+  return fs.readFileSync(templatePath, 'utf8');
+}
+
+/**
+ * Generates core-config.yaml for a project
+ *
+ * @param {string} targetDir - Target directory
+ * @param {string} mode - Installation mode (greenfield/brownfield)
+ * @param {Object} context - Config context
+ * @param {Object} [options] - Generation options
+ * @param {boolean} [options.dryRun] - Don't write file, just return content
+ * @returns {Object} Generation result
+ */
+function generateConfig(targetDir, mode, context, options = {}) {
+  const templateName =
+    mode === 'brownfield' ? ConfigTemplates.BROWNFIELD : ConfigTemplates.GREENFIELD;
+
+  try {
+    const template = loadConfigTemplate(templateName);
+    const rendered = renderConfigTemplate(template, context);
+
+    // Validate YAML syntax
+    try {
+      yaml.load(rendered);
+    } catch (yamlError) {
+      return {
+        success: false,
+        error: `Generated YAML is invalid: ${yamlError.message}`,
+        content: rendered,
+      };
+    }
+
+    const configDir = path.join(targetDir, '.aios-core');
+    const configPath = path.join(configDir, 'core-config.yaml');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, rendered, 'utf8');
+    }
+
+    return {
+      success: true,
+      path: configPath,
+      content: rendered,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      content: null,
+    };
+  }
+}
+
+/**
+ * Generates deployment config context from user inputs
+ *
+ * @param {Object} inputs - User inputs from wizard
+ * @returns {Object} Deployment configuration
+ */
+function buildDeploymentConfig(inputs = {}) {
+  return {
+    workflow: inputs.workflow || DeploymentWorkflow.STAGING_FIRST,
+    stagingBranch: inputs.stagingBranch || 'staging',
+    productionBranch: inputs.productionBranch || 'main',
+    stagingEnvName: inputs.stagingEnvName || 'Staging',
+    productionEnvName: inputs.productionEnvName || 'Production',
+    platform: inputs.platform || DeploymentPlatform.NONE,
+    qualityGates: {
+      lint: inputs.lint !== false,
+      typecheck: inputs.typecheck !== false,
+      tests: inputs.tests !== false,
+      securityScan: inputs.securityScan || false,
+      minCoverage: inputs.minCoverage || 50,
+    },
+    autoAssignReviewers: inputs.autoAssignReviewers || false,
+    draftByDefault: inputs.draftByDefault || false,
+  };
+}
+
+/**
+ * Gets default deployment config for a mode
+ *
+ * @param {string} mode - Installation mode
+ * @returns {Object} Default deployment config
+ */
+function getDefaultDeploymentConfig(mode) {
+  if (mode === 'brownfield') {
+    // Brownfield might use direct-to-main if solo project
+    return {
+      ...DEFAULT_DEPLOYMENT_CONFIG,
+      // Keep staging-first as default, but brownfield analyzer may change this
+    };
+  }
+
+  return { ...DEFAULT_DEPLOYMENT_CONFIG };
+}
+
+module.exports = {
+  buildConfigContext,
+  renderConfigTemplate,
+  loadConfigTemplate,
+  generateConfig,
+  buildDeploymentConfig,
+  getDefaultDeploymentConfig,
+  formatArrayAsYaml,
+  escapeYamlString,
+  ConfigTemplates,
+  DeploymentWorkflow,
+  DeploymentPlatform,
+  DEFAULT_DEPLOYMENT_CONFIG,
+  TEMPLATES_DIR,
+};

package/.aios-core/infrastructure/scripts/documentation-integrity/deployment-config-loader.js

@@ -0,0 +1,308 @@
+/**
+ * Deployment Config Loader
+ *
+ * Shared utility for loading deployment configuration from core-config.yaml.
+ * Implements the Configuration-Driven Architecture pattern.
+ *
+ * Usage:
+ *   const { loadDeploymentConfig } = require('./deployment-config-loader');
+ *   const config = loadDeploymentConfig(projectRoot);
+ *
+ * @module documentation-integrity/deployment-config-loader
+ * @version 1.0.0
+ * @story 6.9
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Default deployment configuration
+ * Used when core-config.yaml doesn't exist or deployment section is missing
+ *
+ * @type {Object}
+ */
+const DEFAULT_DEPLOYMENT_CONFIG = {
+  workflow: 'staging-first',
+
+  branches: {
+    staging_targets: ['feature/*', 'fix/*', 'docs/*', 'chore/*', 'refactor/*', 'test/*'],
+    production_targets: ['hotfix/*'],
+    staging_branch: 'staging',
+    production_branch: 'main',
+    default_target: 'staging',
+  },
+
+  environments: {
+    staging: {
+      name: 'Staging',
+      auto_deploy: true,
+      platform: null,
+      url: null,
+      promotion_message: 'After validation, create PR to main for production',
+    },
+    production: {
+      name: 'Production',
+      auto_deploy: true,
+      platform: null,
+      url: null,
+      promotion_message: 'This is the final production deployment',
+    },
+  },
+
+  quality_gates: {
+    lint: true,
+    typecheck: true,
+    tests: true,
+    security_scan: false,
+    min_coverage: 50,
+  },
+
+  pr_defaults: {
+    auto_assign_reviewers: false,
+    draft_by_default: false,
+    include_deployment_info: true,
+  },
+};
+
+/**
+ * Loads deployment configuration from core-config.yaml
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Deployment configuration (merged with defaults)
+ */
+function loadDeploymentConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.aios-core', 'core-config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    console.warn(`[deployment-config-loader] core-config.yaml not found at ${configPath}`);
+    console.warn('[deployment-config-loader] Using default deployment configuration');
+    return { ...DEFAULT_DEPLOYMENT_CONFIG };
+  }
+
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(configContent);
+
+    if (!config || !config.deployment) {
+      console.warn('[deployment-config-loader] No deployment section in core-config.yaml');
+      console.warn('[deployment-config-loader] Using default deployment configuration');
+      return { ...DEFAULT_DEPLOYMENT_CONFIG };
+    }
+
+    // Deep merge with defaults to ensure all required fields exist
+    return deepMerge(DEFAULT_DEPLOYMENT_CONFIG, config.deployment);
+  } catch (error) {
+    console.error(`[deployment-config-loader] Error loading config: ${error.message}`);
+    console.warn('[deployment-config-loader] Using default deployment configuration');
+    return { ...DEFAULT_DEPLOYMENT_CONFIG };
+  }
+}
+
+/**
+ * Loads project configuration from core-config.yaml
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object|null} Project configuration or null if not found
+ */
+function loadProjectConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.aios-core', 'core-config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(configContent);
+    return config.project || null;
+  } catch (error) {
+    console.error(`[deployment-config-loader] Error loading project config: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Gets the target branch for a given source branch
+ *
+ * @param {string} sourceBranch - Source branch name
+ * @param {Object} deploymentConfig - Deployment configuration
+ * @returns {string} Target branch name
+ */
+function getTargetBranch(sourceBranch, deploymentConfig) {
+  const { branches, workflow } = deploymentConfig;
+
+  // Check if it's a staging branch (used for promotion)
+  if (sourceBranch === branches.staging_branch) {
+    return branches.production_branch;
+  }
+
+  // Check production targets (hotfix/* etc.)
+  for (const pattern of branches.production_targets || []) {
+    if (matchesBranchPattern(sourceBranch, pattern)) {
+      return branches.production_branch;
+    }
+  }
+
+  // Check staging targets
+  for (const pattern of branches.staging_targets || []) {
+    if (matchesBranchPattern(sourceBranch, pattern)) {
+      // If direct-to-main workflow, target production
+      if (workflow === 'direct-to-main') {
+        return branches.production_branch;
+      }
+      return branches.staging_branch || branches.production_branch;
+    }
+  }
+
+  // Default target - resolve symbolic name to actual branch
+  const defaultTarget = (branches.default_target || 'production').toLowerCase();
+  const stagingBranch = branches.staging_branch;
+  const productionBranch = branches.production_branch;
+
+  // Handle symbolic names
+  if (defaultTarget === 'staging') {
+    return stagingBranch || productionBranch;
+  }
+  if (defaultTarget === 'production') {
+    return productionBranch;
+  }
+
+  // Handle explicit branch names as fallback (for manually-edited configs)
+  if (stagingBranch && defaultTarget === stagingBranch.toLowerCase()) {
+    return stagingBranch;
+  }
+  if (productionBranch && defaultTarget === productionBranch.toLowerCase()) {
+    return productionBranch;
+  }
+
+  // Conservative fallback with warning
+  console.warn(
+    `[deployment-config-loader] Unknown default_target "${branches.default_target}", falling back to production`,
+  );
+  return productionBranch;
+}
+
+/**
+ * Checks if a branch name matches a pattern
+ *
+ * @param {string} branchName - Branch name to check
+ * @param {string} pattern - Pattern to match (e.g., "feature/*")
+ * @returns {boolean} True if matches
+ */
+function matchesBranchPattern(branchName, pattern) {
+  // Escape regex metacharacters first, then convert glob wildcards
+  // Order matters: escape special chars, then convert * and ?
+  const regexPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex metacharacters (except * and ?)
+    .replace(/\*/g, '.*') // Convert glob * to regex .*
+    .replace(/\?/g, '.'); // Convert glob ? to regex .
+
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(branchName);
+}
+
+/**
+ * Gets environment configuration by name
+ *
+ * @param {string} envName - Environment name (staging/production)
+ * @param {Object} deploymentConfig - Deployment configuration
+ * @returns {Object|null} Environment configuration
+ */
+function getEnvironmentConfig(envName, deploymentConfig) {
+  const normalized = envName.toLowerCase();
+  return deploymentConfig.environments?.[normalized] || null;
+}
+
+/**
+ * Checks if quality gate is enabled
+ *
+ * @param {string} gateName - Gate name (lint, typecheck, tests, security_scan)
+ * @param {Object} deploymentConfig - Deployment configuration
+ * @returns {boolean} True if gate is enabled
+ */
+function isQualityGateEnabled(gateName, deploymentConfig) {
+  return deploymentConfig.quality_gates?.[gateName] === true;
+}
+
+/**
+ * Gets all enabled quality gates
+ *
+ * @param {Object} deploymentConfig - Deployment configuration
+ * @returns {string[]} List of enabled gate names
+ */
+function getEnabledQualityGates(deploymentConfig) {
+  const gates = deploymentConfig.quality_gates || {};
+  return Object.entries(gates)
+    .filter(([key, value]) => value === true && key !== 'min_coverage')
+    .map(([key]) => key);
+}
+
+/**
+ * Deep merge two objects
+ *
+ * @param {Object} target - Target object
+ * @param {Object} source - Source object
+ * @returns {Object} Merged object
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] || {}, source[key]);
+    } else if (source[key] !== undefined) {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Validates deployment configuration
+ *
+ * @param {Object} config - Deployment configuration to validate
+ * @returns {Object} Validation result with isValid and errors
+ */
+function validateDeploymentConfig(config) {
+  const errors = [];
+
+  // Check workflow
+  if (!['staging-first', 'direct-to-main'].includes(config.workflow)) {
+    errors.push(`Invalid workflow: ${config.workflow}`);
+  }
+
+  // Check branches
+  if (!config.branches?.production_branch) {
+    errors.push('Missing production_branch');
+  }
+
+  if (config.workflow === 'staging-first' && !config.branches?.staging_branch) {
+    errors.push('staging-first workflow requires staging_branch');
+  }
+
+  // Check environments
+  if (!config.environments?.production) {
+    errors.push('Missing production environment configuration');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+module.exports = {
+  loadDeploymentConfig,
+  loadProjectConfig,
+  getTargetBranch,
+  matchesBranchPattern,
+  getEnvironmentConfig,
+  isQualityGateEnabled,
+  getEnabledQualityGates,
+  validateDeploymentConfig,
+  deepMerge,
+  DEFAULT_DEPLOYMENT_CONFIG,
+};