vibeman 0.0.3 → 0.0.6

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

@@ -1,318 +0,0 @@
-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;
-}