vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,224 @@
+import { EventEmitter } from 'events';
+import { Task, WorktreeInfo, AgentExecution, VibingPhase, QualityResults } from '../types/index.js';
+import { TaskService } from '../tasks/task-service.js';
+import { WorktreeService } from '../vcs/worktree-service.js';
+import { RoutingPolicyManager, type ResolvedProvider } from './routing-policy.js';
+export interface AgentExecutionUpdate {
+    executionId: string;
+    status: AgentExecution['status'];
+    logs: string[];
+    error?: string;
+}
+export declare class AgentService extends EventEmitter {
+    private taskService;
+    private projectRoot;
+    private executionRegistry;
+    private worktreeService;
+    private logPersistence;
+    private coreAgentService;
+    private promptService;
+    private initialized;
+    private routingPolicyManager;
+    private genericStates;
+    private readonly defaultTools;
+    private readonly systemPrompts;
+    constructor(taskService: TaskService, projectRoot?: string, worktreeService?: WorktreeService);
+    /**
+     * Start a generic execution that is not backed by an AI provider.
+     * This enables persistent logs and status queries via existing APIs.
+     */
+    startGenericExecution(taskId: string, options?: {
+        workflowId?: string;
+        workingDirectory?: string;
+    }): Promise<string>;
+    /** Append a log line to a generic execution and notify listeners (best-effort). */
+    logGenericExecution(executionId: string, message: string, level?: 'info' | 'warn' | 'error', data?: Record<string, unknown>): Promise<void>;
+    /** Mark a generic execution as completed/failed/cancelled and notify listeners. */
+    completeGenericExecution(executionId: string, status: AgentExecution['status'], error?: string): Promise<void>;
+    private getAgentConfig;
+    private initialize;
+    private setupEventForwarding;
+    /**
+     * Map core agent update to legacy format
+     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
+     */
+    private mapToLegacyUpdate;
+    /**
+     * Create a concise, human-readable line from a structured execution message
+     */
+    private summarizeMessage;
+    /**
+     * Initialize worktree manager
+     */
+    private initializeWorktrees;
+    /**
+     * Execute a task using AI in an isolated worktree
+     */
+    executeTask(taskId: string, workflowId?: string, options?: {
+        rerunContext?: {
+            reason: string;
+            previousExecutionId?: string;
+            failurePhase?: VibingPhase;
+            qualityResults?: QualityResults;
+            lastLogs?: string[];
+            attempt?: number;
+        };
+        providerOverride?: Partial<ResolvedProvider>;
+        workflowConfig?: import('../types/index.js').VibingConfig;
+    }): Promise<string>;
+    /**
+     * Build an appended system prompt with rerun context (reason, logs, failed checks)
+     */
+    private buildRerunSystemPrompt;
+    /**
+     * Stop a running execution and cleanup worktree
+     */
+    stopExecution(executionId: string): Promise<void>;
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId: string): AgentExecution | null;
+    /**
+     * Get execution logs
+     */
+    getExecutionLogs(executionId: string): string[];
+    /**
+     * Get all executions for a task
+     */
+    getTaskExecutions(taskId: string): AgentExecution[];
+    /**
+     * Improve task content using AI
+     */
+    improveTaskContent(task: Task, taskData: {
+        title: string;
+        type: string;
+        priority: string;
+        content: string;
+    }, executionId?: string): Promise<{
+        type: string;
+        priority: string;
+        content: string;
+        title?: string;
+        executionId: string;
+        selectedModel?: string;
+    }>;
+    /**
+     * Perform AI code review of changes in a worktree
+     */
+    aiReviewCode(taskId: string, reviewContext?: string, options?: {
+        overrides?: Partial<ResolvedProvider>;
+        executionId?: string;
+        workflowId?: string;
+    }): Promise<{
+        executionId: string;
+        reviewSummary: string;
+        recommendations: string[];
+        qualityScore: number;
+    }>;
+    /**
+     * Perform AI-assisted merge of a task's worktree into the base project
+     */
+    aiMerge(taskId: string, options?: {
+        baseBranch?: string;
+        overrides?: Partial<ResolvedProvider>;
+        executionId?: string;
+        workflowId?: string;
+    }): Promise<{
+        executionId: string;
+    }>;
+    /**
+     * Get persistent execution logs
+     */
+    getPersistedExecutionLogs(executionId: string): Promise<{
+        metadata: any;
+        logs: any[];
+    }>;
+    /**
+     * List all execution metadata from persistence
+     */
+    listAllExecutions(): Promise<any[]>;
+    /**
+     * Clean up old execution logs
+     */
+    cleanupOldExecutionLogs(maxAgeDays?: number): Promise<number>;
+    /**
+     * Remove execution logs for a specific task
+     */
+    removeExecutionLogsByTask(taskId: string): Promise<number>;
+    /**
+     * Get execution log statistics
+     */
+    getExecutionLogStats(): Promise<{
+        total: number;
+        byStatus: Record<string, number>;
+        totalLogFiles: number;
+        oldestExecution?: string;
+        newestExecution?: string;
+    }>;
+    /**
+     * Get statistics about executions
+     */
+    getExecutionStats(): {
+        total: number;
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        worktrees: {
+            active: number;
+            total: number;
+            enabled: boolean;
+        };
+    };
+    /**
+     * Get worktree service instance
+     */
+    getWorktreeService(): WorktreeService;
+    /**
+     * Get worktree information for a task
+     */
+    getWorktreeInfo(taskId: string): WorktreeInfo | null;
+    /**
+     * Get core agent service metrics
+     */
+    getCoreMetrics(): {
+        totalExecutions: number;
+        activeExecutions: number;
+        completedExecutions: number;
+        failedExecutions: number;
+        cancelledExecutions: number;
+    };
+    /**
+     * Get available AI providers
+     */
+    getAvailableProviders(): Map<string, import("./ai-providers/types.js").AIProvider>;
+    /**
+     * Validate provider setup
+     */
+    validateProviders(): Promise<Map<string, import("./ai-providers/types.js").ProviderStatus>>;
+    /**
+     * Get available models from all providers
+     */
+    getAvailableModels(): Promise<import("./ai-providers/types.js").ModelInfo[]>;
+    /**
+     * Parse improvement result from AI response
+     */
+    private parseImprovementResult;
+    /**
+     * Parse review result from AI response
+     */
+    private parseReviewResult;
+    /**
+     * Resolve provider for specific operation with failover support
+     */
+    private resolveProviderForOperation;
+    /**
+     * Execute with provider resolution and failover
+     */
+    private executeWithRouting;
+    /**
+     * Get routing policy manager (for tRPC router access)
+     */
+    getRoutingPolicyManager(): RoutingPolicyManager;
+}