vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/workflows/vibing-orchestrator.d.ts

@@ -0,0 +1,318 @@
+import { EventEmitter } from 'events';
+import type { VibingExecution, VibingPhase, VibingConfig } from '../types/index.js';
+import { TaskService } from '../tasks/task-service.js';
+import { AgentService } from '../agent/agent-service.js';
+import { WorktreeService } from '../vcs/worktree-service.js';
+import { GitService } from '../vcs/git-service.js';
+import type { ResolvedProvider } from '../agent/routing-policy.js';
+export declare class VibingOrchestrator extends EventEmitter {
+    private taskService;
+    private agentService;
+    private worktreeService;
+    private config;
+    private gitService?;
+    private workflows;
+    private qualityPipeline;
+    private workflowDB;
+    private initialized;
+    private computeVisibleTimeline;
+    private buildTimeline;
+    constructor(taskService: TaskService, agentService: AgentService, worktreeService: WorktreeService, config: VibingConfig, gitService?: GitService | undefined, persistenceDataDir?: string);
+    /**
+     * Initialize workflow orchestrator by loading existing workflows
+     * Call this after construction to load persisted workflows
+     */
+    initialize(): Promise<void>;
+    private normalizeWorkflow;
+    /**
+     * Execute a task once (no phase management). Optionally associates with a workflow.
+     */
+    executeTask(taskId: string, workflowId?: string): Promise<{
+        executionId: string;
+    }>;
+    stopExecution(executionId: string): Promise<void>;
+    getExecutionStatus(executionId: string): import("../types/index.js").AgentExecution | null;
+    getPersistedExecutionLogs(executionId: string): Promise<{
+        metadata: any;
+        logs: any[];
+    }>;
+    getExecutionLogs(executionId: string): string[];
+    getTaskExecutions(taskId: string): import("../types/index.js").AgentExecution[];
+    getExecutionStats(): {
+        total: number;
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        worktrees: {
+            active: number;
+            total: number;
+            enabled: boolean;
+        };
+    };
+    listAllExecutions(): Promise<any[]>;
+    improveTaskContent(taskId: string, data: {
+        title: string;
+        type: string;
+        priority: string;
+        content: string;
+    }, options?: {
+        executionId?: string;
+        workflowId?: string;
+    }): Promise<{
+        type: string;
+        priority: string;
+        content: string;
+        title?: string;
+        executionId: string;
+        selectedModel?: string;
+    }>;
+    aiReviewCode(taskId: string, reviewContext?: string, options?: {
+        workflowId?: string;
+        overrides?: Partial<ResolvedProvider>;
+        executionId?: string;
+    }): Promise<{
+        executionId: string;
+        reviewSummary: string;
+        recommendations: string[];
+        qualityScore: number;
+    }>;
+    aiMerge(taskId: string, options?: {
+        baseBranch?: string;
+        workflowId?: string;
+        provider?: string;
+        model?: string;
+        executionId?: string;
+    }): Promise<{
+        executionId: string;
+    }>;
+    listWorktrees(): Promise<(import("../types/index.js").WorktreeInfo & {
+        isConnectedToTask: boolean;
+    })[]>;
+    syncWorktreeState(): Promise<void>;
+    getWorktreeInfo(taskId: string): any;
+    createWorktree(taskId: string): Promise<any>;
+    deleteWorktree(taskId: string, force?: boolean): Promise<void>;
+    cleanupWorktree(params: {
+        taskId?: string;
+        worktreePath?: string;
+        branchName?: string;
+        isConnectedToTask: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    createPullRequest(taskId: string, baseBranch?: string): Promise<{
+        success: boolean;
+        pullRequest?: any;
+        error?: string;
+    }>;
+    openInEditor(worktreePath: string): Promise<{
+        readonly success: true;
+    }>;
+    openInTerminal(worktreePath: string): Promise<{
+        readonly success: true;
+    }>;
+    checkWorktreeStatus(workflowId: string): Promise<{
+        clean: boolean;
+        uncommittedFiles: string[];
+        worktreePath?: string;
+    }>;
+    approveAndContinueReview(workflowId: string): Promise<void>;
+    /**
+     * Mark workflow as completed by human decision.
+     * Does not perform merge/cleanup; simply finalizes the workflow and emits completion.
+     */
+    markWorkflowCompleted(workflowId: string): Promise<void>;
+    ensureInitialized(): Promise<void>;
+    /**
+     * Start AI-assisted workflow for a task
+     */
+    startWorkflow(taskId: string, customConfig?: Partial<VibingConfig>): Promise<string>;
+    /**
+     * Pause a workflow execution
+     */
+    pauseWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Reset a workflow by deleting its record and optionally its worktree.
+     */
+    resetWorkflow(workflowId: string, options?: {
+        deleteWorktree?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Approve workflow changes and proceed to merge
+     */
+    approveWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Reject workflow and request changes
+     */
+    rejectWorkflow(workflowId: string, feedback: string): Promise<void>;
+    /**
+     * Get workflow status
+     */
+    getWorkflow(workflowId: string): VibingExecution | null;
+    /**
+     * Get all workflows for a task
+     */
+    getTaskWorkflows(taskId: string): VibingExecution[];
+    /**
+     * Get latest workflow for a task, preferring most recently updated.
+     * Falls back to newest startTime when lastUpdatedAt is unavailable.
+     */
+    getLatestWorkflowByTask(taskId: string): VibingExecution | null;
+    /**
+     * Transition workflow to new phase
+     */
+    private transitionToPhase;
+    /**
+     * Save workflow to persistence layer
+     */
+    private saveWorkflow;
+    /**
+     * Execute implementation phase with AI coding
+     */
+    private executeImplementation;
+    /**
+     * Public: re-run implementation phase on demand
+     * Forces phase to 'implementing' and executes implementation again.
+     */
+    rerunImplementation(workflowId: string, feedback?: string, providerOverride?: {
+        provider?: string;
+        model?: string;
+    }): Promise<void>;
+    /**
+     * Get previous phase, preferring the phase where failure occurred
+     */
+    getPreviousPhase(workflowId: string): VibingPhase | null;
+    /**
+     * Rerun the phase that led to failure (or lastPhase if available)
+     */
+    rerunPreviousPhase(workflowId: string): Promise<void>;
+    /**
+     * Rerun a specific phase programmatically
+     */
+    rerunPhase(workflowId: string, phase: VibingPhase): Promise<void>;
+    /**
+     * Reset workflow state from a given phase onward (inclusive).
+     * Clears timeline entries, execution IDs, attempts, and phase results for later phases
+     * so that a rerun behaves like a fresh run from that step.
+     */
+    private resetFromPhase;
+    /**
+     * Perform AI code review of implemented changes
+     */
+    private performAICodeReview;
+    /**
+     * Execute AI review as a dedicated phase
+     */
+    private executeAiReviewPhase;
+    private executeAwaitingReview;
+    /**
+     * Execute validation phase with quality checks
+     */
+    private executeValidation;
+    /**
+     * Public: run validation phase on demand
+     */
+    runValidation(workflowId: string): Promise<void>;
+    /**
+     * Execute merge phase
+     */
+    private executeMerge;
+    private updateCleanupStatus;
+    /**
+     * Public: run merge phase on demand
+     * This will attempt merge regardless of current phase.
+     */
+    runMerge(workflowId: string, options?: {
+        provider?: string;
+        model?: string;
+    }): Promise<void>;
+    /**
+     * Execute cleanup phase: remove worktree/branch and finalize workflow
+     */
+    private executeCleanup;
+    /**
+     * Public: run cleanup phase on demand
+     */
+    runCleanup(workflowId: string): Promise<void>;
+    /**
+     * Public: manually skip to next phase
+     */
+    skipToNextPhase(workflowId: string): Promise<void>;
+    /**
+     * Wait for an execution to complete
+     */
+    private waitForExecution;
+    /**
+     * Wait for the AgentService to emit an executionCreated event for the given task/workflow
+     */
+    private waitForExecutionCreated;
+    /**
+     * Get workflow statistics
+     */
+    getWorkflowStats(): {
+        total: number;
+        byPhase: Record<VibingPhase, number>;
+        active: number;
+        completed: number;
+        failed: number;
+    };
+    /**
+     * Get workflow persistence information
+     */
+    getWorkflowPersistenceInfo(): {
+        filePath: string;
+        workflowCount: number;
+    };
+    /**
+     * Force save all workflows to disk
+     */
+    saveAllWorkflows(): Promise<void>;
+    /**
+     * Reload workflows from disk
+     */
+    reloadWorkflows(): Promise<void>;
+    /**
+     * Remove workflows by task ID
+     */
+    removeWorkflowsByTask(taskId: string): Promise<number>;
+    /**
+     * Get comprehensive workflow statistics
+     */
+    getDetailedStats(): Promise<{
+        memoryStats: {
+            total: number;
+            byPhase: Record<VibingPhase, number>;
+            active: number;
+            completed: number;
+            failed: number;
+        };
+        persistenceStats: {
+            total: number;
+            byPhase: Record<string, number>;
+            oldestWorkflow?: string;
+            newestWorkflow?: string;
+        };
+        persistencePath: string;
+    }>;
+    /**
+     * Update workflow options without changing phase
+     */
+    updateWorkflowOptions(workflowId: string, config: Partial<VibingConfig>): Promise<void>;
+    /**
+     * Continue workflow execution from current state
+     */
+    continueWorkflow(workflowId: string): Promise<void>;
+    private computeNextActionPhase;
+    private requireWorkflow;
+    private getAIReviewThreshold;
+    private assertPhase;
+    private createNewWorkflow;
+    private maybeRetryImplementation;
+    private handlePhaseFailure;
+    /**
+     * Get the agent service instance
+     */
+    getAgentService(): AgentService;
+}