@holoscript/framework 6.0.3 → 6.0.4

package/dist/implementations-D9T3un9D.d.ts

@@ -1,236 +0,0 @@
-/**
- * Protocol Implementations
- *
- * Canonical home for BaseAgent, BaseService, GoalSynthesizer, MicroPhaseDecomposer.
- * These were absorbed from @holoscript/agent-protocol which now keeps only specs/interfaces.
- */
-declare enum ProtocolPhase {
-    INTAKE = 0,
-    REFLECT = 1,
-    EXECUTE = 2,
-    COMPRESS = 3,
-    REINTAKE = 4,
-    GROW = 5,
-    EVOLVE = 6,
-    AUTONOMIZE = 7
-}
-interface PhaseResult {
-    phase: ProtocolPhase;
-    status: 'success' | 'failure' | 'skipped';
-    data: unknown;
-    durationMs: number;
-    timestamp: number;
-}
-interface AgentIdentity {
-    id: string;
-    name: string;
-    domain: string;
-    version: string;
-    capabilities: string[];
-}
-interface ProtocolCycleResult {
-    cycleId: string;
-    task: string;
-    domain: string;
-    phases: PhaseResult[];
-    status: 'complete' | 'partial' | 'failed';
-    totalDurationMs: number;
-    startedAt: number;
-    completedAt: number;
-}
-interface Goal {
-    id: string;
-    description: string;
-    category: string;
-    priority: 'low' | 'medium' | 'high';
-    estimatedComplexity: number;
-    generatedAt: string;
-    source: 'autonomous-boredom' | 'user-instruction' | 'system-mandate';
-}
-interface MicroPhaseTask {
-    id: string;
-    name: string;
-    estimatedDuration: number;
-    dependencies: string[];
-    execute: () => Promise<unknown>;
-    priority?: number;
-    timeout?: number;
-    retryCount?: number;
-}
-interface MicroPhaseGroup {
-    id: string;
-    name: string;
-    tasks: MicroPhaseTask[];
-    parallel: boolean;
-    estimatedDuration: number;
-}
-interface ExecutionPlan {
-    groups: MicroPhaseGroup[];
-    totalEstimatedTime: number;
-    parallelizationRatio: number;
-}
-interface ExecutionResult {
-    taskId: string;
-    status: 'success' | 'failure' | 'timeout' | 'skipped';
-    duration: number;
-    result?: unknown;
-    error?: Error;
-    timestamp: number;
-}
-interface ServiceMetadata {
-    name: string;
-    version: string;
-    description: string;
-    dependencies?: string[];
-    lifecycle: string;
-    initializedAt?: Date;
-    readyAt?: Date;
-}
-interface ServiceMetrics {
-    requestCount: number;
-    errorCount: number;
-    latency: {
-        p50: number;
-        p95: number;
-        p99: number;
-    };
-    lastRequestAt?: Date;
-    lastErrorAt?: Date;
-}
-interface ServiceConfig {
-    enabled: boolean;
-    timeout: number;
-    retries: number;
-    [key: string]: unknown;
-}
-type PWGSeverity = 'low' | 'medium' | 'high' | 'critical';
-interface Pattern {
-    id: string;
-    domain: string;
-    problem: string;
-    solution: string;
-    context?: string;
-    tags: string[];
-    confidence: number;
-    createdAt: number;
-    updatedAt: number;
-}
-interface Wisdom {
-    id: string;
-    domain: string;
-    insight: string;
-    context: string;
-    source: string;
-    tags: string[];
-    createdAt: number;
-}
-interface Gotcha {
-    id: string;
-    domain: string;
-    mistake: string;
-    fix: string;
-    severity: PWGSeverity;
-    tags: string[];
-    createdAt: number;
-}
-type PWGEntry = Pattern | Wisdom | Gotcha;
-declare function isPattern(entry: PWGEntry): entry is Pattern;
-declare function isWisdom(entry: PWGEntry): entry is Wisdom;
-declare function isGotcha(entry: PWGEntry): entry is Gotcha;
-declare abstract class BaseAgent {
-    abstract readonly identity: AgentIdentity;
-    /** Phase 0: Gather data and context */
-    abstract intake(input: unknown): Promise<PhaseResult>;
-    /** Phase 1: Analyze and understand */
-    abstract reflect(data: unknown): Promise<PhaseResult>;
-    /** Phase 2: Take action */
-    abstract execute(plan: unknown): Promise<PhaseResult>;
-    /** Phase 3: Store knowledge efficiently */
-    abstract compress(results: unknown): Promise<PhaseResult>;
-    /** Phase 4: Re-evaluate with compressed knowledge */
-    abstract reintake(compressed: unknown): Promise<PhaseResult>;
-    /** Phase 5: Learn patterns, wisdom, gotchas */
-    abstract grow(learnings: unknown): Promise<PhaseResult>;
-    /** Phase 6: Adapt and optimize */
-    abstract evolve(adaptations: unknown): Promise<PhaseResult>;
-    /**
-     * Execute a complete 7-phase cycle
-     */
-    runCycle(task: string, context?: Record<string, unknown>): Promise<ProtocolCycleResult>;
-}
-declare enum ServiceLifecycle {
-    INITIALIZING = "initializing",
-    READY = "ready",
-    DEGRADED = "degraded",
-    STOPPING = "stopping",
-    STOPPED = "stopped",
-    ERROR = "error"
-}
-declare enum ServiceErrorCode {
-    VALIDATION_ERROR = "VALIDATION_ERROR",
-    NOT_FOUND = "NOT_FOUND",
-    CONFLICT = "CONFLICT",
-    RATE_LIMIT = "RATE_LIMIT",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
-}
-declare class ServiceError extends Error {
-    code: ServiceErrorCode;
-    statusCode: number;
-    details?: Record<string, unknown> | undefined;
-    constructor(code: ServiceErrorCode, message: string, statusCode?: number, details?: Record<string, unknown> | undefined);
-}
-declare abstract class BaseService {
-    protected metadata: ServiceMetadata;
-    protected config: ServiceConfig;
-    protected metrics: ServiceMetrics;
-    constructor(metadata: Omit<ServiceMetadata, 'lifecycle' | 'initializedAt' | 'readyAt'>, config?: Partial<ServiceConfig>);
-    initialize(): Promise<void>;
-    stop(): Promise<void>;
-    getMetadata(): ServiceMetadata;
-    getMetrics(): ServiceMetrics;
-    isReady(): boolean;
-    protected recordRequest(latency: number): void;
-    protected recordError(_error: Error): void;
-    protected executeWithMetrics<T>(op: () => Promise<T>): Promise<T>;
-    protected onInit(): Promise<void>;
-    protected onReady(): Promise<void>;
-    protected onStop(): Promise<void>;
-}
-declare class ServiceManager {
-    private services;
-    private started;
-    register(service: BaseService): void;
-    get size(): number;
-    startAll(): Promise<void>;
-    stopAll(): Promise<void>;
-    health(): ServiceManagerHealth;
-}
-/** Health status of a single service */
-interface ServiceHealth {
-    name: string;
-    ready: boolean;
-    lifecycle: string;
-}
-/** Aggregate health status from ServiceManager */
-interface ServiceManagerHealth {
-    totalServices: number;
-    readyCount: number;
-    allReady: boolean;
-    services: ServiceHealth[];
-}
-
-declare class MicroPhaseDecomposer {
-    private nodes;
-    private edges;
-    private reverseEdges;
-    private history;
-    registerTask(task: MicroPhaseTask): void;
-    createExecutionPlan(): ExecutionPlan;
-    executePlan(plan: ExecutionPlan): Promise<ExecutionResult[]>;
-    getHistory(): ExecutionResult[];
-    reset(): void;
-    private topologicalSort;
-}
-
-export { type AgentIdentity as A, BaseAgent as B, type ExecutionPlan as E, type Goal as G, MicroPhaseDecomposer as M, type PhaseResult as P, type ServiceConfig as S, type Wisdom as W, ProtocolPhase as a, type ProtocolCycleResult as b, BaseService as c, type ExecutionResult as d, type Gotcha as e, type MicroPhaseGroup as f, type MicroPhaseTask as g, type PWGEntry as h, type PWGSeverity as i, type Pattern as j, ServiceError as k, ServiceErrorCode as l, type ServiceHealth as m, ServiceLifecycle as n, ServiceManager as o, type ServiceManagerHealth as p, type ServiceMetadata as q, type ServiceMetrics as r, isGotcha as s, isPattern as t, isWisdom as u };