@supaku/agentfactory-cli 0.3.0 → 0.4.1

package/dist/src/analyze-logs.d.ts

@@ -2,8 +2,8 @@
 /**
  * AgentFactory Log Analyzer CLI
  *
- * Analyzes agent session logs for errors and improvement opportunities.
- * Can automatically create deduplicated Linear issues in the backlog.
+ * Thin wrapper around the analyze-logs runner. Handles dotenv, arg parsing,
+ * SIGINT, and process.exit so the runner stays process-agnostic.
  *
  * Usage:
  *   af-analyze-logs [options]

package/dist/src/analyze-logs.js

@@ -2,8 +2,8 @@
 /**
  * AgentFactory Log Analyzer CLI
  *
- * Analyzes agent session logs for errors and improvement opportunities.
- * Can automatically create deduplicated Linear issues in the backlog.
+ * Thin wrapper around the analyze-logs runner. Handles dotenv, arg parsing,
+ * SIGINT, and process.exit so the runner stays process-agnostic.
  *
  * Usage:
  *   af-analyze-logs [options]
@@ -23,25 +23,10 @@
  *   AGENT_LOGS_DIR                    Base directory for logs (default: .agent-logs)
  */
 import path from 'path';
-import { execSync } from 'child_process';
 import { config } from 'dotenv';
 // Load environment variables from .env.local in CWD
 config({ path: path.resolve(process.cwd(), '.env.local') });
-import { createLogAnalyzer } from '@supaku/agentfactory';
-/**
- * Get the git repository root directory
- */
-function getGitRoot() {
-    try {
-        return execSync('git rev-parse --show-toplevel', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-    }
-    catch {
-        return process.cwd();
-    }
-}
+import { runLogAnalyzer, printSummary } from './lib/analyze-logs-runner.js';
 const DEFAULT_POLL_INTERVAL = 5000;
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -127,189 +112,33 @@ Examples:
   af-analyze-logs --verbose
 `);
 }
-/**
- * Analyze a single session and print results
- */
-async function analyzeAndPrintSession(analyzer, sessionId, options, stats) {
-    console.log(`\nAnalyzing session: ${sessionId}`);
-    console.log('-'.repeat(50));
-    const result = analyzer.analyzeSession(sessionId);
-    if (!result) {
-        console.log('  [SKIP] Session not found or incomplete');
-        return false;
-    }
-    console.log(`  Issue: ${result.metadata.issueIdentifier}`);
-    console.log(`  Work Type: ${result.metadata.workType}`);
-    console.log(`  Status: ${result.metadata.status}`);
-    console.log(`  Events: ${result.eventsAnalyzed}`);
-    console.log(`  Errors: ${result.errorsFound}`);
-    console.log(`  Patterns: ${result.patterns.length}`);
-    stats.sessionsAnalyzed++;
-    stats.totalErrors += result.errorsFound;
-    stats.totalPatterns += result.patterns.length;
-    if (options.verbose && result.patterns.length > 0) {
-        console.log('\n  Detected Patterns:');
-        for (const pattern of result.patterns) {
-            console.log(`    - [${pattern.severity}] ${pattern.title}`);
-            console.log(`      Type: ${pattern.type}, Occurrences: ${pattern.occurrences}`);
-            if (pattern.tool) {
-                console.log(`      Tool: ${pattern.tool}`);
-            }
-        }
-    }
-    if (result.suggestedIssues.length > 0) {
-        console.log(`\n  Suggested Issues: ${result.suggestedIssues.length}`);
-        if (options.verbose) {
-            for (const issue of result.suggestedIssues) {
-                console.log(`    - ${issue.title}`);
-                console.log(`      Signature: ${issue.signature}`);
-                console.log(`      Labels: ${issue.labels.join(', ')}`);
-            }
-        }
-        try {
-            const issueResults = await analyzer.createIssues(result.suggestedIssues, sessionId, options.dryRun);
-            for (const issueResult of issueResults) {
-                if (issueResult.created) {
-                    console.log(`  [${options.dryRun ? 'WOULD CREATE' : 'CREATED'}] ${issueResult.identifier}`);
-                    stats.issuesCreated++;
-                }
-                else {
-                    console.log(`  [${options.dryRun ? 'WOULD UPDATE' : 'UPDATED'}] ${issueResult.identifier}`);
-                    stats.issuesUpdated++;
-                }
-            }
-        }
-        catch (error) {
-            console.log(`  [ERROR] Failed to create issues: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (!options.dryRun) {
-        analyzer.markProcessed(sessionId, result);
-        console.log('  [PROCESSED]');
-    }
-    return true;
-}
-/**
- * Print summary statistics
- */
-function printSummary(stats, dryRun) {
-    console.log('\n' + '='.repeat(50));
-    console.log('=== Summary ===\n');
-    console.log(`  Sessions analyzed: ${stats.sessionsAnalyzed}`);
-    console.log(`  Total errors found: ${stats.totalErrors}`);
-    console.log(`  Total patterns detected: ${stats.totalPatterns}`);
-    console.log(`  Issues created: ${stats.issuesCreated}${dryRun ? ' (dry run)' : ''}`);
-    console.log(`  Issues updated: ${stats.issuesUpdated}${dryRun ? ' (dry run)' : ''}`);
-    console.log('');
-}
-/**
- * Format time for display
- */
-function formatTime() {
-    return new Date().toLocaleTimeString();
-}
-/**
- * Watch mode - continuously poll for new sessions
- */
-async function runFollowMode(analyzer, options) {
-    const stats = {
-        sessionsAnalyzed: 0,
-        totalErrors: 0,
-        totalPatterns: 0,
-        issuesCreated: 0,
-        issuesUpdated: 0,
-    };
-    const processedInSession = new Set();
-    console.log(`[${formatTime()}] Watching for new sessions (poll interval: ${options.interval}ms)`);
-    console.log(`[${formatTime()}] Press Ctrl+C to stop\n`);
-    let running = true;
-    const shutdown = () => {
-        console.log(`\n[${formatTime()}] Stopping...`);
-        running = false;
-        printSummary(stats, options.dryRun);
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-    // Initial check for existing unprocessed sessions
-    const initialSessions = analyzer.getUnprocessedSessions();
-    if (initialSessions.length > 0) {
-        console.log(`[${formatTime()}] Found ${initialSessions.length} existing unprocessed session(s)`);
-        for (const sid of initialSessions) {
-            if (!running)
-                break;
-            await analyzeAndPrintSession(analyzer, sid, options, stats);
-            processedInSession.add(sid);
-        }
-    }
-    // Poll loop
-    while (running) {
-        await new Promise((resolve) => setTimeout(resolve, options.interval));
-        if (!running)
-            break;
-        const sessions = analyzer.getUnprocessedSessions();
-        const newSessions = sessions.filter((s) => !processedInSession.has(s));
-        if (newSessions.length > 0) {
-            console.log(`[${formatTime()}] Found ${newSessions.length} new session(s) ready for analysis`);
-            for (const sid of newSessions) {
-                if (!running)
-                    break;
-                const analyzed = await analyzeAndPrintSession(analyzer, sid, options, stats);
-                if (analyzed) {
-                    processedInSession.add(sid);
-                }
-            }
-        }
-    }
-}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
 async function main() {
     const options = parseArgs();
     if (options.showHelp) {
         printHelp();
         process.exit(0);
     }
-    const gitRoot = getGitRoot();
-    const logsDir = process.env.AGENT_LOGS_DIR ?? `${gitRoot}/.agent-logs`;
-    console.log('\n=== AgentFactory Log Analyzer ===\n');
-    if (options.dryRun) {
-        console.log('[DRY RUN MODE - No issues will be created]\n');
-    }
-    const analyzer = createLogAnalyzer({ logsDir });
-    if (options.cleanup) {
-        console.log('Cleaning up old logs...\n');
-        const deleted = analyzer.cleanupOldLogs();
-        console.log(`Deleted ${deleted} old log entries.\n`);
-        return;
-    }
+    // Create AbortController for SIGINT handling in follow mode
+    const controller = new AbortController();
     if (options.follow) {
-        await runFollowMode(analyzer, options);
-        return;
-    }
-    // Standard one-shot mode
-    const stats = {
-        sessionsAnalyzed: 0,
-        totalErrors: 0,
-        totalPatterns: 0,
-        issuesCreated: 0,
-        issuesUpdated: 0,
-    };
-    let sessionsToAnalyze;
-    if (options.sessionId) {
-        sessionsToAnalyze = [options.sessionId];
-        console.log(`Analyzing session: ${options.sessionId}\n`);
-    }
-    else {
-        sessionsToAnalyze = analyzer.getUnprocessedSessions();
-        console.log(`Found ${sessionsToAnalyze.length} unprocessed session(s)\n`);
-    }
-    if (sessionsToAnalyze.length === 0) {
-        console.log('No sessions to analyze.\n');
-        return;
-    }
-    for (const sid of sessionsToAnalyze) {
-        await analyzeAndPrintSession(analyzer, sid, options, stats);
-    }
-    printSummary(stats, options.dryRun);
+        const shutdown = () => {
+            controller.abort();
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    const result = await runLogAnalyzer({
+        sessionId: options.sessionId,
+        follow: options.follow,
+        interval: options.interval,
+        dryRun: options.dryRun,
+        cleanup: options.cleanup,
+        verbose: options.verbose,
+    }, controller.signal);
+    printSummary(result, options.dryRun);
 }
 main().catch((error) => {
     console.error('Error:', error instanceof Error ? error.message : error);

package/dist/src/cleanup.d.ts

@@ -1,12 +1,8 @@
 #!/usr/bin/env node
 /**
- * AgentFactory Worktree Cleanup
+ * AgentFactory Worktree Cleanup CLI
  *
- * Cleans up orphaned git worktrees in the .worktrees/ directory.
- * Run this script periodically to remove worktrees from:
- * - Crashed agent sessions
- * - Completed work where cleanup failed
- * - Stale branches that have been merged/deleted
+ * Thin wrapper around the cleanup runner.
  *
  * Usage:
  *   af-cleanup [options]

package/dist/src/cleanup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/cleanup.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG"}
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/cleanup.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;GAaG"}

package/dist/src/cleanup.js

@@ -1,12 +1,8 @@
 #!/usr/bin/env node
 /**
- * AgentFactory Worktree Cleanup
+ * AgentFactory Worktree Cleanup CLI
  *
- * Cleans up orphaned git worktrees in the .worktrees/ directory.
- * Run this script periodically to remove worktrees from:
- * - Crashed agent sessions
- * - Completed work where cleanup failed
- * - Stale branches that have been merged/deleted
+ * Thin wrapper around the cleanup runner.
  *
  * Usage:
  *   af-cleanup [options]
@@ -17,30 +13,14 @@
  *   --path <dir>        Custom worktrees directory (default: .worktrees)
  *   --help, -h          Show this help message
  */
-import { execSync } from 'child_process';
-import { existsSync, readdirSync, statSync } from 'fs';
-import { resolve, basename } from 'path';
-/**
- * Get the git repository root directory
- */
-function getGitRoot() {
-    try {
-        return execSync('git rev-parse --show-toplevel', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-    }
-    catch {
-        return process.cwd();
-    }
-}
+import { basename } from 'path';
+import { runCleanup, getGitRoot } from './lib/cleanup-runner.js';
 function parseArgs() {
     const args = process.argv.slice(2);
-    const gitRoot = getGitRoot();
     const result = {
         dryRun: false,
         force: false,
-        worktreePath: resolve(gitRoot, '.worktrees'),
+        worktreePath: undefined,
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -91,206 +71,7 @@ Examples:
   af-cleanup --force
 `);
 }
-/**
- * Get list of git worktrees from 'git worktree list'
- */
-function getGitWorktrees() {
-    const worktrees = new Map();
-    try {
-        const output = execSync('git worktree list --porcelain', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let currentPath = '';
-        for (const line of output.split('\n')) {
-            if (line.startsWith('worktree ')) {
-                currentPath = line.substring(9);
-            }
-            else if (line.startsWith('branch ')) {
-                const branch = line.substring(7).replace('refs/heads/', '');
-                worktrees.set(currentPath, branch);
-            }
-        }
-    }
-    catch (error) {
-        console.error('Failed to list git worktrees:', error);
-    }
-    return worktrees;
-}
-/**
- * Check if a git branch exists
- */
-function branchExists(branchName) {
-    try {
-        execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Scan the worktrees directory and identify orphaned worktrees
- */
-function scanWorktrees(options) {
-    const worktreesDir = resolve(options.worktreePath);
-    const result = [];
-    if (!existsSync(worktreesDir)) {
-        console.log(`Worktrees directory not found: ${worktreesDir}`);
-        return result;
-    }
-    const gitWorktrees = getGitWorktrees();
-    const entries = readdirSync(worktreesDir);
-    for (const entry of entries) {
-        const entryPath = resolve(worktreesDir, entry);
-        try {
-            if (!statSync(entryPath).isDirectory()) {
-                continue;
-            }
-        }
-        catch {
-            continue;
-        }
-        const info = {
-            path: entryPath,
-            branch: entry,
-            isOrphaned: false,
-        };
-        const isKnownWorktree = gitWorktrees.has(entryPath);
-        const branchName = isKnownWorktree ? gitWorktrees.get(entryPath) : entry;
-        if (options.force) {
-            info.isOrphaned = true;
-            info.reason = 'force cleanup requested';
-        }
-        else if (!isKnownWorktree) {
-            info.isOrphaned = true;
-            info.reason = 'not registered with git worktree';
-        }
-        else if (!branchExists(branchName)) {
-            info.isOrphaned = true;
-            info.reason = `branch '${branchName}' no longer exists`;
-        }
-        result.push(info);
-    }
-    return result;
-}
-/**
- * Remove a single worktree
- */
-function removeWorktree(worktreePath) {
-    try {
-        execSync(`git worktree remove "${worktreePath}" --force`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return { success: true };
-    }
-    catch {
-        try {
-            execSync(`rm -rf "${worktreePath}"`, {
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            execSync('git worktree prune', {
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            return { success: true };
-        }
-        catch (rmError) {
-            return {
-                success: false,
-                error: rmError instanceof Error ? rmError.message : String(rmError),
-            };
-        }
-    }
-}
-/**
- * Main cleanup function
- */
-function cleanup(options) {
-    const result = {
-        scanned: 0,
-        orphaned: 0,
-        cleaned: 0,
-        errors: [],
-    };
-    console.log('Scanning worktrees...\n');
-    try {
-        execSync('git worktree prune', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    catch {
-        console.log('Note: Could not prune git worktree metadata');
-    }
-    const worktrees = scanWorktrees(options);
-    result.scanned = worktrees.length;
-    if (worktrees.length === 0) {
-        console.log('No worktrees found.\n');
-        return result;
-    }
-    console.log(`Found ${worktrees.length} worktree(s) in ${options.worktreePath}/\n`);
-    for (const wt of worktrees) {
-        const status = wt.isOrphaned ? '  orphaned' : '    active';
-        const reason = wt.reason ? ` (${wt.reason})` : '';
-        console.log(`  ${status}: ${basename(wt.path)}${reason}`);
-    }
-    console.log('');
-    const orphaned = worktrees.filter((wt) => wt.isOrphaned);
-    result.orphaned = orphaned.length;
-    if (orphaned.length === 0) {
-        console.log('No orphaned worktrees to clean up.\n');
-        return result;
-    }
-    if (options.dryRun) {
-        console.log(`[DRY RUN] Would clean up ${orphaned.length} orphaned worktree(s):\n`);
-        for (const wt of orphaned) {
-            console.log(`  Would remove: ${wt.path}`);
-        }
-        console.log('');
-        return result;
-    }
-    console.log(`Cleaning up ${orphaned.length} orphaned worktree(s)...\n`);
-    for (const wt of orphaned) {
-        process.stdout.write(`  Removing ${basename(wt.path)}... `);
-        const removal = removeWorktree(wt.path);
-        if (removal.success) {
-            console.log('done');
-            result.cleaned++;
-        }
-        else {
-            console.log(`FAILED: ${removal.error}`);
-            result.errors.push({ path: wt.path, error: removal.error || 'Unknown error' });
-        }
-    }
-    console.log('');
-    try {
-        execSync('git worktree prune', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        console.log('Pruned git worktree metadata.\n');
-    }
-    catch {
-        // Ignore prune errors
-    }
-    return result;
-}
-// Main execution
-function main() {
-    const options = parseArgs();
-    console.log('\n=== AgentFactory Worktree Cleanup ===\n');
-    if (options.dryRun) {
-        console.log('[DRY RUN MODE - No changes will be made]\n');
-    }
-    if (options.force) {
-        console.log('[FORCE MODE - All worktrees will be removed]\n');
-    }
-    const result = cleanup(options);
+function printSummary(result) {
     console.log('=== Summary ===\n');
     console.log(`  Scanned:  ${result.scanned} worktree(s)`);
     console.log(`  Orphaned: ${result.orphaned}`);
@@ -302,6 +83,24 @@ function main() {
         }
     }
     console.log('');
+}
+// Main execution
+function main() {
+    const args = parseArgs();
+    console.log('\n=== AgentFactory Worktree Cleanup ===\n');
+    if (args.dryRun) {
+        console.log('[DRY RUN MODE - No changes will be made]\n');
+    }
+    if (args.force) {
+        console.log('[FORCE MODE - All worktrees will be removed]\n');
+    }
+    const result = runCleanup({
+        dryRun: args.dryRun,
+        force: args.force,
+        worktreePath: args.worktreePath,
+        gitRoot: getGitRoot(),
+    });
+    printSummary(result);
     if (result.errors.length > 0) {
         process.exit(1);
     }

package/dist/src/lib/analyze-logs-runner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log Analyzer Runner -- Programmatic API for the log analyzer CLI.
+ *
+ * Extracts the core logic from the analyze-logs bin script so that it can be
+ * invoked programmatically (e.g. from a Next.js route handler or test) without
+ * process.exit / dotenv / argv coupling.
+ */
+export interface AnalyzerRunnerConfig {
+    /** Analyze a specific session */
+    sessionId?: string;
+    /** Watch for new sessions and analyze as they complete */
+    follow?: boolean;
+    /** Poll interval in milliseconds (default: 5000) */
+    interval?: number;
+    /** Show what would be created without creating issues */
+    dryRun?: boolean;
+    /** Cleanup old logs based on retention policy */
+    cleanup?: boolean;
+    /** Show detailed analysis output */
+    verbose?: boolean;
+    /** Base directory for logs (default: {gitRoot}/.agent-logs or AGENT_LOGS_DIR env) */
+    logsDir?: string;
+    /** Git root for default paths (default: auto-detect) */
+    gitRoot?: string;
+}
+export interface AnalyzerResult {
+    sessionsAnalyzed: number;
+    totalErrors: number;
+    totalPatterns: number;
+    issuesCreated: number;
+    issuesUpdated: number;
+}
+/** Detect the git repository root. Falls back to cwd. */
+export declare function getGitRoot(): string;
+export declare function printSummary(stats: AnalyzerResult, dryRun: boolean): void;
+/**
+ * Run the log analyzer programmatically.
+ *
+ * For one-shot mode (default) the returned promise resolves with the analysis
+ * result once all sessions have been processed.
+ *
+ * For follow mode (`config.follow = true`) the analyzer keeps running until
+ * the optional `signal` is aborted.  When the signal fires the current poll
+ * cycle finishes and the accumulated stats are returned.
+ */
+export declare function runLogAnalyzer(config?: AnalyzerRunnerConfig, signal?: AbortSignal): Promise<AnalyzerResult>;
+//# sourceMappingURL=analyze-logs-runner.d.ts.map

package/dist/src/lib/analyze-logs-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-logs-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/analyze-logs-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,MAAM,WAAW,oBAAoB;IACnC,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iDAAiD;IACjD,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;CACtB;AAQD,yDAAyD;AACzD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AA0GD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CASzE;AAqED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,MAAM,GAAE,oBAAyB,EACjC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAkDzB"}