@lumenflow/cli 1.6.0 → 2.1.0

package/dist/rotate-progress.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * Rotate Progress CLI Command
+ *
+ * Moves completed WUs from status.md In Progress section to Completed section.
+ * Keeps the status file tidy by archiving done work.
+ *
+ * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
+ *
+ * Usage:
+ *   pnpm rotate:progress
+ *   pnpm rotate:progress --dry-run
+ *   pnpm rotate:progress --limit 10
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { EXIT_CODES, STATUS_SECTIONS, DIRECTORIES, FILE_SYSTEM, } from '@lumenflow/core/dist/wu-constants.js';
+import { runCLI } from './cli-entry-point.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[rotate:progress]';
+/**
+ * Parse command line arguments for rotate-progress
+ *
+ * @param argv - Process argv array
+ * @returns Parsed arguments
+ */
+export function parseRotateArgs(argv) {
+    const args = {};
+    // Skip node and script name
+    const cliArgs = argv.slice(2);
+    for (let i = 0; i < cliArgs.length; i++) {
+        const arg = cliArgs[i];
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        }
+        else if (arg === '--dry-run' || arg === '-n') {
+            args.dryRun = true;
+        }
+        else if (arg === '--limit' || arg === '-l') {
+            const val = cliArgs[++i];
+            if (val)
+                args.limit = parseInt(val, 10);
+        }
+    }
+    return args;
+}
+/**
+ * Get WU status from YAML file
+ */
+function getWuStatus(wuId, baseDir = process.cwd()) {
+    const yamlPath = join(baseDir, DIRECTORIES.WU_DIR, `${wuId}.yaml`);
+    if (!existsSync(yamlPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(yamlPath, { encoding: FILE_SYSTEM.ENCODING });
+        const yaml = parseYaml(content);
+        return yaml?.status || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get all WU statuses from YAML files
+ */
+function getAllWuStatuses(baseDir = process.cwd()) {
+    const statuses = new Map();
+    const wuDir = join(baseDir, DIRECTORIES.WU_DIR);
+    if (!existsSync(wuDir)) {
+        return statuses;
+    }
+    const files = readdirSync(wuDir);
+    for (const file of files) {
+        if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+            const wuId = file.replace(/\.ya?ml$/, '');
+            const status = getWuStatus(wuId, baseDir);
+            if (status) {
+                statuses.set(wuId, status);
+            }
+        }
+    }
+    return statuses;
+}
+/**
+ * Find WUs in the In Progress section that have status=done in YAML
+ *
+ * @param statusContent - Content of status.md file
+ * @param wuStatuses - Map of WU IDs to their statuses from YAML
+ * @returns Array of WU IDs that should be moved to Completed
+ */
+export function findCompletedWUs(statusContent, wuStatuses) {
+    const completed = [];
+    // Find the In Progress section
+    const inProgressStart = statusContent.indexOf(STATUS_SECTIONS.IN_PROGRESS);
+    if (inProgressStart === -1) {
+        return completed;
+    }
+    // Find the end of In Progress section (next ## heading or end of file)
+    const afterInProgress = statusContent.slice(inProgressStart + STATUS_SECTIONS.IN_PROGRESS.length);
+    const nextSectionMatch = afterInProgress.match(/\n##/);
+    const inProgressSection = nextSectionMatch
+        ? afterInProgress.slice(0, nextSectionMatch.index)
+        : afterInProgress;
+    // Extract WU IDs from In Progress section
+    const wuIdMatches = inProgressSection.match(/WU-\d+/g) || [];
+    const uniqueWuIds = [...new Set(wuIdMatches)];
+    // Check which ones have done status
+    for (const wuId of uniqueWuIds) {
+        const status = wuStatuses.get(wuId);
+        if (status === 'done' || status === 'completed') {
+            completed.push(wuId);
+        }
+    }
+    return completed;
+}
+/**
+ * Build the rotated status.md content
+ *
+ * @param statusContent - Original status.md content
+ * @param completedWUs - WU IDs to move to Completed
+ * @returns Updated status.md content
+ */
+export function buildRotatedContent(statusContent, completedWUs) {
+    if (completedWUs.length === 0) {
+        return statusContent;
+    }
+    let content = statusContent;
+    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    // For each completed WU, move it from In Progress to Completed
+    for (const wuId of completedWUs) {
+        // Find and remove the line from In Progress section
+        const wuLineRegex = new RegExp(`\\n?-\\s*\\[?[\\sx]?\\]?\\s*\\[?${wuId}[^\\n]*`, 'gi');
+        const match = content.match(wuLineRegex);
+        if (match) {
+            // Extract the original line text
+            const originalLine = match[0].trim();
+            // Remove from current position
+            content = content.replace(wuLineRegex, '');
+            // Extract title from the original line
+            // Match "WU-XXXX - Title" or "WU-XXXX Title" patterns
+            const titleMatch = originalLine.match(/WU-\d+\s*[-—]?\s*([^(]*)/);
+            let title = wuId;
+            if (titleMatch) {
+                const fullMatch = titleMatch[0].trim();
+                const wuPart = wuId;
+                // Get everything after the WU ID
+                const rest = fullMatch
+                    .slice(wuId.length)
+                    .replace(/^[\s-—]+/, '')
+                    .trim();
+                title = rest ? `${wuPart} - ${rest}` : wuPart;
+            }
+            // Build the completed entry with date
+            const completedEntry = `- [x] ${title} (${today})`;
+            // Add to Completed section
+            const completedSectionIndex = content.indexOf(STATUS_SECTIONS.COMPLETED);
+            if (completedSectionIndex !== -1) {
+                const insertPoint = completedSectionIndex + STATUS_SECTIONS.COMPLETED.length;
+                content =
+                    content.slice(0, insertPoint) + '\n' + completedEntry + content.slice(insertPoint);
+            }
+        }
+    }
+    // Clean up any double newlines
+    content = content.replace(/\n{3,}/g, '\n\n');
+    return content;
+}
+/**
+ * Print help message for rotate-progress
+ */
+/* istanbul ignore next -- CLI entry point */
+function printHelp() {
+    console.log(`
+Usage: rotate-progress [options]
+
+Move completed WUs from status.md In Progress to Completed section.
+
+Options:
+  -n, --dry-run       Show changes without writing
+  -l, --limit <n>     Maximum number of WUs to rotate
+  -h, --help          Show this help message
+
+How it works:
+  1. Scans status.md for WUs listed in "In Progress" section
+  2. Checks each WU's YAML file for status=done
+  3. Moves done WUs to "Completed" section with date stamp
+
+Examples:
+  rotate:progress               # Rotate all completed WUs
+  rotate:progress --dry-run     # Preview what would be rotated
+  rotate:progress --limit 5     # Rotate at most 5 WUs
+`);
+}
+/**
+ * Main entry point for rotate-progress command
+ */
+/* istanbul ignore next -- CLI entry point */
+async function main() {
+    const args = parseRotateArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // Read status.md
+    const statusPath = join(process.cwd(), DIRECTORIES.STATUS_PATH);
+    if (!existsSync(statusPath)) {
+        console.error(`${LOG_PREFIX} Error: ${statusPath} not found`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const statusContent = readFileSync(statusPath, {
+        encoding: FILE_SYSTEM.ENCODING,
+    });
+    // Get all WU statuses
+    const wuStatuses = getAllWuStatuses();
+    // Find completed WUs
+    let completedWUs = findCompletedWUs(statusContent, wuStatuses);
+    if (completedWUs.length === 0) {
+        console.log(`${LOG_PREFIX} No completed WUs to rotate.`);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // Apply limit if specified
+    if (args.limit && args.limit > 0) {
+        completedWUs = completedWUs.slice(0, args.limit);
+    }
+    console.log(`${LOG_PREFIX} Found ${completedWUs.length} WU(s) to rotate:`);
+    for (const wuId of completedWUs) {
+        console.log(`  - ${wuId}`);
+    }
+    if (args.dryRun) {
+        console.log(`\n${LOG_PREFIX} DRY RUN - No changes made.`);
+        const newContent = buildRotatedContent(statusContent, completedWUs);
+        console.log(`\n${LOG_PREFIX} Preview of changes:`);
+        console.log('---');
+        console.log(newContent.slice(0, 500) + '...');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // Build and write updated content
+    const newContent = buildRotatedContent(statusContent, completedWUs);
+    writeFileSync(statusPath, newContent, { encoding: FILE_SYSTEM.ENCODING });
+    console.log(`\n${LOG_PREFIX} ✅ Rotated ${completedWUs.length} WU(s) to Completed section.`);
+}
+// Run main if executed directly
+if (import.meta.main) {
+    runCLI(main);
+}

package/dist/session-coordinator.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/**
+ * Session Coordinator CLI Command
+ *
+ * Manages agent sessions - starting, stopping, status, and handoffs.
+ * Sessions track which agent is working on which WU and facilitate
+ * coordination between multiple agents.
+ *
+ * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
+ *
+ * Usage:
+ *   pnpm session:start --wu WU-1112 --agent claude-code
+ *   pnpm session:stop --reason "Completed work"
+ *   pnpm session:status
+ *   pnpm session:handoff --wu WU-1112 --agent cursor
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { EXIT_CODES, LUMENFLOW_PATHS, FILE_SYSTEM } from '@lumenflow/core/dist/wu-constants.js';
+import { runCLI } from './cli-entry-point.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[session]';
+/**
+ * Session subcommands
+ */
+export var SessionCommand;
+(function (SessionCommand) {
+    SessionCommand["START"] = "start";
+    SessionCommand["STOP"] = "stop";
+    SessionCommand["STATUS"] = "status";
+    SessionCommand["HANDOFF"] = "handoff";
+})(SessionCommand || (SessionCommand = {}));
+/**
+ * Parse command line arguments for session-coordinator
+ *
+ * @param argv - Process argv array
+ * @returns Parsed arguments
+ */
+export function parseSessionArgs(argv) {
+    const args = {};
+    // Skip node and script name
+    const cliArgs = argv.slice(2);
+    for (let i = 0; i < cliArgs.length; i++) {
+        const arg = cliArgs[i];
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        }
+        else if (arg === '--wu' || arg === '-w') {
+            args.wuId = cliArgs[++i];
+        }
+        else if (arg === '--agent' || arg === '-a') {
+            args.agent = cliArgs[++i];
+        }
+        else if (arg === '--reason' || arg === '-r') {
+            args.reason = cliArgs[++i];
+        }
+        else if (!arg.startsWith('-')) {
+            // Subcommand
+            if (Object.values(SessionCommand).includes(arg)) {
+                args.command = arg;
+            }
+        }
+    }
+    // Default to status if no command given
+    if (!args.command && !args.help) {
+        args.command = SessionCommand.STATUS;
+    }
+    return args;
+}
+/**
+ * Validate session command arguments
+ *
+ * @param args - Parsed session arguments
+ * @returns Validation result
+ */
+export function validateSessionCommand(args) {
+    const { command, wuId } = args;
+    switch (command) {
+        case SessionCommand.START:
+            if (!wuId) {
+                return {
+                    valid: false,
+                    error: 'session start requires --wu <id> to specify which WU to work on',
+                };
+            }
+            break;
+        case SessionCommand.HANDOFF:
+            if (!wuId) {
+                return {
+                    valid: false,
+                    error: 'session handoff requires --wu <id> to specify which WU to hand off',
+                };
+            }
+            break;
+        case SessionCommand.STOP:
+        case SessionCommand.STATUS:
+            // No required arguments
+            break;
+        default:
+            return {
+                valid: false,
+                error: `Unknown command: ${command}`,
+            };
+    }
+    return { valid: true };
+}
+/**
+ * Get path to current session file
+ */
+function getSessionPath() {
+    return join(process.cwd(), LUMENFLOW_PATHS.SESSION_CURRENT);
+}
+/**
+ * Read current session state
+ */
+function readCurrentSession() {
+    const path = getSessionPath();
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(path, { encoding: FILE_SYSTEM.ENCODING });
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write session state
+ */
+function writeSession(session) {
+    const path = getSessionPath();
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    if (session === null) {
+        // Remove session file if clearing
+        if (existsSync(path)) {
+            const { unlinkSync } = require('node:fs');
+            unlinkSync(path);
+        }
+    }
+    else {
+        writeFileSync(path, JSON.stringify(session, null, 2), {
+            encoding: FILE_SYSTEM.ENCODING,
+        });
+    }
+}
+/**
+ * Print help message for session-coordinator
+ */
+/* istanbul ignore next -- CLI entry point */
+function printHelp() {
+    console.log(`
+Usage: session <command> [options]
+
+Manage agent sessions for WU work coordination.
+
+Commands:
+  start     Start a new session
+  stop      Stop current session
+  status    Show current session status
+  handoff   Hand off session to another agent
+
+Options:
+  -w, --wu <id>       WU ID to work on (required for start/handoff)
+  -a, --agent <type>  Agent type (e.g., claude-code, cursor, aider)
+  -r, --reason <msg>  Reason for stopping session
+  -h, --help          Show this help message
+
+Examples:
+  session start --wu WU-1112 --agent claude-code
+  session stop --reason "Completed acceptance criteria"
+  session status
+  session handoff --wu WU-1112 --agent cursor
+
+Session files are stored in: ${LUMENFLOW_PATHS.SESSION_CURRENT}
+`);
+}
+/**
+ * Handle start command
+ */
+/* istanbul ignore next -- CLI entry point */
+function handleStart(args) {
+    const current = readCurrentSession();
+    if (current) {
+        console.log(`${LOG_PREFIX} Active session already exists:`);
+        console.log(`  WU: ${current.wuId}`);
+        console.log(`  Agent: ${current.agent}`);
+        console.log(`  Started: ${current.startedAt}`);
+        console.log(`\n${LOG_PREFIX} Stop current session first with: session stop`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const session = {
+        wuId: args.wuId,
+        agent: args.agent || 'unknown',
+        startedAt: new Date().toISOString(),
+        lastActivity: new Date().toISOString(),
+    };
+    writeSession(session);
+    console.log(`${LOG_PREFIX} ✅ Session started`);
+    console.log(`  WU: ${session.wuId}`);
+    console.log(`  Agent: ${session.agent}`);
+    console.log(`  Started: ${session.startedAt}`);
+}
+/**
+ * Handle stop command
+ */
+/* istanbul ignore next -- CLI entry point */
+function handleStop(args) {
+    const current = readCurrentSession();
+    if (!current) {
+        console.log(`${LOG_PREFIX} No active session to stop.`);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const duration = Date.now() - new Date(current.startedAt).getTime();
+    const durationMin = Math.round(duration / 60000);
+    console.log(`${LOG_PREFIX} ✅ Session stopped`);
+    console.log(`  WU: ${current.wuId}`);
+    console.log(`  Agent: ${current.agent}`);
+    console.log(`  Duration: ${durationMin} minutes`);
+    if (args.reason) {
+        console.log(`  Reason: ${args.reason}`);
+    }
+    writeSession(null);
+}
+/**
+ * Handle status command
+ */
+/* istanbul ignore next -- CLI entry point */
+function handleStatus() {
+    const current = readCurrentSession();
+    if (!current) {
+        console.log(`${LOG_PREFIX} No active session.`);
+        console.log(`\n${LOG_PREFIX} Start a session with: session start --wu WU-XXXX`);
+        return;
+    }
+    const duration = Date.now() - new Date(current.startedAt).getTime();
+    const durationMin = Math.round(duration / 60000);
+    console.log(`${LOG_PREFIX} Active session:`);
+    console.log(`  WU: ${current.wuId}`);
+    console.log(`  Agent: ${current.agent}`);
+    console.log(`  Started: ${current.startedAt}`);
+    console.log(`  Duration: ${durationMin} minutes`);
+    console.log(`  Last activity: ${current.lastActivity}`);
+}
+/**
+ * Handle handoff command
+ */
+/* istanbul ignore next -- CLI entry point */
+function handleHandoff(args) {
+    const current = readCurrentSession();
+    if (current) {
+        console.log(`${LOG_PREFIX} Stopping current session...`);
+        handleStop({ reason: `Handoff to ${args.agent || 'another agent'}` });
+    }
+    console.log(`\n${LOG_PREFIX} Starting new session for handoff...`);
+    handleStart(args);
+}
+/**
+ * Main entry point for session-coordinator command
+ */
+/* istanbul ignore next -- CLI entry point */
+async function main() {
+    const args = parseSessionArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const validation = validateSessionCommand(args);
+    if (!validation.valid) {
+        console.error(`${LOG_PREFIX} Error: ${validation.error}`);
+        printHelp();
+        process.exit(EXIT_CODES.ERROR);
+    }
+    switch (args.command) {
+        case SessionCommand.START:
+            handleStart(args);
+            break;
+        case SessionCommand.STOP:
+            handleStop(args);
+            break;
+        case SessionCommand.STATUS:
+            handleStatus();
+            break;
+        case SessionCommand.HANDOFF:
+            handleHandoff(args);
+            break;
+        default:
+            console.error(`${LOG_PREFIX} Unknown command: ${args.command}`);
+            printHelp();
+            process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Run main if executed directly
+if (import.meta.main) {
+    runCLI(main);
+}