codecrucible-synth/dist/core/agent.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Unified Agent System
 * Consolidates: enhanced-agentic-client.ts, simple-agent.ts, complex-agent.ts,
 *              agentic-system.ts, agent-manager.ts, agent-orchestrator.ts
 * Created: 2024-12-19 | Purpose: Single agent system with all capabilities
 */
import { EventEmitter } from 'events';
import { UnifiedModelClient } from '../refactor/unified-model-client.js';
import { AgentConfig } from '../config/config-manager.js';
export type { AgentConfig };
import { PerformanceMonitor } from '../utils/performance.js';
import { ExecutionRequest, ExecutionResponse, Task, Workflow, ProjectContext, ExecutionResult } from './types.js';
export { ExecutionResult };
export interface AgentCapability {
    name: string;
    description: string;
    handler: (task: Task) => Promise<ExecutionResult>;
    priority: number;
    enabled: boolean;
}
export interface AgentMetrics {
    tasksCompleted: number;
    averageExecutionTime: number;
    successRate: number;
    errorCount: number;
    lastExecutionTime: number;
}
export declare class UnifiedAgent extends EventEmitter {
    private agent;
    private modelClient;
    private performanceMonitor;
    private config;
    private capabilities;
    private activeWorkflows;
    private metrics;
    private executionQueue;
    constructor(modelClient: UnifiedModelClient, performanceMonitor: PerformanceMonitor);
    /**
     * Initialize agent capabilities
     */
    private initializeCapabilities;
    /**
     * Load configuration
     */
    private loadConfig;
    /**
     * Register a new capability
     */
    registerCapability(capability: AgentCapability): void;
    /**
     * Execute agent request with intelligent routing
     */
    execute(request: ExecutionRequest, _context?: ProjectContext): Promise<ExecutionResponse>;
    /**
     * Create execution plan based on request
     */
    private createExecutionPlan;
    /**
     * Execute workflow tasks
     */
    private executeWorkflow;
    /**
     * Execute individual task
     */
    private executeTask;
    /**
     * Utility methods
     */
    private generateWorkflowId;
    private generateTaskId;
    private isSimpleQuery;
    private determineRequestType;
    private getValidCapability;
    private _getProjectStructure;
    private chunkArray;
    private updateMetrics;
    /**
     * Get agent metrics
     */
    getMetrics(): AgentMetrics;
    /**
     * Clean up agent resources
     */
    destroy(): Promise<void>;
    /**
     * Get active workflows
     */
    getActiveWorkflows(): Workflow[];
    /**
     * Get available capabilities
     */
    getCapabilities(): AgentCapability[];
    /**
     * Enable/disable capability
     */
    setCapabilityEnabled(name: string, enabled: boolean): void;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<AgentConfig>): Promise<void>;
}
export declare const timeoutManager: {
    executeWithRetry<T>(fn: () => Promise<T>, retries?: number): Promise<T>;
};
interface EditSummary {
    total: number;
    approved: number;
    rejected: number;
}
interface EditConfirmationResult {
    approved: boolean;
    edits: unknown;
}
interface EditApplicationResult {
    success: boolean;
    edits: unknown;
}
interface ConfirmationResult {
    approved: unknown[];
    rejected: unknown[];
}
export declare const globalEditConfirmation: {
    getPendingEditsCount: () => number;
    proposeEdits: (edits: unknown) => Promise<EditConfirmationResult>;
    confirmAllEdits: () => Promise<ConfirmationResult>;
    applyEdits: (edits: unknown) => Promise<EditApplicationResult>;
    clearPendingEdits: () => void;
    generateEditSummary: () => EditSummary;
    displayEditSummary: () => void;
};
interface IndexResult {
    indexed: boolean;
    path: string;
}
export declare const globalRAGSystem: {
    indexPath: (path: string) => Promise<IndexResult>;
};
export declare const registerShutdownHandler: (handler: () => void) => void;
export declare const createManagedInterval: (fn: () => void, interval: number) => NodeJS.Timeout;
export declare const clearManagedInterval: (id: NodeJS.Timeout) => void;
export declare const initializeEditConfirmation: () => {
    getPendingEditsCount: () => number;
    proposeEdits: (edits: unknown) => Promise<EditConfirmationResult>;
    confirmAllEdits: () => Promise<ConfirmationResult>;
    applyEdits: (edits: unknown) => Promise<EditApplicationResult>;
    clearPendingEdits: () => void;
    generateEditSummary: () => EditSummary;
    displayEditSummary: () => void;
};
export declare const createUnifiedModelClient: (config: Record<string, unknown>) => UnifiedModelClient;
export interface AgentContext {
    modelClient: UnifiedModelClient;
    workingDirectory: string;
    config: AgentConfig;
}
//# sourceMappingURL=agent.d.ts.map