@bbigbang/agent-node 0.1.0

package/dist/nativeMissionAgentDispatch.js

@@ -0,0 +1,463 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { Executor } from './executor.js';
+const NATIVE_OUTPUT_DIR = 'native-output';
+function hashString(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 32);
+}
+function deriveAgentType(workerModel, modelMode) {
+    const model = (workerModel ?? '').trim().toLowerCase();
+    if (model.startsWith('claude'))
+        return 'claude_sdk';
+    if (model.startsWith('codex_acp'))
+        return 'codex_acp';
+    if (model.startsWith('codex'))
+        return 'codex_app_server';
+    if (modelMode === 'droid_default')
+        return 'claude_sdk';
+    return 'codex_app_server';
+}
+function buildAgentPrompt(context) {
+    const sections = [];
+    if (context.title) {
+        sections.push(`# ${context.title}`);
+    }
+    sections.push(`Feature ID: ${context.featureId}`, `Milestone: ${context.milestone}`, '', context.featureDescription, '', context.prompt);
+    return sections.join('\n');
+}
+function buildSystemPrompt() {
+    return [
+        'You are a senior software engineering agent working inside a mission-driven native runtime.',
+        'Your job is to implement the requested feature, write or modify files in the workspace, run relevant tests or commands, and produce a concise handoff summary.',
+        'Follow the project conventions, do not add unnecessary dependencies, and prefer small, focused changes.',
+        'Use bash for shell commands, read_file to inspect existing code, and write_file or edit tools to make changes.',
+        'When you finish, ensure the workspace is in a consistent state and summarize what you implemented.',
+    ].join('\n');
+}
+function redactUrlCredentials(value) {
+    if (!value)
+        return '';
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        return url.toString().replace(/\/$/, '');
+    }
+    catch {
+        return value;
+    }
+}
+function buildPlaceholderRuntimeConfig() {
+    return {
+        model: 'unknown',
+        modelMode: 'unknown',
+        orchestratorModel: null,
+        workerModel: null,
+        validatorModel: null,
+        providerBaseUrl: 'unknown',
+        apiKeyConfigured: false,
+        workerTimeoutMs: 0,
+        workerGracePeriodMs: 0,
+        platform: process.platform,
+        nodeVersion: process.version,
+    };
+}
+export class LocalMissionSink {
+    context;
+    send;
+    requestId;
+    runId;
+    events = [];
+    toolCallsById = new Map();
+    runEndResult = null;
+    constructor(context, send, requestId, runId) {
+        this.context = context;
+        this.send = send;
+        this.requestId = requestId;
+        this.runId = runId;
+    }
+    onContentDelta(text) {
+        this.forwardEvent({ type: 'content.delta', text });
+    }
+    onActivityDelta(text) {
+        this.forwardEvent({ type: 'activity.delta', text });
+    }
+    onThinkingDelta(text) {
+        this.forwardEvent({ type: 'thinking.delta', text });
+    }
+    onToolCall(event) {
+        this.events.push(event);
+        this.toolCallsById.set(event.toolCallId, event);
+        this.sendMissionEvent('mission_tool_call', {
+            toolName: event.name,
+            toolCallId: event.toolCallId,
+            input: event.input,
+            status: event.status,
+            metadata: event.metadata,
+        });
+        this.sendTranscriptEvent({
+            role: 'assistant',
+            kind: 'tool_call',
+            toolName: event.name,
+            toolCallId: event.toolCallId,
+            content: JSON.stringify(event.input ?? {}),
+        });
+    }
+    onToolResult(event) {
+        this.events.push(event);
+        const call = this.toolCallsById.get(event.toolCallId);
+        this.sendMissionEvent('mission_tool_result', {
+            toolCallId: event.toolCallId,
+            output: event.output,
+            detail: event.detail,
+            error: event.error,
+            status: event.status,
+            metadata: event.metadata,
+        });
+        this.sendTranscriptEvent({
+            role: 'tool_result',
+            kind: 'tool_result',
+            toolName: call?.name,
+            toolCallId: event.toolCallId,
+            content: typeof event.output === 'string' ? event.output : '',
+        });
+    }
+    onRunEnd(result) {
+        this.runEndResult = result;
+    }
+    getRunEndResult() {
+        return this.runEndResult;
+    }
+    assembleHandoff() {
+        const { context, runId, events } = this;
+        const whatWasImplemented = [];
+        const commandsRun = [];
+        let commitId;
+        const toolCallsById = new Map();
+        for (const event of events) {
+            if (event.type === 'tool.call') {
+                const entry = toolCallsById.get(event.toolCallId) ?? {};
+                entry.call = event;
+                toolCallsById.set(event.toolCallId, entry);
+            }
+            else if (event.type === 'tool.result') {
+                const entry = toolCallsById.get(event.toolCallId) ?? {};
+                entry.result = event;
+                toolCallsById.set(event.toolCallId, entry);
+            }
+        }
+        for (const { call, result } of toolCallsById.values()) {
+            if (!call)
+                continue;
+            const name = call.name.toLowerCase();
+            const input = call.input;
+            if (name === 'bash' || name.includes('bash')) {
+                const command = typeof input === 'string' ? input : String((input?.command ?? input ?? ''));
+                const exitCode = result?.status === 'failed' ? 1 : result?.error ? 1 : 0;
+                const observation = typeof result?.output === 'string' ? result.output : '';
+                if (command) {
+                    commandsRun.push({ command, exitCode, observation });
+                }
+                const commitMatch = observation.match(/\[\S+\s+([0-9a-f]{7,40})\]/);
+                if (commitMatch) {
+                    commitId = commitMatch[1];
+                }
+            }
+            if (name === 'write_file' || name.includes('write') || name.includes('edit')) {
+                const filePath = typeof input === 'string'
+                    ? ''
+                    : String((input?.path ?? input?.file_path ?? input?.relativePath ?? ''));
+                if (filePath) {
+                    whatWasImplemented.push(`Modified file: ${filePath}`);
+                }
+            }
+        }
+        const stopReason = this.runEndResult?.stopReason ?? 'unknown';
+        const successState = deriveSuccessState(stopReason, this.runEndResult?.error);
+        return {
+            schemaVersion: '2.0.0',
+            salientSummary: `Agent run ${runId} completed with stop reason ${stopReason}.`,
+            whatWasImplemented: whatWasImplemented.length > 0 ? whatWasImplemented : ['No file modifications recorded.'],
+            whatWasLeftUndone: '',
+            verification: {
+                commandsRun,
+                interactiveChecks: [],
+            },
+            tests: {
+                added: [],
+            },
+            discoveredIssues: [],
+            commitId,
+            repoPath: context.workspaceRoot,
+            successState,
+            returnToOrchestrator: successState === 'failure',
+            workerSessionId: runId,
+        };
+    }
+    forwardEvent(event) {
+        this.events.push(event);
+        if (event.type === 'content.delta') {
+            this.sendMissionEvent('mission_content_delta', { text: event.text });
+        }
+        else if (event.type === 'activity.delta') {
+            this.sendMissionEvent('mission_activity_delta', { text: event.text });
+        }
+        else if (event.type === 'thinking.delta') {
+            this.sendMissionEvent('mission_thinking_delta', { text: event.text });
+        }
+    }
+    sendMissionEvent(eventType, payload) {
+        this.send({
+            type: 'mission.run.event',
+            requestId: this.requestId,
+            missionId: this.context.missionId,
+            runtimeProvider: 'bigbang_native',
+            eventType,
+            source: 'bigbang_native',
+            eventTime: Date.now(),
+            featureId: this.context.featureId,
+            payload,
+        });
+    }
+    sendTranscriptEvent(partial) {
+        const entry = {
+            workerSessionId: this.runId,
+            featureId: this.context.featureId,
+            milestone: this.context.milestone,
+            role: partial.role,
+            kind: partial.kind,
+            toolName: partial.toolName,
+            toolCallId: partial.toolCallId,
+            content: partial.content,
+            timestamp: Date.now(),
+        };
+        this.sendMissionEvent('mission_worker_transcript', entry);
+    }
+}
+function deriveSuccessState(stopReason, error) {
+    if (error)
+        return 'failure';
+    if (stopReason === 'completed' || stopReason === 'end_turn' || stopReason === 'stop')
+        return 'success';
+    if (stopReason === 'failed' || stopReason === 'cancelled' || stopReason === 'approval_denied') {
+        return 'failure';
+    }
+    return 'partial';
+}
+export class NativeMissionAgentExecutor {
+    executor;
+    sinks = new Map();
+    completions = new Map();
+    send;
+    constructor(params) {
+        this.send = params.send;
+        this.executor = new Executor({
+            db: params.db,
+            config: params.config,
+            send: (msg) => this.handleExecutorMessage(msg),
+        });
+    }
+    async dispatch(msg, sink) {
+        this.sinks.set(msg.runId, sink);
+        return new Promise((resolve, reject) => {
+            this.completions.set(msg.runId, { resolve, reject });
+            this.executor
+                .dispatch(msg, { persist: false })
+                .then(() => {
+                this.completions.delete(msg.runId);
+                resolve();
+            })
+                .catch((error) => {
+                this.completions.delete(msg.runId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        }).finally(() => {
+            this.sinks.delete(msg.runId);
+        });
+    }
+    async cancelRun(runId) {
+        return this.executor.cancelRun(runId);
+    }
+    handleExecutorMessage(msg) {
+        if (msg.type === 'run.event') {
+            const sink = this.sinks.get(msg.runId);
+            if (sink) {
+                this.forwardServerEvent(sink, msg.event);
+            }
+            return;
+        }
+        if (msg.type === 'run.end') {
+            const sink = this.sinks.get(msg.runId);
+            if (sink) {
+                sink.onRunEnd({ stopReason: msg.stopReason, error: msg.error });
+            }
+            const completion = this.completions.get(msg.runId);
+            if (completion) {
+                this.completions.delete(msg.runId);
+                if (msg.error) {
+                    completion.reject(new Error(msg.error));
+                }
+                else {
+                    completion.resolve();
+                }
+            }
+            return;
+        }
+        if (msg.type === 'run.accepted') {
+            // NativeMissionAgentDispatch sends mission.run.accepted itself.
+            return;
+        }
+        this.send(msg);
+    }
+    forwardServerEvent(sink, event) {
+        if (event.type === 'content.delta') {
+            sink.onContentDelta(event.text);
+        }
+        else if (event.type === 'activity.delta') {
+            sink.onActivityDelta(event.text);
+        }
+        else if (event.type === 'thinking.delta') {
+            sink.onThinkingDelta(event.text);
+        }
+        else if (event.type === 'tool.call') {
+            sink.onToolCall(event);
+        }
+        else if (event.type === 'tool.result') {
+            sink.onToolResult(event);
+        }
+    }
+}
+export class NativeMissionAgentDispatch {
+    context;
+    send;
+    executor;
+    requestId;
+    runId;
+    cancelRequested = false;
+    constructor(context, send, executor, requestId) {
+        this.context = context;
+        this.send = send;
+        this.executor = executor;
+        this.requestId = requestId;
+        this.runId = randomUUID();
+    }
+    get pid() {
+        return null;
+    }
+    async dispatch() {
+        const { context, send, runId, requestId } = this;
+        const outputDir = path.join(context.missionDir, NATIVE_OUTPUT_DIR);
+        mkdirSync(outputDir, { recursive: true });
+        const conversationId = hashString(`${context.missionDir}:${context.featureId}`);
+        const sessionKey = hashString(context.featureId);
+        const hostKey = hashString(context.workspaceRoot);
+        send({
+            type: 'mission.run.accepted',
+            requestId,
+            missionId: context.missionId,
+            missionDir: context.missionDir,
+            runtimeProvider: 'bigbang_native',
+            featureId: context.featureId,
+            pid: null,
+        });
+        const runDispatchMsg = {
+            type: 'run.dispatch',
+            runId,
+            conversationId,
+            agentType: deriveAgentType(context.workerModel, context.modelMode),
+            workspacePath: context.workspaceRoot,
+            prompt: buildAgentPrompt(context),
+            systemPromptText: buildSystemPrompt(),
+            sessionKey,
+            hostKey,
+            dispatchMode: 'cold_start',
+        };
+        const sink = new LocalMissionSink(context, send, requestId, runId);
+        let runError;
+        try {
+            await this.executor.dispatch(runDispatchMsg, sink);
+        }
+        catch (error) {
+            runError = String(error?.message ?? error);
+            if (!sink.getRunEndResult()) {
+                sink.onRunEnd({ stopReason: 'failed', error: runError });
+            }
+        }
+        const runEnd = sink.getRunEndResult() ?? { stopReason: 'failed', error: runError ?? 'Run ended without result' };
+        const handoff = sink.assembleHandoff();
+        if (this.cancelRequested || runEnd.stopReason === 'cancelled') {
+            handoff.successState = 'failure';
+            handoff.returnToOrchestrator = true;
+            if (!runError)
+                runError = 'Worker was cancelled';
+        }
+        const failed = handoff.successState === 'failure';
+        const exitCode = failed ? 1 : 0;
+        const status = failed ? 'failed' : 'completed';
+        const output = {
+            schemaVersion: '2.0.0',
+            featureId: context.featureId,
+            status,
+            implementedFiles: handoff.whatWasImplemented.filter((item) => item.includes('Modified file:')),
+            fileOperations: handoff.whatWasImplemented.map((item) => ({
+                path: item.replace('Modified file: ', ''),
+                relativePath: item.replace('Modified file: ', ''),
+                operation: 'write',
+                timestamp: Date.now(),
+            })),
+            runtimeConfig: buildPlaceholderRuntimeConfig(),
+            handoff,
+            exitCode,
+            error: runError,
+        };
+        const outputPath = path.join(outputDir, `${context.featureId}.json`);
+        writeFileSync(outputPath, `${JSON.stringify(output, null, 2)}\n`, 'utf8');
+        send({
+            type: 'mission.run.end',
+            requestId,
+            missionId: context.missionId,
+            missionDir: context.missionDir,
+            runtimeProvider: 'bigbang_native',
+            featureId: context.featureId,
+            exitCode,
+            reason: runEnd.stopReason ?? (failed ? 'failed' : undefined),
+            output: output,
+            handoff: handoff,
+            ...(runError ? { error: runError } : {}),
+        });
+        return output;
+    }
+    cancel() {
+        this.cancelRequested = true;
+        void this.executor.cancelRun?.(this.runId).catch(() => undefined);
+    }
+}
+export function buildContextFromRequest(msg) {
+    if (!msg.featureDescription) {
+        throw new Error('Native mission run request is missing featureDescription.');
+    }
+    if (!msg.milestone) {
+        throw new Error('Native mission run request is missing milestone.');
+    }
+    return {
+        featureId: msg.featureId,
+        featureDescription: msg.featureDescription,
+        milestone: msg.milestone,
+        expectedBehavior: msg.expectedBehavior,
+        title: msg.title,
+        prompt: msg.prompt,
+        missionId: msg.missionId,
+        workspaceRoot: msg.workspaceRoot,
+        missionDir: msg.missionDir,
+        modelMode: msg.modelMode,
+        orchestratorModel: msg.orchestratorModel,
+        workerModel: msg.workerModel,
+        validatorModel: msg.validatorModel,
+        priorHandoffs: msg.priorHandoffs,
+        preconditions: msg.preconditions,
+        validationContract: msg.validationContract,
+        workspaceFiles: msg.workspaceFiles,
+        useAgentDispatch: msg.useAgentDispatch,
+    };
+}