cistack 3.2.0 → 5.0.0

package/src/generators/workflow.js

@@ -20,7 +20,10 @@ class WorkflowGenerator {
     this.projectPath = projectPath;
     this.envVars = config.envVars || { secrets: [], public: [], all: [], sourceFile: null };
     this.monorepoPackages = config.monorepoPackages || [];
+    this.lockFiles = new Set(config.lockFiles || []);
     this.extraConfig = config._config || {}; // raw cistack.config.js
+    this.defaultBranch = config.defaultBranch || config.currentBranch || null;
+    this.workflowLayout = this.extraConfig.workflowLayout === 'split' ? 'split' : 'single';
 
     // Convenient accessors
     this.primaryLang = this.languages[0] || { name: 'JavaScript', packageManager: 'npm', nodeVersion: '20' };
@@ -29,26 +32,64 @@ class WorkflowGenerator {
     this.hasDocker = this.hosting.some((h) => h.name === 'Docker');
     this.primaryHosting = this.hosting.filter((h) => h.name !== 'Docker')[0] || null;
 
-    // Monorepo mode: per-package workflows if configured or if > 1 package
+    // Monorepo mode: always keep the root matrix workflow for monorepos.
+    // Split layout may additionally emit one workflow per workspace.
     this.isMonorepo = this.monorepoPackages.length > 0;
-    this.perPackageWorkflows = this.isMonorepo && (
+    this.perPackageWorkflows = this.workflowLayout === 'split' && this.isMonorepo && (
       (this.extraConfig.monorepo && this.extraConfig.monorepo.perPackage) ||
       this.monorepoPackages.length > 1
     );
+
+    // Initial runtime detection
+    this._detectRuntimeVersions();
+  }
+
+  _detectRuntimeVersions() {
+    const fs = require('fs');
+    const path = require('path');
+
+    // 1. Node.js
+    if (!this.primaryLang.nodeVersion) {
+      const nvmrcPath = path.join(this.projectPath, '.nvmrc');
+      if (fs.existsSync(nvmrcPath)) {
+        this.primaryLang.nodeVersion = fs.readFileSync(nvmrcPath, 'utf8').trim().replace('v', '');
+      } else {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(path.join(this.projectPath, 'package.json'), 'utf8'));
+          if (pkg.engines && pkg.engines.node) {
+            const match = pkg.engines.node.match(/(\d+)/);
+            if (match) this.primaryLang.nodeVersion = match[1];
+          }
+        } catch (_) {}
+      }
+      this.primaryLang.nodeVersion = this.primaryLang.nodeVersion || '20';
+    }
+
+    // 2. Python
+    if (this.primaryLang.name === 'Python' && !this.primaryLang.pythonVersion) {
+      const pythonVersionPath = path.join(this.projectPath, '.python-version');
+      if (fs.existsSync(pythonVersionPath)) {
+        this.primaryLang.pythonVersion = fs.readFileSync(pythonVersionPath, 'utf8').trim();
+      } else {
+        this.primaryLang.pythonVersion = '3.11';
+      }
+    }
   }
 
   generate() {
     const workflows = [];
 
-    if (this.perPackageWorkflows) {
-      // ── Monorepo: one CI file per workspace ─────────────────────────────
-      for (const pkg of this.monorepoPackages) {
-        workflows.push({
-          filename: `ci-${this._slugify(pkg.name)}.yml`,
-          content: this._buildCIWorkflow(pkg),
-        });
+    if (this.isMonorepo) {
+      if (this.perPackageWorkflows) {
+        // ── Monorepo split mode: one CI file per workspace ───────────────
+        for (const pkg of this.monorepoPackages) {
+          workflows.push({
+            filename: `ci-${this._slugify(pkg.name)}.yml`,
+            content: this._buildCIWorkflow(pkg),
+          });
+        }
       }
-      // Root-level CI file (matrix over all packages)
+      // ── Monorepo root CI file (matrix over all packages) ──────────────
       workflows.push({
         filename: 'ci.yml',
         content: this._buildMonorepoRootCI(),
@@ -94,7 +135,7 @@ class WorkflowGenerator {
     const lang = this._langForPackage(pkg);
     const jobs = {};
 
-    const branches = this.extraConfig.branches || ['main', 'master', 'develop'];
+    const branches = this._resolveBranches(['main', 'master', 'develop']);
 
     // ── lint job ──────────────────────────────────────────────────────────
     jobs.lint = {
@@ -104,8 +145,12 @@ class WorkflowGenerator {
         this._stepCheckout(),
         ...this._setupSteps(lang),
         this._stepInstallDeps(lang),
-        this._stepLint(lang),
+        this._stepLint(lang, pkg),
       ].filter(Boolean),
+      env: {
+        CI: 'true',
+        ...this._getPublicEnv(),
+      },
     };
 
     // ── test job ──────────────────────────────────────────────────────────
@@ -117,16 +162,20 @@ class WorkflowGenerator {
         ...(testMatrix ? { strategy: testMatrix } : {}),
         steps: [
           this._stepCheckout(),
-          ...this._setupSteps(lang),
+          ...this._setupSteps(lang, !!testMatrix),
           this._stepInstallDeps(lang),
-          ...this._unitTestSteps(lang),
+          ...this._unitTestSteps(lang, pkg),
           this._stepUploadCoverage(),
         ].filter(Boolean),
+        env: {
+          CI: 'true',
+          ...this._getPublicEnv(),
+        },
       };
     }
 
     // ── build job ─────────────────────────────────────────────────────────
-    const buildSteps = this._buildSteps(lang);
+    const buildSteps = this._buildSteps(lang, pkg);
     if (buildSteps.length > 0) {
       jobs.build = {
         name: '🏗️ Build',
@@ -137,18 +186,46 @@ class WorkflowGenerator {
           ...this._setupSteps(lang),
           this._stepInstallDeps(lang),
           ...buildSteps,
-          this._stepUploadArtifact(),
+          this._stepUploadArtifact(lang),
         ].filter(Boolean),
+        env: {
+          NODE_ENV: 'production',
+          ...this._getPublicEnv(),
+        },
+      };
+    }
+
+    // ── lighthouse job ──────────────────────────────────────────────────
+    if (jobs.build && this.frameworks.some(f => ['Next.js', 'React', 'Vue', 'Svelte', 'Nuxt'].includes(f.name))) {
+      jobs.lighthouse = {
+        name: '⚡ Lighthouse Audit',
+        'runs-on': 'ubuntu-latest',
+        needs: ['build'],
+        if: "github.event_name == 'pull_request'",
+        steps: [
+          this._stepCheckout(),
+          {
+            name: 'Run Lighthouse on build output',
+            uses: 'treosh/lighthouse-ci-action@v11',
+            with: {
+              uploadArtifacts: true,
+              temporaryPublicStorage: true,
+              configPath: './.lighthouserc.json',
+            },
+          },
+        ],
+        'continue-on-error': true,
       };
     }
 
     // ── e2e job ───────────────────────────────────────────────────────────
     if (this.e2eTests.length > 0) {
       const e2eTest = this.e2eTests[0];
+      const e2eNeeds = jobs.build ? ['build'] : ['lint', ...(jobs.test ? ['test'] : [])];
       jobs.e2e = {
         name: '🎭 E2E Tests',
         'runs-on': 'ubuntu-latest',
-        needs: ['build'],
+        needs: e2eNeeds,
         steps: [
           this._stepCheckout(),
           ...this._setupSteps(lang),
@@ -191,9 +268,13 @@ class WorkflowGenerator {
     };
 
     const envComment = this._envComment();
+    const pipelineStages = ['lint'];
+    if (jobs.test) pipelineStages.push('test');
+    if (jobs.build) pipelineStages.push('build');
+    if (jobs.e2e) pipelineStages.push('e2e');
     const header =
       `# Generated by cistack v${version} — https://github.com/cistack\n` +
-      `# CI Pipeline: lint → test → build${this.e2eTests.length > 0 ? ' → e2e' : ''}\n` +
+      `# CI Pipeline: ${pipelineStages.join(' → ')}\n` +
       envComment +
       `\n`;
 
@@ -203,8 +284,18 @@ class WorkflowGenerator {
   // ── Monorepo root CI (matrix over all workspaces) ────────────────────────
   _buildMonorepoRootCI() {
     const lang = this.primaryLang;
-    const branches = this.extraConfig.branches || ['main', 'master', 'develop'];
-    const pkgPaths = this.monorepoPackages.map((p) => p.relativePath);
+    const branches = this._resolveBranches(['main', 'master', 'develop']);
+    const matrixEntries = this.monorepoPackages.map((pkg) => {
+      const pkgScripts = (pkg.packageJson && pkg.packageJson.scripts) || {};
+      return {
+        name: pkg.name,
+        package: pkg.relativePath,
+        lintScript: this._findScript(['lint', 'lint:ci', 'eslint'], pkg) || '',
+        testScript: (pkgScripts['test:ci'] && 'test:ci') || (pkgScripts.test && 'test') || '',
+        buildScript: this._findScript(['build', 'build:prod', 'compile'], pkg) || '',
+      };
+    });
+    const buildablePackages = matrixEntries.filter((pkg) => pkg.buildScript);
 
     const workflow = {
       name: 'CI — Monorepo',
@@ -222,50 +313,71 @@ class WorkflowGenerator {
           'runs-on': 'ubuntu-latest',
           strategy: {
             matrix: {
-              package: pkgPaths,
+              include: matrixEntries,
             },
             'fail-fast': false,
           },
           steps: [
             this._stepCheckout(),
             ...this._setupSteps(lang),
-            {
-              name: 'Install dependencies',
-              run: lang.packageManager === 'pnpm'
-                ? 'pnpm --filter ${{ matrix.package }} install --frozen-lockfile'
-                : lang.packageManager === 'yarn'
-                ? 'yarn workspace ${{ matrix.package }} install'
-                : 'npm ci --workspace=${{ matrix.package }}',
-            },
+            this._stepInstallDeps(lang),
             {
               name: 'Lint',
-              run: lang.packageManager === 'pnpm'
-                ? 'pnpm --filter ${{ matrix.package }} run lint --if-present'
-                : lang.packageManager === 'yarn'
-                ? 'yarn workspace ${{ matrix.package }} run lint || true'
-                : 'npm run --workspace=${{ matrix.package }} lint || true',
+              if: '${{ matrix.lintScript != \'\' }}',
+              run: this._workspaceRunCommand(lang, '${{ matrix.lintScript }}'),
             },
             {
               name: 'Test',
-              run: lang.packageManager === 'pnpm'
-                ? 'pnpm --filter ${{ matrix.package }} run test --if-present'
-                : lang.packageManager === 'yarn'
-                ? 'yarn workspace ${{ matrix.package }} run test || true'
-                : 'npm run --workspace=${{ matrix.package }} test || true',
+              if: '${{ matrix.testScript != \'\' }}',
+              run: this._workspaceRunCommand(lang, '${{ matrix.testScript }}'),
             },
             {
               name: 'Build',
-              run: lang.packageManager === 'pnpm'
-                ? 'pnpm --filter ${{ matrix.package }} run build --if-present'
-                : lang.packageManager === 'yarn'
-                ? 'yarn workspace ${{ matrix.package }} run build || true'
-                : 'npm run --workspace=${{ matrix.package }} build || true',
+              if: '${{ matrix.buildScript != \'\' }}',
+              run: this._workspaceRunCommand(lang, '${{ matrix.buildScript }}'),
             },
           ].filter(Boolean),
+          env: {
+            NODE_ENV: 'test',
+            CI: 'true',
+            ...this._getPublicEnv(),
+          },
         },
       },
     };
 
+    if (buildablePackages.length > 0 && this.frameworks.some(f => ['Next.js', 'React', 'Vue', 'Svelte', 'Nuxt'].includes(f.name))) {
+      workflow.jobs.lighthouse = {
+        name: '⚡ Lighthouse (Root)',
+        'runs-on': 'ubuntu-latest',
+        strategy: {
+          matrix: {
+            include: buildablePackages,
+          },
+        },
+        steps: [
+          this._stepCheckout(),
+          ...this._setupSteps(lang),
+          {
+            ...this._stepInstallDeps(lang),
+          },
+          {
+            name: 'Build workspace',
+            run: this._workspaceRunCommand(lang, '${{ matrix.buildScript }}'),
+          },
+          {
+            name: 'Lighthouse',
+            uses: 'treosh/lighthouse-ci-action@v11',
+            with: {
+              uploadArtifacts: true,
+              temporaryPublicStorage: true,
+            },
+          },
+        ],
+        'continue-on-error': true,
+      };
+    }
+
     return this._toYaml(
       workflow,
       `# Generated by cistack v${version} — https://github.com/cistack\n# Monorepo CI — matrix over all workspaces\n\n`
@@ -279,8 +391,11 @@ class WorkflowGenerator {
   _buildDeployWorkflow() {
     const h = this.primaryHosting;
     const lang = this.primaryLang;
-    const branches = this.extraConfig.branches || ['main', 'master'];
+    const branches = this._resolveBranches(['main', 'master']);
+    const productionBranches = branches.filter((b) => b !== 'develop');
+    const deployBranches = productionBranches.length > 0 ? productionBranches : branches;
     const isGHPages = h.name === 'GitHub Pages';
+    const supportsPreview = ['Firebase', 'Vercel', 'Netlify'].includes(h.name);
 
     const preDeploySteps = [
       this._stepCheckout(),
@@ -288,9 +403,10 @@ class WorkflowGenerator {
       this._stepInstallDeps(lang),
     ].filter(Boolean);
 
-    const deploySteps = this._hostingDeploySteps(h, lang, false); // production
-    // GitHub Pages has no PR preview concept — skip preview job for it
-    const previewSteps = isGHPages ? [] : this._hostingDeploySteps(h, lang, true);
+    const primaryDeployBranch = deployBranches[0] || this.defaultBranch || 'main';
+    const deploySteps = this._hostingDeploySteps(h, lang, false, primaryDeployBranch); // production
+    // Only generate PR preview steps for platforms that natively isolate them
+    const previewSteps = supportsPreview ? this._hostingDeploySteps(h, lang, true, primaryDeployBranch) : [];
 
     // GitHub Pages requires special permissions on the deploy job
     const ghPagesPermissions = isGHPages
@@ -315,7 +431,27 @@ class WorkflowGenerator {
         if: "github.event_name == 'pull_request'",
         'runs-on': 'ubuntu-latest',
         environment: 'preview',
-        steps: [...preDeploySteps, ...previewSteps].filter(Boolean),
+        steps: [
+          ...preDeploySteps,
+          ...previewSteps,
+          {
+            name: 'Comment PR',
+            if: 'always()',
+            uses: 'actions/github-script@v7',
+            with: {
+              script: `
+                const deploymentUrl = process.env.DEPLOYMENT_URL;
+                if (!deploymentUrl) return;
+                github.rest.issues.createComment({
+                  issue_number: context.issue.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: '🚀 **Deployment Preview Ready!**\\n\\n[View Preview](' + deploymentUrl + ')'
+                });
+              `
+            }
+          }
+        ].filter(Boolean),
       };
     }
 
@@ -331,14 +467,18 @@ class WorkflowGenerator {
 
     const envComment = this._envComment();
 
-    // GitHub Pages doesn't need pull_request trigger (no preview)
-    const onTrigger = isGHPages
-      ? { push: { branches: branches.filter((b) => b !== 'develop') }, workflow_dispatch: {} }
-      : { push: { branches: branches.filter((b) => b !== 'develop') }, pull_request: { branches }, workflow_dispatch: {} };
+    // Only trigger on PR if the platform supports preview deployments
+    const onTrigger = supportsPreview
+      ? { push: { branches: deployBranches }, pull_request: { branches }, workflow_dispatch: {} }
+      : { push: { branches: deployBranches }, workflow_dispatch: {} };
 
     const workflow = {
       name: `Deploy to ${h.name}`,
       on: onTrigger,
+      concurrency: {
+        group: '${{ github.workflow }}-${{ github.ref }}',
+        'cancel-in-progress': true,
+      },
       jobs,
     };
 
@@ -353,14 +493,15 @@ class WorkflowGenerator {
   // ══════════════════════════════════════════════════════════════════════════
 
   _buildDockerWorkflow() {
+    const branches = this._resolveBranches(['main', 'master']);
     const workflow = {
       name: 'Docker Build & Push',
       on: {
         push: {
-          branches: ['main', 'master'],
+          branches,
           tags: ['v*.*.*'],
         },
-        pull_request: { branches: ['main', 'master'] },
+        pull_request: { branches },
       },
       env: {
         REGISTRY: 'ghcr.io',
@@ -431,6 +572,7 @@ class WorkflowGenerator {
 
   _buildSecurityWorkflow() {
     const lang = this.primaryLang;
+    const branches = this._resolveBranches(['main', 'master']);
     const steps = [this._stepCheckout()];
 
     if (['JavaScript', 'TypeScript'].includes(lang.name)) {
@@ -450,7 +592,7 @@ class WorkflowGenerator {
 
     if (lang.name === 'Python') {
       steps.push(
-        { name: 'Set up Python', uses: 'actions/setup-python@v5', with: { 'python-version': '3.x' } },
+        { name: 'Set up Python', uses: 'actions/setup-python@v5', with: { 'python-version': lang.pythonVersion || '3.11' } },
         { name: 'Install safety', run: 'pip install safety' },
         { name: 'Run safety check', run: 'safety check' },
       );
@@ -476,19 +618,19 @@ class WorkflowGenerator {
     const workflow = {
       name: 'Security Audit',
       on: {
-        push: { branches: ['main', 'master'] },
-        pull_request: { branches: ['main', 'master'] },
+        push: { branches },
+        pull_request: { branches },
         schedule: [{ cron: '0 6 * * 1' }],
       },
+      permissions: {
+        actions: 'read',
+        contents: 'read',
+        'security-events': 'write',
+      },
       jobs: {
         security: {
           name: '🔒 Security Audit',
           'runs-on': 'ubuntu-latest',
-          permissions: {
-            actions: 'read',
-            contents: 'read',
-            'security-events': 'write',
-          },
           steps: steps.filter(Boolean),
         },
       },
@@ -509,12 +651,19 @@ class WorkflowGenerator {
    * Returns setup + cache steps for the given language.
    * v2.0.0: added explicit caching for pip, poetry, cargo, maven, gradle, bundler, go, composer.
    */
-  _setupSteps(lang) {
+  _setupSteps(lang, useMatrix = false) {
     const steps = [];
     const cacheOverride = this.extraConfig.cache || {};
 
     // ── JavaScript / TypeScript ──────────────────────────────────────────
     if (['JavaScript', 'TypeScript'].includes(lang.name)) {
+      if (lang.packageManager === 'bun') {
+        steps.push({
+          name: 'Set up Bun',
+          uses: 'oven-sh/setup-bun@v2',
+          with: { 'bun-version': 'latest' },
+        });
+      }
       if (lang.packageManager === 'pnpm') {
         steps.push({ name: 'Install pnpm', uses: 'pnpm/action-setup@v3', with: { version: 'latest' } });
       }
@@ -522,9 +671,17 @@ class WorkflowGenerator {
         name: 'Set up Node.js',
         uses: 'actions/setup-node@v4',
         with: {
-          'node-version': lang.nodeVersion || '20',
+          'node-version': useMatrix ? '${{ matrix.node-version }}' : (lang.nodeVersion || '20'),
           // Use native caching in setup-node
-          cache: cacheOverride.npm !== false ? (lang.packageManager === 'yarn' ? 'yarn' : lang.packageManager === 'pnpm' ? 'pnpm' : 'npm') : undefined,
+          cache: cacheOverride.npm !== false
+            ? (lang.packageManager === 'yarn'
+              ? 'yarn'
+              : lang.packageManager === 'pnpm'
+              ? 'pnpm'
+              : lang.packageManager === 'npm'
+              ? 'npm'
+              : undefined)
+            : undefined,
         },
       });
     }
@@ -535,7 +692,7 @@ class WorkflowGenerator {
         name: 'Set up Python',
         uses: 'actions/setup-python@v5',
         with: { 
-          'python-version': '3.x',
+          'python-version': useMatrix ? '${{ matrix.python-version }}' : (lang.pythonVersion || '3.11'),
           // Native caching for pip/poetry
           cache: cacheOverride.pip !== false ? (lang.packageManager === 'poetry' ? 'poetry' : 'pip') : undefined
         },
@@ -623,9 +780,9 @@ class WorkflowGenerator {
 
   _stepInstallDeps(lang) {
     const pm = lang.packageManager;
-    if (pm === 'npm')     return { name: 'Install dependencies', run: 'npm ci' };
-    if (pm === 'yarn')    return { name: 'Install dependencies', run: 'yarn install --frozen-lockfile' };
-    if (pm === 'pnpm')    return { name: 'Install dependencies', run: 'pnpm install --frozen-lockfile' };
+    if (pm === 'npm')     return { name: 'Install dependencies', run: this.lockFiles.has('package-lock.json') ? 'npm ci' : 'npm install' };
+    if (pm === 'yarn')    return { name: 'Install dependencies', run: this.lockFiles.has('yarn.lock') ? 'yarn install --frozen-lockfile' : 'yarn install' };
+    if (pm === 'pnpm')    return { name: 'Install dependencies', run: this.lockFiles.has('pnpm-lock.yaml') ? 'pnpm install --frozen-lockfile' : 'pnpm install' };
     if (pm === 'bun')     return { name: 'Install dependencies', run: 'bun install' };
     if (pm === 'pip')     return { name: 'Install dependencies', run: 'pip install -r requirements.txt' };
     if (pm === 'poetry')  return { name: 'Install dependencies', run: 'pip install poetry && poetry install' };
@@ -639,46 +796,50 @@ class WorkflowGenerator {
     return { name: 'Install dependencies', run: 'npm ci' };
   }
 
-  _stepLint(lang) {
-    const pm = lang.packageManager || 'npm';
-
+  _stepLint(lang, pkg = null) {
     if (['JavaScript', 'TypeScript'].includes(lang.name)) {
-      const lintScript = this._findScript(['lint', 'lint:ci', 'eslint']);
-      const typeCheck  = this._findScript(['type-check', 'typecheck', 'tsc']);
-      const format     = this._findScript(['format:check', 'prettier:check', 'fmt:check']);
-      const runPfx     = pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm' : 'npm run';
+      const lintScript = this._findScript(['lint', 'lint:ci', 'eslint'], pkg);
+      const typeCheck  = this._findScript(['type-check', 'typecheck', 'tsc'], pkg);
+      const format     = this._findScript(['format:check', 'prettier:check', 'fmt:check'], pkg);
 
       const cmds = [];
-      if (lintScript) cmds.push(`${runPfx} ${lintScript}`);
-      if (typeCheck)  cmds.push(`${runPfx} ${typeCheck}`);
-      if (format)     cmds.push(`${runPfx} ${format}`);
-      if (cmds.length === 0) cmds.push('npx eslint . --ext .js,.jsx,.ts,.tsx --max-warnings 0');
+      if (lintScript) cmds.push(this._scriptCommand(lang, lintScript, pkg));
+      if (typeCheck)  cmds.push(this._scriptCommand(lang, typeCheck, pkg));
+      if (format)     cmds.push(this._scriptCommand(lang, format, pkg));
+      if (cmds.length === 0) {
+        const lintTarget = pkg ? pkg.relativePath : '.';
+        cmds.push(`npx eslint ${lintTarget} --ext .js,.jsx,.ts,.tsx --max-warnings 0`);
+      }
 
       return { name: 'Lint', run: cmds.join('\n') };
     }
 
-    if (lang.name === 'Python') return { name: 'Lint', run: 'pip install flake8 && flake8 .' };
+    if (lang.name === 'Python') return { name: 'Lint', run: 'pip install flake8 black && flake8 . && black --check .' };
     if (lang.name === 'Go')     return { name: 'Lint', run: 'gofmt -d . && go vet ./...' };
     if (lang.name === 'Rust')   return { name: 'Lint', run: 'cargo clippy -- -D warnings && cargo fmt --check' };
     if (lang.name === 'Ruby')   return { name: 'Lint', run: 'gem install rubocop && rubocop' };
-    if (lang.name === 'PHP')    return { name: 'Lint', run: 'vendor/bin/phpcs' };
+    if (lang.name === 'PHP')    return { name: 'Lint', run: 'vendor/bin/phpcs && vendor/bin/phpstan analyze' };
 
     return null;
   }
 
-  _unitTestSteps(lang) {
+  _unitTestSteps(lang, pkg = null) {
+    if (pkg && ['JavaScript', 'TypeScript'].includes(lang.name)) {
+      const pkgTestScript = this._findScript(['test:ci', 'test'], pkg);
+      if (pkgTestScript) {
+        return [{ name: 'Run tests', run: this._scriptCommand(lang, pkgTestScript, pkg) }];
+      }
+    }
     return this.unitTests.map((t) => ({ name: `Run ${t.name}`, run: t.command }));
   }
 
-  _buildSteps(lang) {
-    const pm = lang.packageManager || 'npm';
-    const buildScript = this._findScript(['build', 'build:prod']);
+  _buildSteps(lang, pkg = null) {
+    const buildScript = this._findScript(['build', 'build:prod', 'compile'], pkg);
     if (!buildScript && !['Go', 'Rust', 'Java', 'Kotlin'].includes(lang.name)) return [];
 
     const steps = [];
     if (['JavaScript', 'TypeScript'].includes(lang.name) && buildScript) {
-      const runPfx = pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm' : 'npm';
-      steps.push({ name: 'Build', run: `${runPfx} run ${buildScript}`, env: { NODE_ENV: 'production' } });
+      steps.push({ name: 'Build', run: this._scriptCommand(lang, buildScript, pkg), env: { NODE_ENV: 'production' } });
     }
     if (lang.name === 'Go')         steps.push({ name: 'Build', run: 'go build -v ./...' });
     if (lang.name === 'Rust')       steps.push({ name: 'Build', run: 'cargo build --release' });
@@ -688,8 +849,21 @@ class WorkflowGenerator {
     return steps;
   }
 
-  _stepUploadArtifact() {
-    const buildDir = (this.frameworks[0] && this.frameworks[0].buildDir) || 'dist';
+  _stepUploadArtifact(lang) {
+    let buildDir = null;
+
+    if (['JavaScript', 'TypeScript'].includes(lang.name)) {
+      buildDir = (this.frameworks[0] && this.frameworks[0].buildDir) || null;
+    } else if (lang.name === 'Rust') {
+      buildDir = 'target/release';
+    } else if (lang.name === 'Java') {
+      buildDir = 'target';
+    } else if (lang.name === 'Kotlin') {
+      buildDir = 'build/libs';
+    }
+
+    if (!buildDir) return null;
+
     return {
       name: 'Upload build artifact',
       uses: 'actions/upload-artifact@v4',
@@ -719,15 +893,48 @@ class WorkflowGenerator {
     return null;
   }
 
+  _resolveBranches(fallback) {
+    if (Array.isArray(this.extraConfig.branches) && this.extraConfig.branches.length > 0) {
+      return [...new Set(this.extraConfig.branches)];
+    }
+    if (this.defaultBranch) {
+      return [this.defaultBranch];
+    }
+    return fallback;
+  }
+
+  _workspaceRunCommand(lang, scriptName) {
+    const pm = lang.packageManager || 'npm';
+    if (pm === 'pnpm') return `pnpm --filter \${{ matrix.package }} run ${scriptName}`;
+    if (pm === 'yarn') return `yarn workspace \${{ matrix.name }} run ${scriptName}`;
+    if (pm === 'bun') return `bun run --filter './\${{ matrix.package }}' ${scriptName}`;
+    return `npm run ${scriptName} --workspace=\${{ matrix.name }}`;
+  }
+
+  _scriptCommand(lang, scriptName, pkg = null) {
+    const pm = lang.packageManager || 'npm';
+
+    if (pkg) {
+      if (pm === 'pnpm') return `pnpm --filter ${pkg.relativePath} run ${scriptName}`;
+      if (pm === 'yarn') return `yarn workspace ${pkg.name} run ${scriptName}`;
+      if (pm === 'bun') return `bun run --filter './${pkg.relativePath}' ${scriptName}`;
+      return `npm run ${scriptName} --workspace=${pkg.name}`;
+    }
+
+    if (pm === 'yarn') return `yarn run ${scriptName}`;
+    if (pm === 'pnpm') return `pnpm run ${scriptName}`;
+    if (pm === 'bun') return `bun run ${scriptName}`;
+    return `npm run ${scriptName}`;
+  }
+
   // ══════════════════════════════════════════════════════════════════════════
   // Hosting-specific deploy steps
   // ══════════════════════════════════════════════════════════════════════════
 
-  _hostingDeploySteps(h, lang, isPreview = false) {
+  _hostingDeploySteps(h, lang, isPreview = false, productionBranch = null) {
     const steps = [];
     const buildScript = this._findScript(['build', 'build:prod']);
-    const pm = lang.packageManager || 'npm';
-    const runCmd = (s) => `${pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm' : 'npm'} run ${s}`;
+    const runCmd = (s) => this._scriptCommand(lang, s);
 
     switch (h.name) {
       case 'Firebase': {
@@ -767,7 +974,8 @@ class WorkflowGenerator {
           },
           {
             name: 'Deploy to Vercel',
-            run: `vercel deploy --prebuilt${prodFlag ? ' ' + prodFlag : ''} --token=\${{ secrets.VERCEL_TOKEN }}`,
+            id: 'deploy',
+            run: `vercel deploy --prebuilt${prodFlag ? ' ' + prodFlag : ''} --token=\${{ secrets.VERCEL_TOKEN }} > deployment_url.txt && echo "DEPLOYMENT_URL=$(cat deployment_url.txt)" >> $GITHUB_ENV`,
             env: vercelEnv,
           },
         );
@@ -780,10 +988,11 @@ class WorkflowGenerator {
         }
         steps.push({
           name: isPreview ? 'Deploy Preview' : 'Deploy to Netlify',
+          id: 'netlify_deploy',
           uses: 'nwtgck/actions-netlify@v3.0',
           with: {
-            'publish-dir': h.publishDir || 'dist',
-            'production-branch': 'main',
+            'publish-dir': h.publishDir || (this.frameworks[0] && this.frameworks[0].buildDir) || 'dist',
+            'production-branch': productionBranch || this.defaultBranch || 'main',
             'github-token': '${{ secrets.GITHUB_TOKEN }}',
             'deploy-message': isPreview ? 'Preview Deploy – ${{ github.event.number }}' : 'Production Deploy – ${{ github.sha }}',
             'enable-pull-request-comment': true,
@@ -796,6 +1005,12 @@ class WorkflowGenerator {
             NETLIFY_SITE_ID: '${{ secrets.NETLIFY_SITE_ID }}',
           },
         });
+        if (isPreview) {
+          steps.push({
+            name: 'Set Netlify URL',
+            run: 'echo "DEPLOYMENT_URL=${{ steps.netlify_deploy.outputs.deploy-url }}" >> $GITHUB_ENV'
+          });
+        }
         break;
       }
 
@@ -930,11 +1145,12 @@ class WorkflowGenerator {
     return lang;
   }
 
-  _findScript(names) {
+  _findScript(names, pkg = null) {
     const fs = require('fs');
     const path = require('path');
     try {
-      const raw = JSON.parse(fs.readFileSync(path.join(this.projectPath, 'package.json'), 'utf8'));
+      const pkgPath = pkg ? path.join(this.projectPath, pkg.relativePath, 'package.json') : path.join(this.projectPath, 'package.json');
+      const raw = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
       const scripts = raw.scripts || {};
       for (const n of names) {
         if (scripts[n]) return n;
@@ -973,6 +1189,21 @@ class WorkflowGenerator {
     });
     return header + raw;
   }
+
+  _getPublicEnv() {
+    const env = {};
+    if (this.envVars && this.envVars.public) {
+      for (const p of this.envVars.public) {
+        const parts = p.split('=');
+        if (parts.length >= 2) {
+          env[parts[0]] = parts.slice(1).join('=');
+        } else {
+          env[p] = `\${{ vars.${p} || secrets.${p} }}`;
+        }
+      }
+    }
+    return env;
+  }
 }
 
 module.exports = WorkflowGenerator;