@lumenflow/cli 1.6.0 → 2.1.0

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);
+}

package/dist/git-diff.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * Git Diff CLI Tool
+ *
+ * Provides WU-aware git diff with:
+ * - Staged/cached diff support
+ * - Name-only and stat output modes
+ * - File filtering
+ *
+ * Usage:
+ *   node git-diff.js [ref] [--staged] [--name-only] [--stat]
+ *
+ * WU-1109: INIT-003 Phase 4b - Migrate git operations
+ */
+import { createGitForPath, getGitForCwd } from '@lumenflow/core';
+/**
+ * Parse command line arguments for git-diff
+ */
+export function parseGitDiffArgs(argv) {
+    const args = {};
+    // Skip node and script name
+    const cliArgs = argv.slice(2);
+    let afterDoubleDash = false;
+    for (let i = 0; i < cliArgs.length; i++) {
+        const arg = cliArgs[i];
+        if (arg === '--') {
+            afterDoubleDash = true;
+            continue;
+        }
+        if (afterDoubleDash) {
+            // Everything after -- is a path
+            args.path = arg;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        }
+        else if (arg === '--staged' || arg === '--cached') {
+            args.staged = true;
+        }
+        else if (arg === '--name-only') {
+            args.nameOnly = true;
+        }
+        else if (arg === '--stat') {
+            args.stat = true;
+        }
+        else if (arg === '--base-dir') {
+            args.baseDir = cliArgs[++i];
+        }
+        else if (!arg.startsWith('-') && !args.ref) {
+            // Positional argument for ref
+            args.ref = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Get git diff with audit logging
+ */
+export async function getGitDiff(args) {
+    try {
+        const git = args.baseDir ? createGitForPath(args.baseDir) : getGitForCwd();
+        // Build diff arguments
+        const rawArgs = ['diff'];
+        if (args.staged) {
+            rawArgs.push('--cached');
+        }
+        if (args.nameOnly) {
+            rawArgs.push('--name-only');
+        }
+        if (args.stat) {
+            rawArgs.push('--stat');
+        }
+        if (args.ref) {
+            rawArgs.push(args.ref);
+        }
+        if (args.path) {
+            rawArgs.push('--', args.path);
+        }
+        const output = await git.raw(rawArgs);
+        const trimmedOutput = output.trim();
+        const hasDiff = trimmedOutput !== '';
+        // Parse output based on mode
+        if (args.nameOnly) {
+            const files = trimmedOutput ? trimmedOutput.split('\n').filter((f) => f.trim()) : [];
+            return {
+                success: true,
+                hasDiff,
+                files,
+            };
+        }
+        if (args.stat) {
+            return {
+                success: true,
+                hasDiff,
+                stat: trimmedOutput,
+            };
+        }
+        return {
+            success: true,
+            hasDiff,
+            diff: trimmedOutput,
+        };
+    }
+    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-diff [ref] [options] [-- path]
+
+Show changes between commits, commit and working tree, etc.
+
+Arguments:
+  ref                   Reference to diff against (e.g., HEAD~1, main)
+  path                  Path to filter diff
+
+Options:
+  --base-dir <dir>      Base directory for git operations
+  --staged, --cached    Show staged changes
+  --name-only           Show only names of changed files
+  --stat                Show diffstat
+  -h, --help            Show this help message
+
+Examples:
+  git-diff
+  git-diff --staged
+  git-diff HEAD~1
+  git-diff --name-only
+  git-diff -- src/index.ts
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseGitDiffArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    const result = await getGitDiff(args);
+    if (result.success) {
+        if (result.files) {
+            // Name-only mode
+            result.files.forEach((f) => console.log(f));
+        }
+        else if (result.stat) {
+            // Stat mode
+            console.log(result.stat);
+        }
+        else if (result.diff) {
+            // Full diff
+            console.log(result.diff);
+        }
+        // Empty diff produces no output
+    }
+    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);
+}