salmon-loop 0.2.3

package/dist/core/protocols/acp/handlers.js

@@ -0,0 +1,51 @@
+import { randomUUID } from 'node:crypto';
+export function createAcpSessionStore() {
+    const sessions = new Map();
+    return {
+        create(input) {
+            const now = new Date().toISOString();
+            const id = `sess_${Date.now()}_${process.pid}_${randomUUID()}`;
+            const session = {
+                id,
+                cwd: input.cwd,
+                mcpServers: input.mcpServers,
+                createdAt: now,
+                updatedAt: now,
+                title: input.title,
+                history: [],
+                cancelRequested: false,
+            };
+            sessions.set(id, session);
+            return session;
+        },
+        upsert(session) {
+            sessions.set(session.id, session);
+            return session;
+        },
+        get(id) {
+            return sessions.get(id);
+        },
+        update(id, mutate) {
+            const current = sessions.get(id);
+            if (!current)
+                return undefined;
+            const updated = mutate(current);
+            updated.updatedAt = new Date().toISOString();
+            sessions.set(id, updated);
+            return updated;
+        },
+        list() {
+            return Array.from(sessions.values());
+        },
+        delete(id) {
+            return sessions.delete(id);
+        },
+    };
+}
+export function isTerminalTaskEvent(event) {
+    return (event.type === 'task.completed' ||
+        event.type === 'task.failed' ||
+        event.type === 'task.awaiting_input' ||
+        event.type === 'task.cancelled');
+}
+//# sourceMappingURL=handlers.js.map

package/dist/core/protocols/acp/permission-provider.js

@@ -0,0 +1,122 @@
+function toToolKind(request) {
+    const name = request.toolName.toLowerCase();
+    if (name.includes('read') ||
+        name.includes('get') ||
+        name.includes('view') ||
+        name.includes('ls') ||
+        name.includes('list') ||
+        (request.sideEffects.length > 0 && request.sideEffects.every((e) => e === 'fs_read')))
+        return 'read';
+    if (name.includes('write') ||
+        name.includes('edit') ||
+        name.includes('patch') ||
+        request.sideEffects.includes('fs_write'))
+        return 'edit';
+    if (name.includes('delete') ||
+        name.includes('remove') ||
+        name.includes('rm') ||
+        request.sideEffects.includes('fs_delete'))
+        return 'delete';
+    if (name.includes('move') || name.includes('rename') || name.includes('mv'))
+        return 'move';
+    if (name.includes('grep') || name.includes('search') || name.includes('find'))
+        return 'search';
+    if (name.includes('run') ||
+        name.includes('exec') ||
+        name.includes('spawn') ||
+        request.sideEffects.includes('process'))
+        return 'execute';
+    if (name.includes('plan') || name.includes('think') || name.includes('reason'))
+        return 'think';
+    if (name.includes('fetch') || name.includes('curl') || name.includes('http'))
+        return 'fetch';
+    return 'other';
+}
+function buildPermissionOptions() {
+    return [
+        { kind: 'allow_once', name: 'Allow once', optionId: 'allow_once' },
+        { kind: 'allow_always', name: 'Allow for session', optionId: 'allow_always' },
+        { kind: 'reject_once', name: 'Reject once', optionId: 'reject_once' },
+        { kind: 'reject_always', name: 'Reject for session', optionId: 'reject_always' },
+    ];
+}
+function toToolCallUpdate(request) {
+    const looksAbsolute = typeof request.argsSummary === 'string' &&
+        (request.argsSummary.startsWith('/') ||
+            /^[a-zA-Z]:[\\/]/.test(request.argsSummary) ||
+            request.argsSummary.startsWith('\\\\'));
+    return {
+        toolCallId: request.id,
+        title: request.toolName,
+        kind: toToolKind(request),
+        status: 'pending',
+        rawInput: {
+            toolName: request.toolName,
+            argsSummary: request.argsSummary,
+            riskLevel: request.riskLevel,
+            sideEffects: request.sideEffects,
+        },
+        locations: looksAbsolute ? [{ path: request.argsSummary }] : undefined,
+    };
+}
+export function createAcpToolAuthorizationProvider(params) {
+    return {
+        async requestAuthorization(request) {
+            const enforceClientCapabilities = params.enforceClientCapabilities ?? true;
+            if (enforceClientCapabilities) {
+                if (request.sideEffects.includes('fs_read') &&
+                    !params.clientCapabilities.fs?.readTextFile) {
+                    return {
+                        outcome: 'deny',
+                        reason: 'client_missing_capability: fs.readTextFile',
+                        source: 'auto',
+                    };
+                }
+                if (request.sideEffects.includes('fs_write') &&
+                    !params.clientCapabilities.fs?.writeTextFile) {
+                    return {
+                        outcome: 'deny',
+                        reason: 'client_missing_capability: fs.writeTextFile',
+                        source: 'auto',
+                    };
+                }
+                if (request.sideEffects.includes('process') && !params.clientCapabilities.terminal) {
+                    return { outcome: 'deny', reason: 'client_missing_capability: terminal', source: 'auto' };
+                }
+            }
+            const permissionPolicy = params.getPermissionPolicy?.() ?? 'ask';
+            if (permissionPolicy === 'allow_all') {
+                return { outcome: 'allow_session', source: 'auto', reason: 'session_mode:yolo' };
+            }
+            const hasSideEffects = request.sideEffects.some((effect) => effect !== 'fs_read');
+            if (permissionPolicy === 'deny_all' && hasSideEffects) {
+                return { outcome: 'deny', reason: 'session_config:deny_all', source: 'auto' };
+            }
+            const toolCall = toToolCallUpdate(request);
+            const response = await params.conn.requestPermission({
+                sessionId: params.sessionId,
+                toolCall,
+                options: buildPermissionOptions(),
+            });
+            if (response.outcome.outcome === 'cancelled') {
+                return { outcome: 'deny', reason: 'cancelled', source: 'user' };
+            }
+            switch (response.outcome.optionId) {
+                case 'allow_once':
+                    return { outcome: 'allow_once', source: 'user' };
+                case 'allow_always':
+                    return { outcome: 'allow_session', source: 'user' };
+                case 'reject_once':
+                case 'reject_always':
+                    return { outcome: 'deny', reason: 'rejected', source: 'user' };
+                default:
+                    return {
+                        outcome: 'deny',
+                        reason: `unknown option: ${response.outcome.optionId}`,
+                        source: 'user',
+                    };
+            }
+        },
+    };
+}
+//# sourceMappingURL=permission-provider.js.map

package/dist/core/protocols/acp/stdio-server.js

@@ -0,0 +1,116 @@
+import { Readable, Writable } from 'node:stream';
+import { AgentSideConnection } from '@agentclientprotocol/sdk';
+import { tryGetLogger } from '../../observability/logger.js';
+const INVALID_REQUEST = {
+    jsonrpc: '2.0',
+    id: null,
+    error: { code: -32600, message: 'Invalid Request' },
+};
+const PARSE_ERROR = {
+    jsonrpc: '2.0',
+    id: null,
+    error: { code: -32700, message: 'Parse error' },
+};
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function formatLineSnippet(line, maxLength = 160) {
+    if (line.length <= maxLength)
+        return line;
+    return `${line.slice(0, maxLength - 3)}...`;
+}
+function safeWarn(message) {
+    const logger = tryGetLogger();
+    if (logger)
+        logger.warn(message);
+}
+function createNdjsonWriter(output) {
+    const writer = output.getWriter();
+    const encoder = new TextEncoder();
+    let tail = Promise.resolve();
+    return {
+        async write(message) {
+            const content = JSON.stringify(message) + '\n';
+            const data = encoder.encode(content);
+            tail = tail
+                .catch(() => undefined)
+                .then(() => writer.write(data))
+                .catch((error) => {
+                const detail = error instanceof Error ? error.message : String(error);
+                safeWarn(`ACP stdio failed to write NDJSON line. reason="${detail}"`);
+            });
+            await tail;
+        },
+    };
+}
+async function writeInvalidRequest(ndjson, line) {
+    const snippet = formatLineSnippet(line);
+    safeWarn(`ACP stdio received non-object JSON; returning Invalid Request. line="${snippet}"`);
+    await ndjson.write(INVALID_REQUEST);
+}
+async function processStdioLine(line, ndjson, controller) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isJsonObject(parsed)) {
+            await writeInvalidRequest(ndjson, trimmed);
+            return;
+        }
+        if (parsed.params && typeof parsed.params === 'object' && !Array.isArray(parsed.params)) {
+            const params = parsed.params;
+            if (params.mcpServers === null) {
+                delete params.mcpServers;
+            }
+        }
+        controller.enqueue(parsed);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        safeWarn(`ACP stdio failed to parse JSON line. reason="${detail}"`);
+        await ndjson.write(PARSE_ERROR);
+    }
+}
+export function createAcpStdioStream(output, input) {
+    const textDecoder = new TextDecoder();
+    const ndjson = createNdjsonWriter(output);
+    const readable = new ReadableStream({
+        async start(controller) {
+            let buffer = '';
+            const reader = input.getReader();
+            try {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    if (!value)
+                        continue;
+                    buffer += textDecoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        await processStdioLine(line, ndjson, controller);
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+                controller.close();
+            }
+        },
+    });
+    const writable = new WritableStream({
+        async write(message) {
+            await ndjson.write(message);
+        },
+    });
+    return { readable, writable };
+}
+export function startAcpStdioServer(createAgent) {
+    const output = Writable.toWeb(process.stdout);
+    const input = Readable.toWeb(process.stdin);
+    const stream = createAcpStdioStream(output, input);
+    return new AgentSideConnection((conn) => createAgent(conn), stream);
+}
+//# sourceMappingURL=stdio-server.js.map

package/dist/core/reflection/engine.js

@@ -0,0 +1,55 @@
+import { getLogger } from '../observability/logger.js';
+import { getPromptRegistry } from '../prompts/registry.js';
+import { executeUpdateKnowledge } from '../tools/builtin/knowledge.js';
+export class ReflectionEngine {
+    llm;
+    constructor(llm) {
+        this.llm = llm;
+    }
+    async reflect(input, repoRoot) {
+        const promptRegistry = getPromptRegistry();
+        await promptRegistry.init();
+        // Only reflect if there were failures and final success
+        const failures = input.history.filter((h) => h.error);
+        if (failures.length === 0 || !input.success) {
+            return { lessons: [] };
+        }
+        getLogger().debug(`[Reflection] Triggering reflection for ${failures.length} failures.`);
+        const prompt = promptRegistry.renderReflection(input);
+        try {
+            const response = await this.llm.chat([{ role: 'user', content: prompt }], {
+                responseFormat: 'json_object',
+            });
+            const content = response.content;
+            // Extract JSON from response (handle potential markdown markers)
+            const jsonStr = content.match(/\{[\s\S]*\}/)?.[0] || content;
+            const result = JSON.parse(jsonStr);
+            // Persist suggested knowledge if any
+            if (result.suggestedRules && result.suggestedRules.length > 0) {
+                // Since we are in the engine, we can call the executor directly
+                const mockCtx = { repoRoot };
+                await executeUpdateKnowledge({
+                    category: 'project_rules',
+                    rules: result.suggestedRules,
+                    deprecated_rules: result.deprecatedRules,
+                }, mockCtx);
+            }
+            if (result.suggestedDecisions && result.suggestedDecisions.length > 0) {
+                const mockCtx = { repoRoot };
+                for (const decision of result.suggestedDecisions) {
+                    await executeUpdateKnowledge({
+                        category: 'architectural_decisions',
+                        decision,
+                    }, mockCtx);
+                }
+            }
+            getLogger().debug(`[Reflection] Reflection completed with ${result.lessons?.length ?? 0} lessons.`);
+            return result;
+        }
+        catch (e) {
+            getLogger().warn(`[Reflection] Failed to perform reflection: ${e instanceof Error ? e.message : String(e)}`);
+            return { lessons: [] };
+        }
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/core/reflection/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/runtime/agent-server-runtime.js

@@ -0,0 +1,88 @@
+import { InMemoryTaskStore } from '@a2a-js/sdk/server';
+import { createTaskEventBus } from '../interaction/events/bus.js';
+import { createInteractionFacade } from '../interaction/orchestration/facade.js';
+import { createA2AInteractionExecutor } from '../protocols/a2a/sdk/executor.js';
+import { createA2ASdkExpressApp } from '../protocols/a2a/sdk/server.js';
+import { createSidecarFastifyPlugin, } from './sidecar-fastify-plugin.js';
+export function createAgentServerRuntime(deps) {
+    const eventBus = deps.a2a.eventBus ?? createTaskEventBus();
+    const taskStore = deps.a2a.taskStore ?? new InMemoryTaskStore();
+    const facade = createInteractionFacade({
+        executeTask: deps.a2a.executeTask,
+        eventBus,
+    });
+    const executor = createA2AInteractionExecutor({
+        facade: {
+            createTask: (input) => facade.createTask(input).then((result) => ({ task: result.task })),
+            getTask: (id) => facade.getTask(id),
+            cancelTask: (id) => facade.cancelTask(id),
+        },
+        taskEventBus: eventBus,
+        taskStore,
+    });
+    const agentCard = deps.a2a.buildAgentCard();
+    const a2aApp = createA2ASdkExpressApp({
+        agentCard,
+        agentExecutor: executor,
+        taskStore,
+        userBuilder: deps.a2a.userBuilder,
+        authMiddleware: deps.a2a.authMiddleware,
+    });
+    const sidecarPlugin = createSidecarFastifyPlugin({
+        routes: deps.sidecar.routes,
+        scope: deps.listen.sidecar.type === 'tcp' ? 'tcp' : 'uds',
+        allowConditional: deps.sidecar.allowConditional,
+        authorize: deps.sidecar.authorize,
+        baseUrl: deps.sidecar.baseUrl,
+    });
+    const sidecarServer = deps.createFastify();
+    let a2aServerInstance = null;
+    let sidecarServerInstance = null;
+    let started = false;
+    async function start() {
+        if (started) {
+            throw new Error('Runtime already started');
+        }
+        if (deps.configureA2A) {
+            await deps.configureA2A(a2aApp);
+        }
+        if (deps.configureSidecar) {
+            await deps.configureSidecar(sidecarServer);
+        }
+        await sidecarServer.register(sidecarPlugin);
+        a2aServerInstance = await new Promise((resolve, reject) => {
+            const server = a2aApp.listen(deps.listen.a2a.port, deps.listen.a2a.host ?? '0.0.0.0', (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(server);
+            });
+        });
+        const sidecarListenOpts = deps.listen.sidecar.type === 'tcp'
+            ? { port: deps.listen.sidecar.port, host: deps.listen.sidecar.host }
+            : { path: deps.listen.sidecar.path };
+        sidecarServerInstance = await sidecarServer.listen(sidecarListenOpts);
+        started = true;
+    }
+    async function close() {
+        if (a2aServerInstance) {
+            await new Promise((resolve) => {
+                a2aServerInstance.close(() => resolve());
+            });
+            a2aServerInstance = null;
+        }
+        if (sidecarServerInstance) {
+            await sidecarServer.close();
+            sidecarServerInstance = null;
+        }
+        started = false;
+    }
+    return {
+        eventBus,
+        a2aServer: a2aApp,
+        sidecarServer,
+        start,
+        close,
+    };
+}
+//# sourceMappingURL=agent-server-runtime.js.map

package/dist/core/runtime/bun-runtime.js

@@ -0,0 +1,26 @@
+import { Readable } from 'stream';
+export function getBunRuntime() {
+    const runtime = globalThis.Bun;
+    if (!runtime || typeof runtime.spawn !== 'function') {
+        return undefined;
+    }
+    return runtime;
+}
+export function normalizeSignal(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return null;
+}
+export function toNodeReadableStream(stream) {
+    if (!stream)
+        return undefined;
+    if (typeof stream.on === 'function') {
+        return stream;
+    }
+    if (typeof stream.getReader === 'function') {
+        return Readable.fromWeb(stream);
+    }
+    return undefined;
+}
+//# sourceMappingURL=bun-runtime.js.map

package/dist/core/runtime/command-runner-context.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { isCommandAvailableLocal, spawnCommandLocal } from './spawn-command.js';
+const storage = new AsyncLocalStorage();
+export function getActiveCommandRunner() {
+    return storage.getStore();
+}
+export function createLocalCommandRunner() {
+    return {
+        spawnCommand: spawnCommandLocal,
+        isCommandAvailable: isCommandAvailableLocal,
+    };
+}
+export function withCommandRunner(runner, fn) {
+    return storage.run(runner, fn);
+}
+//# sourceMappingURL=command-runner-context.js.map

package/dist/core/runtime/exit-codes.js

@@ -0,0 +1,11 @@
+export const EXIT_CODES = {
+    success: 0,
+    failure: 1,
+    cancelled: 130,
+};
+export function getExitCode(result) {
+    if (result.reason === 'Operation cancelled by user')
+        return EXIT_CODES.cancelled;
+    return result.success ? EXIT_CODES.success : EXIT_CODES.failure;
+}
+//# sourceMappingURL=exit-codes.js.map

package/dist/core/runtime/fastify-fetch-bridge.js

@@ -0,0 +1,51 @@
+import { Readable } from 'node:stream';
+export function buildFetchRequest(input, baseUrl) {
+    const method = input.method ?? 'GET';
+    const url = new URL(input.url ?? '/', baseUrl);
+    const headers = new Headers();
+    const entries = input.headers ?? {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (typeof value === 'string') {
+            headers.set(key, value);
+        }
+        else if (Array.isArray(value)) {
+            headers.set(key, value.join(','));
+        }
+    }
+    let body;
+    if (!['GET', 'HEAD'].includes(method.toUpperCase()) && input.body !== undefined) {
+        if (typeof input.body === 'string' ||
+            input.body instanceof Uint8Array ||
+            input.body instanceof ArrayBuffer) {
+            body = input.body;
+        }
+        else if (input.body instanceof Blob) {
+            body = input.body;
+        }
+        else {
+            body = JSON.stringify(input.body);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+        }
+    }
+    return new Request(url, { method, headers, body });
+}
+function toNodeStream(body) {
+    if (typeof Readable.fromWeb === 'function') {
+        return Readable.fromWeb(body);
+    }
+    return Readable.from(body);
+}
+export async function sendFetchResponse(reply, response) {
+    reply.status(response.status);
+    response.headers.forEach((value, key) => {
+        reply.header(key, value);
+    });
+    if (!response.body) {
+        reply.send();
+        return;
+    }
+    reply.send(toNodeStream(response.body));
+}
+//# sourceMappingURL=fastify-fetch-bridge.js.map

package/dist/core/runtime/fastify-server-bundle.js

@@ -0,0 +1,26 @@
+export function createFastifyServerBundle(deps) {
+    const a2aServer = deps.createFastify();
+    const sidecarServer = deps.createFastify();
+    async function start() {
+        if (deps.configureA2A) {
+            await deps.configureA2A(a2aServer);
+        }
+        await a2aServer.register(deps.a2aPlugin);
+        if (deps.configureSidecar) {
+            await deps.configureSidecar(sidecarServer);
+        }
+        await sidecarServer.register(deps.sidecarPlugin);
+        await a2aServer.listen(deps.a2aListen);
+        await sidecarServer.listen(deps.sidecarListen);
+    }
+    async function close() {
+        await Promise.all([a2aServer.close(), sidecarServer.close()]);
+    }
+    return {
+        a2aServer,
+        sidecarServer,
+        start,
+        close,
+    };
+}
+//# sourceMappingURL=fastify-server-bundle.js.map