@lumenflow/cli 1.6.0 → 2.0.0

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

package/dist/git-log.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * Git Log CLI Tool
+ *
+ * Provides WU-aware git log with:
+ * - Oneline and custom format output
+ * - Max count limiting
+ * - Date and author filtering
+ *
+ * Usage:
+ *   node git-log.js [ref] [--oneline] [-n <count>] [--format <format>]
+ *
+ * WU-1109: INIT-003 Phase 4b - Migrate git operations
+ */
+import { createGitForPath, getGitForCwd } from '@lumenflow/core';
+/**
+ * Parse command line arguments for git-log
+ */
+export function parseGitLogArgs(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 === '--oneline') {
+            args.oneline = true;
+        }
+        else if (arg === '-n') {
+            const val = cliArgs[++i];
+            if (val)
+                args.maxCount = parseInt(val, 10);
+        }
+        else if (arg === '--max-count') {
+            const val = cliArgs[++i];
+            if (val)
+                args.maxCount = parseInt(val, 10);
+        }
+        else if (arg.startsWith('-n') && arg.length > 2) {
+            // Handle -n5 format
+            args.maxCount = parseInt(arg.slice(2), 10);
+        }
+        else if (arg === '--format') {
+            args.format = cliArgs[++i];
+        }
+        else if (arg === '--since') {
+            args.since = cliArgs[++i];
+        }
+        else if (arg === '--author') {
+            args.author = cliArgs[++i];
+        }
+        else if (arg === '--base-dir') {
+            args.baseDir = cliArgs[++i];
+        }
+        else if (!arg.startsWith('-') && !args.ref) {
+            // Positional argument for ref
+            args.ref = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Parse structured log output
+ */
+function parseLogOutput(output) {
+    if (!output.trim()) {
+        return [];
+    }
+    const commits = [];
+    // Parse format: hash|message|author|date (separated by |||)
+    const lines = output.trim().split('\n');
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const parts = line.split('|||');
+        if (parts.length >= 2) {
+            commits.push({
+                hash: parts[0].trim(),
+                message: parts[1].trim(),
+                author: parts[2]?.trim(),
+                date: parts[3]?.trim(),
+            });
+        }
+        else {
+            // Fallback for oneline format (hash + message)
+            const match = line.match(/^([a-f0-9]+)\s+(.*)$/);
+            if (match) {
+                commits.push({
+                    hash: match[1],
+                    message: match[2],
+                });
+            }
+        }
+    }
+    return commits;
+}
+/**
+ * Get git log with audit logging
+ */
+export async function getGitLog(args) {
+    try {
+        const git = args.baseDir ? createGitForPath(args.baseDir) : getGitForCwd();
+        // Build log arguments
+        const rawArgs = ['log'];
+        if (args.maxCount) {
+            rawArgs.push(`-n`, String(args.maxCount));
+        }
+        if (args.oneline) {
+            rawArgs.push('--oneline');
+        }
+        else if (args.format) {
+            rawArgs.push(`--format=${args.format}`);
+        }
+        else {
+            // Use structured format for parsing
+            rawArgs.push('--format=%H|||%s|||%an|||%ai');
+        }
+        if (args.since) {
+            rawArgs.push(`--since=${args.since}`);
+        }
+        if (args.author) {
+            rawArgs.push(`--author=${args.author}`);
+        }
+        if (args.ref) {
+            rawArgs.push(args.ref);
+        }
+        const output = await git.raw(rawArgs);
+        const trimmedOutput = output.trim();
+        // Parse commits
+        const commits = args.oneline || args.format ? [] : parseLogOutput(trimmedOutput);
+        return {
+            success: true,
+            commits,
+            output: args.oneline || args.format ? trimmedOutput : undefined,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Handle case of repo with no commits
+        if (errorMessage.includes('does not have any commits') ||
+            errorMessage.includes('fatal: bad revision') ||
+            errorMessage.includes("fatal: your current branch 'main' does not have any commits")) {
+            return {
+                success: true,
+                commits: [],
+            };
+        }
+        return {
+            success: false,
+            error: errorMessage,
+            commits: [],
+        };
+    }
+}
+/**
+ * Print help message
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+function printHelp() {
+    console.log(`
+Usage: git-log [ref] [options]
+
+Show commit logs.
+
+Arguments:
+  ref                   Revision range (e.g., main..feature)
+
+Options:
+  --base-dir <dir>      Base directory for git operations
+  --oneline             Show each commit on a single line
+  -n <number>           Limit the number of commits
+  --max-count <number>  Limit the number of commits
+  --format <format>     Pretty-print format string
+  --since <date>        Show commits more recent than a date
+  --author <pattern>    Limit to commits by author
+  -h, --help            Show this help message
+
+Examples:
+  git-log
+  git-log --oneline
+  git-log -n 10
+  git-log main..feature
+  git-log --since="2024-01-01"
+  git-log --author="test@example.com"
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseGitLogArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    const result = await getGitLog(args);
+    if (result.success) {
+        if (result.output !== undefined) {
+            // Custom format or oneline mode
+            if (result.output) {
+                console.log(result.output);
+            }
+        }
+        else {
+            // Structured output
+            for (const commit of result.commits) {
+                console.log(`commit ${commit.hash}`);
+                if (commit.author)
+                    console.log(`Author: ${commit.author}`);
+                if (commit.date)
+                    console.log(`Date:   ${commit.date}`);
+                console.log('');
+                console.log(`    ${commit.message}`);
+                console.log('');
+            }
+        }
+    }
+    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-status.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Git Status CLI Tool
+ *
+ * Provides WU-aware git status with:
+ * - Porcelain and short output formats
+ * - Parsed file status (staged, modified, untracked)
+ * - Clean/dirty state detection
+ *
+ * Usage:
+ *   node git-status.js [path] [--porcelain] [--short]
+ *
+ * WU-1109: INIT-003 Phase 4b - Migrate git operations
+ */
+import { createGitForPath, getGitForCwd } from '@lumenflow/core';
+/**
+ * Parse command line arguments for git-status
+ */
+export function parseGitStatusArgs(argv) {
+    const args = {
+        porcelain: false,
+        short: false,
+    };
+    // 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 === '--porcelain') {
+            args.porcelain = true;
+        }
+        else if (arg === '--short' || arg === '-s') {
+            args.short = true;
+        }
+        else if (arg === '--base-dir') {
+            args.baseDir = cliArgs[++i];
+        }
+        else if (!arg.startsWith('-')) {
+            // Positional argument for path
+            args.path = arg;
+        }
+    }
+    return args;
+}
+/**
+ * Parse porcelain status output into categorized files
+ */
+function parseStatusOutput(output) {
+    const staged = [];
+    const modified = [];
+    const untracked = [];
+    const deleted = [];
+    // Don't filter based on trim - leading spaces are significant in git status
+    const lines = output.split('\n').filter((line) => line.length > 0);
+    for (const line of lines) {
+        if (line.length < 3)
+            continue;
+        const indexStatus = line[0];
+        const workTreeStatus = line[1];
+        const filePath = line.slice(3).trim();
+        // Handle renames (e.g., "R  old -> new")
+        const fileName = filePath.includes(' -> ') ? filePath.split(' -> ')[1] : filePath;
+        // Untracked files
+        if (indexStatus === '?' && workTreeStatus === '?') {
+            untracked.push(fileName);
+            continue;
+        }
+        // Staged changes (index has status)
+        if (indexStatus !== ' ' && indexStatus !== '?') {
+            staged.push(fileName);
+            if (indexStatus === 'D') {
+                deleted.push(fileName);
+            }
+        }
+        // Working tree changes (unstaged modifications)
+        if (workTreeStatus === 'M') {
+            modified.push(fileName);
+        }
+        else if (workTreeStatus === 'D' && indexStatus === ' ') {
+            // Only count as deleted in working tree if not already staged for deletion
+            deleted.push(fileName);
+        }
+    }
+    return { staged, modified, untracked, deleted };
+}
+/**
+ * Get git status with audit logging
+ */
+export async function getGitStatus(args) {
+    try {
+        const git = args.baseDir ? createGitForPath(args.baseDir) : getGitForCwd();
+        // Get porcelain status
+        const rawArgs = ['status', '--porcelain'];
+        if (args.path) {
+            rawArgs.push('--', args.path);
+        }
+        const output = await git.raw(rawArgs);
+        // Don't trim the entire output - leading spaces in lines are significant for git status
+        // Only trim trailing newlines
+        const trimmedOutput = output.replace(/\n+$/, '');
+        const isClean = trimmedOutput === '';
+        // If porcelain mode requested, return raw output
+        if (args.porcelain) {
+            return {
+                success: true,
+                isClean,
+                output: trimmedOutput,
+            };
+        }
+        // Parse the status output
+        const { staged, modified, untracked, deleted } = parseStatusOutput(trimmedOutput);
+        return {
+            success: true,
+            isClean,
+            staged,
+            modified,
+            untracked,
+            deleted,
+            output: args.short ? trimmedOutput : undefined,
+        };
+    }
+    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-status [path] [options]
+
+Show the working tree status.
+
+Arguments:
+  path                  Path to filter status
+
+Options:
+  --base-dir <dir>      Base directory for git operations
+  --porcelain           Give the output in an easy-to-parse format
+  --short, -s           Give the output in short format
+  -h, --help            Show this help message
+
+Examples:
+  git-status
+  git-status src/
+  git-status --porcelain
+  git-status --short
+`);
+}
+/**
+ * Main entry point
+ */
+/* istanbul ignore next -- CLI entry point tested via subprocess */
+async function main() {
+    const args = parseGitStatusArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    const result = await getGitStatus(args);
+    if (result.success) {
+        if (result.output !== undefined) {
+            // Porcelain or short mode
+            if (result.output) {
+                console.log(result.output);
+            }
+        }
+        else {
+            // Human-readable output
+            if (result.isClean) {
+                console.log('nothing to commit, working tree clean');
+            }
+            else {
+                if (result.staged && result.staged.length > 0) {
+                    console.log('Changes to be committed:');
+                    result.staged.forEach((f) => console.log(`  ${f}`));
+                    console.log('');
+                }
+                if (result.modified && result.modified.length > 0) {
+                    console.log('Changes not staged for commit:');
+                    result.modified.forEach((f) => console.log(`  modified:   ${f}`));
+                    console.log('');
+                }
+                if (result.untracked && result.untracked.length > 0) {
+                    console.log('Untracked files:');
+                    result.untracked.forEach((f) => console.log(`  ${f}`));
+                }
+            }
+        }
+    }
+    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);
+}