@lumenflow/cli 2.2.2 → 2.3.2

package/dist/mem-start.js

@@ -10,8 +10,8 @@
  * Usage:
  *   pnpm mem:start --wu WU-1234 [--agent-type <type>] [--context-tier <tier>] [--quiet]
  *
- * @see {@link tools/lib/mem-start-core.mjs} - Core logic
- * @see {@link tools/__tests__/mem-start.test.mjs} - Tests
+ * @see {@link packages/@lumenflow/cli/src/lib/mem-start-core.ts} - Core logic
+ * @see {@link packages/@lumenflow/cli/src/__tests__/mem-start.test.ts} - Tests
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';

package/dist/mem-summarize.js

@@ -16,8 +16,8 @@
  *   pnpm mem:summarize --wu WU-1234 --dry-run # Preview without changes
  *   pnpm mem:summarize --wu WU-1234 --json    # Output as JSON
  *
- * @see {@link tools/lib/mem-summarize-core.mjs} - Core logic
- * @see {@link tools/__tests__/mem-summarize.test.mjs} - Tests
+ * @see {@link packages/@lumenflow/cli/src/lib/mem-summarize-core.ts} - Core logic
+ * @see {@link packages/@lumenflow/cli/src/__tests__/mem-summarize.test.ts} - Tests
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';

package/dist/mem-triage.js

@@ -16,8 +16,8 @@
  *   pnpm mem:triage --promote mem-aaa1 --lane "Operations: Tooling"
  *   pnpm mem:triage --archive mem-aaa1 --reason "Duplicate"
  *
- * @see {@link tools/lib/mem-triage-core.mjs} - Core logic
- * @see {@link tools/__tests__/mem-triage.test.mjs} - Tests
+ * @see {@link packages/@lumenflow/cli/src/lib/mem-triage-core.ts} - Core logic
+ * @see {@link packages/@lumenflow/cli/src/__tests__/mem-triage.test.ts} - Tests
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';

package/dist/merge-block.js

@@ -0,0 +1,222 @@
+/**
+ * @file merge-block.ts
+ * Merge block utilities for safe, idempotent config insertion (WU-1171)
+ *
+ * This module provides utilities to safely merge LumenFlow configuration
+ * into existing files using bounded markers (LUMENFLOW:START/END).
+ */
+/**
+ * Marker comments for LumenFlow blocks
+ */
+export const MARKERS = {
+    START: '<!-- LUMENFLOW:START -->',
+    END: '<!-- LUMENFLOW:END -->',
+};
+/**
+ * Detect the predominant line ending in content.
+ *
+ * @param content - The file content to analyze
+ * @returns '\r\n' for CRLF, '\n' for LF (default)
+ */
+export function detectLineEnding(content) {
+    if (!content) {
+        return '\n';
+    }
+    const crlfCount = (content.match(/\r\n/g) || []).length;
+    const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
+    // If no line endings found, default to LF
+    if (crlfCount === 0 && lfCount === 0) {
+        return '\n';
+    }
+    // Use majority line ending
+    return crlfCount >= lfCount ? '\r\n' : '\n';
+}
+/**
+ * Normalize line endings in content to the specified style.
+ *
+ * @param content - The content to normalize
+ * @param lineEnding - The target line ending
+ * @returns Content with normalized line endings
+ */
+export function normalizeLineEndings(content, lineEnding) {
+    // First normalize to LF, then convert to target
+    const normalized = content.replace(/\r\n/g, '\n');
+    if (lineEnding === '\r\n') {
+        return normalized.replace(/\n/g, '\r\n');
+    }
+    return normalized;
+}
+/**
+ * Extract the LumenFlow block from content if it exists.
+ *
+ * @param content - The file content to search
+ * @returns Extraction result with block details
+ */
+export function extractMergeBlock(content) {
+    // Use indexOf for simple string matching instead of regex to avoid DOS vulnerability
+    const startIndexes = [];
+    const endIndexes = [];
+    let pos = 0;
+    while ((pos = content.indexOf(MARKERS.START, pos)) !== -1) {
+        startIndexes.push(pos);
+        pos += MARKERS.START.length;
+    }
+    pos = 0;
+    while ((pos = content.indexOf(MARKERS.END, pos)) !== -1) {
+        endIndexes.push(pos);
+        pos += MARKERS.END.length;
+    }
+    // Check for malformed cases
+    if (startIndexes.length > 1) {
+        return { found: false, malformed: true, malformedReason: 'multiple-start' };
+    }
+    if (endIndexes.length > 1) {
+        return { found: false, malformed: true, malformedReason: 'multiple-end' };
+    }
+    const hasStart = startIndexes.length === 1;
+    const hasEnd = endIndexes.length === 1;
+    if (hasStart && !hasEnd) {
+        return { found: false, malformed: true, malformedReason: 'missing-end' };
+    }
+    if (!hasStart && hasEnd) {
+        return { found: false, malformed: true, malformedReason: 'missing-start' };
+    }
+    if (!hasStart && !hasEnd) {
+        return { found: false };
+    }
+    // Both markers present - extract content
+    const startIndex = startIndexes[0];
+    const endMarkerIndex = endIndexes[0];
+    const endIndex = endMarkerIndex + MARKERS.END.length;
+    // Verify END comes after START
+    if (endMarkerIndex <= startIndex) {
+        return { found: false, malformed: true, malformedReason: 'missing-end' };
+    }
+    // Extract content between markers (excluding the markers and surrounding newlines)
+    const afterStart = startIndex + MARKERS.START.length;
+    const beforeEnd = endMarkerIndex;
+    let blockContent = content.slice(afterStart, beforeEnd);
+    // Trim leading/trailing newlines from the block content
+    // Use simple loop to avoid regex ReDoS vulnerability
+    blockContent = trimNewlines(blockContent);
+    return {
+        found: true,
+        content: blockContent,
+        startIndex,
+        endIndex,
+    };
+}
+/**
+ * Insert a new merge block into content.
+ *
+ * @param originalContent - The existing file content
+ * @param blockContent - The content to place inside the block
+ * @returns The content with the new block appended
+ */
+export function insertMergeBlock(originalContent, blockContent) {
+    const lineEnding = detectLineEnding(originalContent);
+    const normalizedBlock = normalizeLineEndings(blockContent, lineEnding);
+    // Ensure content ends with newlines for separation
+    let content = originalContent;
+    if (!content.endsWith(lineEnding)) {
+        content += lineEnding;
+    }
+    if (!content.endsWith(lineEnding + lineEnding) && content.trim().length > 0) {
+        content += lineEnding;
+    }
+    // Build the block
+    const block = [MARKERS.START, normalizedBlock, MARKERS.END, ''].join(lineEnding);
+    return content + block;
+}
+/**
+ * Update or insert a merge block in content.
+ *
+ * @param originalContent - The existing file content
+ * @param newBlockContent - The new content for the block
+ * @returns Result with the updated content and metadata
+ */
+export function updateMergeBlock(originalContent, newBlockContent) {
+    const lineEnding = detectLineEnding(originalContent);
+    const extraction = extractMergeBlock(originalContent);
+    // If malformed, warn and append fresh block
+    if (extraction.malformed) {
+        const warning = `LumenFlow markers are malformed (${extraction.malformedReason}). Appending fresh block.`;
+        const result = insertMergeBlock(originalContent, newBlockContent);
+        return {
+            content: result,
+            updated: true,
+            wasInserted: true,
+            warning,
+        };
+    }
+    // If no existing block, insert new one
+    if (!extraction.found) {
+        return {
+            content: insertMergeBlock(originalContent, newBlockContent),
+            updated: true,
+            wasInserted: true,
+        };
+    }
+    // Check if content is unchanged
+    const normalizedNew = normalizeLineEndings(newBlockContent, lineEnding).trim();
+    const normalizedExisting = (extraction.content || '').trim();
+    if (normalizedNew === normalizedExisting) {
+        return {
+            content: originalContent,
+            updated: false,
+            unchanged: true,
+        };
+    }
+    // Replace existing block - at this point we know extraction.found is true
+    // so startIndex and endIndex are defined
+    const startIdx = extraction.startIndex ?? 0;
+    const endIdx = extraction.endIndex ?? originalContent.length;
+    const before = originalContent.slice(0, startIdx);
+    const after = originalContent.slice(endIdx);
+    // Build the new block with preserved line endings
+    const newBlock = [
+        MARKERS.START,
+        normalizeLineEndings(newBlockContent, lineEnding),
+        MARKERS.END,
+    ].join(lineEnding);
+    // Combine parts, ensuring proper line ending between before and block
+    let result = before;
+    if (!result.endsWith(lineEnding) && result.length > 0) {
+        result += lineEnding;
+    }
+    result += newBlock;
+    // Handle after part
+    if (after.trim().length > 0) {
+        if (!result.endsWith(lineEnding)) {
+            result += lineEnding;
+        }
+        result += after;
+    }
+    else if (after.includes(lineEnding)) {
+        // Preserve trailing newline if original had it
+        if (!result.endsWith(lineEnding)) {
+            result += lineEnding;
+        }
+    }
+    return {
+        content: result,
+        updated: true,
+    };
+}
+/**
+ * Trim leading and trailing newlines from a string.
+ * Uses simple loop to avoid regex ReDoS vulnerability.
+ */
+function trimNewlines(str) {
+    let start = 0;
+    let end = str.length;
+    // Trim leading newlines
+    while (start < end && (str[start] === '\r' || str[start] === '\n')) {
+        start++;
+    }
+    // Trim trailing newlines
+    while (end > start && (str[end - 1] === '\r' || str[end - 1] === '\n')) {
+        end--;
+    }
+    return str.slice(start, end);
+}

package/dist/metrics-cli.js

@@ -25,12 +25,14 @@ import { Command } from 'commander';
 import { captureMetricsSnapshot, calculateDORAMetrics, calculateFlowState, } from '@lumenflow/metrics';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
+import { createWuPaths } from '@lumenflow/core/dist/wu-paths.js';
 /** Log prefix for console output */
 const LOG_PREFIX = '[metrics]';
 /** Default snapshot output path */
 const DEFAULT_OUTPUT = '.lumenflow/snapshots/metrics-latest.json';
+const wuPaths = createWuPaths();
 /** WU directory relative to repo root */
-const WU_DIR = 'docs/04-operations/tasks/wu';
+const WU_DIR = wuPaths.WU_DIR();
 /** Skip-gates audit file path */
 const SKIP_GATES_PATH = '.lumenflow/skip-gates-audit.ndjson';
 /**
@@ -424,9 +426,10 @@ async function main() {
             break;
     }
 }
-// Guard main() for testability
-import { fileURLToPath } from 'node:url';
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+// WU-1181: Use import.meta.main instead of process.argv[1] comparison
+// The old pattern fails with pnpm symlinks because process.argv[1] is the symlink
+// path but import.meta.url resolves to the real path - they never match
+if (import.meta.main) {
     main().catch((err) => {
         die(`Metrics command failed: ${err.message}`);
     });

package/dist/metrics-snapshot.js

@@ -305,9 +305,10 @@ async function main() {
         console.log(`${LOG_PREFIX} ✅ Snapshot written to: ${outputPath}`);
     }
 }
-// Guard main() for testability (WU-1366)
-import { fileURLToPath } from 'node:url';
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+// WU-1181: Use import.meta.main instead of process.argv[1] comparison
+// The old pattern fails with pnpm symlinks because process.argv[1] is the symlink
+// path but import.meta.url resolves to the real path - they never match
+if (import.meta.main) {
     main().catch((err) => {
         die(`Metrics snapshot failed: ${err.message}`);
     });

package/dist/orchestrate-initiative.js

@@ -11,7 +11,7 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlan, formatExecutionPlan, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointMode, LOG_PREFIX, } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanAsync, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
 import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
 const program = new Command()
     .name('orchestrate-initiative')
@@ -61,7 +61,7 @@ const program = new Command()
         if (progressOnly) {
             return;
         }
-        const checkpointDecision = resolveCheckpointMode({ checkpointPerWave, noCheckpoint, dryRun }, wus);
+        const checkpointDecision = await resolveCheckpointModeAsync({ checkpointPerWave, noCheckpoint, dryRun }, wus);
         if (checkpointDecision.enabled) {
             if (initIds.length > 1) {
                 console.error(chalk.red(`${LOG_PREFIX} Error: Checkpoint mode only supports single initiative`));
@@ -76,7 +76,7 @@ const program = new Command()
             return;
         }
         console.log(chalk.cyan(`${LOG_PREFIX} Building execution plan...`));
-        const plan = buildExecutionPlan(wus);
+        const plan = await buildExecutionPlanAsync(wus);
         if (plan.waves.length === 0) {
             console.log(chalk.green(`${LOG_PREFIX} All WUs are complete! Nothing to execute.`));
             return;
@@ -89,8 +89,14 @@ const program = new Command()
             console.log(chalk.cyan('To execute this plan, remove the --dry-run flag.'));
             return;
         }
+        // WU-1202: Output spawn XML for actual execution (not dry-run)
+        // formatExecutionPlan only shows the plan structure, not spawn commands
+        // formatExecutionPlanWithEmbeddedSpawns includes Task XML for spawning agents
+        console.log('');
+        console.log(chalk.bold('Spawn Commands:'));
+        console.log(formatExecutionPlanWithEmbeddedSpawns(plan));
         console.log(chalk.green(`${LOG_PREFIX} Execution plan output complete.`));
-        console.log(chalk.cyan('Copy the spawn commands above to execute.'));
+        console.log(chalk.cyan('Copy the spawn XML above to execute agents.'));
     }
     catch (error) {
         console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));