cistack 3.2.0 → 5.0.0

package/src/index.js

@@ -18,6 +18,7 @@ const WorkflowGenerator = require('./generators/workflow');
 const DependabotGenerator = require('./generators/dependabot');
 const ReleaseGenerator  = require('./generators/release');
 const ConfigLoader      = require('./config/loader');
+const combineWorkflows  = require('./utils/workflow-combiner');
 const { ensureDir, writeFile, banner, smartMergeWorkflow } = require('./utils/helpers');
 
 const WorkflowAnalyzer = require('./analyzers/workflow');
@@ -42,17 +43,16 @@ class CIFlow {
     try {
       // ── 1. Load cistack.config.js ─────────────────────────────────────
       const configLoader = new ConfigLoader(this.projectPath);
-      const userConfig = configLoader.load();
+      const userConfig = await configLoader.load();
       if (Object.keys(userConfig).length > 0) {
         spinner.info(chalk.cyan('cistack.config.js loaded'));
-        spinner.start('Scanning project...');
-        // Allow config to override outputDir
         if (userConfig.outputDir) {
           this.outputDir = path.join(this.projectPath, userConfig.outputDir);
         }
       }
 
       // ── 2. Analyse the codebase ───────────────────────────────────────
+      if (!spinner.isSpinning) spinner.start('Scanning project...');
       const analyzer = new CodebaseAnalyzer(this.projectPath, { verbose: this.verbose });
       const codebaseInfo = await analyzer.analyse();
       spinner.succeed(chalk.green('Project scanned'));
@@ -81,13 +81,22 @@ class CIFlow {
         frameworks,
         languages,
         testing,
+        releaseInfo,
         envVars,
         monorepoPackages,
+        lockFiles: codebaseInfo.lockFiles,
+        defaultBranch: codebaseInfo.defaultBranch,
+        currentBranch: codebaseInfo.currentBranch,
         _config: userConfig,
       });
 
       // ── 5. Print summary ───────────────────────────────────────────────
-      this._printSummary(finalConfig, releaseInfo, envVars, monorepoPackages);
+      this._printSummary(
+        finalConfig,
+        finalConfig.releaseInfo || releaseInfo,
+        finalConfig.envVars || envVars,
+        finalConfig.monorepoPackages || monorepoPackages
+      );
 
       // ── 6. Optional interactive confirmation ──────────────────────────
       if (this.prompt) {
@@ -97,21 +106,26 @@ class CIFlow {
       // ── 7. Generate CI/CD workflow(s) ─────────────────────────────────
       spinner.start('Generating workflow(s)...');
       const generator = new WorkflowGenerator(finalConfig, this.projectPath);
-      const workflows = generator.generate();
-      spinner.succeed(chalk.green(`Generated ${workflows.length} CI workflow(s)`));
+      let workflows = generator.generate();
 
       // ── 8. Generate dependabot.yml ────────────────────────────────────
       const dependabotGen = new DependabotGenerator(codebaseInfo);
       const dependabotFile = dependabotGen.generate();
 
-      // ── 9. Generate release.yml (if release tooling detected) ─────────
+      // ── 9. Generate release.yml (if release tooling detected or configured) ─
       let releaseWorkflow = null;
-      if (releaseInfo) {
-        const releaseGen = new ReleaseGenerator(releaseInfo, finalConfig, this.projectPath);
+      const combinedReleaseInfo = finalConfig.releaseInfo || releaseInfo;
+      if (combinedReleaseInfo) {
+        const releaseGen = new ReleaseGenerator(combinedReleaseInfo, finalConfig, this.projectPath);
         releaseWorkflow = releaseGen.generate();
         if (releaseWorkflow) workflows.push(releaseWorkflow);
       }
 
+      if (this._workflowLayout(finalConfig) !== 'split') {
+        workflows = [combineWorkflows(workflows, { config: finalConfig, releaseInfo: combinedReleaseInfo })];
+      }
+      spinner.succeed(chalk.green(`Generated ${workflows.length} workflow file(s)`));
+
       // ── 10. Write files ────────────────────────────────────────────────
       if (this.dryRun) {
         this._dryRunPrint(workflows, dependabotFile);
@@ -244,6 +258,11 @@ class CIFlow {
     console.log('');
   }
 
+  _workflowLayout(config) {
+    const layout = config && config._config && config._config.workflowLayout;
+    return layout === 'split' ? 'split' : 'single';
+  }
+
   async _interactiveConfirm(config) {
     const { confirmed } = await inquirer.prompt([
       {
@@ -388,19 +407,15 @@ class CIFlow {
     ensureDir(githubDir);
 
     if (exists && !this.force) {
+      // dependabot.yml has a fixed schema, simpler to just overwrite or keep if identical
       const existing = fs.readFileSync(filePath, 'utf8');
-      const { content: merged, changes } = smartMergeWorkflow(existing, dependabotFile.content);
-
-      if (changes.length === 0) {
+      if (existing.trim() === dependabotFile.content.trim()) {
         console.log(chalk.dim(`  ○ No changes: dependabot.yml`));
         return;
       }
-
-      writeFile(filePath, merged);
-      console.log(chalk.yellow(`  ↻ Smart-merged: dependabot.yml`));
-      for (const c of changes) {
-        console.log(chalk.dim(`    • ${c}`));
-      }
+      
+      writeFile(filePath, dependabotFile.content);
+      console.log(chalk.yellow(`  ↻ Updated: dependabot.yml (schema mismatch for smart-merge)`));
     } else {
       writeFile(filePath, dependabotFile.content);
       console.log(chalk.green(`  ✔ Written:      .github/dependabot.yml`));

package/src/utils/helpers.js

@@ -129,16 +129,17 @@ function _mergeJob(existJob, genJob, jobId) {
     }
   }
 
-  // Merge steps by name
+  // Merge steps
   if (genJob.steps) {
-    const existStepsByName = {};
-    for (const s of (existJob.steps || [])) {
-      if (s.name) existStepsByName[s.name] = s;
-    }
-
     const mergedSteps = [];
     for (const genStep of genJob.steps) {
-      const existStep = existStepsByName[genStep.name];
+      // Find matches by name, uses, or id
+      const existStep = (existJob.steps || []).find(s => 
+        (genStep.name && s.name === genStep.name) ||
+        (genStep.id && s.id === genStep.id) ||
+        (genStep.uses && s.uses === genStep.uses)
+      );
+
       if (!existStep) {
         mergedSteps.push(genStep);
         jobChanges.push(`  job "${jobId}" → added step "${genStep.name}"`);
@@ -153,6 +154,19 @@ function _mergeJob(existJob, genJob, jobId) {
         }
       }
     }
+    // Append any existing steps that were NOT matched by a generated step
+    // This ensures user customizations are preserved.
+    for (const existStep of (existJob.steps || [])) {
+      const isMatched = genJob.steps.some((genStep) => 
+        (genStep.name && existStep.name === genStep.name) ||
+        (genStep.id && existStep.id === genStep.id) ||
+        (genStep.uses && existStep.uses === genStep.uses)
+      );
+      if (!isMatched) {
+        mergedSteps.push(existStep);
+      }
+    }
+    
     merged.steps = mergedSteps;
   }
 

package/src/utils/workflow-combiner.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const path = require('path');
+const yaml = require('js-yaml');
+const { version } = require('../../package.json');
+
+function stripHeader(content) {
+  return content.replace(/^(?:#[^\n]*\n)+\n?/, '');
+}
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function dedupeArray(values) {
+  const seen = new Set();
+  const result = [];
+
+  for (const value of values) {
+    const key = isPlainObject(value) || Array.isArray(value)
+      ? JSON.stringify(value)
+      : String(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+  }
+
+  return result;
+}
+
+function mergeDeep(target, source) {
+  if (Array.isArray(target) || Array.isArray(source)) {
+    return dedupeArray([...(target || []), ...(source || [])]);
+  }
+  if (isPlainObject(target) && isPlainObject(source)) {
+    const merged = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      merged[key] = key in merged ? mergeDeep(merged[key], value) : value;
+    }
+    return merged;
+  }
+  return source === undefined ? target : source;
+}
+
+function mergePermissions(target, source) {
+  const rank = { none: 0, read: 1, write: 2 };
+  const merged = { ...(target || {}) };
+
+  for (const [key, value] of Object.entries(source || {})) {
+    const current = merged[key];
+    if (!current) {
+      merged[key] = value;
+      continue;
+    }
+    merged[key] = (rank[value] || 0) > (rank[current] || 0) ? value : current;
+  }
+
+  return merged;
+}
+
+function prefixJobMap(jobs, prefix) {
+  const mapping = {};
+  for (const jobId of Object.keys(jobs || {})) {
+    mapping[jobId] = `${prefix}_${jobId}`;
+  }
+
+  const prefixed = {};
+  for (const [jobId, job] of Object.entries(jobs || {})) {
+    const nextJob = JSON.parse(JSON.stringify(job));
+    if (typeof nextJob.needs === 'string') {
+      nextJob.needs = mapping[nextJob.needs] || nextJob.needs;
+    } else if (Array.isArray(nextJob.needs)) {
+      nextJob.needs = nextJob.needs.map((need) => mapping[need] || need);
+    }
+    prefixed[mapping[jobId]] = nextJob;
+  }
+
+  return prefixed;
+}
+
+function unwrapExpression(expr) {
+  if (typeof expr !== 'string') return '';
+  return expr.trim().replace(/^\${{\s*/, '').replace(/\s*}}$/, '');
+}
+
+function quote(value) {
+  return String(value).replace(/'/g, "\\'");
+}
+
+function buildBranchCondition(branches, refName) {
+  if (!Array.isArray(branches) || branches.length === 0) return '';
+  return branches
+    .map((branch) => `${refName} == '${quote(branch)}'`)
+    .join(' || ');
+}
+
+function buildTriggerCondition(onConfig) {
+  if (!onConfig) return '';
+
+  if (typeof onConfig === 'string') {
+    return `github.event_name == '${quote(onConfig)}'`;
+  }
+
+  if (Array.isArray(onConfig)) {
+    return onConfig
+      .map((eventName) => `github.event_name == '${quote(eventName)}'`)
+      .join(' || ');
+  }
+
+  const clauses = [];
+
+  for (const [eventName, eventConfig] of Object.entries(onConfig)) {
+    if (eventName === 'push') {
+      const branchExpr = buildBranchCondition(eventConfig && eventConfig.branches, 'github.ref_name');
+      clauses.push(branchExpr ? `(github.event_name == 'push' && (${branchExpr}))` : "github.event_name == 'push'");
+      continue;
+    }
+
+    if (eventName === 'pull_request') {
+      const branchExpr = buildBranchCondition(eventConfig && eventConfig.branches, 'github.base_ref');
+      clauses.push(branchExpr ? `(github.event_name == 'pull_request' && (${branchExpr}))` : "github.event_name == 'pull_request'");
+      continue;
+    }
+
+    if (eventName === 'workflow_dispatch') {
+      clauses.push("github.event_name == 'workflow_dispatch'");
+      continue;
+    }
+
+    if (eventName === 'schedule') {
+      clauses.push("github.event_name == 'schedule'");
+      continue;
+    }
+
+    clauses.push(`github.event_name == '${quote(eventName)}'`);
+  }
+
+  return clauses.join(' || ');
+}
+
+function applyTriggerCondition(job, triggerCondition) {
+  if (!triggerCondition) return job;
+
+  const nextJob = { ...job };
+  const existingIf = unwrapExpression(nextJob.if);
+  nextJob.if = existingIf
+    ? `(${triggerCondition}) && (${existingIf})`
+    : triggerCondition;
+  return nextJob;
+}
+
+function collectRequiredSecrets(config, releaseInfo) {
+  const secrets = new Set();
+
+  for (const hosting of config.hosting || []) {
+    for (const secret of hosting.secrets || []) {
+      secrets.add(secret);
+    }
+  }
+
+  for (const secret of (config.envVars && config.envVars.secrets) || []) {
+    secrets.add(secret);
+  }
+
+  if (releaseInfo && releaseInfo.requiresNpmToken) {
+    secrets.add('NPM_TOKEN');
+  }
+
+  return [...secrets];
+}
+
+function buildHeader(sections, config, releaseInfo) {
+  const sectionList = dedupeArray(sections).join(', ');
+  const requiredSecrets = collectRequiredSecrets(config, releaseInfo);
+  const secretsDoc = requiredSecrets.length > 0
+    ? `# Required secrets: ${requiredSecrets.join(', ')}\n# Add these at: Settings → Secrets and Variables → Actions\n`
+    : '';
+
+  return (
+    `# Generated by cistack v${version} — https://github.com/cistack\n` +
+    `# Unified Pipeline: ${sectionList}\n` +
+    `${secretsDoc}` +
+    `# Dependabot remains in .github/dependabot.yml\n\n`
+  );
+}
+
+function combineWorkflows(workflows, options = {}) {
+  const config = options.config || {};
+  const releaseInfo = options.releaseInfo || null;
+  const combined = {
+    name: 'Pipeline',
+    on: {},
+    concurrency: {
+      group: '${{ github.workflow }}-${{ github.ref }}',
+      'cancel-in-progress': true,
+    },
+    jobs: {},
+  };
+  const sections = [];
+
+  for (const workflow of workflows.filter(Boolean)) {
+    const parsed = yaml.load(stripHeader(workflow.content));
+    const triggerCondition = buildTriggerCondition(parsed.on || {});
+    const prefix = path.basename(workflow.filename, path.extname(workflow.filename))
+      .replace(/[^a-z0-9]+/gi, '_')
+      .replace(/^_+|_+$/g, '')
+      .toLowerCase();
+
+    sections.push(prefix);
+    combined.on = mergeDeep(combined.on, parsed.on || {});
+    if (parsed.env) {
+      combined.env = mergeDeep(combined.env || {}, parsed.env);
+    }
+    if (parsed.permissions) {
+      combined.permissions = mergePermissions(combined.permissions, parsed.permissions);
+    }
+
+    const prefixedJobs = prefixJobMap(parsed.jobs, prefix);
+    for (const [jobId, job] of Object.entries(prefixedJobs)) {
+      combined.jobs[jobId] = applyTriggerCondition(job, triggerCondition);
+    }
+  }
+
+  const raw = yaml.dump(combined, {
+    indent: 2,
+    lineWidth: 120,
+    quotingType: "'",
+    forceQuotes: false,
+    noRefs: true,
+  });
+
+  return {
+    filename: 'pipeline.yml',
+    content: buildHeader(sections, config, releaseInfo) + raw,
+  };
+}
+
+module.exports = combineWorkflows;