@renseiai/agentfactory-cli 0.8.0

package/dist/src/lib/auto-updater.js

@@ -0,0 +1,109 @@
+/**
+ * Auto-Updater for AgentFactory CLI.
+ *
+ * When enabled, checks for new versions and can automatically update
+ * the CLI package. For long-running processes (fleet, governor), it
+ * waits until there are no active workers before restarting.
+ *
+ * Configuration (in order of precedence):
+ *   1. CLI flag: --auto-update / --no-auto-update
+ *   2. .env.local: AF_AUTO_UPDATE=true
+ *   3. .agentfactory/config.yaml: autoUpdate: true
+ */
+import { execSync } from 'child_process';
+// ---------------------------------------------------------------------------
+// ANSI colors
+// ---------------------------------------------------------------------------
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+/**
+ * Resolve whether auto-update is enabled from all config sources.
+ */
+export function isAutoUpdateEnabled(cliFlag) {
+    // CLI flag takes highest precedence
+    if (cliFlag !== undefined)
+        return cliFlag;
+    // Environment variable
+    const envVal = process.env.AF_AUTO_UPDATE;
+    if (envVal === '1' || envVal === 'true')
+        return true;
+    if (envVal === '0' || envVal === 'false')
+        return false;
+    // Default: disabled
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Update execution
+// ---------------------------------------------------------------------------
+/**
+ * Attempt to install the latest version of the CLI package.
+ * Returns true if the update succeeded.
+ */
+function installUpdate(targetVersion) {
+    const pkg = `@renseiai/agentfactory-cli@${targetVersion}`;
+    console.log(`${c.cyan}Updating to ${pkg}...${c.reset}`);
+    try {
+        // Detect package manager used for global install
+        execSync(`npm ls -g @renseiai/agentfactory-cli --depth=0 2>/dev/null`, { stdio: 'ignore' });
+        execSync(`npm install -g ${pkg}`, { stdio: 'inherit' });
+        return true;
+    }
+    catch {
+        // npm global didn't work — try pnpm
+        try {
+            execSync(`pnpm add -g ${pkg}`, { stdio: 'inherit' });
+            return true;
+        }
+        catch {
+            console.log(`${c.yellow}Auto-update failed. Update manually: npm i -g ${pkg}${c.reset}`);
+            return false;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Perform auto-update if enabled and an update is available.
+ *
+ * For long-running processes (fleet, governor), this should be called
+ * periodically. It will:
+ *   1. Check if auto-update is enabled
+ *   2. Verify an update is available
+ *   3. Wait for active workers to finish (if hasActiveWorkers provided)
+ *   4. Install the update
+ *   5. Exit the process so the service manager can restart with the new version
+ *
+ * Returns true if an update was applied (process will exit shortly after).
+ */
+export async function maybeAutoUpdate(updateCheck, config) {
+    if (!isAutoUpdateEnabled(config.cliFlag))
+        return false;
+    if (!updateCheck?.updateAvailable)
+        return false;
+    // If there are active workers, skip this cycle
+    if (config.hasActiveWorkers) {
+        const active = await config.hasActiveWorkers();
+        if (active) {
+            console.log(`${c.dim}Update v${updateCheck.latestVersion} available but workers are active — deferring${c.reset}`);
+            return false;
+        }
+    }
+    console.log(`\n${c.green}${c.bold}Auto-updating:${c.reset} v${updateCheck.currentVersion} → v${updateCheck.latestVersion}`);
+    const success = installUpdate(updateCheck.latestVersion);
+    if (!success)
+        return false;
+    // Call pre-restart hook
+    if (config.onBeforeRestart) {
+        await config.onBeforeRestart();
+    }
+    console.log(`${c.green}Update complete. Restarting...${c.reset}\n`);
+    // Exit with code 0 — service managers (systemd, pm2, etc.) will restart
+    process.exit(0);
+}

package/dist/src/lib/cleanup-runner.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Cleanup Runner -- Programmatic API for the worktree cleanup CLI.
+ *
+ * Exports `runCleanup()` so worktree cleanup can be invoked from code
+ * without going through process.argv / process.env / process.exit.
+ */
+export interface CleanupRunnerConfig {
+    /** Show what would be cleaned up without removing (default: false) */
+    dryRun?: boolean;
+    /** Force removal even if worktree appears active (default: false) */
+    force?: boolean;
+    /** Custom worktrees directory (default: {gitRoot}/.worktrees) */
+    worktreePath?: string;
+    /** Git root for default worktree path (default: auto-detect) */
+    gitRoot?: string;
+}
+export interface CleanupResult {
+    scanned: number;
+    orphaned: number;
+    cleaned: number;
+    skipped: number;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+export declare function getGitRoot(): string;
+export declare function runCleanup(config?: CleanupRunnerConfig): CleanupResult;
+//# sourceMappingURL=cleanup-runner.d.ts.map

package/dist/src/lib/cleanup-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/cleanup-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC/C;AAuBD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AAgSD,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,aAAa,CAUtE"}

package/dist/src/lib/cleanup-runner.js

@@ -0,0 +1,295 @@
+/**
+ * Cleanup Runner -- Programmatic API for the worktree cleanup CLI.
+ *
+ * Exports `runCleanup()` so worktree cleanup can be invoked from code
+ * without going through process.argv / process.env / process.exit.
+ */
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, statSync } from 'fs';
+import { resolve, basename } from 'path';
+/** Delay between worktree removals (ms) to let IDEs process filesystem events. */
+const IDE_SETTLE_DELAY_MS = 1500;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function getGitRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+/**
+ * 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;
+    }
+}
+/**
+ * Check if any processes (IDEs, language servers, etc.) have files open in a
+ * directory.  Uses `lsof` on macOS/Linux.  Returns a deduplicated list of
+ * process command names so the caller can warn the user.
+ */
+function getProcessesUsingPath(dirPath) {
+    try {
+        // lsof +D is recursive but can be slow on large trees.
+        // We use a short timeout and suppress errors — if it fails, we treat the
+        // path as free (better to over-delete than hang forever).
+        const output = execSync(`lsof +D "${dirPath}" 2>/dev/null || true`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        });
+        if (!output.trim())
+            return [];
+        const commands = new Set();
+        for (const line of output.split('\n').slice(1)) {
+            const cmd = line.split(/\s+/)[0];
+            if (cmd)
+                commands.add(cmd);
+        }
+        return [...commands];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Sleep synchronously for the given number of milliseconds.
+ */
+function sleepSync(ms) {
+    execSync(`sleep ${(ms / 1000).toFixed(1)}`, { stdio: 'pipe' });
+}
+/**
+ * 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 with safety checks.
+ *
+ * SAFETY: Refuses to remove paths where .git is a directory (main working tree)
+ * to prevent catastrophic data loss.
+ *
+ * IDE SAFETY: Detects processes (VS Code, Cursor, etc.) with open file handles
+ * in the worktree.  When detected and `force` is false, the removal is skipped
+ * to prevent IDE crashes caused by sudden workspace root deletion.
+ */
+function removeWorktree(worktreePath, force) {
+    // Safety check: never remove the main working tree
+    try {
+        const gitPath = resolve(worktreePath, '.git');
+        if (existsSync(gitPath) && statSync(gitPath).isDirectory()) {
+            return {
+                success: false,
+                error: `SAFETY: ${worktreePath} is the main working tree (.git is a directory). Refusing to remove.`,
+            };
+        }
+    }
+    catch {
+        // If we can't check, err on the side of caution
+        return { success: false, error: `SAFETY: Could not verify ${worktreePath} is not the main working tree.` };
+    }
+    // IDE safety: check for processes with open file handles in this worktree
+    const processes = getProcessesUsingPath(worktreePath);
+    if (processes.length > 0 && !force) {
+        return {
+            success: false,
+            skipped: true,
+            error: `IDE/process still open: ${processes.join(', ')}. Use --force to remove anyway.`,
+        };
+    }
+    if (processes.length > 0) {
+        console.log(`\n    warning: ${processes.join(', ')} has files open — forcing removal`);
+    }
+    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'],
+            });
+            return { success: true };
+        }
+        catch (rmError) {
+            return {
+                success: false,
+                error: rmError instanceof Error ? rmError.message : String(rmError),
+            };
+        }
+    }
+}
+/**
+ * Core cleanup logic
+ */
+function cleanup(options) {
+    const result = {
+        scanned: 0,
+        orphaned: 0,
+        cleaned: 0,
+        skipped: 0,
+        errors: [],
+    };
+    console.log('Scanning worktrees...\n');
+    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) {
+            const procs = getProcessesUsingPath(wt.path);
+            const procNote = procs.length > 0 ? ` [open: ${procs.join(', ')}]` : '';
+            console.log(`  Would remove: ${wt.path}${procNote}`);
+        }
+        console.log('');
+        return result;
+    }
+    console.log(`Cleaning up ${orphaned.length} orphaned worktree(s)...\n`);
+    let removedCount = 0;
+    for (const wt of orphaned) {
+        // Settle between removals so IDE file watchers can process previous
+        // deletion events without being overwhelmed.
+        if (removedCount > 0) {
+            sleepSync(IDE_SETTLE_DELAY_MS);
+        }
+        process.stdout.write(`  Removing ${basename(wt.path)}... `);
+        const removal = removeWorktree(wt.path, options.force);
+        if (removal.success) {
+            console.log('done');
+            result.cleaned++;
+            removedCount++;
+        }
+        else if (removal.skipped) {
+            console.log(`SKIPPED: ${removal.error}`);
+            result.skipped++;
+        }
+        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;
+}
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+export function runCleanup(config) {
+    const gitRoot = config?.gitRoot ?? getGitRoot();
+    const options = {
+        dryRun: config?.dryRun ?? false,
+        force: config?.force ?? false,
+        worktreePath: config?.worktreePath ?? resolve(gitRoot, '.worktrees'),
+    };
+    return cleanup(options);
+}

package/dist/src/lib/governor-dependencies.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Real Governor Dependencies
+ *
+ * Maps each GovernorDependencies callback to its real implementation
+ * using the Linear SDK (via LinearAgentClient) and Redis storage
+ * (from @renseiai/agentfactory-server).
+ */
+import type { LinearAgentClient, WorkflowContext } from '@renseiai/agentfactory-linear';
+import type { GovernorDependencies } from '@renseiai/agentfactory';
+export interface RealDependenciesConfig {
+    linearClient: LinearAgentClient;
+    resolveOAuthClient?: () => Promise<LinearAgentClient | undefined>;
+    organizationId?: string;
+    generatePrompt?: (identifier: string, workType: string, mentionContext?: string, workflowContext?: WorkflowContext) => string;
+}
+/**
+ * Create real GovernorDependencies backed by the Linear SDK and Redis.
+ *
+ * Each callback wraps its implementation in a try/catch so that a single
+ * failing dependency does not crash the entire governor scan loop.
+ */
+export declare function createRealDependencies(config: RealDependenciesConfig): GovernorDependencies;
+//# sourceMappingURL=governor-dependencies.d.ts.map

package/dist/src/lib/governor-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-dependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/governor-dependencies.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACvF,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,wBAAwB,CAAA;AAiC/B,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,iBAAiB,CAAA;IAC/B,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAA;IACjE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,eAAe,KAAK,MAAM,CAAA;CAC9H;AA6BD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,oBAAoB,CA6TtB"}