@lumenflow/cli 1.6.0 → 2.1.0

package/dist/file-delete.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * File Delete CLI Tool
+ *
+ * Provides audited file delete operations with:
+ * - Scope checking against WU code_paths
+ * - Recursive directory deletion
+ * - Force option for missing files
+ * - Audit logging
+ *
+ * Usage:
+ *   node file-delete.js <path> [--recursive] [--force]
+ *
+ * WU-1108: INIT-003 Phase 4a - Migrate file operations
+ */
+import { rm, stat, readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+/**
+ * Default configuration for file delete operations
+ */
+export const FILE_DELETE_DEFAULTS = {
+    /** Delete directories recursively */
+    recursive: false,
+    /** Don't error on missing files */
+    force: false,
+};
+/**
+ * Parse command line arguments for file-delete
+ */
+export function parseFileDeleteArgs(argv) {
+    const args = {
+        recursive: FILE_DELETE_DEFAULTS.recursive,
+        force: FILE_DELETE_DEFAULTS.force,
+    };
+    // 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 === '--recursive' || arg === '-r') {
+            args.recursive = true;
+        }
+        else if (arg === '--force' || arg === '-f') {
+            args.force = true;
+        }
+        else if (!arg.startsWith('-') && !args.path) {
+            // Positional argument for path
+            args.path = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Check if path exists and get its type
+ */
+async function getPathInfo(targetPath) {
+    try {
+        const stats = await stat(targetPath);
+        return { exists: true, isDirectory: stats.isDirectory() };
+    }
+    catch {
+        return { exists: false, isDirectory: false };
+    }
+}
+/**
+ * Count items in a directory recursively
+ */
+async function countItems(dirPath) {
+    let count = 0;
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            count++;
+            if (entry.isDirectory()) {
+                count += await countItems(join(dirPath, entry.name));
+            }
+        }
+    }
+    catch {
+        // Ignore errors in counting
+    }
+    return count;
+}
+/**
+ * Delete a file or directory with audit logging and safety checks
+ */
+export async function deleteFileWithAudit(args) {
+    const startTime = Date.now();
+    const targetPath = args.path ? resolve(args.path) : '';
+    const recursive = args.recursive ?? FILE_DELETE_DEFAULTS.recursive;
+    const force = args.force ?? FILE_DELETE_DEFAULTS.force;
+    const auditLog = {
+        operation: 'delete',
+        path: targetPath,
+        timestamp: new Date().toISOString(),
+        success: false,
+    };
+    try {
+        // Validate path
+        if (!targetPath) {
+            throw new Error('Path is required');
+        }
+        // Check if path exists
+        const pathInfo = await getPathInfo(targetPath);
+        if (!pathInfo.exists) {
+            if (force) {
+                // Force option - don't error on missing files
+                auditLog.success = true;
+                auditLog.durationMs = Date.now() - startTime;
+                return {
+                    success: true,
+                    metadata: {
+                        deletedCount: 0,
+                        wasDirectory: false,
+                    },
+                    auditLog,
+                };
+            }
+            else {
+                throw new Error(`ENOENT: no such file or directory: ${targetPath}`);
+            }
+        }
+        // Check if it's a directory and recursive is needed
+        if (pathInfo.isDirectory && !recursive) {
+            // Check if directory is empty
+            const entries = await readdir(targetPath);
+            if (entries.length > 0) {
+                throw new Error(`ENOTEMPTY: directory not empty: ${targetPath}. Use --recursive to delete non-empty directories.`);
+            }
+        }
+        // Count items before deletion (for metadata)
+        let deletedCount = 1;
+        if (pathInfo.isDirectory && recursive) {
+            deletedCount = 1 + (await countItems(targetPath)); // +1 for the directory itself
+        }
+        // Perform deletion
+        await rm(targetPath, { recursive, force });
+        // Build metadata
+        const metadata = {
+            deletedCount,
+            wasDirectory: pathInfo.isDirectory,
+        };
+        // Success
+        auditLog.success = true;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: true,
+            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-delete <path> [options]
+
+Delete a file or directory with audit logging.
+
+Arguments:
+  path                  Path to file or directory to delete
+
+Options:
+  --path <path>         Path to file (alternative to positional)
+  -r, --recursive       Delete directories recursively
+  -f, --force           Don't error if file doesn't exist
+  -h, --help            Show this help message
+
+Safety Notes:
+  - Non-empty directories require --recursive flag
+  - Use --force to ignore missing files
+  - All deletions are logged for audit purposes
+
+Examples:
+  file-delete temp.txt
+  file-delete --path output/build --recursive
+  file-delete missing.txt --force
+  file-delete old-dir -rf
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseFileDeleteArgs(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 deleteFileWithAudit(args);
+    if (result.success) {
+        if (result.metadata?.deletedCount === 0) {
+            console.log(`Nothing to delete (${args.path} does not exist)`);
+        }
+        else {
+            const itemType = result.metadata?.wasDirectory ? 'directory' : 'file';
+            const countInfo = result.metadata?.deletedCount && result.metadata.deletedCount > 1
+                ? ` (${result.metadata.deletedCount} items)`
+                : '';
+            console.log(`Deleted ${itemType}: ${args.path}${countInfo}`);
+        }
+    }
+    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-edit.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * File Edit CLI Tool
+ *
+ * Provides audited file edit operations with:
+ * - Scope checking against WU code_paths
+ * - Exact string replacement
+ * - Uniqueness validation
+ * - Replace-all support
+ * - Audit logging
+ *
+ * Usage:
+ *   node file-edit.js <path> --old-string <old> --new-string <new> [--replace-all]
+ *
+ * WU-1108: INIT-003 Phase 4a - Migrate file operations
+ */
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+/**
+ * Default configuration for file edit operations
+ */
+export const FILE_EDIT_DEFAULTS = {
+    /** Default encoding */
+    encoding: 'utf-8',
+    /** Replace all occurrences (default: false - requires unique match) */
+    replaceAll: false,
+};
+/**
+ * Parse command line arguments for file-edit
+ */
+export function parseFileEditArgs(argv) {
+    const args = {
+        encoding: FILE_EDIT_DEFAULTS.encoding,
+        replaceAll: FILE_EDIT_DEFAULTS.replaceAll,
+    };
+    // 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 === '--old-string' || arg === '--old') {
+            args.oldString = cliArgs[++i];
+        }
+        else if (arg === '--new-string' || arg === '--new') {
+            args.newString = cliArgs[++i];
+        }
+        else if (arg === '--encoding') {
+            args.encoding = cliArgs[++i];
+        }
+        else if (arg === '--replace-all') {
+            args.replaceAll = true;
+        }
+        else if (!arg.startsWith('-') && !args.path) {
+            // Positional argument for path
+            args.path = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Count occurrences of a string in content
+ */
+function countOccurrences(content, searchString) {
+    let count = 0;
+    let pos = 0;
+    while ((pos = content.indexOf(searchString, pos)) !== -1) {
+        count++;
+        pos += searchString.length;
+    }
+    return count;
+}
+/**
+ * Create a simple diff preview
+ */
+function createDiff(original, modified, oldString, newString) {
+    // Find the first occurrence for context
+    const index = original.indexOf(oldString);
+    if (index === -1)
+        return '';
+    // Get context around the change (50 chars before and after)
+    const contextSize = 50;
+    const start = Math.max(0, index - contextSize);
+    const end = Math.min(original.length, index + oldString.length + contextSize);
+    const beforeContext = original.slice(start, index);
+    const afterContext = original.slice(index + oldString.length, end);
+    return [
+        `--- original`,
+        `+++ modified`,
+        `@@ -1 +1 @@`,
+        `-${beforeContext}${oldString}${afterContext}`,
+        `+${beforeContext}${newString}${afterContext}`,
+    ].join('\n');
+}
+/**
+ * Edit a file with audit logging and safety checks
+ */
+export async function editFileWithAudit(args) {
+    const startTime = Date.now();
+    const filePath = args.path ? resolve(args.path) : '';
+    const encoding = args.encoding ?? FILE_EDIT_DEFAULTS.encoding;
+    const replaceAll = args.replaceAll ?? FILE_EDIT_DEFAULTS.replaceAll;
+    const oldString = args.oldString ?? '';
+    const newString = args.newString ?? '';
+    const auditLog = {
+        operation: 'edit',
+        path: filePath,
+        timestamp: new Date().toISOString(),
+        success: false,
+    };
+    try {
+        // Validate inputs
+        if (!filePath) {
+            throw new Error('Path is required');
+        }
+        if (!oldString) {
+            throw new Error('old-string is required');
+        }
+        // newString can be empty (for deletion)
+        // Read file content
+        const content = await readFile(filePath, { encoding });
+        // Count occurrences
+        const occurrences = countOccurrences(content, oldString);
+        if (occurrences === 0) {
+            throw new Error(`old_string not found in file: "${oldString.slice(0, 50)}${oldString.length > 50 ? '...' : ''}"`);
+        }
+        if (occurrences > 1 && !replaceAll) {
+            throw new Error(`old_string is not unique in file (found ${occurrences} occurrences). ` +
+                `Use --replace-all to replace all occurrences, or provide more context to make it unique.`);
+        }
+        // Perform replacement
+        let newContent;
+        let replacements;
+        if (replaceAll) {
+            newContent = content.split(oldString).join(newString);
+            replacements = occurrences;
+        }
+        else {
+            newContent = content.replace(oldString, newString);
+            replacements = 1;
+        }
+        // Create diff preview
+        const diff = createDiff(content, newContent, oldString, newString);
+        // Write file
+        await writeFile(filePath, newContent, { encoding });
+        // Success
+        auditLog.success = true;
+        auditLog.durationMs = Date.now() - startTime;
+        return {
+            success: true,
+            replacements,
+            diff,
+            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-edit <path> --old-string <old> --new-string <new> [options]
+
+Edit file by replacing exact string matches with audit logging.
+
+Arguments:
+  path                  Path to file to edit
+
+Options:
+  --path <path>         Path to file (alternative to positional)
+  --old-string <str>    String to find and replace (required)
+  --new-string <str>    Replacement string (required, can be empty)
+  --old <str>           Shorthand for --old-string
+  --new <str>           Shorthand for --new-string
+  --replace-all         Replace all occurrences (default: single unique match)
+  --encoding <enc>      File encoding (default: utf-8)
+  -h, --help            Show this help message
+
+Notes:
+  - By default, old-string must be unique in the file (exactly 1 match)
+  - Use --replace-all to replace multiple occurrences
+  - This ensures you don't accidentally modify unintended locations
+
+Examples:
+  file-edit src/index.ts --old "console.log" --new "logger.info"
+  file-edit config.json --old '"debug": true' --new '"debug": false'
+  file-edit --path file.txt --old foo --new bar --replace-all
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseFileEditArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (!args.path) {
+        console.error('Error: path is required');
+        printHelp();
+        process.exit(1);
+    }
+    if (!args.oldString) {
+        console.error('Error: --old-string is required');
+        printHelp();
+        process.exit(1);
+    }
+    if (args.newString === undefined) {
+        console.error('Error: --new-string is required');
+        printHelp();
+        process.exit(1);
+    }
+    const result = await editFileWithAudit(args);
+    if (result.success) {
+        console.log(`Replaced ${result.replacements} occurrence(s) in ${args.path}`);
+        if (result.diff) {
+            console.log('\nDiff preview:');
+            console.log(result.diff);
+        }
+    }
+    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-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);
+}