@supaku/agentfactory-cli 0.1.1 → 0.2.0

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

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Log Analyzer CLI
+ *
+ * Analyzes agent session logs for errors and improvement opportunities.
+ * Can automatically create deduplicated Linear issues in the backlog.
+ *
+ * Usage:
+ *   af-analyze-logs [options]
+ *
+ * Options:
+ *   --session <id>      Analyze a specific session
+ *   --follow, -f        Watch for new sessions and analyze as they complete
+ *   --interval <ms>     Poll interval in milliseconds (default: 5000)
+ *   --dry-run           Show what would be created without creating issues
+ *   --cleanup           Cleanup old logs based on retention policy
+ *   --verbose           Show detailed analysis output
+ *   --help, -h          Show this help message
+ *
+ * Environment (loaded from .env.local in CWD):
+ *   LINEAR_API_KEY                    Required for issue creation
+ *   AGENT_LOG_RETENTION_DAYS          Days before cleanup (default: 7)
+ *   AGENT_LOGS_DIR                    Base directory for logs (default: .agent-logs)
+ */
+export {};
+//# sourceMappingURL=analyze-logs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-logs.d.ts","sourceRoot":"","sources":["../../src/analyze-logs.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/src/analyze-logs.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Log Analyzer CLI
+ *
+ * Analyzes agent session logs for errors and improvement opportunities.
+ * Can automatically create deduplicated Linear issues in the backlog.
+ *
+ * Usage:
+ *   af-analyze-logs [options]
+ *
+ * Options:
+ *   --session <id>      Analyze a specific session
+ *   --follow, -f        Watch for new sessions and analyze as they complete
+ *   --interval <ms>     Poll interval in milliseconds (default: 5000)
+ *   --dry-run           Show what would be created without creating issues
+ *   --cleanup           Cleanup old logs based on retention policy
+ *   --verbose           Show detailed analysis output
+ *   --help, -h          Show this help message
+ *
+ * Environment (loaded from .env.local in CWD):
+ *   LINEAR_API_KEY                    Required for issue creation
+ *   AGENT_LOG_RETENTION_DAYS          Days before cleanup (default: 7)
+ *   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();
+    }
+}
+const DEFAULT_POLL_INTERVAL = 5000;
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {
+        follow: false,
+        interval: DEFAULT_POLL_INTERVAL,
+        dryRun: false,
+        cleanup: false,
+        verbose: false,
+        showHelp: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--session':
+                result.sessionId = args[++i];
+                break;
+            case '--follow':
+            case '-f':
+                result.follow = true;
+                break;
+            case '--interval':
+                result.interval = parseInt(args[++i], 10) || DEFAULT_POLL_INTERVAL;
+                break;
+            case '--dry-run':
+                result.dryRun = true;
+                break;
+            case '--cleanup':
+                result.cleanup = true;
+                break;
+            case '--verbose':
+                result.verbose = true;
+                break;
+            case '--help':
+            case '-h':
+                result.showHelp = true;
+                break;
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+AgentFactory Log Analyzer - Analyze agent session logs for errors and improvements
+
+Usage:
+  af-analyze-logs [options]
+
+Options:
+  --session <id>      Analyze a specific session
+  --follow, -f        Watch for new sessions and analyze as they complete
+  --interval <ms>     Poll interval in milliseconds (default: 5000)
+  --dry-run           Show what would be created without creating issues
+  --cleanup           Cleanup old logs based on retention policy
+  --verbose           Show detailed analysis output
+  --help, -h          Show this help message
+
+Environment Variables:
+  LINEAR_API_KEY                    Required for creating Linear issues
+  AGENT_LOG_RETENTION_DAYS          Days before log cleanup (default: 7)
+  AGENT_LOGS_DIR                    Base directory for logs (default: .agent-logs)
+
+Examples:
+  # Analyze all unprocessed sessions
+  af-analyze-logs
+
+  # Analyze a specific session
+  af-analyze-logs --session abc123
+
+  # Watch for new sessions and analyze continuously
+  af-analyze-logs --follow
+
+  # Watch with custom poll interval (10 seconds)
+  af-analyze-logs -f --interval 10000
+
+  # Preview what issues would be created (no actual changes)
+  af-analyze-logs --dry-run
+
+  # Clean up logs older than retention period
+  af-analyze-logs --cleanup
+
+  # Show detailed output during analysis
+  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);
+                }
+            }
+        }
+    }
+}
+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;
+    }
+    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);
+}
+main().catch((error) => {
+    console.error('Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/src/cleanup.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Worktree Cleanup
+ *
+ * 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
+ *
+ * Usage:
+ *   af-cleanup [options]
+ *
+ * Options:
+ *   --dry-run           Show what would be cleaned up without removing anything
+ *   --force             Force removal even if worktree appears active
+ *   --path <dir>        Custom worktrees directory (default: .worktrees)
+ *   --help, -h          Show this help message
+ */
+export {};
+//# sourceMappingURL=cleanup.d.ts.map

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

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

package/dist/src/cleanup.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Worktree Cleanup
+ *
+ * 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
+ *
+ * Usage:
+ *   af-cleanup [options]
+ *
+ * Options:
+ *   --dry-run           Show what would be cleaned up without removing anything
+ *   --force             Force removal even if worktree appears active
+ *   --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();
+    }
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const gitRoot = getGitRoot();
+    const result = {
+        dryRun: false,
+        force: false,
+        worktreePath: resolve(gitRoot, '.worktrees'),
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--dry-run':
+                result.dryRun = true;
+                break;
+            case '--force':
+                result.force = true;
+                break;
+            case '--path':
+                result.worktreePath = args[++i];
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+AgentFactory Worktree Cleanup - Remove orphaned git worktrees
+
+Usage:
+  af-cleanup [options]
+
+Options:
+  --dry-run           Show what would be cleaned up without removing
+  --force             Force removal even if worktree appears active
+  --path <dir>        Custom worktrees directory (default: .worktrees)
+  --help, -h          Show this help message
+
+Orphaned worktrees are identified by:
+  - Branch no longer exists (merged/deleted)
+  - Not listed in 'git worktree list' (stale directory)
+  - Lock file exists but is stale
+
+Examples:
+  # Preview what would be cleaned up
+  af-cleanup --dry-run
+
+  # Clean up orphaned worktrees
+  af-cleanup
+
+  # Force cleanup all worktrees (use with caution)
+  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);
+    console.log('=== Summary ===\n');
+    console.log(`  Scanned:  ${result.scanned} worktree(s)`);
+    console.log(`  Orphaned: ${result.orphaned}`);
+    console.log(`  Cleaned:  ${result.cleaned}`);
+    if (result.errors.length > 0) {
+        console.log(`  Errors:   ${result.errors.length}`);
+        for (const err of result.errors) {
+            console.log(`    - ${basename(err.path)}: ${err.error}`);
+        }
+    }
+    console.log('');
+    if (result.errors.length > 0) {
+        process.exit(1);
+    }
+}
+main();

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;;;GAKG;AAEH,QAAA,MAAM,OAAO,QAAkB,CAAA;AAE/B,iBAAS,SAAS,IAAI,IAAI,CAgBzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;;;GAKG;AAEH,QAAA,MAAM,OAAO,QAAkB,CAAA;AAE/B,iBAAS,SAAS,IAAI,IAAI,CAoBzB"}