vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/agent/core-agent-service.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Core Agent Service - Pure AI Execution Engine
+ * Provider-agnostic AI execution service
+ */
+import { EventEmitter } from 'events';
+import { AIProvider, ExecutionOptions, ExecutionMessage, ModelInfo, ProviderStatus } from './ai-providers/index.js';
+/**
+ * Execution state tracking
+ */
+export interface ExecutionState {
+    id: string;
+    provider: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    startTime: string;
+    endTime?: string;
+    error?: string;
+    messages: ExecutionMessage[];
+    result?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost?: number;
+    };
+    abortController?: AbortController;
+}
+/**
+ * Execution request
+ */
+export interface ExecutionRequest {
+    prompt: string;
+    options?: ExecutionOptions;
+    provider?: string;
+    metadata?: Record<string, any>;
+    executionId?: string;
+}
+/**
+ * Execution update event
+ */
+export interface ExecutionUpdate {
+    executionId: string;
+    status: ExecutionState['status'];
+    message?: ExecutionMessage;
+    error?: string;
+}
+/**
+ * Agent Service Configuration
+ */
+export interface AgentServiceConfig {
+    defaultProvider?: string;
+    executionTimeout?: number;
+}
+/**
+ * Pure AI Execution Service
+ * Manages AI providers and executions without business logic
+ */
+export declare class CoreAgentService extends EventEmitter {
+    private providers;
+    private defaultProvider;
+    private executions;
+    private config;
+    constructor(config?: AgentServiceConfig);
+    /**
+     * Register an AI provider
+     */
+    registerProvider(name: string, provider: AIProvider): void;
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name: string): void;
+    /**
+     * Get default provider name
+     */
+    getDefaultProvider(): string | null;
+    /**
+     * Get provider by name
+     */
+    getProvider(name: string): AIProvider | null;
+    /**
+     * Get all registered providers
+     */
+    getProviders(): Map<string, AIProvider>;
+    /**
+     * Execute a prompt with streaming
+     */
+    execute(request: ExecutionRequest): Promise<string>;
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId: string): ExecutionState | null;
+    /**
+     * Get execution messages
+     */
+    getExecutionMessages(executionId: string): ExecutionMessage[];
+    /**
+     * Stop an execution
+     */
+    stopExecution(executionId: string): Promise<void>;
+    /**
+     * Get all executions
+     */
+    getAllExecutions(): ExecutionState[];
+    /**
+     * Clear completed executions
+     */
+    clearCompletedExecutions(): number;
+    /**
+     * Validate all providers
+     */
+    validateProviders(): Promise<Map<string, ProviderStatus>>;
+    /**
+     * Get available models from all providers
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Generate execution ID
+     */
+    private generateExecutionId;
+}

package/dist/runtime/api/agent/core-agent-service.js

@@ -0,0 +1,267 @@
+/**
+ * Core Agent Service - Pure AI Execution Engine
+ * Provider-agnostic AI execution service
+ */
+import { EventEmitter } from 'events';
+import { log } from '../lib/logger.js';
+import { generateId } from '../lib/id-generator.js';
+/**
+ * Pure AI Execution Service
+ * Manages AI providers and executions without business logic
+ */
+export class CoreAgentService extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.providers = new Map();
+        this.defaultProvider = null;
+        this.executions = new Map();
+        this.config = {
+            executionTimeout: config.executionTimeout || 30 * 60 * 1000, // 30 minutes
+            ...config,
+        };
+    }
+    /**
+     * Register an AI provider
+     */
+    registerProvider(name, provider) {
+        this.providers.set(name, provider);
+        log.debug(`Registered AI provider: ${name}`, undefined, 'core-agent-service');
+        // Set as default if it's the first provider or matches config
+        if (!this.defaultProvider || name === this.config.defaultProvider) {
+            this.defaultProvider = name;
+            log.debug(`Set default provider: ${name}`, undefined, 'core-agent-service');
+        }
+    }
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name) {
+        if (!this.providers.has(name)) {
+            throw new Error(`Provider ${name} not registered`);
+        }
+        this.defaultProvider = name;
+        log.debug(`Changed default provider to: ${name}`, undefined, 'core-agent-service');
+    }
+    /**
+     * Get default provider name
+     */
+    getDefaultProvider() {
+        return this.defaultProvider;
+    }
+    /**
+     * Get provider by name
+     */
+    getProvider(name) {
+        return this.providers.get(name) || null;
+    }
+    /**
+     * Get all registered providers
+     */
+    getProviders() {
+        return new Map(this.providers);
+    }
+    /**
+     * Execute a prompt with streaming
+     */
+    async execute(request) {
+        // Determine which provider to use
+        const providerName = request.provider || this.defaultProvider;
+        if (!providerName) {
+            throw new Error('No provider specified and no default provider set');
+        }
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            throw new Error(`Provider ${providerName} not found`);
+        }
+        const executionId = request.executionId || this.generateExecutionId();
+        const abortController = new AbortController();
+        // Set timeout
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, this.config.executionTimeout);
+        const execution = {
+            id: executionId,
+            provider: provider.name,
+            status: 'pending',
+            startTime: new Date().toISOString(),
+            messages: [],
+            abortController,
+        };
+        this.executions.set(executionId, execution);
+        // Emit execution created event
+        this.emit('executionCreated', { executionId, provider: execution.provider });
+        try {
+            execution.status = 'running';
+            this.emit('executionStarted', { executionId });
+            const options = {
+                ...request.options,
+                abortSignal: abortController.signal,
+            };
+            let result = '';
+            const messages = [];
+            // Execute with streaming
+            for await (const message of provider.execute(request.prompt, options)) {
+                execution.messages.push(message);
+                // Emit message events
+                this.emit('executionMessage', {
+                    executionId,
+                    message,
+                });
+                // Collect assistant messages
+                if (message.type === 'assistant') {
+                    const content = message.content;
+                    messages.push(content);
+                    // Emit update for UI streaming
+                    this.emit('executionUpdate', {
+                        executionId,
+                        status: execution.status,
+                        message,
+                    });
+                }
+                // Handle result
+                if (message.type === 'result') {
+                    const resultMsg = message;
+                    if (resultMsg.success) {
+                        result = resultMsg.result || messages.join('\n');
+                        execution.result = result;
+                        execution.usage = resultMsg.usage;
+                    }
+                    else {
+                        throw new Error(resultMsg.error || 'Execution failed');
+                    }
+                }
+            }
+            // Mark as completed
+            execution.status = 'completed';
+            execution.endTime = new Date().toISOString();
+            clearTimeout(timeoutId);
+            // Emit completion event
+            this.emit('executionCompleted', {
+                executionId,
+                result,
+                usage: execution.usage,
+            });
+            return result;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Handle cancellation
+            if (abortController.signal.aborted) {
+                execution.status = 'cancelled';
+                execution.error = 'Execution cancelled';
+                this.emit('executionCancelled', { executionId });
+            }
+            else {
+                execution.status = 'failed';
+                execution.error = error instanceof Error ? error.message : String(error);
+                this.emit('executionFailed', {
+                    executionId,
+                    error: execution.error,
+                });
+            }
+            execution.endTime = new Date().toISOString();
+            throw error;
+        }
+    }
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId) {
+        const execution = this.executions.get(executionId);
+        if (!execution)
+            return null;
+        // Return copy without internal fields
+        const { abortController, ...publicState } = execution;
+        return publicState;
+    }
+    /**
+     * Get execution messages
+     */
+    getExecutionMessages(executionId) {
+        const execution = this.executions.get(executionId);
+        return execution ? [...execution.messages] : [];
+    }
+    /**
+     * Stop an execution
+     */
+    async stopExecution(executionId) {
+        const execution = this.executions.get(executionId);
+        if (!execution) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        if (execution.status !== 'running') {
+            throw new Error(`Execution ${executionId} is not running`);
+        }
+        if (execution.abortController) {
+            execution.abortController.abort();
+            execution.status = 'cancelled';
+            execution.endTime = new Date().toISOString();
+            this.emit('executionCancelled', { executionId });
+        }
+    }
+    /**
+     * Get all executions
+     */
+    getAllExecutions() {
+        return Array.from(this.executions.values()).map((e) => {
+            const { abortController, ...publicState } = e;
+            return publicState;
+        });
+    }
+    /**
+     * Clear completed executions
+     */
+    clearCompletedExecutions() {
+        let cleared = 0;
+        for (const [id, execution] of this.executions) {
+            if (['completed', 'failed', 'cancelled'].includes(execution.status)) {
+                this.executions.delete(id);
+                cleared++;
+            }
+        }
+        return cleared;
+    }
+    /**
+     * Validate all providers
+     */
+    async validateProviders() {
+        const results = new Map();
+        for (const [name, provider] of this.providers) {
+            try {
+                const status = await provider.validateSetup();
+                results.set(name, status);
+            }
+            catch (error) {
+                results.set(name, {
+                    available: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    models: [],
+                    capabilities: provider.getCapabilities(),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get available models from all providers
+     */
+    async getAvailableModels() {
+        const models = [];
+        for (const [name, provider] of this.providers) {
+            try {
+                const providerModels = await provider.detectAvailableModels();
+                models.push(...providerModels);
+            }
+            catch (error) {
+                log.warn(`Failed to get models from provider ${name}`, error, 'core-agent-service');
+            }
+        }
+        return models;
+    }
+    /**
+     * Generate execution ID
+     */
+    generateExecutionId() {
+        return generateId('exec');
+    }
+}

package/dist/runtime/api/agent/parsers.d.ts

@@ -0,0 +1,16 @@
+export declare function parseImprovementResult(result: string, originalData: {
+    title: string;
+    type: string;
+    priority: string;
+    content: string;
+}): {
+    type: string;
+    priority: string;
+    content: string;
+    title?: string;
+};
+export declare function parseReviewResult(result: string): {
+    reviewSummary: string;
+    recommendations: string[];
+    qualityScore: number;
+};