agentic-orchestrator 0.1.0

package/dist/apps/control-plane/core/kernel.d.ts

@@ -0,0 +1,445 @@
+import { SchemaRegistry } from './schemas.js';
+import { type ToolResponse } from './response.js';
+import type { RuntimeSessionsSnapshot } from './runtime-sessions.js';
+import { ToolHandlerRegistry, ToolRouter, type ToolHandlerContext } from '../application/tools/tool-router.js';
+import { type AcquireRunLeaseInput } from '../application/services/run-lease-service.js';
+import { CollisionQueueService } from '../application/services/collision-queue-service.js';
+import { type FeatureDeleteResult } from '../application/services/feature-deletion-service.js';
+type AnyRecord = Record<string, any>;
+interface KernelContext {
+    actor_type?: string;
+    actor_id?: string;
+}
+export interface AgentsRoleConfig {
+    system_prompt_path?: string;
+}
+export interface AgentsRuntimeConfig {
+    default_provider?: string;
+    default_model?: string;
+    provider_config_env?: string;
+}
+export interface AgentsConfigSnapshot {
+    version?: number;
+    roles?: Record<string, AgentsRoleConfig>;
+    missing_prompt_behavior?: 'ignore' | 'error' | string;
+    runtime?: AgentsRuntimeConfig;
+}
+interface PolicyConfigSnapshot extends AnyRecord {
+    rbac?: Record<string, string[]>;
+}
+export declare class AopKernel {
+    repoRoot: string;
+    schemaRegistry: SchemaRegistry;
+    loaded: boolean;
+    gatesConfig: AnyRecord;
+    policy: PolicyConfigSnapshot;
+    agentsConfig: AgentsConfigSnapshot;
+    toolRegistry: AnyRecord | null;
+    toolHandlers: ToolHandlerRegistry;
+    toolRouter: ToolRouter;
+    private readonly runLeaseService;
+    private readonly lockService;
+    readonly collisionQueueService: CollisionQueueService;
+    private readonly reportingService;
+    private readonly featureStateService;
+    private readonly featureLifecycleService;
+    private readonly planService;
+    private readonly patchService;
+    private readonly gateService;
+    private readonly qaIndexService;
+    private readonly mergeService;
+    private readonly featureDeletionService;
+    private readonly pathLayout;
+    constructor(repoRoot: string);
+    getRepoRoot(): string;
+    getAgentsConfig(): AgentsConfigSnapshot;
+    getRbacPolicy(): Record<string, string[]>;
+    getPolicySnapshot(): AnyRecord;
+    getGatesConfig(): AnyRecord;
+    getFeaturesDir(): string;
+    get orchestratorDir(): string;
+    get featuresDir(): string;
+    get indexPath(): string;
+    get indexLockPath(): string;
+    runLeaseTtlSeconds(): number;
+    emptyRuntimeSessions(at?: string): RuntimeSessionsSnapshot;
+    normalizeRuntimeSessions(value: unknown, at?: string): RuntimeSessionsSnapshot;
+    normalizeIndexShape(value: unknown): AnyRecord;
+    isRunLeaseFresh(runtimeSessions: RuntimeSessionsSnapshot): boolean;
+    load(): Promise<void>;
+    ensureLoaded(): Promise<void>;
+    authorize(actorType: string, toolName: string): boolean;
+    invoke(toolName: string, args?: AnyRecord, context?: KernelContext): Promise<AnyRecord>;
+    normalizeError(error: unknown): ToolResponse;
+    dispatchTool(toolName: string, args: AnyRecord, context: ToolHandlerContext): Promise<unknown>;
+    private registerToolHandlers;
+    featurePath(featureId: any): string;
+    featureLockPath(featureId: any): string;
+    statePath(featureId: any): string;
+    planPath(featureId: any): string;
+    qaIndexPath(featureId: any): string;
+    decisionsPath(featureId: any): string;
+    logsPath(featureId: any): string;
+    evidencePath(featureId: any): string;
+    specPath(featureId: any): string;
+    worktreePath(featureId: any): string;
+    ensureFeatureLayout(featureId: any): Promise<void>;
+    makeDefaultState(featureId: any, branch: any, worktreePath: any): {
+        feature_id: any;
+        version: number;
+        branch: any;
+        worktree_path: string;
+        status: "planning";
+        gate_profile: string;
+        gates: {
+            plan: "na";
+            fast: "na";
+            full: "na";
+            merge: "na";
+        };
+        locks: {
+            held: any[];
+        };
+        collisions: {
+            files: any[];
+            areas: any[];
+            contracts: any[];
+        };
+        cluster: {
+            orchestrator_session_id: string;
+            planner_session_id: string;
+            builder_session_id: string;
+            qa_session_id: string;
+        };
+        role_status: {
+            planner: "ready";
+            builder: "ready";
+            qa: "ready";
+        };
+        last_updated: string;
+    };
+    readState(featureId: string): Promise<{
+        frontMatter: AnyRecord;
+        body: string;
+        raw: string;
+    }>;
+    writeState(featureId: string, frontMatter: AnyRecord, body?: string): Promise<void>;
+    withFeatureLock<T>(featureId: string, operation: () => Promise<T>): Promise<T>;
+    withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
+    readIndex(): Promise<AnyRecord>;
+    writeIndex(index: any): Promise<void>;
+    validateSchema(schemaName: string, value: unknown): Promise<{
+        valid: boolean;
+        errors?: unknown;
+    }>;
+    getRuntimeSessions(): Promise<RuntimeSessionsSnapshot>;
+    acquireRunLease(input: AcquireRunLeaseInput): Promise<{
+        data: {
+            runtime_sessions: RuntimeSessionsSnapshot;
+            took_over_stale: boolean;
+            reused_existing_owner: boolean;
+        };
+    }>;
+    renewRunLease(runId: string, ownerInstanceId: string): Promise<{
+        data: {
+            lease_expires_at: string;
+        };
+    }>;
+    releaseRunLease(runId: string, ownerInstanceId: string): Promise<{
+        data: {
+            released: boolean;
+        };
+    }>;
+    updateOrchestratorSession(params: {
+        run_id: string;
+        owner_instance_id: string;
+        orchestrator_session_id: string;
+        increment_epoch?: boolean;
+    }): Promise<{
+        data: {
+            runtime_sessions: RuntimeSessionsSnapshot;
+        };
+    }>;
+    updateFeatureSessionAssignment(params: {
+        run_id: string;
+        owner_instance_id: string;
+        feature_id: string;
+        planner_session_id: string;
+        builder_session_id: string;
+        qa_session_id: string;
+    }): Promise<{
+        data: {
+            updated: boolean;
+        };
+    }>;
+    pruneFeatureSessionAssignments(params: {
+        run_id: string;
+        owner_instance_id: string;
+        active_feature_ids: string[];
+    }): Promise<{
+        data: {
+            removed: string[];
+        };
+    }>;
+    updateState(featureId: string, expectedVersion: number | null, updater: (frontMatter: AnyRecord, body: string) => Promise<{
+        frontMatter?: AnyRecord;
+        body?: string;
+    }>): Promise<{
+        [x: string]: any;
+    }>;
+    featureDiscoverSpecs(): Promise<{
+        data: {
+            specs: Array<{
+                feature_id: string;
+                spec_path: string;
+            }>;
+        };
+    }>;
+    featureInit(featureId: any): Promise<{
+        data: {
+            feature_id: string | null;
+            initialized: boolean;
+            worktree_path: string;
+        };
+    }>;
+    featureGetContext(featureId: any): Promise<{
+        data: {
+            feature_id: string;
+            spec: string;
+            state: unknown;
+            plan: unknown;
+            qa_test_index: unknown;
+            latest_evidence: unknown;
+        };
+    }>;
+    featureStateGet(featureId: any): Promise<{
+        data: {
+            front_matter: {
+                [x: string]: any;
+            };
+            body: string;
+        };
+    }>;
+    featureStatePatch(featureId: any, expectedVersion: any, patch: any): Promise<{
+        data: {
+            feature_id: string;
+            version: number;
+            status: string;
+        };
+    }>;
+    featureLogAppend(featureId: any, note: any, context: any): Promise<{
+        data: {
+            feature_id: string;
+            appended: boolean;
+            log_path: string;
+        };
+    }>;
+    planGet(featureId: any): Promise<{
+        data: {
+            feature_id: string;
+            plan: unknown;
+        };
+    }>;
+    collectAcceptedPlans(excludeFeatureId?: any): Promise<{
+        [x: string]: any;
+    }[]>;
+    requiredResourcesForPlan(plan: any): Promise<string[]>;
+    assertPlanLocksHeld(featureId: any, plan: any): Promise<void>;
+    validatePlanRevisionRules(existingPlan: any, plan: any, expectedPlanVersion?: any): void;
+    validatePlanSchema(plan: any): Promise<void>;
+    checkPlanCollision(featureId: any, plan: any): Promise<unknown>;
+    planSubmit(featureId: any, plan: any, expectedVersion?: any): Promise<{
+        data: {
+            feature_id: string | null;
+            accepted: boolean;
+            plan_version: number;
+        };
+    }>;
+    planUpdate(featureId: any, expectedPlanVersion: any, plan: any): Promise<{
+        data: {
+            feature_id: string | null;
+            accepted: boolean;
+            plan_version: number;
+        };
+    }>;
+    repoEnsureWorktree(featureId: any): Promise<{
+        data: {
+            feature_id: any;
+            branch: any;
+            worktree_path_abs: string;
+            existed: boolean;
+        };
+    }>;
+    loadAcceptedPlan(featureId: any): Promise<{
+        [x: string]: any;
+    }>;
+    validatePatchPaths(featureId: any, parsedDiff: any, plan: any): Promise<string[]>;
+    repoApplyPatch(featureId: any, unifiedDiff: any): Promise<{
+        data: {
+            feature_id: string;
+            changed_files: string[];
+            status_porcelain: string[];
+            qa_index_version: number;
+        };
+    }>;
+    repoStatus(featureId: any): Promise<{
+        data: {
+            feature_id: any;
+            branch: string;
+            status_porcelain: string[];
+        };
+    }>;
+    repoDiff(featureId: any, options?: any[]): Promise<{
+        data: {
+            feature_id: any;
+            diff: string;
+        };
+    }>;
+    repoReadFile(featureId: any, filePath: any): Promise<{
+        data: {
+            feature_id: any;
+            path: string;
+            content: string;
+        };
+    }>;
+    repoSearch(featureId: any, query: any): Promise<{
+        data: {
+            feature_id: any;
+            query: any;
+            matches: ({
+                raw: string;
+                path?: undefined;
+                line?: undefined;
+                snippet?: undefined;
+            } | {
+                path: string;
+                line: number;
+                snippet: string;
+                raw?: undefined;
+            })[];
+        };
+    }>;
+    repoDiffBundle(featureId: any): Promise<{
+        data: {
+            feature_id: any;
+            diff_stat: string;
+            diff: string;
+            touched_files: string[];
+            last_gate_summary: {
+                [x: string]: any;
+            };
+        };
+    }>;
+    gatesList(profileName?: any): Promise<{
+        data: {
+            [x: string]: any;
+        };
+    }>;
+    gateProfileAndMode(profileName: any, mode: any): Promise<{
+        [x: string]: any;
+    }>;
+    gatesRun(featureId: any, profileName: any, mode: any): Promise<{
+        data: {
+            feature_id: string;
+            mode: string;
+            profile: string;
+            overall: string;
+            coverage: unknown;
+            evidence_path: string;
+        };
+        evidence: {
+            log_path: string;
+        };
+    }>;
+    evidenceLatest(featureId: any): Promise<{
+        data: {
+            feature_id: string;
+            latest: {
+                [x: string]: any;
+            } | null;
+            path?: string;
+        };
+    }>;
+    qaTestIndexGet(featureId: any): Promise<{
+        data: {
+            index: {
+                [x: string]: any;
+            };
+            summary: {
+                [x: string]: any;
+            };
+            pending_required_tests: {
+                [x: string]: any;
+            };
+        };
+    }>;
+    qaTestIndexUpdate(featureId: any, expectedVersion: any, updates: any, evidenceRefs: any): Promise<{
+        data: {
+            feature_id: string;
+            version: number;
+        };
+    }>;
+    locksAcquire(resource: any, featureId: any, waitTimeoutSeconds?: any): Promise<{
+        data: {
+            resource: string;
+            feature_id: string;
+            lease_id: any;
+            expires_at: any;
+            stale_reclaimed: any;
+        };
+        evidence: {
+            code: "stale_lock_reclaimed";
+            message: string;
+        };
+    }>;
+    locksRelease(resource: any, featureId: any): Promise<{
+        data: {
+            resource: string;
+            feature_id: string;
+            released: boolean;
+        };
+    }>;
+    collisionsScan(): Promise<{
+        data: {
+            collisions: any[];
+        };
+    }>;
+    reportDashboard(): Promise<{
+        data: {
+            index: {
+                [x: string]: any;
+            };
+            features: any[];
+        };
+    }>;
+    reportFeatureSummary(featureId: any): Promise<{
+        data: {
+            feature_id: string;
+            state: {
+                [x: string]: any;
+            };
+            diff_stat: any;
+            touched_files: any;
+            last_gate_summary: any;
+            qa_summary: any;
+        };
+    }>;
+    featureReadyToMerge(featureId: any, commitMessage: any, mergeStrategy: any, userApprovalToken: any): Promise<{
+        data: {
+            feature_id: string;
+            merge_sha: string;
+            merge_strategy: string;
+            status: string;
+        };
+    }>;
+    featureDelete(featureId: string | null, dryRun: boolean | null, confirm: boolean | null, removeWorktree: boolean | null, removeBranch: string | null): Promise<FeatureDeleteResult>;
+    renewLeases(featureIds: any): Promise<void>;
+    recoverFromState(): Promise<{
+        data: {
+            recovered: boolean;
+            stale_features: string[];
+            active: unknown;
+        };
+    }>;
+}
+export {};