@backburner/cli 0.1.0

package/dist/src/cli/runtime/provider-runtime-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/runtime/provider-runtime.js

@@ -0,0 +1,152 @@
+import * as path from "node:path";
+import { CodexCliAgent } from "../../agents/codex.js";
+import { CompositeAgentRunner } from "../../agents/composite-runner.js";
+import { GitHubBrokerService } from "../../github/broker.js";
+import { ComposedBrokerService } from "../../github/composed.js";
+import { ScopedBrokerToolService } from "../../github/scoped-broker.js";
+import { createSmitheryMcpBridgeServicesFromStatuses } from "../../mcps/index.js";
+import { createTeeFileLogger } from "../../utils/logger.js";
+import { PlanBreakdownSessionStore } from "../../workstreams/plan-breakdown-generator/store.js";
+import { PlanBreakdownToolService } from "../../workstreams/plan-breakdown-generator/tools.js";
+import { WaveAssessmentSessionStore } from "../../workstreams/wave-assessment/store.js";
+import { WaveAssessmentToolService } from "../../workstreams/wave-assessment/tools.js";
+import { antigravityRuntimeProvider } from "./providers/antigravity.js";
+import { claudeRuntimeProvider } from "./providers/claude.js";
+import { codexRuntimeProvider } from "./providers/codex.js";
+import { geminiRuntimeProvider } from "./providers/gemini.js";
+import { openCodeRuntimeProvider } from "./providers/opencode.js";
+import { buildCapabilitiesByProvider, buildEffectiveProviderBrokerToolAllowLists } from "./provider-tools.js";
+const providerRuntimeDescriptors = [
+    codexRuntimeProvider,
+    geminiRuntimeProvider,
+    claudeRuntimeProvider,
+    openCodeRuntimeProvider,
+    antigravityRuntimeProvider
+];
+export async function setupProviderRuntime(input) {
+    let brokerServer;
+    let brokerLogger;
+    try {
+        let agentRunner = input.agentRunner;
+        let capabilitiesByProvider;
+        let providerBrokerToolAllowLists;
+        let brokerToolScope;
+        const enabledProviderDescriptors = providerRuntimeDescriptors.filter((descriptor) => descriptor.isEnabled(input.config));
+        if (!agentRunner && enabledProviderDescriptors.length > 0) {
+            const brokerToolUnion = new Set();
+            for (const descriptor of enabledProviderDescriptors) {
+                descriptor.toolAllowList(input.config).forEach((toolName) => brokerToolUnion.add(toolName));
+            }
+            brokerLogger = createTeeFileLogger(input.logger, path.join(input.logDir, "github-broker.log"));
+            const githubBrokerService = new GitHubBrokerService(input.gitHubGateway, input.config.repos, brokerLogger, Array.from(brokerToolUnion));
+            const planBreakdownSessionStore = new PlanBreakdownSessionStore(input.logDir);
+            const planBreakdownToolService = new PlanBreakdownToolService(planBreakdownSessionStore, input.logger);
+            const waveAssessmentSessionStore = new WaveAssessmentSessionStore(input.logDir);
+            const waveAssessmentToolService = new WaveAssessmentToolService(waveAssessmentSessionStore, input.logger);
+            let smitheryBridgeServices = [];
+            try {
+                smitheryBridgeServices = await createSmitheryMcpBridgeServicesFromStatuses(input.currentMcpStatuses, { apiKey: process.env.SMITHERY_API_KEY }, undefined, Array.from(brokerToolUnion));
+            }
+            catch (err) {
+                input.logger.warn(`Failed to initialize Smithery MCP bridge tools: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            const brokerService = new ComposedBrokerService([
+                githubBrokerService,
+                ...smitheryBridgeServices,
+                planBreakdownToolService,
+                waveAssessmentToolService,
+                input.memoryToolService,
+                input.backburnerGitToolService
+            ]);
+            brokerToolScope = new ScopedBrokerToolService(brokerService);
+            brokerServer = await input.startBrokerServer({
+                brokerService: brokerToolScope,
+                host: "127.0.0.1",
+                port: input.brokerPort,
+                logger: brokerLogger
+            });
+            const composite = new CompositeAgentRunner();
+            const planBreakdownTools = [
+                "plan_breakdown.start_session",
+                "plan_breakdown.apply_patch",
+                "plan_breakdown.inspect_session",
+                "plan_breakdown.validate_session",
+                "plan_breakdown.export_session"
+            ];
+            const memoryTools = ["memory_search", "memory_add"];
+            const waveAssessmentTools = [
+                "wave_assessment.start_session",
+                "wave_assessment.add_finding",
+                "wave_assessment.complete_session",
+                "wave_assessment.export_session"
+            ];
+            const backburnerGitTools = input.backburnerGitToolService.listTools().map((tool) => tool.name);
+            const extraTools = [...planBreakdownTools, ...waveAssessmentTools, ...memoryTools, ...backburnerGitTools];
+            const providerBrokerToolAllowListsForRun = new Map();
+            for (const descriptor of enabledProviderDescriptors) {
+                providerBrokerToolAllowListsForRun.set(descriptor.provider, [
+                    ...descriptor.toolAllowList(input.config),
+                    ...extraTools
+                ]);
+            }
+            const registeredPublicBrokerToolNames = brokerService.listTools().map((tool) => tool.name);
+            capabilitiesByProvider = buildCapabilitiesByProvider({
+                capabilities: input.config.capabilities,
+                mcps: input.config.mcps,
+                mcpStatuses: input.currentMcpStatuses,
+                enabledAgents: input.config.agents.filter((agent) => agent.enabled),
+                providerBrokerToolAllowLists: providerBrokerToolAllowListsForRun,
+                registeredPublicBrokerToolNames
+            });
+            const effectiveProviderBrokerToolAllowListsForRun = buildEffectiveProviderBrokerToolAllowLists({
+                declaredMcps: input.config.mcps,
+                enabledAgents: input.config.agents.filter((agent) => agent.enabled),
+                providerBrokerToolAllowLists: providerBrokerToolAllowListsForRun,
+                capabilitiesByProvider,
+                registeredPublicBrokerToolNames,
+                internalAlwaysAllowedTools: extraTools
+            });
+            providerBrokerToolAllowLists = effectiveProviderBrokerToolAllowListsForRun;
+            for (const descriptor of enabledProviderDescriptors) {
+                descriptor.register({
+                    composite,
+                    commandRunner: input.commandRunner,
+                    config: input.config,
+                    logDir: input.logDir,
+                    logger: input.logger,
+                    serverUrl: brokerServer.url,
+                    toolAllowList: effectiveProviderBrokerToolAllowListsForRun.get(descriptor.provider) ?? [],
+                    planBreakdownSessionStore,
+                    waveAssessmentSessionStore
+                });
+            }
+            agentRunner = composite;
+        }
+        if (!agentRunner) {
+            agentRunner = new CodexCliAgent({
+                commandRunner: input.commandRunner,
+                logDir: input.logDir,
+                logger: input.logger,
+                planBreakdownSessionStore: new PlanBreakdownSessionStore(input.logDir),
+                waveAssessmentSessionStore: new WaveAssessmentSessionStore(input.logDir)
+            });
+        }
+        return {
+            agentRunner,
+            ...(capabilitiesByProvider ? { capabilitiesByProvider } : {}),
+            ...(providerBrokerToolAllowLists ? { providerBrokerToolAllowLists } : {}),
+            ...(brokerToolScope ? { brokerToolScope } : {}),
+            ...(brokerServer ? { brokerServer } : {}),
+            ...(brokerLogger ? { brokerLogger } : {})
+        };
+    }
+    catch (error) {
+        if (brokerServer) {
+            await brokerServer.close();
+        }
+        if (brokerLogger) {
+            await brokerLogger.close();
+        }
+        throw error;
+    }
+}

package/dist/src/cli/runtime/provider-tools.js

@@ -0,0 +1,73 @@
+import { deriveProjectedCapabilityToolNames, projectCapabilities } from "../../capabilities/projection.js";
+export function buildCapabilitiesByProvider(input) {
+    const projections = new Map();
+    if (input.capabilities.sensors.length === 0 && input.capabilities.controllers.length === 0) {
+        return projections;
+    }
+    for (const agent of input.enabledAgents) {
+        const providerAllowList = input.providerBrokerToolAllowLists.get(agent.provider);
+        if (!providerAllowList) {
+            continue;
+        }
+        projections.set(agent.provider, projectCapabilities({
+            capabilities: input.capabilities,
+            declaredMcps: input.mcps,
+            mcpStatuses: input.mcpStatuses,
+            registeredPublicBrokerToolNames: input.registeredPublicBrokerToolNames,
+            providerRunAllowList: providerAllowList
+        }));
+    }
+    return projections;
+}
+export function buildEffectiveProviderBrokerToolAllowLists(input) {
+    const projectedToolsByProvider = new Map();
+    for (const [provider, capabilities] of input.capabilitiesByProvider.entries()) {
+        projectedToolsByProvider.set(provider, new Set(deriveProjectedCapabilityToolNames(capabilities)));
+    }
+    const registeredTools = new Set(input.registeredPublicBrokerToolNames);
+    const internalTools = new Set(input.internalAlwaysAllowedTools);
+    const hostedMcpHandles = new Set(input.declaredMcps.map((mcp) => mcp.handle));
+    const effective = new Map();
+    for (const agent of input.enabledAgents) {
+        if (effective.has(agent.provider)) {
+            continue;
+        }
+        const providerAllowList = input.providerBrokerToolAllowLists.get(agent.provider) ?? [];
+        const providerAllowedRegisteredTools = input.registeredPublicBrokerToolNames.filter((toolName) => providerAllowListAllowsTool(providerAllowList, toolName, hostedMcpHandles));
+        const projectedTools = projectedToolsByProvider.get(agent.provider) ?? new Set();
+        const effectiveTools = new Set();
+        for (const toolName of input.internalAlwaysAllowedTools) {
+            effectiveTools.add(toolName);
+        }
+        for (const toolName of providerAllowedRegisteredTools) {
+            if (internalTools.has(toolName)) {
+                effectiveTools.add(toolName);
+                continue;
+            }
+            if (!isDeclaredHostedMcpTool(toolName, hostedMcpHandles)) {
+                effectiveTools.add(toolName);
+                continue;
+            }
+            if (projectedTools.has(toolName)) {
+                effectiveTools.add(toolName);
+            }
+        }
+        effective.set(agent.provider, [...effectiveTools].filter((toolName) => internalTools.has(toolName) || registeredTools.has(toolName)));
+    }
+    return effective;
+}
+function providerAllowListAllowsTool(providerAllowList, publicToolName, hostedMcpHandles) {
+    if (isDeclaredHostedMcpTool(publicToolName, hostedMcpHandles)) {
+        return providerAllowList.includes(publicToolName);
+    }
+    return providerAllowList.some((allowedToolName) => {
+        if (allowedToolName === publicToolName || allowedToolName === "*") {
+            return true;
+        }
+        return allowedToolName.endsWith(".*") && publicToolName.startsWith(allowedToolName.slice(0, -1));
+    });
+}
+function isDeclaredHostedMcpTool(publicToolName, hostedMcpHandles) {
+    const dotIndex = publicToolName.indexOf(".");
+    return dotIndex > 0 && hostedMcpHandles.has(publicToolName.slice(0, dotIndex));
+}

package/dist/src/cli/runtime/providers/antigravity.js

@@ -0,0 +1,26 @@
+import { AntigravityCliAgent } from "../../../agents/antigravity.js";
+export const antigravityRuntimeProvider = {
+    provider: "antigravity",
+    isEnabled: (config) => config.agents.some((agent) => agent.enabled && agent.provider === "antigravity"),
+    toolAllowList: (config) => config.antigravity.githubBroker.toolAllowList,
+    register: (input) => {
+        input.composite.register("antigravity", new AntigravityCliAgent({
+            commandRunner: input.commandRunner,
+            logDir: input.logDir,
+            logger: input.logger,
+            ...(process.env.BACKBURNER_ANTIGRAVITY_CONFIG_HOME
+                ? { configHome: process.env.BACKBURNER_ANTIGRAVITY_CONFIG_HOME }
+                : {}),
+            ...(process.env.BACKBURNER_GEMINI_CONFIG_HOME
+                ? { legacyGeminiConfigHome: process.env.BACKBURNER_GEMINI_CONFIG_HOME }
+                : {}),
+            githubBroker: {
+                serverName: input.config.antigravity.githubBroker.serverName,
+                serverUrl: input.serverUrl,
+                toolAllowList: [...input.toolAllowList]
+            },
+            planBreakdownSessionStore: input.planBreakdownSessionStore,
+            waveAssessmentSessionStore: input.waveAssessmentSessionStore
+        }));
+    }
+};

package/dist/src/cli/runtime/providers/claude.js

@@ -0,0 +1,20 @@
+import { ClaudeCodeCliAgent } from "../../../agents/claude.js";
+export const claudeRuntimeProvider = {
+    provider: "claude",
+    isEnabled: (config) => config.agents.some((agent) => agent.enabled && agent.provider === "claude"),
+    toolAllowList: (config) => config.claude.githubBroker.toolAllowList,
+    register: (input) => {
+        input.composite.register("claude", new ClaudeCodeCliAgent({
+            commandRunner: input.commandRunner,
+            logDir: input.logDir,
+            logger: input.logger,
+            githubBroker: {
+                serverName: input.config.claude.githubBroker.serverName,
+                serverUrl: input.serverUrl,
+                toolAllowList: [...input.toolAllowList]
+            },
+            planBreakdownSessionStore: input.planBreakdownSessionStore,
+            waveAssessmentSessionStore: input.waveAssessmentSessionStore
+        }));
+    }
+};

package/dist/src/cli/runtime/providers/codex.js

@@ -0,0 +1,20 @@
+import { CodexCliAgent } from "../../../agents/codex.js";
+export const codexRuntimeProvider = {
+    provider: "codex",
+    isEnabled: (config) => config.agents.some((agent) => agent.enabled && agent.provider === "codex"),
+    toolAllowList: (config) => config.codex.githubBroker.toolAllowList,
+    register: (input) => {
+        input.composite.register("codex", new CodexCliAgent({
+            commandRunner: input.commandRunner,
+            logDir: input.logDir,
+            logger: input.logger,
+            githubBroker: {
+                serverName: input.config.codex.githubBroker.serverName,
+                serverUrl: input.serverUrl,
+                toolAllowList: [...input.toolAllowList]
+            },
+            planBreakdownSessionStore: input.planBreakdownSessionStore,
+            waveAssessmentSessionStore: input.waveAssessmentSessionStore
+        }));
+    }
+};

package/dist/src/cli/runtime/providers/gemini.js

@@ -0,0 +1,20 @@
+import { GeminiCliAgent } from "../../../agents/gemini.js";
+export const geminiRuntimeProvider = {
+    provider: "gemini",
+    isEnabled: (config) => config.agents.some((agent) => agent.enabled && agent.provider === "gemini"),
+    toolAllowList: (config) => config.gemini.githubBroker.toolAllowList,
+    register: (input) => {
+        input.composite.register("gemini", new GeminiCliAgent({
+            commandRunner: input.commandRunner,
+            logDir: input.logDir,
+            logger: input.logger,
+            githubBroker: {
+                serverName: input.config.gemini.githubBroker.serverName,
+                serverUrl: input.serverUrl,
+                toolAllowList: [...input.toolAllowList]
+            },
+            planBreakdownSessionStore: input.planBreakdownSessionStore,
+            waveAssessmentSessionStore: input.waveAssessmentSessionStore
+        }));
+    }
+};

package/dist/src/cli/runtime/providers/opencode.js

@@ -0,0 +1,20 @@
+import { OpenCodeCliAgent } from "../../../agents/opencode.js";
+export const openCodeRuntimeProvider = {
+    provider: "opencode",
+    isEnabled: (config) => config.agents.some((agent) => agent.enabled && agent.provider === "opencode"),
+    toolAllowList: (config) => config.opencode.githubBroker.toolAllowList,
+    register: (input) => {
+        input.composite.register("opencode", new OpenCodeCliAgent({
+            commandRunner: input.commandRunner,
+            logDir: input.logDir,
+            logger: input.logger,
+            githubBroker: {
+                serverName: input.config.opencode.githubBroker.serverName,
+                serverUrl: input.serverUrl,
+                toolAllowList: [...input.toolAllowList]
+            },
+            planBreakdownSessionStore: input.planBreakdownSessionStore,
+            waveAssessmentSessionStore: input.waveAssessmentSessionStore
+        }));
+    }
+};

package/dist/src/cli/runtime/run-context.js

@@ -0,0 +1,131 @@
+import * as path from "node:path";
+import { AgentPool } from "../../agents/pool.js";
+import { loadConfig } from "../../config/loader.js";
+import { GitCliGateway, LocalRepoSyncService } from "../../git/types.js";
+import { GitOpsLifecycleService } from "../../git/gitops-lifecycle.js";
+import { MergePrepWorkspaceService } from "../../git/merge-prep-workspace.js";
+import { BackburnerGitToolService } from "../../git/backburner-git-tool-service.js";
+import { GhCliGitHubGateway } from "../../github/gateway.js";
+import { GitHubScanService } from "../../github/service.js";
+import { parseGitHubRemoteUrl } from "../../github/utils.js";
+import { JournalService } from "../../journal/index.js";
+import { JsonJobMemoryStore } from "../../memory/json-store.js";
+import { JobMemoryToolService } from "../../memory/tool-service.js";
+import { createSmitheryMcpResolverFromEnv, reconcileMcpStatus } from "../../mcps/index.js";
+import { StateStore } from "../../state/loader.js";
+import { ExecFileCommandRunner } from "../../utils/command-runner.js";
+import { defaultStderrLogger } from "../../utils/logger.js";
+import { defaultBackburnerCodeRoot, defaultBackburnerManagementRoot, defaultBackburnerOutputsRoot, resolveOutputsStateRoot, resolveOutputsLogsRoot, resolveOutputsJournalRoot } from "../../utils/paths.js";
+import { TriageFollowUpService } from "../../workflows/triage.js";
+import { ImplementationWorkflowService } from "../../worktrees/service.js";
+import { WorkspaceRecoveryService } from "../../worktrees/workspace-recovery.js";
+import { DEFAULT_GITHUB_BROKER_PORT as CLI_DEFAULT_GITHUB_BROKER_PORT, readNumberFlag, readOptionalStringFlag, readStringFlag } from "../options.js";
+export async function createRunContext(input) {
+    const { rest, options } = input;
+    const managementDir = path.resolve(options.managementDir ?? readStringFlag(rest, "--management-dir", defaultBackburnerManagementRoot()));
+    const configuredOutputsDir = options.outputsDir ?? readOptionalStringFlag(rest, "--outputs-dir");
+    const outputsDir = path.resolve(configuredOutputsDir ?? defaultBackburnerOutputsRoot());
+    const useLegacyStateDirWithoutOutputs = options.stateDir !== undefined && configuredOutputsDir === undefined;
+    const logger = options.logger ?? defaultStderrLogger;
+    const codeRoot = path.resolve(readOptionalStringFlag(rest, "--code-root") ?? defaultBackburnerCodeRoot());
+    const brokerPort = readNumberFlag(rest, "--broker-port", CLI_DEFAULT_GITHUB_BROKER_PORT);
+    const commandRunner = options.commandRunner ?? new ExecFileCommandRunner();
+    const gitGateway = options.gitGateway ?? new GitCliGateway(commandRunner);
+    const gitOpsLifecycle = options.gitOpsLifecycleService ?? new GitOpsLifecycleService(gitGateway);
+    const workspaceRecoveryService = options.workspaceRecoveryService ?? new WorkspaceRecoveryService();
+    logger.info(`Preparing management root ${managementDir}`);
+    const managementGitOps = await gitOpsLifecycle.prepareManagementRoot(managementDir);
+    logger.info(`Loading orchestrator config from ${managementDir}`);
+    const config = await loadConfig(managementDir);
+    const agentPool = new AgentPool(config.maxConcurrentAgents);
+    logger.info(`Agent pool: maxConcurrentAgents=${agentPool.maxConcurrent}`);
+    let outputsGitOpsPrepared;
+    if (useLegacyStateDirWithoutOutputs) {
+        logger.info(`Skipping outputs root GitOps because explicit state is stored at ${options.stateDir}`);
+        outputsGitOpsPrepared = { status: "skipped_not_git" };
+    }
+    else {
+        logger.info(`Preparing outputs root ${outputsDir}`);
+        outputsGitOpsPrepared = await gitOpsLifecycle.prepareOutputsRoot(outputsDir);
+    }
+    const stateDir = path.resolve(options.stateDir ?? resolveOutputsStateRoot(outputsDir));
+    const defaultLogDir = options.stateDir !== undefined ? stateDir : resolveOutputsLogsRoot(outputsDir);
+    const logDir = path.resolve(options.logDir ?? readStringFlag(rest, "--log-dir", defaultLogDir));
+    let managementRepo;
+    try {
+        const remoteResult = await commandRunner.run("git", ["remote", "get-url", "origin"], { cwd: managementDir });
+        const remoteUrl = remoteResult.stdout.trim();
+        const identity = parseGitHubRemoteUrl(remoteUrl);
+        if (identity) {
+            managementRepo = { repoSlug: `${identity.owner}/${identity.name}` };
+        }
+    }
+    catch {
+        // Management repo identity resolve failed, classifyPullRequest will handle missing managementRepo
+    }
+    const stateStore = new StateStore({ stateDir, executionDir: logDir });
+    const journal = options.journalService ?? new JournalService(resolveOutputsJournalRoot(outputsDir));
+    const memoryStore = new JsonJobMemoryStore({ filePath: path.join(stateDir, "job-memory.json") });
+    const memoryToolService = new JobMemoryToolService(memoryStore, logger);
+    const backburnerGitToolService = new BackburnerGitToolService(commandRunner, logger);
+    logger.info(`Loading persisted state from ${stateDir}`);
+    if (logDir !== stateDir) {
+        logger.info(`Loading execution log from ${logDir}`);
+    }
+    const previousState = await stateStore.load();
+    let currentMcpStatuses = previousState.mcpStatuses ?? [];
+    if (config.mcps.length > 0) {
+        try {
+            const resolvedMcps = await createSmitheryMcpResolverFromEnv().resolveDependencies(config.mcps, currentMcpStatuses);
+            const reconciliation = reconcileMcpStatus(config.mcps, currentMcpStatuses, resolvedMcps, new Date().toISOString());
+            currentMcpStatuses = reconciliation.records;
+            await stateStore.writeMcpStatusState(currentMcpStatuses);
+            logger.info(`MCP readiness reconciled: added=${reconciliation.added.length}, updated=${reconciliation.updated.length}, unchanged=${reconciliation.unchanged.length}, removed=${reconciliation.removed.length}`);
+        }
+        catch (err) {
+            logger.warn(`Failed to reconcile MCP readiness: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const gitHubGateway = options.gitHubGateway ?? new GhCliGitHubGateway(commandRunner, config.allowedUsers);
+    const syncService = options.syncService ??
+        new LocalRepoSyncService(gitGateway, gitHubGateway);
+    const scanService = options.scanService ?? new GitHubScanService(gitHubGateway);
+    const implementationWorkflowService = new ImplementationWorkflowService(gitGateway, gitHubGateway);
+    const triageFollowUpService = new TriageFollowUpService(gitGateway, gitHubGateway);
+    const mergePrepService = options.mergePrepService ?? new MergePrepWorkspaceService(gitGateway);
+    const enabledRepos = config.repos.filter((repo) => repo.enabled);
+    const results = [];
+    return {
+        managementDir,
+        outputsDir,
+        stateDir,
+        logDir,
+        logger,
+        codeRoot,
+        brokerPort,
+        commandRunner,
+        gitGateway,
+        gitOpsLifecycle,
+        workspaceRecoveryService,
+        managementGitOps,
+        config,
+        agentPool,
+        outputsGitOpsPrepared,
+        ...(managementRepo ? { managementRepo } : {}),
+        stateStore,
+        journal,
+        memoryStore,
+        memoryToolService,
+        backburnerGitToolService,
+        previousState,
+        currentMcpStatuses,
+        gitHubGateway,
+        syncService,
+        scanService,
+        implementationWorkflowService,
+        triageFollowUpService,
+        mergePrepService,
+        enabledRepos,
+        results
+    };
+}

package/dist/src/cli/tui/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./tracker.js";
+export * from "./screen.js";