@renseiai/agentfactory 0.8.0

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

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest';
+import { mapSpringAiEvent, } from './spring-ai-provider.js';
+function freshState() {
+    return {
+        sessionId: null,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        turnCount: 0,
+    };
+}
+describe('mapSpringAiEvent', () => {
+    it('maps session.started to init', () => {
+        const state = freshState();
+        const event = { type: 'session.started', session_id: 'sess-abc' };
+        const result = mapSpringAiEvent(event, state);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            type: 'init',
+            sessionId: 'sess-abc',
+        });
+        expect(state.sessionId).toBe('sess-abc');
+    });
+    it('maps turn.started to system with incrementing turn count', () => {
+        const state = freshState();
+        const event = { type: 'turn.started' };
+        const r1 = mapSpringAiEvent(event, state);
+        expect(r1[0]).toMatchObject({
+            type: 'system',
+            subtype: 'turn_started',
+            message: 'Turn 1 started',
+        });
+        expect(state.turnCount).toBe(1);
+        const r2 = mapSpringAiEvent(event, state);
+        expect(r2[0]).toMatchObject({ message: 'Turn 2 started' });
+        expect(state.turnCount).toBe(2);
+    });
+    it('maps turn.completed to result with accumulated usage', () => {
+        const state = freshState();
+        state.turnCount = 1;
+        const event = {
+            type: 'turn.completed',
+            usage: { input_tokens: 100, output_tokens: 50, model: 'gpt-4' },
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: true,
+            cost: {
+                inputTokens: 100,
+                outputTokens: 50,
+                numTurns: 1,
+            },
+        });
+        expect(state.totalInputTokens).toBe(100);
+        expect(state.totalOutputTokens).toBe(50);
+    });
+    it('accumulates usage across multiple turns', () => {
+        const state = freshState();
+        state.turnCount = 2;
+        mapSpringAiEvent({ type: 'turn.completed', usage: { input_tokens: 100, output_tokens: 50 } }, state);
+        const result = mapSpringAiEvent({ type: 'turn.completed', usage: { input_tokens: 200, output_tokens: 80 } }, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: true,
+            cost: { inputTokens: 300, outputTokens: 130 },
+        });
+    });
+    it('maps turn.completed without usage', () => {
+        const state = freshState();
+        const result = mapSpringAiEvent({ type: 'turn.completed' }, state);
+        expect(result[0]).toMatchObject({ type: 'result', success: true });
+    });
+    it('maps turn.failed to failed result', () => {
+        const state = freshState();
+        const event = {
+            type: 'turn.failed',
+            error: { message: 'Model error', code: 'MODEL_ERROR' },
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: false,
+            errors: ['Model error'],
+            errorSubtype: 'turn_failed',
+        });
+    });
+    it('maps turn.failed without error message', () => {
+        const state = freshState();
+        const result = mapSpringAiEvent({ type: 'turn.failed' }, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: false,
+            errors: ['Turn failed'],
+        });
+    });
+    it('maps assistant.message to assistant_text', () => {
+        const state = freshState();
+        const event = {
+            type: 'assistant.message',
+            id: 'msg-1',
+            text: 'Analysis complete',
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result).toEqual([{
+                type: 'assistant_text',
+                text: 'Analysis complete',
+                raw: event,
+            }]);
+    });
+    it('maps tool.invocation to tool_use', () => {
+        const state = freshState();
+        const event = {
+            type: 'tool.invocation',
+            id: 'tool-1',
+            tool_name: 'shell',
+            input: { command: 'ls -la' },
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'tool_use',
+            toolName: 'shell',
+            toolUseId: 'tool-1',
+            input: { command: 'ls -la' },
+        });
+    });
+    it('maps tool.result to tool_result', () => {
+        const state = freshState();
+        const event = {
+            type: 'tool.result',
+            id: 'tool-1',
+            tool_name: 'shell',
+            content: 'file1.txt\nfile2.txt',
+            is_error: false,
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            toolName: 'shell',
+            toolUseId: 'tool-1',
+            content: 'file1.txt\nfile2.txt',
+            isError: false,
+        });
+    });
+    it('maps tool.result with error', () => {
+        const state = freshState();
+        const event = {
+            type: 'tool.result',
+            id: 'tool-1',
+            tool_name: 'shell',
+            content: 'command not found',
+            is_error: true,
+        };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            isError: true,
+            content: 'command not found',
+        });
+    });
+    it('maps error event', () => {
+        const state = freshState();
+        const event = { type: 'error', message: 'Connection lost', code: 'CONN_ERROR' };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'error',
+            message: 'Connection lost',
+            code: 'CONN_ERROR',
+        });
+    });
+    it('maps error event without message', () => {
+        const state = freshState();
+        const result = mapSpringAiEvent({ type: 'error' }, state);
+        expect(result[0]).toMatchObject({
+            type: 'error',
+            message: 'Unknown error',
+        });
+    });
+    it('handles unknown event type gracefully', () => {
+        const state = freshState();
+        const event = { type: 'unknown.event' };
+        const result = mapSpringAiEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'unknown',
+        });
+    });
+});
+describe('SpringAiProvider', () => {
+    it('exports SpringAiProvider class', async () => {
+        const { SpringAiProvider } = await import('./spring-ai-provider.js');
+        const provider = new SpringAiProvider();
+        expect(provider.name).toBe('spring-ai');
+    });
+    it('exports createSpringAiProvider factory', async () => {
+        const { createSpringAiProvider } = await import('./spring-ai-provider.js');
+        const provider = createSpringAiProvider();
+        expect(provider.name).toBe('spring-ai');
+    });
+});

package/dist/src/providers/types.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Agent Provider Interface
+ *
+ * Abstracts the underlying agent SDK (Claude, Codex, Amp, etc.)
+ * so the orchestrator is provider-agnostic.
+ *
+ * All three providers follow the same pattern:
+ * 1. Initialize with config + working directory
+ * 2. Send a prompt
+ * 3. Iterate over a stream of events
+ * 4. Get a final result with cost/token data
+ */
+/** Supported agent provider names */
+export type AgentProviderName = 'claude' | 'codex' | 'amp' | 'spring-ai' | 'a2a';
+/**
+ * Agent Provider
+ *
+ * Each provider implements spawn/resume to create an AgentHandle
+ * that streams normalized AgentEvents.
+ */
+export interface AgentProvider {
+    /** Provider identifier */
+    readonly name: AgentProviderName;
+    /** Spawn a new agent session */
+    spawn(config: AgentSpawnConfig): AgentHandle;
+    /** Resume a previously interrupted session */
+    resume(sessionId: string, config: AgentSpawnConfig): AgentHandle;
+}
+/**
+ * Configuration passed to a provider when spawning an agent.
+ * Provider implementations translate these to SDK-specific options.
+ */
+export interface AgentSpawnConfig {
+    /** The prompt/instruction for the agent */
+    prompt: string;
+    /** Working directory for the agent */
+    cwd: string;
+    /** Environment variables to pass to the agent process */
+    env: Record<string, string>;
+    /** AbortController for cancellation support */
+    abortController: AbortController;
+    /** Whether agent runs in autonomous mode (no user input) */
+    autonomous: boolean;
+    /** Sandbox level for filesystem/network restrictions */
+    sandboxEnabled: boolean;
+    /**
+     * Tools to auto-allow without prompting for permission.
+     * Uses Claude Code permission pattern format: 'Bash(prefix:glob)'.
+     * Examples: 'Bash(pnpm:*)', 'Bash(git commit:*)'.
+     * When omitted the provider may supply defaults for autonomous agents.
+     */
+    allowedTools?: string[];
+    /**
+     * Callback to capture PID when the agent process is spawned.
+     * Providers call this once the underlying process is created.
+     */
+    onProcessSpawned?: (pid: number | undefined) => void;
+    /**
+     * In-process MCP servers providing typed tools to the agent.
+     * Created by ToolRegistry.createServers() from registered plugins.
+     */
+    mcpServers?: Record<string, import('@anthropic-ai/claude-agent-sdk').McpServerConfig>;
+    /**
+     * Maximum number of agentic turns (API round-trips) before stopping.
+     * Coordinators need more turns than standard agents since they poll sub-agent status.
+     * When omitted, the provider's default applies.
+     */
+    maxTurns?: number;
+}
+/**
+ * Handle to a running agent session.
+ * Returned by AgentProvider.spawn() and AgentProvider.resume().
+ */
+export interface AgentHandle {
+    /** Provider-specific session/thread ID (available after init event) */
+    sessionId: string | null;
+    /** Async iterable stream of normalized events */
+    stream: AsyncIterable<AgentEvent>;
+    /**
+     * Inject a follow-up user message into the running session.
+     * Used for user prompts without restarting the agent.
+     */
+    injectMessage(text: string): Promise<void>;
+    /**
+     * Stop the agent. Delegates to the provider's abort mechanism.
+     */
+    stop(): Promise<void>;
+}
+/**
+ * Normalized agent event.
+ * Each provider maps its native events to this common format.
+ */
+export type AgentEvent = AgentInitEvent | AgentSystemEvent | AgentAssistantTextEvent | AgentToolUseEvent | AgentToolResultEvent | AgentToolProgressEvent | AgentResultEvent | AgentErrorEvent;
+/** Agent initialized — contains session ID for resume */
+export interface AgentInitEvent {
+    type: 'init';
+    sessionId: string;
+    raw: unknown;
+}
+/** System-level event (status changes, compaction, etc.) */
+export interface AgentSystemEvent {
+    type: 'system';
+    subtype: string;
+    message?: string;
+    raw: unknown;
+}
+/** Assistant text output */
+export interface AgentAssistantTextEvent {
+    type: 'assistant_text';
+    text: string;
+    raw: unknown;
+}
+/** Agent is invoking a tool */
+export interface AgentToolUseEvent {
+    type: 'tool_use';
+    toolName: string;
+    toolUseId?: string;
+    input: Record<string, unknown>;
+    raw: unknown;
+}
+/** Tool execution result */
+export interface AgentToolResultEvent {
+    type: 'tool_result';
+    toolName?: string;
+    toolUseId?: string;
+    content: string;
+    isError: boolean;
+    raw: unknown;
+}
+/** Tool execution progress update */
+export interface AgentToolProgressEvent {
+    type: 'tool_progress';
+    toolName: string;
+    elapsedSeconds: number;
+    raw: unknown;
+}
+/** Final result — agent has finished */
+export interface AgentResultEvent {
+    type: 'result';
+    success: boolean;
+    /** Completion message (only on success) */
+    message?: string;
+    /** Error messages (only on failure) */
+    errors?: string[];
+    /** Error subtype from the provider (e.g., 'error_during_execution', 'error_max_turns') */
+    errorSubtype?: string;
+    /** Cost/usage data */
+    cost?: AgentCostData;
+    raw: unknown;
+}
+/** Error event */
+export interface AgentErrorEvent {
+    type: 'error';
+    message: string;
+    code?: string;
+    raw: unknown;
+}
+/** Cost and token usage data */
+export interface AgentCostData {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalCostUsd?: number;
+    numTurns?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/providers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/providers/types.ts"],"names":[],"mappings":"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"}

package/dist/src/providers/types.js

@@ -0,0 +1,13 @@
+/**
+ * Agent Provider Interface
+ *
+ * Abstracts the underlying agent SDK (Claude, Codex, Amp, etc.)
+ * so the orchestrator is provider-agnostic.
+ *
+ * All three providers follow the same pattern:
+ * 1. Initialize with config + working directory
+ * 2. Send a prompt
+ * 3. Iterate over a stream of events
+ * 4. Get a final result with cost/token data
+ */
+export {};

package/dist/src/templates/adapters.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Tool Permission Adapters
+ *
+ * Translate abstract tool permissions to provider-native format.
+ */
+import type { ToolPermission, ToolPermissionAdapter } from './types.js';
+import type { AgentProviderName } from '../providers/types.js';
+/**
+ * Claude Code tool permission adapter.
+ *
+ * Translates abstract permissions to Claude Code's format:
+ *   { shell: "pnpm *" }  → "Bash(pnpm:*)"
+ *   { shell: "git commit *" } → "Bash(git commit:*)"
+ *   "user-input" → "AskUserQuestion"
+ */
+export declare class ClaudeToolPermissionAdapter implements ToolPermissionAdapter {
+    translatePermissions(permissions: ToolPermission[]): string[];
+    private translateOne;
+}
+/**
+ * OpenAI Codex tool permission adapter.
+ *
+ * Codex uses sandbox policies (--full-auto / workspace-write / read-only)
+ * and TOML-based sandbox_permissions rather than per-tool allowlists.
+ * Shell permissions are passed through as command patterns for documentation
+ * and future granular support.
+ *
+ *   { shell: "pnpm *" }  → "shell:pnpm *"
+ *   "user-input" → "user-input" (no-op — Codex exec is non-interactive)
+ */
+export declare class CodexToolPermissionAdapter implements ToolPermissionAdapter {
+    translatePermissions(permissions: ToolPermission[]): string[];
+    private translateOne;
+}
+/**
+ * Spring AI tool permission adapter.
+ *
+ * Spring AI uses @Tool annotations and ToolCallAdvisor for tool configuration.
+ * Shell permissions map to Spring AI's tool-call allowlist format:
+ *   { shell: "pnpm *" }  → "spring-tool:shell:pnpm *"
+ *   "user-input" → "user-input" (no-op — Spring AI agent is non-interactive)
+ */
+export declare class SpringAiToolPermissionAdapter implements ToolPermissionAdapter {
+    translatePermissions(permissions: ToolPermission[]): string[];
+    private translateOne;
+}
+/**
+ * Create a tool permission adapter for the given provider.
+ */
+export declare function createToolPermissionAdapter(provider: AgentProviderName): ToolPermissionAdapter;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/src/templates/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../../src/templates/adapters.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IACvE,oBAAoB,CAAC,WAAW,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE;IAI7D,OAAO,CAAC,YAAY;CAwBrB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,0BAA2B,YAAW,qBAAqB;IACtE,oBAAoB,CAAC,WAAW,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE;IAI7D,OAAO,CAAC,YAAY;CAWrB;AAED;;;;;;;GAOG;AACH,qBAAa,6BAA8B,YAAW,qBAAqB;IACzE,oBAAoB,CAAC,WAAW,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE;IAI7D,OAAO,CAAC,YAAY;CAWrB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,qBAAqB,CAa9F"}

package/dist/src/templates/adapters.js

@@ -0,0 +1,104 @@
+/**
+ * Tool Permission Adapters
+ *
+ * Translate abstract tool permissions to provider-native format.
+ */
+/**
+ * Claude Code tool permission adapter.
+ *
+ * Translates abstract permissions to Claude Code's format:
+ *   { shell: "pnpm *" }  → "Bash(pnpm:*)"
+ *   { shell: "git commit *" } → "Bash(git commit:*)"
+ *   "user-input" → "AskUserQuestion"
+ */
+export class ClaudeToolPermissionAdapter {
+    translatePermissions(permissions) {
+        return permissions.map(p => this.translateOne(p));
+    }
+    translateOne(permission) {
+        if (typeof permission === 'string') {
+            if (permission === 'user-input') {
+                return 'AskUserQuestion';
+            }
+            // Pass through other string permissions as-is
+            return permission;
+        }
+        if ('shell' in permission) {
+            // Convert "pnpm *" → "Bash(pnpm:*)"
+            // Convert "git commit *" → "Bash(git commit:*)"
+            const pattern = permission.shell;
+            const spaceIndex = pattern.lastIndexOf(' ');
+            if (spaceIndex === -1) {
+                return `Bash(${pattern}:*)`;
+            }
+            const command = pattern.substring(0, spaceIndex);
+            const glob = pattern.substring(spaceIndex + 1);
+            return `Bash(${command}:${glob})`;
+        }
+        return String(permission);
+    }
+}
+/**
+ * OpenAI Codex tool permission adapter.
+ *
+ * Codex uses sandbox policies (--full-auto / workspace-write / read-only)
+ * and TOML-based sandbox_permissions rather than per-tool allowlists.
+ * Shell permissions are passed through as command patterns for documentation
+ * and future granular support.
+ *
+ *   { shell: "pnpm *" }  → "shell:pnpm *"
+ *   "user-input" → "user-input" (no-op — Codex exec is non-interactive)
+ */
+export class CodexToolPermissionAdapter {
+    translatePermissions(permissions) {
+        return permissions.map(p => this.translateOne(p));
+    }
+    translateOne(permission) {
+        if (typeof permission === 'string') {
+            return permission;
+        }
+        if ('shell' in permission) {
+            return `shell:${permission.shell}`;
+        }
+        return String(permission);
+    }
+}
+/**
+ * Spring AI tool permission adapter.
+ *
+ * Spring AI uses @Tool annotations and ToolCallAdvisor for tool configuration.
+ * Shell permissions map to Spring AI's tool-call allowlist format:
+ *   { shell: "pnpm *" }  → "spring-tool:shell:pnpm *"
+ *   "user-input" → "user-input" (no-op — Spring AI agent is non-interactive)
+ */
+export class SpringAiToolPermissionAdapter {
+    translatePermissions(permissions) {
+        return permissions.map(p => this.translateOne(p));
+    }
+    translateOne(permission) {
+        if (typeof permission === 'string') {
+            return permission;
+        }
+        if ('shell' in permission) {
+            return `spring-tool:shell:${permission.shell}`;
+        }
+        return String(permission);
+    }
+}
+/**
+ * Create a tool permission adapter for the given provider.
+ */
+export function createToolPermissionAdapter(provider) {
+    switch (provider) {
+        case 'claude':
+            return new ClaudeToolPermissionAdapter();
+        case 'codex':
+            return new CodexToolPermissionAdapter();
+        case 'amp':
+            return new ClaudeToolPermissionAdapter();
+        case 'spring-ai':
+            return new SpringAiToolPermissionAdapter();
+        default:
+            return new ClaudeToolPermissionAdapter();
+    }
+}

package/dist/src/templates/adapters.test.d.ts

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

package/dist/src/templates/adapters.test.d.ts.map

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