@renseiai/agentfactory 0.8.0

package/dist/src/providers/spring-ai-provider.integration.test.js

@@ -0,0 +1,351 @@
+/**
+ * Integration tests for Spring AI Provider
+ *
+ * Tests the full provider lifecycle using mock subprocess that emits
+ * Spring AI JSONL events, covering:
+ * - Happy path spawn + complete
+ * - Session resume
+ * - Error handling (missing JAR, missing Java, agent crash)
+ * - Cost data extraction accuracy
+ * - Tool permission adapter output
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SpringAiProvider } from './spring-ai-provider.js';
+import { SpringAiToolPermissionAdapter, createToolPermissionAdapter } from '../templates/adapters.js';
+import { PassThrough } from 'stream';
+import { EventEmitter } from 'events';
+function createMockChild(pid = 1234) {
+    const child = new EventEmitter();
+    child.pid = pid;
+    child.stdin = new PassThrough();
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    child.exitCode = null;
+    child.kill = vi.fn();
+    return child;
+}
+let mockChild;
+vi.mock('child_process', () => ({
+    spawn: vi.fn(() => mockChild),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeConfig(overrides) {
+    return {
+        prompt: 'Test prompt',
+        cwd: '/tmp/test',
+        env: { SPRING_AI_AGENT_JAR: '/path/to/agent.jar' },
+        abortController: new AbortController(),
+        autonomous: true,
+        sandboxEnabled: false,
+        ...overrides,
+    };
+}
+function writeLine(child, data) {
+    child.stdout.write(JSON.stringify(data) + '\n');
+}
+function endProcess(child, exitCode = 0) {
+    child.stdout.end();
+    child.exitCode = exitCode;
+    child.emit('exit', exitCode);
+}
+async function collectEvents(stream) {
+    const events = [];
+    for await (const event of stream) {
+        events.push(event);
+    }
+    return events;
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('SpringAiProvider integration', () => {
+    let provider;
+    beforeEach(() => {
+        mockChild = createMockChild();
+        provider = new SpringAiProvider();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('happy path spawn + complete', () => {
+        it('produces init, assistant_text, and result events', async () => {
+            const handle = provider.spawn(makeConfig());
+            expect(handle.sessionId).toBeNull();
+            // Emit events asynchronously
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-001' });
+                writeLine(mockChild, { type: 'turn.started' });
+                writeLine(mockChild, { type: 'assistant.message', id: 'msg-1', text: 'Hello world' });
+                writeLine(mockChild, {
+                    type: 'turn.completed',
+                    usage: { input_tokens: 150, output_tokens: 75, model: 'gpt-4' },
+                });
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            expect(events).toHaveLength(4);
+            expect(events[0]).toMatchObject({ type: 'init', sessionId: 'sess-001' });
+            expect(events[1]).toMatchObject({ type: 'system', subtype: 'turn_started', message: 'Turn 1 started' });
+            expect(events[2]).toMatchObject({ type: 'assistant_text', text: 'Hello world' });
+            expect(events[3]).toMatchObject({
+                type: 'result',
+                success: true,
+                cost: { inputTokens: 150, outputTokens: 75, numTurns: 1 },
+            });
+            // sessionId should be set after init event
+            expect(handle.sessionId).toBe('sess-001');
+        });
+        it('handles multi-turn sessions with accumulated cost', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-002' });
+                writeLine(mockChild, { type: 'turn.started' });
+                writeLine(mockChild, { type: 'assistant.message', id: 'msg-1', text: 'Analyzing...' });
+                writeLine(mockChild, {
+                    type: 'turn.completed',
+                    usage: { input_tokens: 100, output_tokens: 50 },
+                });
+                writeLine(mockChild, { type: 'turn.started' });
+                writeLine(mockChild, { type: 'assistant.message', id: 'msg-2', text: 'Done!' });
+                writeLine(mockChild, {
+                    type: 'turn.completed',
+                    usage: { input_tokens: 200, output_tokens: 80 },
+                });
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const resultEvents = events.filter(e => e.type === 'result');
+            expect(resultEvents).toHaveLength(2);
+            // Second result should have accumulated totals
+            expect(resultEvents[1]).toMatchObject({
+                type: 'result',
+                success: true,
+                cost: { inputTokens: 300, outputTokens: 130, numTurns: 2 },
+            });
+        });
+    });
+    describe('tool use events', () => {
+        it('maps tool invocation and result events', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-003' });
+                writeLine(mockChild, { type: 'turn.started' });
+                writeLine(mockChild, {
+                    type: 'tool.invocation',
+                    id: 'tool-1',
+                    tool_name: 'shell',
+                    input: { command: 'ls -la' },
+                });
+                writeLine(mockChild, {
+                    type: 'tool.result',
+                    id: 'tool-1',
+                    tool_name: 'shell',
+                    content: 'file1.txt\nfile2.txt',
+                    is_error: false,
+                });
+                writeLine(mockChild, { type: 'turn.completed' });
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const toolUse = events.find(e => e.type === 'tool_use');
+            const toolResult = events.find(e => e.type === 'tool_result');
+            expect(toolUse).toMatchObject({
+                type: 'tool_use',
+                toolName: 'shell',
+                toolUseId: 'tool-1',
+                input: { command: 'ls -la' },
+            });
+            expect(toolResult).toMatchObject({
+                type: 'tool_result',
+                toolName: 'shell',
+                toolUseId: 'tool-1',
+                content: 'file1.txt\nfile2.txt',
+                isError: false,
+            });
+        });
+    });
+    describe('session resume', () => {
+        it('passes resume session ID to CLI args', async () => {
+            const { spawn: mockSpawn } = await import('child_process');
+            const handle = provider.resume('sess-previous', makeConfig());
+            // Verify spawn was called with --resume flag
+            expect(mockSpawn).toHaveBeenCalled();
+            const callArgs = mockSpawn.mock.calls[0];
+            const args = callArgs[1];
+            expect(args).toContain('--resume');
+            expect(args).toContain('sess-previous');
+            // Complete the process to avoid hanging
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-previous' });
+                writeLine(mockChild, { type: 'turn.completed' });
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            expect(events[0]).toMatchObject({ type: 'init', sessionId: 'sess-previous' });
+        });
+    });
+    describe('error handling', () => {
+        it('handles missing SPRING_AI_AGENT_JAR gracefully', async () => {
+            const config = makeConfig({ env: {} }); // No JAR path
+            const handle = provider.spawn(config);
+            const events = await collectEvents(handle.stream);
+            expect(events).toHaveLength(2);
+            expect(events[0]).toMatchObject({
+                type: 'error',
+                message: 'SPRING_AI_AGENT_JAR environment variable is not set',
+            });
+            expect(events[1]).toMatchObject({
+                type: 'result',
+                success: false,
+                errorSubtype: 'configuration_error',
+            });
+        });
+        it('handles agent crash (non-zero exit)', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-crash' });
+                mockChild.stderr.write('Exception in thread "main" java.lang.OutOfMemoryError\n');
+                endProcess(mockChild, 1);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const resultEvent = events.find(e => e.type === 'result');
+            expect(resultEvent).toMatchObject({
+                type: 'result',
+                success: false,
+                errorSubtype: 'process_exit',
+            });
+        });
+        it('detects missing Java runtime', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                mockChild.stderr.write('java: not found\n');
+                endProcess(mockChild, 127);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const resultEvent = events.find(e => e.type === 'result');
+            expect(resultEvent).toMatchObject({
+                type: 'result',
+                success: false,
+                errorSubtype: 'java_not_found',
+            });
+        });
+        it('detects missing JAR file', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                mockChild.stderr.write('Error: Unable to access jarfile /path/to/agent.jar\n');
+                endProcess(mockChild, 1);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const resultEvent = events.find(e => e.type === 'result');
+            expect(resultEvent).toMatchObject({
+                type: 'result',
+                success: false,
+                errorSubtype: 'jar_not_found',
+            });
+        });
+        it('maps error events from the agent', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-err' });
+                writeLine(mockChild, { type: 'error', message: 'Rate limit exceeded', code: 'RATE_LIMIT' });
+                writeLine(mockChild, {
+                    type: 'turn.failed',
+                    error: { message: 'Rate limit exceeded' },
+                });
+                endProcess(mockChild, 1);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const errorEvent = events.find(e => e.type === 'error');
+            const resultEvent = events.find(e => e.type === 'result');
+            expect(errorEvent).toMatchObject({
+                type: 'error',
+                message: 'Rate limit exceeded',
+                code: 'RATE_LIMIT',
+            });
+            expect(resultEvent).toMatchObject({
+                type: 'result',
+                success: false,
+                errors: ['Rate limit exceeded'],
+            });
+        });
+    });
+    describe('abort / stop', () => {
+        it('kills process on stop()', async () => {
+            const handle = provider.spawn(makeConfig());
+            // Start the stream but don't consume it yet
+            setTimeout(async () => {
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-stop' });
+                await handle.stop();
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            expect(events.length).toBeGreaterThanOrEqual(1);
+        });
+        it('injectMessage throws (not supported)', async () => {
+            const handle = provider.spawn(makeConfig());
+            await expect(handle.injectMessage('test')).rejects.toThrow('Spring AI provider does not support mid-session message injection');
+            // Clean up process
+            setTimeout(() => endProcess(mockChild, 0), 10);
+            await collectEvents(handle.stream);
+        });
+    });
+    describe('process spawned callback', () => {
+        it('calls onProcessSpawned with PID', () => {
+            const onProcessSpawned = vi.fn();
+            provider.spawn(makeConfig({ onProcessSpawned }));
+            expect(onProcessSpawned).toHaveBeenCalledWith(1234);
+        });
+    });
+    describe('non-JSON output handling', () => {
+        it('emits system events for non-JSON lines', async () => {
+            const handle = provider.spawn(makeConfig());
+            setTimeout(() => {
+                mockChild.stdout.write('Spring AI Agent v0.1.0 starting...\n');
+                writeLine(mockChild, { type: 'session.started', session_id: 'sess-log' });
+                writeLine(mockChild, { type: 'turn.completed' });
+                endProcess(mockChild, 0);
+            }, 10);
+            const events = await collectEvents(handle.stream);
+            const systemEvent = events.find(e => e.type === 'system' && 'subtype' in e && e.subtype === 'raw_output');
+            expect(systemEvent).toMatchObject({
+                type: 'system',
+                subtype: 'raw_output',
+                message: 'Spring AI Agent v0.1.0 starting...',
+            });
+        });
+    });
+});
+describe('SpringAiToolPermissionAdapter integration', () => {
+    it('factory returns SpringAiToolPermissionAdapter for spring-ai', () => {
+        const adapter = createToolPermissionAdapter('spring-ai');
+        expect(adapter).toBeInstanceOf(SpringAiToolPermissionAdapter);
+    });
+    it('translates full permission set for Spring AI agent', () => {
+        const adapter = createToolPermissionAdapter('spring-ai');
+        const result = adapter.translatePermissions([
+            { shell: 'pnpm *' },
+            { shell: 'git commit *' },
+            { shell: 'gh pr *' },
+            'user-input',
+            'Read',
+            'Write',
+        ]);
+        expect(result).toEqual([
+            'spring-tool:shell:pnpm *',
+            'spring-tool:shell:git commit *',
+            'spring-tool:shell:gh pr *',
+            'user-input',
+            'Read',
+            'Write',
+        ]);
+    });
+});
+describe('createProvider integration', () => {
+    it('creates SpringAiProvider via factory', async () => {
+        const { createProvider } = await import('./index.js');
+        const provider = createProvider('spring-ai');
+        expect(provider.name).toBe('spring-ai');
+    });
+});

package/dist/src/providers/spring-ai-provider.js

@@ -0,0 +1,317 @@
+/**
+ * Spring AI Agent Provider
+ *
+ * Spawns a Spring AI agent JAR as a child process and parses its JSONL event
+ * stream into normalized AgentEvents.
+ *
+ * CLI invocation patterns:
+ *   New session:  java -jar <JAR> --prompt "<prompt>" --cwd <cwd> --json
+ *   Resume:       java -jar <JAR> --resume <sessionId> --prompt "<prompt>" --cwd <cwd> --json
+ *
+ * JSONL event types:
+ *   session.started   → init (sessionId)
+ *   turn.started      → system (turn_started)
+ *   turn.completed    → result (success, usage)
+ *   turn.failed       → result (failure)
+ *   tool.invocation   → tool_use
+ *   tool.result       → tool_result
+ *   assistant.message  → assistant_text
+ *   error             → error
+ */
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+/**
+ * Map a single Spring AI JSONL event to one or more normalized AgentEvents.
+ * Exported for unit testing — the AgentHandle uses this internally.
+ */
+export function mapSpringAiEvent(event, state) {
+    switch (event.type) {
+        case 'session.started':
+            state.sessionId = event.session_id;
+            return [{
+                    type: 'init',
+                    sessionId: event.session_id,
+                    raw: event,
+                }];
+        case 'turn.started':
+            state.turnCount++;
+            return [{
+                    type: 'system',
+                    subtype: 'turn_started',
+                    message: `Turn ${state.turnCount} started`,
+                    raw: event,
+                }];
+        case 'turn.completed':
+            if (event.usage) {
+                state.totalInputTokens += event.usage.input_tokens ?? 0;
+                state.totalOutputTokens += event.usage.output_tokens ?? 0;
+            }
+            return [{
+                    type: 'result',
+                    success: true,
+                    cost: {
+                        inputTokens: state.totalInputTokens || undefined,
+                        outputTokens: state.totalOutputTokens || undefined,
+                        numTurns: state.turnCount || undefined,
+                    },
+                    raw: event,
+                }];
+        case 'turn.failed':
+            return [{
+                    type: 'result',
+                    success: false,
+                    errors: [event.error?.message ?? 'Turn failed'],
+                    errorSubtype: 'turn_failed',
+                    raw: event,
+                }];
+        case 'assistant.message':
+            return [{
+                    type: 'assistant_text',
+                    text: event.text,
+                    raw: event,
+                }];
+        case 'tool.invocation':
+            return [{
+                    type: 'tool_use',
+                    toolName: event.tool_name,
+                    toolUseId: event.id,
+                    input: event.input,
+                    raw: event,
+                }];
+        case 'tool.result':
+            return [{
+                    type: 'tool_result',
+                    toolName: event.tool_name,
+                    toolUseId: event.id,
+                    content: event.content,
+                    isError: event.is_error,
+                    raw: event,
+                }];
+        case 'error':
+            return [{
+                    type: 'error',
+                    message: event.message ?? 'Unknown error',
+                    code: event.code,
+                    raw: event,
+                }];
+        default:
+            return [{
+                    type: 'system',
+                    subtype: 'unknown',
+                    message: `Unhandled Spring AI event type: ${event.type}`,
+                    raw: event,
+                }];
+    }
+}
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+export class SpringAiProvider {
+    name = 'spring-ai';
+    spawn(config) {
+        return this.createHandle(config);
+    }
+    resume(sessionId, config) {
+        return this.createHandle(config, sessionId);
+    }
+    createHandle(config, resumeSessionId) {
+        const abortController = config.abortController;
+        // Resolve Java binary — prefer JAVA_BIN env var, then fall back to 'java'
+        const javaBin = config.env.JAVA_BIN || process.env.JAVA_BIN || 'java';
+        // Resolve the Spring AI agent JAR path
+        const jarPath = config.env.SPRING_AI_AGENT_JAR || process.env.SPRING_AI_AGENT_JAR;
+        if (!jarPath) {
+            return new SpringAiAgentHandle(null, abortController, 'SPRING_AI_AGENT_JAR environment variable is not set');
+        }
+        // Build args
+        const args = ['-jar', jarPath];
+        if (resumeSessionId) {
+            args.push('--resume', resumeSessionId);
+        }
+        args.push('--json');
+        args.push('--cwd', config.cwd);
+        if (config.autonomous) {
+            args.push('--autonomous');
+        }
+        if (config.sandboxEnabled) {
+            args.push('--sandbox');
+        }
+        // Prompt as final arg
+        args.push('--prompt', config.prompt);
+        // Spawn the Java process
+        const child = spawn(javaBin, args, {
+            cwd: config.cwd,
+            env: {
+                ...process.env,
+                ...config.env,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        config.onProcessSpawned?.(child.pid);
+        // Wire up abort
+        const abortHandler = () => {
+            child.kill('SIGTERM');
+        };
+        abortController.signal.addEventListener('abort', abortHandler);
+        child.once('exit', () => {
+            abortController.signal.removeEventListener('abort', abortHandler);
+        });
+        child.on('error', (err) => {
+            console.error('[SpringAiProvider] Child process error:', err.message);
+        });
+        return new SpringAiAgentHandle(child, abortController);
+    }
+}
+// ---------------------------------------------------------------------------
+// AgentHandle implementation
+// ---------------------------------------------------------------------------
+class SpringAiAgentHandle {
+    sessionId = null;
+    child;
+    abortController;
+    mapperState = {
+        sessionId: null,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        turnCount: 0,
+    };
+    initError;
+    constructor(child, abortController, initError) {
+        this.child = child;
+        this.abortController = abortController;
+        this.initError = initError;
+    }
+    get stream() {
+        return this.createEventStream();
+    }
+    async injectMessage(_text) {
+        // Spring AI CLI mode doesn't support mid-session message injection.
+        // The prompt is provided at spawn time. Injection would require
+        // stopping and resuming with a new prompt.
+        throw new Error('Spring AI provider does not support mid-session message injection. ' +
+            'Stop and resume with a new prompt instead.');
+    }
+    async stop() {
+        this.abortController.abort();
+    }
+    async *createEventStream() {
+        // Handle init-time errors (e.g., missing JAR path)
+        if (this.initError) {
+            yield {
+                type: 'error',
+                message: this.initError,
+                raw: null,
+            };
+            yield {
+                type: 'result',
+                success: false,
+                errors: [this.initError],
+                errorSubtype: 'configuration_error',
+                raw: null,
+            };
+            return;
+        }
+        if (!this.child) {
+            yield {
+                type: 'error',
+                message: 'Spring AI process was not created',
+                raw: null,
+            };
+            return;
+        }
+        const stdout = this.child.stdout;
+        if (!stdout) {
+            yield {
+                type: 'error',
+                message: 'Spring AI process has no stdout',
+                raw: null,
+            };
+            return;
+        }
+        // Collect stderr for error reporting
+        let stderr = '';
+        this.child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        // Parse JSONL lines from stdout
+        const rl = createInterface({ input: stdout });
+        let hasResult = false;
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                // Non-JSON output — emit as system event
+                yield {
+                    type: 'system',
+                    subtype: 'raw_output',
+                    message: trimmed,
+                    raw: trimmed,
+                };
+                continue;
+            }
+            const mapped = mapSpringAiEvent(event, this.mapperState);
+            for (const agentEvent of mapped) {
+                if (agentEvent.type === 'init') {
+                    this.sessionId = this.mapperState.sessionId;
+                }
+                if (agentEvent.type === 'result') {
+                    hasResult = true;
+                }
+                yield agentEvent;
+            }
+        }
+        // Wait for process exit
+        const exitCode = await new Promise((resolve) => {
+            if (this.child.exitCode !== null) {
+                resolve(this.child.exitCode);
+            }
+            else {
+                this.child.once('exit', (code) => resolve(code));
+            }
+        });
+        // If we never got a result event, synthesize one from exit code
+        if (!hasResult) {
+            if (exitCode === 0) {
+                yield {
+                    type: 'result',
+                    success: true,
+                    cost: {
+                        inputTokens: this.mapperState.totalInputTokens || undefined,
+                        outputTokens: this.mapperState.totalOutputTokens || undefined,
+                        numTurns: this.mapperState.turnCount || undefined,
+                    },
+                    raw: { exitCode },
+                };
+            }
+            else {
+                const errorMsg = stderr.trim() || `Spring AI process exited with code ${exitCode}`;
+                // Detect common errors
+                const isJavaMissing = stderr.includes('java: not found') ||
+                    stderr.includes('JAVA_HOME') ||
+                    stderr.includes('No such file or directory');
+                const isJarMissing = stderr.includes('Unable to access jarfile') ||
+                    stderr.includes('jarfile');
+                yield {
+                    type: 'result',
+                    success: false,
+                    errors: [errorMsg],
+                    errorSubtype: isJavaMissing ? 'java_not_found'
+                        : isJarMissing ? 'jar_not_found'
+                            : 'process_exit',
+                    raw: { exitCode, stderr },
+                };
+            }
+        }
+    }
+}
+/**
+ * Create a new Spring AI provider instance
+ */
+export function createSpringAiProvider() {
+    return new SpringAiProvider();
+}

package/dist/src/providers/spring-ai-provider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spring-ai-provider.test.d.ts.map

package/dist/src/providers/spring-ai-provider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-ai-provider.test.d.ts","sourceRoot":"","sources":["../../../src/providers/spring-ai-provider.test.ts"],"names":[],"mappings":""}