cistack 1.0.0 → 2.0.0

package/bin/ciflow.js

@@ -9,7 +9,7 @@ const CIFlow = require('../src/index');
 program
   .name('cistack')
   .description('Generate GitHub Actions CI/CD pipelines by analysing your codebase')
-  .version('1.0.0');
+  .version('2.0.0');
 
 program
   .command('generate', { isDefault: true })
@@ -17,19 +17,78 @@ program
   .option('-p, --path <dir>', 'Path to the project root', process.cwd())
   .option('-o, --output <dir>', 'Output directory for workflow files', '.github/workflows')
   .option('--dry-run', 'Print the generated YAML without writing files')
-  .option('--force', 'Overwrite existing workflow files without prompting')
+  .option('--force', 'Overwrite existing workflow files without smart-merge')
   .option('--no-prompt', 'Skip interactive prompts and use detected settings')
   .option('--verbose', 'Show detailed analysis output')
   .action(async (options) => {
     const ciflow = new CIFlow({
       projectPath: path.resolve(options.path),
-      outputDir: options.output,
-      dryRun: options.dryRun,
-      force: options.force,
-      prompt: options.prompt,
-      verbose: options.verbose,
+      outputDir:   options.output,
+      dryRun:      options.dryRun,
+      force:       options.force,
+      prompt:      options.prompt,
+      verbose:     options.verbose,
     });
     await ciflow.run();
   });
 
+program
+  .command('init')
+  .description('Create a starter cistack.config.js in the current directory')
+  .option('-p, --path <dir>', 'Path to the project root', process.cwd())
+  .action(async (options) => {
+    const fs = require('fs');
+    const resolvedPath = path.resolve(options.path);
+    const configPath = path.join(resolvedPath, 'cistack.config.js');
+
+    // Ensure the target directory exists
+    if (!fs.existsSync(resolvedPath)) {
+      fs.mkdirSync(resolvedPath, { recursive: true });
+    }
+
+    if (fs.existsSync(configPath)) {
+      console.error('cistack.config.js already exists. Delete it first or edit it manually.');
+      process.exit(1);
+    }
+
+    const template = `// cistack.config.js
+// Override auto-detected settings for this project.
+// All fields are optional — omit what you don't need.
+
+/** @type {import('cistack').Config} */
+module.exports = {
+  // nodeVersion: '20',          // Override detected Node.js version
+  // packageManager: 'pnpm',    // 'npm' | 'yarn' | 'pnpm' | 'bun'
+  // hosting: ['Firebase'],      // Force a specific hosting provider
+  // branches: ['main', 'staging'], // CI branches (default: main, master, develop)
+  // outputDir: '.github/workflows', // Where to write workflow files
+
+  // cache: {
+  //   npm: true,     // enabled by default
+  //   pip: true,
+  //   cargo: true,
+  //   maven: true,
+  //   gradle: true,
+  //   go: true,
+  //   composer: true,
+  // },
+
+  // monorepo: {
+  //   perPackage: true, // Generate one ci-<name>.yml per workspace
+  // },
+
+  // release: {
+  //   tool: 'semantic-release', // override release tool detection
+  // },
+
+  // secrets: ['MY_EXTRA_SECRET'], // Document additional secrets in workflow comments
+};
+`;
+
+    fs.writeFileSync(configPath, template, 'utf8');
+    const chalk = require('chalk');
+    console.log(chalk.green(`✔ Created cistack.config.js at ${configPath}`));
+    console.log(chalk.dim('  Edit the file to override detected settings.'));
+  });
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cistack",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Automatically generate GitHub Actions CI/CD pipelines by analysing your codebase",
   "main": "src/index.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/ciflow.js",
-    "test": "node bin/ciflow.js --dry-run"
+    "test": "node bin/ciflow.js --dry-run --no-prompt"
   },
   "keywords": [
     "github-actions",
@@ -18,7 +18,14 @@
     "devops",
     "firebase",
     "vercel",
-    "netlify"
+    "netlify",
+    "monorepo",
+    "dependabot",
+    "semantic-release",
+    "changesets",
+    "caching",
+    "turborepo",
+    "nx"
   ],
   "author": "",
   "license": "MIT",

package/src/analyzers/monorepo.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { globSync } = require('glob');
+
+/**
+ * Resolves workspace packages from monorepo config files.
+ *
+ * Supported:
+ *   - package.json#workspaces (npm/yarn workspaces array or { packages: [] })
+ *   - pnpm-workspace.yaml
+ *   - turbo.json  (uses package.json workspaces in conjunction)
+ *   - nx.json     (discovers apps/* and libs/*)
+ *   - lerna.json  (uses lerna packages array)
+ *
+ * Returns: Array<{ name: string, relativePath: string, absolutePath: string, packageJson: object|null }>
+ */
+class MonorepoAnalyzer {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+    this.pkg = codebaseInfo.packageJson || {};
+  }
+
+  async analyze() {
+    if (!this.info.hasMonorepo) return [];
+
+    const workspaceGlobs = this._collectWorkspaceGlobs();
+    if (workspaceGlobs.length === 0) return [];
+
+    const packages = [];
+    const seen = new Set();
+
+    for (const pattern of workspaceGlobs) {
+      // Each glob glob like 'packages/*' → expand to actual dirs
+      const matches = globSync(pattern, {
+        cwd: this.root,
+        onlyDirectories: true,
+        absolute: false,
+        ignore: ['node_modules/**', '**/node_modules/**'],
+      });
+
+      for (const relDir of matches) {
+        if (seen.has(relDir)) continue;
+        seen.add(relDir);
+
+        const absPath = path.join(this.root, relDir);
+        const pkgJsonPath = path.join(absPath, 'package.json');
+        let pkgJson = null;
+
+        if (fs.existsSync(pkgJsonPath)) {
+          try {
+            pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+          } catch (_) {}
+        }
+
+        const name = (pkgJson && pkgJson.name) || path.basename(relDir);
+
+        packages.push({
+          name,
+          relativePath: relDir,
+          absolutePath: absPath,
+          packageJson: pkgJson,
+        });
+      }
+    }
+
+    return packages;
+  }
+
+  _collectWorkspaceGlobs() {
+    const globs = [];
+
+    // 1. package.json workspaces
+    if (this.pkg.workspaces) {
+      const ws = this.pkg.workspaces;
+      if (Array.isArray(ws)) {
+        globs.push(...ws);
+      } else if (ws.packages) {
+        globs.push(...ws.packages);
+      }
+    }
+
+    // 2. pnpm-workspace.yaml
+    const pnpmWsPath = path.join(this.root, 'pnpm-workspace.yaml');
+    if (fs.existsSync(pnpmWsPath)) {
+      try {
+        const yaml = require('js-yaml');
+        const parsed = yaml.load(fs.readFileSync(pnpmWsPath, 'utf8'));
+        if (parsed && parsed.packages) {
+          globs.push(...parsed.packages);
+        }
+      } catch (_) {}
+    }
+
+    // 3. lerna.json
+    const lernaPath = path.join(this.root, 'lerna.json');
+    if (fs.existsSync(lernaPath)) {
+      try {
+        const lerna = JSON.parse(fs.readFileSync(lernaPath, 'utf8'));
+        if (lerna.packages) globs.push(...lerna.packages);
+      } catch (_) {}
+    }
+
+    // 4. nx.json — default convention: apps/* + libs/*
+    const nxPath = path.join(this.root, 'nx.json');
+    if (fs.existsSync(nxPath) && globs.length === 0) {
+      globs.push('apps/*', 'libs/*', 'packages/*');
+    }
+
+    // 5. turbo.json — uses root package.json workspaces (already handled above)
+    // If none found yet, use convention
+    const turboPath = path.join(this.root, 'turbo.json');
+    if (fs.existsSync(turboPath) && globs.length === 0) {
+      globs.push('apps/*', 'packages/*');
+    }
+
+    // Deduplicate
+    return [...new Set(globs)];
+  }
+}
+
+module.exports = MonorepoAnalyzer;

package/src/config/loader.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Loads cistack.config.js (or .cjs / .mjs) from the project root.
+ * Returns an empty object if no config file is found.
+ *
+ * Supported keys:
+ *   nodeVersion      – override detected Node version e.g. '18'
+ *   packageManager   – override detected PM: 'npm'|'yarn'|'pnpm'|'bun'
+ *   hosting          – array of hosting names to force e.g. ['Firebase']
+ *   branches         – branches to run CI on e.g. ['main', 'staging']
+ *   cache            – { npm: bool, cargo: bool, pip: bool, ... } enable/disable caches
+ *   monorepo         – { perPackage: bool } generate one file per workspace
+ *   release          – { tool: 'semantic-release'|'changesets'|'standard-version'|'release-it' }
+ *   secrets          – extra secret names to document in workflow comments
+ *   outputDir        – override default '.github/workflows'
+ */
+class ConfigLoader {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+
+  load() {
+    const candidates = [
+      'cistack.config.js',
+      'cistack.config.cjs',
+      'cistack.config.mjs',
+    ];
+
+    for (const candidate of candidates) {
+      const fullPath = path.join(this.projectPath, candidate);
+      if (fs.existsSync(fullPath)) {
+        try {
+          // Clear require cache so hot-reloads work in watch mode
+          delete require.cache[require.resolve(fullPath)];
+          const cfg = require(fullPath);
+          // Handle both `module.exports = {}` and `export default {}`
+          const resolved = cfg && cfg.__esModule ? cfg.default : cfg;
+          if (resolved && typeof resolved === 'object') {
+            return resolved;
+          }
+        } catch (err) {
+          console.warn(`[cistack] Warning: could not load ${candidate}: ${err.message}`);
+        }
+      }
+    }
+
+    return {};
+  }
+
+  /**
+   * Deep-merge config file settings into detected settings.
+   * Config file always wins on scalar values; arrays overwrite entirely.
+   */
+  static merge(detected, override) {
+    if (!override || typeof override !== 'object') return detected;
+
+    const result = { ...detected };
+
+    for (const [key, val] of Object.entries(override)) {
+      if (val === null || val === undefined) continue;
+
+      if (Array.isArray(val)) {
+        result[key] = val; // arrays overwrite
+      } else if (typeof val === 'object' && !Array.isArray(detected[key])) {
+        result[key] = { ...(detected[key] || {}), ...val };
+      } else {
+        result[key] = val;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Apply config file overrides onto the full detected stack.
+   *
+   * @param {object} cfg          - raw cistack.config.js export
+   * @param {object} detected     - { hosting, frameworks, languages, testing }
+   * @returns {object}            - merged config ready for the generator
+   */
+  static applyToStack(cfg, detected) {
+    if (!cfg || Object.keys(cfg).length === 0) return detected;
+
+    const result = { ...detected };
+
+    // Override primary language settings
+    if (cfg.nodeVersion && result.languages && result.languages.length > 0) {
+      result.languages = result.languages.map((l, i) =>
+        i === 0 && (l.name === 'JavaScript' || l.name === 'TypeScript')
+          ? { ...l, nodeVersion: String(cfg.nodeVersion) }
+          : l
+      );
+    }
+
+    if (cfg.packageManager && result.languages && result.languages.length > 0) {
+      result.languages = result.languages.map((l, i) =>
+        i === 0 ? { ...l, packageManager: cfg.packageManager } : l
+      );
+    }
+
+    // Override hosting
+    if (cfg.hosting && Array.isArray(cfg.hosting)) {
+      result.hosting = cfg.hosting.map((name) => ({
+        name,
+        confidence: 1.0,
+        manual: true,
+        secrets: [],
+        notes: ['set via cistack.config.js'],
+      }));
+    }
+
+    // Pass through raw extras for generators to consume
+    result._config = cfg;
+
+    return result;
+  }
+}
+
+module.exports = ConfigLoader;

package/src/detectors/env.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detects environment variables documented in .env.example or .env.sample.
+ *
+ * Returns:
+ *   {
+ *     secrets: string[],   – keys that look like secrets (TOKEN, KEY, SECRET, PASSWORD, PASS)
+ *     public:  string[],   – other public env vars
+ *     all:     string[],   – full list in file order
+ *     sourceFile: string,  – which file was read
+ *   }
+ */
+class EnvDetector {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+  }
+
+  async detect() {
+    const candidates = ['.env.example', '.env.sample', '.env.template', '.env.defaults'];
+
+    for (const candidate of candidates) {
+      const fullPath = path.join(this.root, candidate);
+      if (fs.existsSync(fullPath)) {
+        const content = fs.readFileSync(fullPath, 'utf8');
+        return this._parse(content, candidate);
+      }
+    }
+
+    return { secrets: [], public: [], all: [], sourceFile: null };
+  }
+
+  _parse(content, sourceFile) {
+    const all = [];
+    const secrets = [];
+    const publicVars = [];
+
+    const SECRET_PATTERN = /SECRET|TOKEN|KEY|PASSWORD|PASS|PRIVATE|AUTH|CREDENTIAL|CERT|PEM/i;
+
+    for (const rawLine of content.split('\n')) {
+      const line = rawLine.trim();
+
+      // Skip comments and blank lines
+      if (!line || line.startsWith('#')) continue;
+
+      // Match KEY=value or KEY= or just KEY
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)\s*(?:=.*)?$/i);
+      if (!match) continue;
+
+      const key = match[1].toUpperCase();
+      if (all.includes(key)) continue; // de-dupe
+
+      all.push(key);
+      if (SECRET_PATTERN.test(key)) {
+        secrets.push(key);
+      } else {
+        publicVars.push(key);
+      }
+    }
+
+    return { secrets, public: publicVars, all, sourceFile };
+  }
+}
+
+module.exports = EnvDetector;

package/src/detectors/release.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detects the release tooling used in a project.
+ *
+ * Checks (in order of priority):
+ *   1. semantic-release
+ *   2. @changesets/cli
+ *   3. release-it
+ *   4. standard-version
+ *
+ * Returns: { tool: string, config: object, publishToNpm: bool } or null
+ */
+class ReleaseDetector {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+    this.pkg = codebaseInfo.packageJson || {};
+    this.deps = {
+      ...(this.pkg.dependencies || {}),
+      ...(this.pkg.devDependencies || {}),
+    };
+    this.scripts = this.pkg.scripts || {};
+  }
+
+  async detect() {
+    // --- semantic-release ---
+    if (this.deps['semantic-release']) {
+      const config = this._loadSemanticReleaseConfig();
+      const plugins = config.plugins || ['@semantic-release/commit-analyzer', '@semantic-release/release-notes-generator', '@semantic-release/github'];
+      return {
+        tool: 'semantic-release',
+        command: 'npx semantic-release',
+        config,
+        plugins,
+        publishToNpm: plugins.some((p) => (typeof p === 'string' ? p : p[0]) === '@semantic-release/npm'),
+        requiresNpmToken: plugins.some((p) => (typeof p === 'string' ? p : p[0]) === '@semantic-release/npm'),
+      };
+    }
+
+    // --- changesets ---
+    if (this.deps['@changesets/cli']) {
+      const publishScript = this.scripts['release'] || this.scripts['publish'];
+      return {
+        tool: 'changesets',
+        command: 'npx changeset publish',
+        publishToNpm: !!(publishScript && publishScript.includes('publish')),
+        requiresNpmToken: true,
+      };
+    }
+
+    // --- release-it ---
+    if (this.deps['release-it']) {
+      const config = this._loadReleaseItConfig();
+      return {
+        tool: 'release-it',
+        command: 'npx release-it --ci',
+        config,
+        publishToNpm: !!(config && config.npm && config.npm.publish !== false),
+        requiresNpmToken: true,
+      };
+    }
+
+    // --- standard-version ---
+    if (this.deps['standard-version']) {
+      return {
+        tool: 'standard-version',
+        command: 'npx standard-version',
+        publishToNpm: false,
+        requiresNpmToken: false,
+      };
+    }
+
+    // --- fallback: check scripts ---
+    const releaseScript = this.scripts['release'] || this.scripts['version'];
+    if (releaseScript) {
+      return {
+        tool: 'custom',
+        command: 'npm run release',
+        publishToNpm: releaseScript.includes('publish'),
+        requiresNpmToken: releaseScript.includes('publish'),
+      };
+    }
+
+    return null;
+  }
+
+  _loadSemanticReleaseConfig() {
+    // Try .releaserc, .releaserc.json, .releaserc.js, package.json#release
+    const candidates = ['.releaserc', '.releaserc.json', '.releaserc.js', '.releaserc.yaml'];
+    for (const c of candidates) {
+      const p = path.join(this.root, c);
+      if (fs.existsSync(p)) {
+        try {
+          const raw = fs.readFileSync(p, 'utf8');
+          if (c.endsWith('.js')) return require(p);
+          return JSON.parse(raw);
+        } catch (_) {}
+      }
+    }
+    if (this.pkg.release) return this.pkg.release;
+    return {};
+  }
+
+  _loadReleaseItConfig() {
+    const candidates = ['.release-it.json', '.release-it.js', '.release-it.yaml'];
+    for (const c of candidates) {
+      const p = path.join(this.root, c);
+      if (fs.existsSync(p)) {
+        try {
+          const raw = fs.readFileSync(p, 'utf8');
+          return JSON.parse(raw);
+        } catch (_) {}
+      }
+    }
+    if (this.pkg['release-it']) return this.pkg['release-it'];
+    return {};
+  }
+}
+
+module.exports = ReleaseDetector;