agentic-orchestrator 0.1.2 → 0.1.4

package/packages/web-dashboard/src/lib/multi-project-config.ts

@@ -0,0 +1,116 @@
+import { access, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+
+const MULTI_PROJECT_CONFIG_PATH = ['agentic', 'orchestrator', 'multi-project.yaml'] as const;
+
+export interface MultiProjectDashboardConfig {
+  defaults?: {
+    max_active_features?: number;
+    max_parallel_gate_runs?: number;
+    dashboard_port?: number;
+    default_project?: string;
+    policy?: string;
+    gates?: string;
+    notifications?: { enabled?: boolean };
+  };
+  projects: Array<{
+    name: string;
+    path: string;
+    policy?: string;
+    gates?: string;
+    dashboard_port?: number;
+  }>;
+}
+
+function resolveHomePath(rawPath: string): string {
+  if (rawPath.startsWith('~/') || rawPath === '~') {
+    return path.join(os.homedir(), rawPath.slice(1));
+  }
+  return rawPath;
+}
+
+function resolveConfiguredPath(rawPath: string, baseDir: string): string {
+  const expanded = resolveHomePath(rawPath);
+  if (path.isAbsolute(expanded)) {
+    return expanded;
+  }
+  return path.resolve(baseDir, expanded);
+}
+
+function parseConfig(raw: string, repoRoot: string): MultiProjectDashboardConfig | null {
+  const parsed = YAML.parse(raw) as unknown;
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+
+  const candidate = parsed as {
+    defaults?: MultiProjectDashboardConfig['defaults'];
+    projects?: Array<{
+      name?: unknown;
+      path?: unknown;
+      policy?: unknown;
+      gates?: unknown;
+      dashboard_port?: unknown;
+    }>;
+  };
+
+  if (!Array.isArray(candidate.projects)) {
+    return null;
+  }
+
+  const projects = candidate.projects
+    .filter((project) => typeof project.name === 'string' && typeof project.path === 'string')
+    .map((project) => {
+      const absoluteProjectPath = resolveConfiguredPath(project.path as string, repoRoot);
+      const policyPath =
+        typeof project.policy === 'string'
+          ? resolveConfiguredPath(project.policy, absoluteProjectPath)
+          : undefined;
+      const gatesPath =
+        typeof project.gates === 'string'
+          ? resolveConfiguredPath(project.gates, absoluteProjectPath)
+          : undefined;
+
+      return {
+        name: project.name as string,
+        path: absoluteProjectPath,
+        policy: policyPath,
+        gates: gatesPath,
+        dashboard_port: typeof project.dashboard_port === 'number' ? project.dashboard_port : undefined
+      };
+    });
+
+  return {
+    defaults: candidate.defaults,
+    projects
+  };
+}
+
+export async function readMultiProjectConfig(repoRoot: string): Promise<MultiProjectDashboardConfig | null> {
+  const configPath = path.join(repoRoot, ...MULTI_PROJECT_CONFIG_PATH);
+  try {
+    const raw = await readFile(configPath, 'utf8');
+    return parseConfig(raw, repoRoot);
+  } catch {
+    return null;
+  }
+}
+
+export async function multiProjectConfigExists(repoRoot: string): Promise<boolean> {
+  const configPath = path.join(repoRoot, ...MULTI_PROJECT_CONFIG_PATH);
+  try {
+    await access(configPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getProjectByName(
+  config: MultiProjectDashboardConfig,
+  name: string
+): MultiProjectDashboardConfig['projects'][number] | null {
+  return config.projects.find((project) => project.name === name) ?? null;
+}

package/packages/web-dashboard/src/lib/orchestrator-tools.ts

@@ -0,0 +1,284 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getAopRoot } from './aop-client';
+
+const STATUS = {
+  BLOCKED: 'blocked'
+} as const;
+
+const TOOLS = {
+  FEATURE_READY_TO_MERGE: 'feature.ready_to_merge',
+  FEATURE_STATE_GET: 'feature.state_get',
+  FEATURE_STATE_PATCH: 'feature.state_patch',
+  FEATURE_LOG_APPEND: 'feature.log_append',
+  FEATURE_SEND_MESSAGE: 'feature.send_message'
+} as const;
+
+interface ToolResponse<TData = Record<string, unknown>> {
+  ok: boolean;
+  data?: TData;
+  error?: {
+    code?: string;
+    message?: string;
+    details?: Record<string, unknown>;
+  };
+}
+
+interface ToolClientIdentity {
+  run_id: string;
+  actor_type: string;
+  actor_id: string;
+  session_id: string;
+}
+
+interface ToolClient {
+  call(toolName: string, args: Record<string, unknown>, identity: ToolClientIdentity): Promise<ToolResponse>;
+}
+
+interface ToolingRuntime {
+  inProcessClient: ToolClient;
+}
+
+interface KernelLike {
+  ensureLoaded(): Promise<void>;
+  setProvider(provider: unknown): void;
+  getAgentsConfig?: () => unknown;
+}
+
+interface RuntimeBridge {
+  AopKernel: new (repoRoot: string) => KernelLike;
+  NullWorkerProvider: new (selection: unknown) => unknown;
+  resolveProviderSelection: (input: { cli: Record<string, string | undefined>; env: NodeJS.ProcessEnv; agentsConfig?: unknown }) => unknown;
+  createToolingRuntime: (
+    repoRoot: string,
+    kernel: KernelLike,
+    options: { generateToolsMarkdown: boolean }
+  ) => Promise<ToolingRuntime>;
+  createOperationId?: (toolName: string, featureId?: string) => string;
+}
+
+interface DashboardToolRuntime {
+  client: ToolClient;
+  createOperationId: (toolName: string, featureId?: string) => string;
+}
+
+const runtimeCacheByRoot = new Map<string, DashboardToolRuntime>();
+let runtimeBridgePromise: Promise<RuntimeBridge> | null = null;
+
+function makeClaims(): ToolClientIdentity {
+  const stamp = Date.now();
+  return {
+    run_id: `run:dashboard:${stamp}`,
+    actor_type: 'orchestrator',
+    actor_id: 'dashboard',
+    session_id: `dashboard:${randomUUID()}`
+  };
+}
+
+function defaultCreateOperationId(toolName: string, featureId?: string): string {
+  const parts = [toolName.replace(/[^a-zA-Z0-9]/g, '_')];
+  if (featureId) {
+    parts.push(featureId.replace(/[^a-zA-Z0-9_-]/g, '_'));
+  }
+  parts.push(randomUUID());
+  return parts.join('__');
+}
+
+function normalizeError(error: unknown, fallbackCode = 'internal_error'): ToolResponse {
+  if (error && typeof error === 'object') {
+    const maybe = error as { code?: unknown; message?: unknown; details?: unknown };
+    return {
+      ok: false,
+      error: {
+        code: typeof maybe.code === 'string' ? maybe.code : fallbackCode,
+        message: typeof maybe.message === 'string' ? maybe.message : 'Operation failed',
+        details: maybe.details && typeof maybe.details === 'object' ? (maybe.details as Record<string, unknown>) : undefined
+      }
+    };
+  }
+  return {
+    ok: false,
+    error: {
+      code: fallbackCode,
+      message: typeof error === 'string' ? error : 'Operation failed'
+    }
+  };
+}
+
+async function loadRuntimeBridge(): Promise<RuntimeBridge> {
+  if (runtimeBridgePromise) {
+    return runtimeBridgePromise;
+  }
+
+  runtimeBridgePromise = (async () => {
+    const modulePath = path.join(getAopRoot(), 'dist', 'apps', 'control-plane', 'index.js');
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const loaded = (await import(/* webpackIgnore: true */ moduleUrl)) as Partial<RuntimeBridge>;
+    if (
+      typeof loaded.AopKernel !== 'function' ||
+      typeof loaded.NullWorkerProvider !== 'function' ||
+      typeof loaded.resolveProviderSelection !== 'function' ||
+      typeof loaded.createToolingRuntime !== 'function'
+    ) {
+      throw new Error(`Control-plane runtime exports unavailable from ${modulePath}`);
+    }
+    return loaded as RuntimeBridge;
+  })();
+
+  return runtimeBridgePromise;
+}
+
+async function getRuntime(repoRoot: string): Promise<DashboardToolRuntime> {
+  const cached = runtimeCacheByRoot.get(repoRoot);
+  if (cached) {
+    return cached;
+  }
+
+  const bridge = await loadRuntimeBridge();
+  const kernel = new bridge.AopKernel(repoRoot);
+  await kernel.ensureLoaded();
+
+  try {
+    const agentsConfig = typeof kernel.getAgentsConfig === 'function' ? kernel.getAgentsConfig() : undefined;
+    const selection = bridge.resolveProviderSelection({
+      cli: {},
+      env: process.env,
+      agentsConfig
+    });
+    kernel.setProvider(new bridge.NullWorkerProvider(selection));
+  } catch {
+    kernel.setProvider(
+      new bridge.NullWorkerProvider({
+        provider: 'custom',
+        model: 'dashboard-default',
+        provider_config_env: null,
+        provider_config_ref: null
+      })
+    );
+  }
+
+  const tooling = await bridge.createToolingRuntime(repoRoot, kernel, { generateToolsMarkdown: false });
+  const runtime = {
+    client: tooling.inProcessClient,
+    createOperationId: bridge.createOperationId ?? defaultCreateOperationId
+  };
+  runtimeCacheByRoot.set(repoRoot, runtime);
+  return runtime;
+}
+
+export async function callOrchestratorTool<TData = Record<string, unknown>>(
+  toolName: string,
+  args: Record<string, unknown>,
+  options: { mutating?: boolean; featureId?: string; repoRoot?: string } = {}
+): Promise<ToolResponse<TData>> {
+  try {
+    const repoRoot = options.repoRoot ?? getAopRoot();
+    const runtime = await getRuntime(repoRoot);
+    const claims = makeClaims();
+    const payload: Record<string, unknown> = { ...args };
+
+    if (options.mutating) {
+      payload.operation_id = runtime.createOperationId(toolName, options.featureId);
+    }
+
+    return (await runtime.client.call(toolName, payload, claims)) as ToolResponse<TData>;
+  } catch (error) {
+    return normalizeError(error, 'runtime_unavailable') as ToolResponse<TData>;
+  }
+}
+
+export async function approveFeatureReview(
+  featureId: string,
+  approvalToken: string,
+  mergeStrategy = 'merge_commit',
+  commitMessage?: string,
+  repoRoot?: string
+): Promise<ToolResponse> {
+  return await callOrchestratorTool(
+    TOOLS.FEATURE_READY_TO_MERGE,
+    {
+      feature_id: featureId,
+      commit_message: commitMessage ?? `feat(${featureId}): merge via dashboard approval`,
+      merge_strategy: mergeStrategy,
+      user_approval_token: approvalToken
+    },
+    { mutating: true, featureId, repoRoot }
+  );
+}
+
+export async function denyFeatureReview(featureId: string, reason: string, repoRoot?: string): Promise<ToolResponse> {
+  const state = await callOrchestratorTool<{ front_matter: { version: number } }>(
+    TOOLS.FEATURE_STATE_GET,
+    { feature_id: featureId },
+    { repoRoot }
+  );
+  if (!state.ok || !state.data) {
+    return state;
+  }
+
+  const expectedVersion = state.data.front_matter.version;
+  const patchResult = await callOrchestratorTool(
+    TOOLS.FEATURE_STATE_PATCH,
+    {
+      feature_id: featureId,
+      expected_version: expectedVersion,
+      patch: {
+        front_matter: {
+          status: STATUS.BLOCKED,
+          status_reason: `Dashboard review denied: ${reason}`
+        }
+      }
+    },
+    { mutating: true, featureId, repoRoot }
+  );
+  if (!patchResult.ok) {
+    return patchResult;
+  }
+
+  await callOrchestratorTool(
+    TOOLS.FEATURE_LOG_APPEND,
+    {
+      feature_id: featureId,
+      note: JSON.stringify({
+        type: 'dashboard_review',
+        decision: 'deny',
+        reason,
+        reviewed_at: new Date().toISOString()
+      })
+    },
+    { mutating: true, featureId, repoRoot }
+  );
+
+  return patchResult;
+}
+
+export async function requestFeatureChanges(featureId: string, message: string, repoRoot?: string): Promise<ToolResponse> {
+  const normalized = message.trim().length > 0 ? message.trim() : 'Please address reviewer feedback and re-run QA.';
+  const send = await callOrchestratorTool(
+    TOOLS.FEATURE_SEND_MESSAGE,
+    {
+      feature_id: featureId,
+      message: `Reviewer requested changes:\n${normalized}`
+    },
+    { mutating: true, featureId, repoRoot }
+  );
+  if (send.ok) {
+    return send;
+  }
+
+  return await callOrchestratorTool(
+    TOOLS.FEATURE_LOG_APPEND,
+    {
+      feature_id: featureId,
+      note: JSON.stringify({
+        type: 'dashboard_review',
+        decision: 'request_changes',
+        message: normalized,
+        reviewed_at: new Date().toISOString(),
+        dispatch_fallback: true
+      })
+    },
+    { mutating: true, featureId, repoRoot }
+  );
+}

package/packages/web-dashboard/src/lib/types.ts

@@ -0,0 +1,58 @@
+export interface FeatureSummary {
+  id: string;
+  feature_id: string;
+  status: string;
+  phase?: 'planning' | 'building' | 'qa' | 'ready_to_merge' | 'merged' | 'blocked' | 'unknown';
+  plan_version?: number;
+  locks_held?: string[];
+  gate_profile?: string;
+  branch?: string | null;
+  worktree_path?: string | null;
+  last_updated?: string;
+  status_reason?: string;
+  activity_state?: 'active' | 'idle' | 'waiting_input' | 'blocked' | 'exited' | 'unknown';
+  activity_last_event_at?: string;
+  activity_detected_via?: 'jsonl' | 'ledger' | 'process' | 'unknown';
+  pr?: {
+    number?: number;
+    url?: string;
+    ci_status?: string;
+    review_decision?: string;
+    merge_ready?: boolean;
+    pending_review_threads?: number;
+    has_conflicts?: boolean;
+    merge_score?: number;
+  } | null;
+}
+
+export interface FeaturesIndex {
+  active: string[];
+  blocked: string[];
+  merged: string[];
+  blocked_queue?: Array<{ feature_id: string; detected_at: string; collision_fingerprint: string }>;
+}
+
+export interface SSEEvent {
+  type: 'snapshot' | 'error';
+  features?: FeaturesIndex;
+  payload?: DashboardStatusPayload;
+  message?: string;
+}
+
+export interface EvidenceArtifact {
+  name: string;
+  path: string;
+  updated_at: string;
+}
+
+export interface FeatureDetail {
+  feature: FeatureSummary;
+  plan: Record<string, unknown> | null;
+  diff: string;
+  evidence: EvidenceArtifact[];
+}
+
+export interface DashboardStatusPayload {
+  index: FeaturesIndex;
+  features: FeatureSummary[];
+}

package/packages/web-dashboard/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "jsx": "preserve",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "allowJs": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    },
+    "incremental": true,
+    "isolatedModules": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": [
+    "next-env.d.ts",
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    ".next/types/**/*.ts",
+    "next.config.js"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/packages/web-dashboard/vitest.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});