@lumenflow/cli 2.4.0 → 2.5.1

package/dist/onboarding-smoke-test.js

@@ -0,0 +1,400 @@
+/**
+ * @file onboarding-smoke-test.ts
+ * Onboarding smoke-test gate for lumenflow init + wu:create flows (WU-1315)
+ *
+ * This gate creates a temp repo, runs lumenflow init --full, validates:
+ * - Injected package.json scripts use standalone binary format
+ * - Lane-inference.yaml uses hierarchical format (not flat lanes array)
+ * - wu:create works with requireRemote=false
+ *
+ * Used as part of the gates pipeline to catch regressions before release.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as yaml from 'yaml';
+import { execFileSync } from 'node:child_process';
+import { scaffoldProject } from './init.js';
+/** Package.json file name constant */
+const PACKAGE_JSON_FILE = 'package.json';
+/** Lane inference file name constant */
+const LANE_INFERENCE_FILE = '.lumenflow.lane-inference.yaml';
+/** LumenFlow config file name constant */
+const LUMENFLOW_CONFIG_FILE = '.lumenflow.config.yaml';
+/** Git binary path - uses system PATH which is acceptable for smoke tests */
+const GIT_BINARY = 'git';
+/** Required package.json scripts from LumenFlow init */
+const REQUIRED_SCRIPTS = ['wu:claim', 'wu:done', 'wu:create', 'gates'];
+/**
+ * Validate that package.json has the required LumenFlow scripts
+ * in the correct standalone binary format.
+ *
+ * @param options - Validation options
+ * @returns Validation result
+ */
+export function validateInitScripts(options) {
+    const { projectDir } = options;
+    const packageJsonPath = path.join(projectDir, PACKAGE_JSON_FILE);
+    // Check if package.json exists
+    if (!fs.existsSync(packageJsonPath)) {
+        return {
+            valid: false,
+            missingScripts: [],
+            invalidScripts: [],
+            error: `${PACKAGE_JSON_FILE} not found in ${projectDir}`,
+        };
+    }
+    let packageJson;
+    try {
+        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (err) {
+        return {
+            valid: false,
+            missingScripts: [],
+            invalidScripts: [],
+            error: `Failed to parse ${PACKAGE_JSON_FILE}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const scripts = packageJson.scripts ?? {};
+    const missingScripts = [];
+    const invalidScripts = [];
+    for (const script of REQUIRED_SCRIPTS) {
+        if (!scripts[script]) {
+            missingScripts.push(script);
+        }
+        else {
+            // Validate script uses standalone binary format
+            // Should be 'wu-claim' or 'gates', not 'pnpm exec lumenflow wu:claim'
+            const value = scripts[script];
+            if (value.includes('pnpm exec') || value.includes('npx lumenflow')) {
+                invalidScripts.push(script);
+            }
+        }
+    }
+    return {
+        valid: missingScripts.length === 0 && invalidScripts.length === 0,
+        missingScripts,
+        invalidScripts,
+    };
+}
+/**
+ * Validate a single parent lane and its sub-lanes
+ */
+function validateParentLane(parentLane, subLanes, errors) {
+    // Skip comment-only keys or non-object values
+    if (typeof subLanes !== 'object' || subLanes === null) {
+        return;
+    }
+    // Parent lane names should be capitalized
+    if (parentLane[0] !== parentLane[0].toUpperCase()) {
+        const capitalizedName = parentLane.charAt(0).toUpperCase() + parentLane.slice(1);
+        errors.push(`Parent lane "${parentLane}" should be capitalized (e.g., "${capitalizedName}")`);
+    }
+    // Validate each sub-lane
+    const subLaneEntries = subLanes;
+    for (const [subLaneName, subLaneConfig] of Object.entries(subLaneEntries)) {
+        validateSubLane(parentLane, subLaneName, subLaneConfig, errors);
+    }
+}
+/**
+ * Validate a single sub-lane configuration
+ */
+function validateSubLane(parentLane, subLaneName, subLaneConfig, errors) {
+    if (typeof subLaneConfig !== 'object' || subLaneConfig === null) {
+        return;
+    }
+    const config = subLaneConfig;
+    // Required fields for sub-lanes
+    if (!config.description && !config.code_paths) {
+        errors.push(`Sub-lane "${parentLane}: ${subLaneName}" is missing required fields (description, code_paths)`);
+    }
+}
+/**
+ * Validate that lane-inference.yaml uses the correct hierarchical format.
+ *
+ * Expected format:
+ * ```yaml
+ * Framework:
+ *   Core:
+ *     description: '...'
+ *     code_paths: [...]
+ *     keywords: [...]
+ * ```
+ *
+ * Not the old flat format:
+ * ```yaml
+ * lanes:
+ *   - name: Framework
+ *     code_paths: [...]
+ * ```
+ *
+ * @param options - Validation options
+ * @returns Validation result
+ */
+export function validateLaneInferenceFormat(options) {
+    const { projectDir } = options;
+    const laneInferencePath = path.join(projectDir, LANE_INFERENCE_FILE);
+    // Check if file exists
+    if (!fs.existsSync(laneInferencePath)) {
+        return {
+            valid: false,
+            errors: [],
+            error: `${LANE_INFERENCE_FILE} not found in ${projectDir}`,
+        };
+    }
+    let content;
+    try {
+        const rawContent = fs.readFileSync(laneInferencePath, 'utf-8');
+        content = yaml.parse(rawContent);
+    }
+    catch (err) {
+        return {
+            valid: false,
+            errors: [],
+            error: `Failed to parse ${LANE_INFERENCE_FILE}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const errors = [];
+    // Check for old flat 'lanes' array format
+    if ('lanes' in content && Array.isArray(content.lanes)) {
+        errors.push("Invalid format: found 'lanes' array. Use hierarchical format (Framework: Core: ...) instead.");
+        return { valid: false, errors };
+    }
+    // Validate hierarchical structure
+    for (const [parentLane, subLanes] of Object.entries(content)) {
+        validateParentLane(parentLane, subLanes, errors);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Initialize a git repository in the given directory
+ */
+function initializeGitRepo(projectDir) {
+    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Git binary from PATH is acceptable for smoke tests
+    execFileSync(GIT_BINARY, ['init'], { cwd: projectDir, stdio: 'pipe' });
+    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Git binary from PATH is acceptable for smoke tests
+    execFileSync(GIT_BINARY, ['config', 'user.email', 'test@example.com'], {
+        cwd: projectDir,
+        stdio: 'pipe',
+    });
+    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Git binary from PATH is acceptable for smoke tests
+    execFileSync(GIT_BINARY, ['config', 'user.name', 'Test User'], {
+        cwd: projectDir,
+        stdio: 'pipe',
+    });
+    // Create initial commit
+    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Git binary from PATH is acceptable for smoke tests
+    execFileSync(GIT_BINARY, ['add', '-A'], { cwd: projectDir, stdio: 'pipe' });
+    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Git binary from PATH is acceptable for smoke tests
+    execFileSync(GIT_BINARY, ['commit', '-m', 'Initial commit', '--allow-empty'], {
+        cwd: projectDir,
+        stdio: 'pipe',
+    });
+}
+/**
+ * Create a sample WU YAML file for testing
+ */
+function createSampleWuYaml(projectDir) {
+    const wuDir = path.join(projectDir, 'docs', '04-operations', 'tasks', 'wu');
+    fs.mkdirSync(wuDir, { recursive: true });
+    const wuYaml = `id: WU-TEST-001
+title: Test WU
+lane: 'Framework: Core'
+type: feature
+status: ready
+priority: P3
+created: 2026-02-02
+code_paths:
+  - 'src/**'
+acceptance:
+  - Test passes
+`;
+    fs.writeFileSync(path.join(wuDir, 'WU-TEST-001.yaml'), wuYaml);
+}
+/**
+ * Validate that wu:create works with requireRemote=false config.
+ *
+ * This creates a minimal WU in the test project to verify the flow works
+ * without a git remote.
+ *
+ * @param options - Validation options
+ * @returns Validation result
+ */
+async function validateWuCreate(options) {
+    const { projectDir } = options;
+    // Create .lumenflow.config.yaml with requireRemote=false
+    const configPath = path.join(projectDir, LUMENFLOW_CONFIG_FILE);
+    const config = `# LumenFlow Configuration (smoke test)
+git:
+  requireRemote: false
+`;
+    fs.writeFileSync(configPath, config);
+    try {
+        initializeGitRepo(projectDir);
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to initialize git repo: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    // Create a sample WU YAML to simulate wu:create output
+    // Note: We don't actually run wu:create as it requires the full CLI to be installed
+    // Instead we validate the config would allow it to work
+    createSampleWuYaml(projectDir);
+    return { success: true };
+}
+/**
+ * Collect errors from validation results
+ */
+function collectScriptsErrors(scriptsResult) {
+    const errors = [];
+    if (scriptsResult.error) {
+        errors.push(`Init scripts validation error: ${scriptsResult.error}`);
+    }
+    if (scriptsResult.missingScripts.length > 0) {
+        errors.push(`Missing scripts: ${scriptsResult.missingScripts.join(', ')}`);
+    }
+    if (scriptsResult.invalidScripts.length > 0) {
+        errors.push(`Invalid script format: ${scriptsResult.invalidScripts.join(', ')}`);
+    }
+    return errors;
+}
+/**
+ * Collect errors from lane validation results
+ */
+function collectLaneErrors(laneResult) {
+    const errors = [];
+    if (laneResult.error) {
+        errors.push(`Lane-inference validation error: ${laneResult.error}`);
+    }
+    errors.push(...laneResult.errors);
+    return errors;
+}
+/**
+ * Run validations in the temp directory
+ */
+async function runValidations(tempDir, skipWuCreate) {
+    const errors = [];
+    // Step 1: Run lumenflow init --full
+    await scaffoldProject(tempDir, { force: true, full: true });
+    // Step 2: Validate init scripts
+    const scriptsResult = validateInitScripts({ projectDir: tempDir });
+    if (!scriptsResult.valid) {
+        errors.push(...collectScriptsErrors(scriptsResult));
+    }
+    // Step 3: Validate lane-inference format
+    const laneResult = validateLaneInferenceFormat({ projectDir: tempDir });
+    if (!laneResult.valid) {
+        errors.push(...collectLaneErrors(laneResult));
+    }
+    // Step 4: Validate wu:create with requireRemote=false (if not skipped)
+    let wuResult;
+    if (!skipWuCreate) {
+        wuResult = await validateWuCreate({ projectDir: tempDir });
+        if (!wuResult.success && wuResult.error) {
+            errors.push(`wu:create validation error: ${wuResult.error}`);
+        }
+    }
+    return { scriptsResult, laneResult, wuResult, errors };
+}
+/**
+ * Clean up temporary directory
+ */
+function cleanupTempDir(tempDir) {
+    if (tempDir && fs.existsSync(tempDir)) {
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Run the full onboarding smoke test.
+ *
+ * Creates a temp directory, runs lumenflow init --full, and validates:
+ * 1. Package.json scripts are correctly injected
+ * 2. Lane-inference.yaml uses hierarchical format
+ * 3. wu:create would work with requireRemote=false
+ *
+ * @param options - Smoke test options
+ * @returns Smoke test result
+ */
+export async function runOnboardingSmokeTest(options = {}) {
+    const { cleanup = true, skipWuCreate = false } = options;
+    let { tempDir } = options;
+    const result = {
+        success: false,
+        errors: [],
+    };
+    // Create temp directory if not provided
+    if (!tempDir) {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-smoke-test-'));
+        result.tempDir = tempDir;
+    }
+    // Ensure directory exists
+    if (!fs.existsSync(tempDir)) {
+        try {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        catch (err) {
+            return {
+                success: false,
+                errors: [
+                    `Failed to create temp directory: ${err instanceof Error ? err.message : String(err)}`,
+                ],
+            };
+        }
+    }
+    try {
+        const { scriptsResult, laneResult, wuResult, errors } = await runValidations(tempDir, skipWuCreate);
+        result.initScriptsValidation = scriptsResult;
+        result.laneInferenceValidation = laneResult;
+        result.wuCreateValidation = wuResult;
+        result.errors = errors;
+        result.success = errors.length === 0;
+    }
+    catch (err) {
+        result.errors = [`Smoke test failed: ${err instanceof Error ? err.message : String(err)}`];
+        result.success = false;
+    }
+    finally {
+        if (cleanup) {
+            cleanupTempDir(tempDir);
+        }
+    }
+    return result;
+}
+/**
+ * Run the onboarding smoke test as a gate.
+ *
+ * This is the entry point for the gates pipeline.
+ *
+ * @param options - Gate options
+ * @returns Gate result with ok status and duration
+ */
+export async function runOnboardingSmokeTestGate(options) {
+    const start = Date.now();
+    const logger = options.logger ?? console;
+    logger.log('Running onboarding smoke test...');
+    const result = await runOnboardingSmokeTest({ cleanup: true });
+    if (result.success) {
+        logger.log('Onboarding smoke test passed.');
+    }
+    else {
+        logger.log('Onboarding smoke test failed:');
+        for (const error of result.errors) {
+            logger.log(`  - ${error}`);
+        }
+    }
+    return {
+        ok: result.success,
+        duration: Date.now() - start,
+    };
+}

package/dist/orchestrate-init-status.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative Status CLI
  *
@@ -10,10 +11,14 @@
  */
 import { Command } from 'commander';
 import { existsSync, readdirSync } from 'node:fs';
-import { loadInitiativeWUs, calculateProgress, formatProgress } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, calculateProgress, formatProgress, getLaneAvailability, resolveLaneConfigsFromConfig, } from '@lumenflow/initiatives';
 import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import chalk from 'chalk';
 const LOG_PREFIX = '[orchestrate:init-status]';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function getCompletedWUs(wuIds) {
     const completed = new Set();
     if (!existsSync(LUMENFLOW_PATHS.STAMPS_DIR)) {
@@ -27,6 +32,21 @@ function getCompletedWUs(wuIds) {
     }
     return completed;
 }
+function formatLaneAvailability(availability, laneConfigs) {
+    const lanes = Object.keys(availability).sort((a, b) => a.localeCompare(b));
+    if (lanes.length === 0) {
+        return '  (no lanes found)';
+    }
+    return lanes
+        .map((lane) => {
+        const entry = availability[lane];
+        const wipLimit = laneConfigs[lane]?.wip_limit ?? 1;
+        const statusLabel = entry.available ? chalk.green('available') : chalk.red('occupied');
+        const occupiedBy = entry.occupiedBy ?? 'none';
+        return `  ${lane}: ${statusLabel} (wip_limit=${wipLimit}, lock_policy=${entry.policy}, in_progress=${entry.inProgressCount}, blocked=${entry.blockedCount}, occupied_by=${occupiedBy})`;
+    })
+        .join('\n');
+}
 const program = new Command()
     .name('orchestrate:init-status')
     .description('Show initiative progress status')
@@ -45,18 +65,26 @@ const program = new Command()
         const completed = getCompletedWUs(wus.map((w) => w.id));
         console.log(chalk.bold('WUs:'));
         for (const wu of wus) {
-            const status = completed.has(wu.id)
-                ? chalk.green('✓ done')
-                : wu.doc.status === 'in_progress'
-                    ? chalk.yellow('⟳ in_progress')
-                    : wu.doc.status === 'blocked'
-                        ? chalk.red('⛔ blocked')
-                        : chalk.gray('○ ready');
+            let status = chalk.gray('○ ready');
+            if (completed.has(wu.id)) {
+                status = chalk.green('✓ done');
+            }
+            else if (wu.doc.status === 'in_progress') {
+                status = chalk.yellow('⟳ in_progress');
+            }
+            else if (wu.doc.status === 'blocked') {
+                status = chalk.red('⛔ blocked');
+            }
             console.log(`  ${wu.id}: ${wu.doc.title} [${status}]`);
         }
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const availability = getLaneAvailability(wus, { laneConfigs });
+        console.log('');
+        console.log(chalk.bold('Lane Availability:'));
+        console.log(formatLaneAvailability(availability, laneConfigs));
     }
     catch (err) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${err.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(err)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });

package/dist/orchestrate-initiative.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative CLI
  *
@@ -11,8 +12,12 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanAsync, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanWithLockPolicy, resolveLaneConfigsFromConfig, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
 import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 const program = new Command()
     .name('orchestrate-initiative')
     .description('Orchestrate initiative execution with parallel agent spawning')
@@ -28,7 +33,7 @@ const program = new Command()
         validateCheckpointFlags({ checkpointPerWave, dryRun, noCheckpoint });
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
     if (!initIds || initIds.length === 0) {
@@ -76,7 +81,8 @@ const program = new Command()
             return;
         }
         console.log(chalk.cyan(`${LOG_PREFIX} Building execution plan...`));
-        const plan = await buildExecutionPlanAsync(wus);
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const plan = buildExecutionPlanWithLockPolicy(wus, { laneConfigs });
         if (plan.waves.length === 0) {
             console.log(chalk.green(`${LOG_PREFIX} All WUs are complete! Nothing to execute.`));
             return;
@@ -99,7 +105,7 @@ const program = new Command()
         console.log(chalk.cyan('Copy the spawn XML above to execute agents.'));
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });