agentic-orchestrator 0.1.26 → 0.1.28

package/apps/control-plane/src/application/kernel-tool-wiring.ts

@@ -0,0 +1,292 @@
+import { TOOLS } from '../core/constants.js';
+import type { ToolHandlerRegistry, ToolHandlerContext } from './tools/tool-router.js';
+import {
+  readStringField,
+  readNumberField,
+  readBooleanField,
+  asArray,
+} from '../core/utils/field-readers.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyRecord = Record<string, any>;
+
+export interface KernelToolFacade {
+  featureDiscoverSpecs(): Promise<unknown>;
+  featureInit(featureId: string | null): Promise<unknown>;
+  featureGetContext(featureId: string | null): Promise<unknown>;
+  featureStateGet(featureId: string | null): Promise<unknown>;
+  featureStatePatch(
+    featureId: string | null,
+    expectedVersion: number | null,
+    patch: unknown,
+  ): Promise<unknown>;
+  featureLogAppend(
+    featureId: string | null,
+    note: string | null,
+    context: ToolHandlerContext,
+  ): Promise<unknown>;
+  planSubmit(
+    featureId: string | null,
+    plan: unknown,
+    expectedVersion: number | null,
+  ): Promise<unknown>;
+  planGet(featureId: string | null): Promise<unknown>;
+  planUpdate(
+    featureId: string | null,
+    expectedPlanVersion: number | null,
+    plan: unknown,
+  ): Promise<unknown>;
+  repoEnsureWorktree(featureId: string | null): Promise<unknown>;
+  repoApplyPatch(featureId: string | null, unifiedDiff: string | null): Promise<unknown>;
+  repoStatus(featureId: string | null): Promise<unknown>;
+  repoDiff(featureId: string | null, options: string[]): Promise<unknown>;
+  repoReadFile(featureId: string | null, filePath: string | null): Promise<unknown>;
+  repoSearch(featureId: string | null, query: string | null): Promise<unknown>;
+  repoDiffBundle(featureId: string | null): Promise<unknown>;
+  featureReadyToMerge(
+    featureId: string | null,
+    commitMessage: string | null,
+    mergeStrategy: string | null,
+    userApprovalToken: string | null,
+  ): Promise<unknown>;
+  featureDelete(
+    featureId: string | null,
+    dryRun: boolean | null,
+    confirm: boolean | null,
+    removeWorktree: boolean | null,
+    removeBranch: string | null,
+  ): Promise<unknown>;
+  gatesList(profileName: string | null): Promise<unknown>;
+  gatesRun(
+    featureId: string | null,
+    profileName: string | null,
+    mode: string | null,
+  ): Promise<unknown>;
+  evidenceLatest(featureId: string | null): Promise<unknown>;
+  qaTestIndexGet(featureId: string | null): Promise<unknown>;
+  qaTestIndexUpdate(
+    featureId: string | null,
+    expectedVersion: number | null,
+    updates: unknown,
+    evidenceRefs: unknown[],
+  ): Promise<unknown>;
+  locksAcquire(
+    resource: string | null,
+    featureId: string | null,
+    waitTimeoutSeconds: number | null,
+  ): Promise<unknown>;
+  locksRelease(resource: string | null, featureId: string | null): Promise<unknown>;
+  collisionsScan(): Promise<unknown>;
+  reportDashboard(): Promise<unknown>;
+  reportFeatureSummary(featureId: string | null): Promise<unknown>;
+  featureSendMessage(featureId: string | null, message: string | null): Promise<unknown>;
+  costRecord(featureId: string | null, tokensDelta: number, costUsdDelta: number): Promise<unknown>;
+  costGet(featureId: string | null): Promise<unknown>;
+  performanceRecordOutcome(args: AnyRecord): Promise<unknown>;
+  performanceGetAnalytics(provider: string | null, model: string | null): Promise<unknown>;
+}
+
+export function registerKernelTools(
+  toolHandlers: ToolHandlerRegistry,
+  kernel: KernelToolFacade,
+): void {
+  toolHandlers.register(
+    TOOLS.FEATURE_DISCOVER_SPECS,
+    async () => await kernel.featureDiscoverSpecs(),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_INIT,
+    async (args) => await kernel.featureInit(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_GET_CONTEXT,
+    async (args) => await kernel.featureGetContext(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_STATE_GET,
+    async (args) => await kernel.featureStateGet(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_STATE_PATCH,
+    async (args) =>
+      await kernel.featureStatePatch(
+        readStringField(args, 'feature_id'),
+        readNumberField(args, 'expected_version'),
+        args.patch,
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_LOG_APPEND,
+    async (args, context) =>
+      await kernel.featureLogAppend(
+        readStringField(args, 'feature_id'),
+        readStringField(args, 'note'),
+        context,
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.PLAN_SUBMIT,
+    async (args) =>
+      await kernel.planSubmit(
+        readStringField(args, 'feature_id'),
+        args.plan_json,
+        readNumberField(args, 'expected_version'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.PLAN_GET,
+    async (args) => await kernel.planGet(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.PLAN_UPDATE,
+    async (args) =>
+      await kernel.planUpdate(
+        readStringField(args, 'feature_id'),
+        readNumberField(args, 'expected_plan_version'),
+        args.plan_json,
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_ENSURE_WORKTREE,
+    async (args) => await kernel.repoEnsureWorktree(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_APPLY_PATCH,
+    async (args) =>
+      await kernel.repoApplyPatch(
+        readStringField(args, 'feature_id'),
+        readStringField(args, 'unified_diff'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_STATUS,
+    async (args) => await kernel.repoStatus(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_DIFF,
+    async (args) =>
+      await kernel.repoDiff(readStringField(args, 'feature_id'), asArray<string>(args.options)),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_READ_FILE,
+    async (args) =>
+      await kernel.repoReadFile(readStringField(args, 'feature_id'), readStringField(args, 'path')),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_SEARCH,
+    async (args) =>
+      await kernel.repoSearch(readStringField(args, 'feature_id'), readStringField(args, 'query')),
+  );
+  toolHandlers.register(
+    TOOLS.REPO_DIFF_BUNDLE,
+    async (args) => await kernel.repoDiffBundle(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_READY_TO_MERGE,
+    async (args) =>
+      await kernel.featureReadyToMerge(
+        readStringField(args, 'feature_id'),
+        readStringField(args, 'commit_message'),
+        readStringField(args, 'merge_strategy'),
+        readStringField(args, 'user_approval_token'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_DELETE,
+    async (args) =>
+      await kernel.featureDelete(
+        readStringField(args, 'feature_id'),
+        readBooleanField(args, 'dry_run'),
+        readBooleanField(args, 'confirm'),
+        readBooleanField(args, 'remove_worktree'),
+        readStringField(args, 'remove_branch'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.GATES_LIST,
+    async (args) => await kernel.gatesList(readStringField(args, 'profile')),
+  );
+  toolHandlers.register(
+    TOOLS.GATES_RUN,
+    async (args) =>
+      await kernel.gatesRun(
+        readStringField(args, 'feature_id'),
+        readStringField(args, 'profile'),
+        readStringField(args, 'mode'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.EVIDENCE_LATEST,
+    async (args) => await kernel.evidenceLatest(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.QA_TEST_INDEX_GET,
+    async (args) => await kernel.qaTestIndexGet(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.QA_TEST_INDEX_UPDATE,
+    async (args) =>
+      await kernel.qaTestIndexUpdate(
+        readStringField(args, 'feature_id'),
+        readNumberField(args, 'expected_version'),
+        args.updates,
+        asArray(args.evidence_refs),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.LOCKS_ACQUIRE,
+    async (args) =>
+      await kernel.locksAcquire(
+        readStringField(args, 'resource'),
+        readStringField(args, 'feature_id'),
+        readNumberField(args, 'wait_timeout_seconds'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.LOCKS_RELEASE,
+    async (args) =>
+      await kernel.locksRelease(
+        readStringField(args, 'resource'),
+        readStringField(args, 'feature_id'),
+      ),
+  );
+  toolHandlers.register(TOOLS.COLLISIONS_SCAN, async () => await kernel.collisionsScan());
+  toolHandlers.register(TOOLS.REPORT_DASHBOARD, async () => await kernel.reportDashboard());
+  toolHandlers.register(
+    TOOLS.REPORT_FEATURE_SUMMARY,
+    async (args) => await kernel.reportFeatureSummary(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.FEATURE_SEND_MESSAGE,
+    async (args) =>
+      await kernel.featureSendMessage(
+        readStringField(args, 'feature_id'),
+        readStringField(args, 'message'),
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.COST_RECORD,
+    async (args) =>
+      await kernel.costRecord(
+        readStringField(args, 'feature_id'),
+        typeof args.tokens_used_delta === 'number' ? args.tokens_used_delta : 0,
+        typeof args.estimated_cost_usd_delta === 'number' ? args.estimated_cost_usd_delta : 0,
+      ),
+  );
+  toolHandlers.register(
+    TOOLS.COST_GET,
+    async (args) => await kernel.costGet(readStringField(args, 'feature_id')),
+  );
+  toolHandlers.register(
+    TOOLS.PERFORMANCE_RECORD_OUTCOME,
+    async (args) => await kernel.performanceRecordOutcome(args),
+  );
+  toolHandlers.register(
+    TOOLS.PERFORMANCE_GET_ANALYTICS,
+    async (args) =>
+      await kernel.performanceGetAnalytics(
+        readStringField(args, 'provider'),
+        readStringField(args, 'model'),
+      ),
+  );
+}