@lumenflow/cli 1.6.0 → 2.0.0

package/dist/file-read.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * File Read CLI Tool
+ *
+ * Provides audited file read operations with:
+ * - Scope checking against WU code_paths
+ * - File size limits
+ * - Line range support
+ * - Audit logging
+ *
+ * Usage:
+ *   node file-read.js <path> [--encoding utf-8] [--start-line N] [--end-line M]
+ *
+ * WU-1108: INIT-003 Phase 4a - Migrate file operations
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+/**
+ * Default configuration for file read operations
+ */
+export const FILE_READ_DEFAULTS = {
+    /** Maximum file size in bytes (10MB) */
+    maxFileSizeBytes: 10 * 1024 * 1024,
+    /** Default encoding */
+    encoding: 'utf-8',
+};
+/**
+ * Parse command line arguments for file-read
+ */
+export function parseFileReadArgs(argv) {
+    const args = {
+        encoding: FILE_READ_DEFAULTS.encoding,
+        maxFileSizeBytes: FILE_READ_DEFAULTS.maxFileSizeBytes,
+    };
+    // 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 === '--path') {
+            args.path = cliArgs[++i];
+        }
+        else if (arg === '--encoding') {
+            args.encoding = cliArgs[++i];
+        }
+        else if (arg === '--start-line') {
+            const val = cliArgs[++i];
+            if (val)
+                args.startLine = parseInt(val, 10);
+        }
+        else if (arg === '--end-line') {
+            const val = cliArgs[++i];
+            if (val)
+                args.endLine = parseInt(val, 10);
+        }
+        else if (arg === '--max-size') {
+            const val = cliArgs[++i];
+            if (val)
+                args.maxFileSizeBytes = parseInt(val, 10);
+        }
+        else if (!arg.startsWith('-') && !args.path) {
+            // Positional argument for path
+            args.path = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Extract a range of lines from content
+ */
+function extractLineRange(content, startLine, endLine) {
+    if (!startLine && !endLine) {
+        return content;
+    }
+    const lines = content.split('\n');
+    const start = (startLine ?? 1) - 1; // Convert to 0-based
+    const end = endLine ?? lines.length; // Keep as 1-based for slice
+    return lines.slice(start, end).join('\n');
+}
+/**
+ * Read a file with audit logging and safety checks
+ */
+export async function readFileWithAudit(args) {
+    const startTime = Date.now();
+    const filePath = args.path ? resolve(args.path) : '';
+    const encoding = args.encoding ?? FILE_READ_DEFAULTS.encoding;
+    const maxSize = args.maxFileSizeBytes ?? FILE_READ_DEFAULTS.maxFileSizeBytes;
+    const auditLog = {
+        operation: 'read',
+        path: filePath,
+        timestamp: new Date().toISOString(),
+        success: false,
+    };
+    try {
+        // Validate path
+        if (!filePath) {
+            throw new Error('Path is required');
+        }
+        // Check file size before reading
+        const fileStats = await stat(filePath);
+        if (fileStats.size > maxSize) {
+            throw new Error(`File size (${fileStats.size} bytes) exceeds maximum allowed (${maxSize} bytes)`);
+        }
+        // Read file content
+        const content = await readFile(filePath, { encoding });
+        // Extract line range if specified
+        const lines = content.split('\n');
+        const resultContent = extractLineRange(content, args.startLine, args.endLine);
+        const resultLines = resultContent.split('\n');
+        // Build metadata
+        const metadata = {
+            sizeBytes: fileStats.size,
+            lineCount: lines.length,
+        };
+        if (args.startLine || args.endLine) {
+            metadata.linesReturned = resultLines.length;
+        }
+        // Success
+        auditLog.success = true;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: true,
+            content: resultContent,
+            metadata,
+            auditLog,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        auditLog.error = errorMessage;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: false,
+            error: errorMessage,
+            auditLog,
+        };
+    }
+}
+/**
+ * Print help message
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+function printHelp() {
+    console.log(`
+Usage: file-read <path> [options]
+
+Read file content with audit logging.
+
+Arguments:
+  path                  Path to file to read
+
+Options:
+  --path <path>         Path to file (alternative to positional)
+  --encoding <enc>      File encoding (default: utf-8)
+  --start-line <n>      Start line (1-based, inclusive)
+  --end-line <n>        End line (1-based, inclusive)
+  --max-size <bytes>    Maximum file size in bytes
+  -h, --help            Show this help message
+
+Examples:
+  file-read src/index.ts
+  file-read --path src/index.ts --start-line 10 --end-line 50
+  file-read config.json --encoding utf-8
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseFileReadArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (!args.path) {
+        console.error('Error: path is required');
+        printHelp();
+        process.exit(1);
+    }
+    const result = await readFileWithAudit(args);
+    if (result.success) {
+        // Output content to stdout
+        console.log(result.content);
+    }
+    else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+}
+// Run main if executed directly
+import { runCLI } from './cli-entry-point.js';
+if (import.meta.main) {
+    runCLI(main);
+}

package/dist/file-write.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * File Write CLI Tool
+ *
+ * Provides audited file write operations with:
+ * - Scope checking against WU code_paths
+ * - PHI scanning (optional)
+ * - Directory creation
+ * - Audit logging
+ *
+ * Usage:
+ *   node file-write.js <path> --content <content> [--encoding utf-8]
+ *
+ * WU-1108: INIT-003 Phase 4a - Migrate file operations
+ */
+import { writeFile, mkdir, stat } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+/**
+ * Default configuration for file write operations
+ */
+export const FILE_WRITE_DEFAULTS = {
+    /** Default encoding */
+    encoding: 'utf-8',
+    /** Create parent directories if they don't exist */
+    createDirectories: true,
+};
+/**
+ * Parse command line arguments for file-write
+ */
+export function parseFileWriteArgs(argv) {
+    const args = {
+        encoding: FILE_WRITE_DEFAULTS.encoding,
+        createDirectories: FILE_WRITE_DEFAULTS.createDirectories,
+    };
+    // 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 === '--path') {
+            args.path = cliArgs[++i];
+        }
+        else if (arg === '--content') {
+            args.content = cliArgs[++i];
+        }
+        else if (arg === '--encoding') {
+            args.encoding = cliArgs[++i];
+        }
+        else if (arg === '--no-create-dirs') {
+            args.createDirectories = false;
+        }
+        else if (arg === '--scan-phi') {
+            args.scanPHI = true;
+        }
+        else if (!arg.startsWith('-') && !args.path) {
+            // Positional argument for path
+            args.path = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Check if directory exists
+ */
+async function directoryExists(dirPath) {
+    try {
+        const stats = await stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write a file with audit logging and safety checks
+ */
+export async function writeFileWithAudit(args) {
+    const startTime = Date.now();
+    const filePath = args.path ? resolve(args.path) : '';
+    const encoding = args.encoding ?? FILE_WRITE_DEFAULTS.encoding;
+    const createDirs = args.createDirectories ?? FILE_WRITE_DEFAULTS.createDirectories;
+    const content = args.content ?? '';
+    const auditLog = {
+        operation: 'write',
+        path: filePath,
+        timestamp: new Date().toISOString(),
+        success: false,
+    };
+    const warnings = [];
+    try {
+        // Validate path
+        if (!filePath) {
+            throw new Error('Path is required');
+        }
+        const parentDir = dirname(filePath);
+        let directoriesCreated = false;
+        // Check parent directory
+        const parentExists = await directoryExists(parentDir);
+        if (!parentExists) {
+            if (createDirs) {
+                await mkdir(parentDir, { recursive: true });
+                directoriesCreated = true;
+            }
+            else {
+                throw new Error(`ENOENT: parent directory does not exist: ${parentDir}`);
+            }
+        }
+        // PHI scanning (if enabled and @lumenflow/core is available)
+        if (args.scanPHI) {
+            try {
+                // Dynamic import to avoid hard dependency
+                const { scanForPHI } = await import('@lumenflow/core/dist/validators/phi-scanner.js');
+                const scanResult = scanForPHI(content);
+                if (scanResult.hasPHI) {
+                    warnings.push(`PHI detected: ${scanResult.matches.length} potential match(es). Review before committing.`);
+                }
+            }
+            catch {
+                // PHI scanner not available - skip silently
+            }
+        }
+        // Write file
+        await writeFile(filePath, content, { encoding });
+        // Calculate bytes written
+        const bytesWritten = Buffer.byteLength(content, encoding);
+        // Build metadata
+        const metadata = {
+            bytesWritten,
+            directoriesCreated,
+        };
+        // Success
+        auditLog.success = true;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            metadata,
+            auditLog,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        auditLog.error = errorMessage;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: false,
+            error: errorMessage,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            auditLog,
+        };
+    }
+}
+/**
+ * Print help message
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+function printHelp() {
+    console.log(`
+Usage: file-write <path> --content <content> [options]
+
+Write content to a file with audit logging.
+
+Arguments:
+  path                  Path to file to write
+
+Options:
+  --path <path>         Path to file (alternative to positional)
+  --content <content>   Content to write (required)
+  --encoding <enc>      File encoding (default: utf-8)
+  --no-create-dirs      Don't create parent directories
+  --scan-phi            Scan content for PHI before writing
+  -h, --help            Show this help message
+
+Examples:
+  file-write output.txt --content "Hello, World!"
+  file-write --path nested/dir/file.txt --content "Content"
+  file-write config.json --content '{"key": "value"}' --encoding utf-8
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseFileWriteArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (!args.path) {
+        console.error('Error: path is required');
+        printHelp();
+        process.exit(1);
+    }
+    if (args.content === undefined) {
+        console.error('Error: --content is required');
+        printHelp();
+        process.exit(1);
+    }
+    const result = await writeFileWithAudit(args);
+    if (result.success) {
+        console.log(`Written ${result.metadata?.bytesWritten} bytes to ${args.path}`);
+        if (result.warnings && result.warnings.length > 0) {
+            for (const warning of result.warnings) {
+                console.warn(`Warning: ${warning}`);
+            }
+        }
+    }
+    else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+}
+// Run main if executed directly
+import { runCLI } from './cli-entry-point.js';
+if (import.meta.main) {
+    runCLI(main);
+}

package/dist/git-branch.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Git Branch CLI Tool
+ *
+ * Provides WU-aware git branch with:
+ * - Branch listing (local, remote, all)
+ * - Current branch detection
+ * - Contains filtering
+ *
+ * Usage:
+ *   node git-branch.js [--list] [-a] [-r] [--show-current]
+ *
+ * WU-1109: INIT-003 Phase 4b - Migrate git operations
+ */
+import { createGitForPath, getGitForCwd } from '@lumenflow/core';
+/**
+ * Parse command line arguments for git-branch
+ */
+export function parseGitBranchArgs(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 === '--list' || arg === '-l') {
+            args.list = true;
+        }
+        else if (arg === '--all' || arg === '-a') {
+            args.all = true;
+        }
+        else if (arg === '--remotes' || arg === '-r') {
+            args.remotes = true;
+        }
+        else if (arg === '--show-current') {
+            args.showCurrent = true;
+        }
+        else if (arg === '--contains') {
+            args.contains = cliArgs[++i];
+        }
+        else if (arg === '--base-dir') {
+            args.baseDir = cliArgs[++i];
+        }
+    }
+    return args;
+}
+/**
+ * Parse branch list output
+ */
+function parseBranchOutput(output) {
+    const branches = [];
+    const lines = output.split('\n').filter((line) => line.trim());
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Check if current branch (starts with *)
+        const isCurrent = trimmed.startsWith('*');
+        // Check if remote branch
+        const isRemote = trimmed.includes('remotes/') || trimmed.startsWith('origin/');
+        // Extract branch name
+        let name = trimmed;
+        if (isCurrent) {
+            name = name.slice(1).trim();
+        }
+        // Remove remote prefix for display
+        if (name.startsWith('remotes/')) {
+            name = name.slice(8);
+        }
+        // Skip HEAD pointer entries
+        if (name.includes(' -> ')) {
+            continue;
+        }
+        branches.push({
+            name,
+            isCurrent,
+            isRemote,
+        });
+    }
+    return branches;
+}
+/**
+ * Get git branch information
+ */
+export async function getGitBranch(args) {
+    try {
+        const git = args.baseDir ? createGitForPath(args.baseDir) : getGitForCwd();
+        // Show current branch only
+        if (args.showCurrent) {
+            const current = await git.getCurrentBranch();
+            return {
+                success: true,
+                current: current || undefined,
+            };
+        }
+        // Build branch arguments
+        const rawArgs = ['branch'];
+        if (args.all) {
+            rawArgs.push('-a');
+        }
+        else if (args.remotes) {
+            rawArgs.push('-r');
+        }
+        if (args.contains) {
+            rawArgs.push('--contains', args.contains);
+        }
+        const output = await git.raw(rawArgs);
+        const branches = parseBranchOutput(output);
+        // Find current branch
+        const currentBranch = branches.find((b) => b.isCurrent);
+        return {
+            success: true,
+            current: currentBranch?.name,
+            branches,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Print help message
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+function printHelp() {
+    console.log(`
+Usage: git-branch [options]
+
+List, create, or delete branches.
+
+Options:
+  --base-dir <dir>      Base directory for git operations
+  --list, -l            List branches
+  -a, --all             List both local and remote branches
+  -r, --remotes         List only remote branches
+  --show-current        Print the name of the current branch
+  --contains <commit>   Only list branches containing the specified commit
+  -h, --help            Show this help message
+
+Examples:
+  git-branch
+  git-branch --list
+  git-branch -a
+  git-branch --show-current
+  git-branch --contains abc123
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseGitBranchArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    const result = await getGitBranch(args);
+    if (result.success) {
+        if (args.showCurrent) {
+            if (result.current) {
+                console.log(result.current);
+            }
+        }
+        else if (result.branches) {
+            for (const branch of result.branches) {
+                const prefix = branch.isCurrent ? '* ' : '  ';
+                console.log(`${prefix}${branch.name}`);
+            }
+        }
+    }
+    else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+}
+// Run main if executed directly
+import { runCLI } from './cli-entry-point.js';
+if (import.meta.main) {
+    runCLI(main);
+}