agentic-orchestrator 0.1.27 → 0.2.0

package/packages/web-dashboard/src/lib/review-contracts.ts

@@ -1,5 +1,5 @@
 export const FEATURE_ID_PATTERN = /^[a-z0-9](?:[a-z0-9_-]{1,126}[a-z0-9])?$/;
-export const RAW_LOG_FILENAME_PATTERN = /^(planner|builder|qa)-[0-9]{13}\.txt$/;
+export const RAW_LOG_FILENAME_PATTERN = /^(planner|builder|qa|reconciler)-[0-9]{13}\.txt$/;
 
 export const TERMINAL_FEATURE_STATUSES = new Set(['merged', 'failed', 'stopped']);
 
@@ -152,8 +152,10 @@ export function normalizeLimit(value: string | null, fallback: number, max: numb
   return Math.min(parsed, max);
 }
 
-export function normalizeRoleFilter(value: string | null): 'planner' | 'builder' | 'qa' | null {
-  if (value === 'planner' || value === 'builder' || value === 'qa') {
+export function normalizeRoleFilter(
+  value: string | null,
+): 'planner' | 'builder' | 'qa' | 'reconciler' | null {
+  if (value === 'planner' || value === 'builder' || value === 'qa' || value === 'reconciler') {
     return value;
   }
   return null;

package/packages/web-dashboard/src/lib/runtime-files.ts

@@ -0,0 +1,285 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+
+export type RunHistoryStatus = 'active' | 'completed' | 'failed' | 'timeout' | 'interrupted';
+
+export type RunHistoryEntry = {
+  run_id: string;
+  started_at: string;
+  ended_at: string | null;
+  status: RunHistoryStatus;
+};
+
+export type ActiveRunLease = {
+  instance_id: string | null;
+  run_id: string;
+  owner_instance_id: string;
+  provider: string | null;
+  model: string | null;
+  started_at: string | null;
+  last_heartbeat_at: string | null;
+  lease_expires_at: string;
+  assigned_feature_ids: string[];
+};
+
+export type ParsedFrontMatter = {
+  frontMatter: Record<string, unknown>;
+  body: string;
+};
+
+const FRONT_MATTER_REGEX = /^---\n([\s\S]*?)\n---\n?/;
+
+function normalizeFrontMatterValue(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object') {
+    return {};
+  }
+  return value as Record<string, unknown>;
+}
+
+export function parseFrontMatter(raw: string): ParsedFrontMatter {
+  const normalized = raw.replace(/\r\n/g, '\n');
+  const match = normalized.match(FRONT_MATTER_REGEX);
+  if (!match) {
+    return { frontMatter: {}, body: normalized };
+  }
+  const parsed = YAML.parse(match[1]);
+  if (parsed == null) {
+    return { frontMatter: {}, body: normalized.slice(match[0].length) };
+  }
+  if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('invalid_front_matter');
+  }
+  const frontMatter = normalizeFrontMatterValue(parsed);
+  return { frontMatter, body: normalized.slice(match[0].length) };
+}
+
+export async function readFeatureStateFrontMatter(
+  featureId: string,
+  repoRoot: string,
+): Promise<ParsedFrontMatter> {
+  const statePath = path.join(repoRoot, '.aop', 'features', featureId, 'state.md');
+  const raw = await fs.readFile(statePath, 'utf8');
+  return parseFrontMatter(raw);
+}
+
+export async function readFeaturesIndex(repoRoot: string): Promise<Record<string, unknown> | null> {
+  const indexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
+  try {
+    const raw = await fs.readFile(indexPath, 'utf8');
+    return JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function hasActiveLeaseValue(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length > 0 &&
+    value !== 'none' &&
+    value !== 'unknown' &&
+    value !== 'unassigned'
+  );
+}
+
+function normalizeActiveRunLease(value: unknown, instanceId: string | null): ActiveRunLease | null {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    !hasActiveLeaseValue(record.run_id) ||
+    !hasActiveLeaseValue(record.owner_instance_id) ||
+    typeof record.lease_expires_at !== 'string'
+  ) {
+    return null;
+  }
+  return {
+    instance_id: instanceId,
+    run_id: record.run_id,
+    owner_instance_id: record.owner_instance_id,
+    provider: typeof record.provider === 'string' ? record.provider : null,
+    model: typeof record.model === 'string' ? record.model : null,
+    started_at: typeof record.started_at === 'string' ? record.started_at : null,
+    last_heartbeat_at:
+      typeof record.last_heartbeat_at === 'string' ? record.last_heartbeat_at : null,
+    lease_expires_at: record.lease_expires_at,
+    assigned_feature_ids:
+      record.feature_sessions && typeof record.feature_sessions === 'object'
+        ? Object.keys(record.feature_sessions as Record<string, unknown>).sort((left, right) =>
+            left.localeCompare(right),
+          )
+        : [],
+  };
+}
+
+function isLeaseFresh(lease: ActiveRunLease): boolean {
+  const expiry = Date.parse(lease.lease_expires_at);
+  return Number.isFinite(expiry) && expiry > Date.now();
+}
+
+function compareLeases(left: ActiveRunLease, right: ActiveRunLease): number {
+  const leftExpiry = Date.parse(left.lease_expires_at);
+  const rightExpiry = Date.parse(right.lease_expires_at);
+  if (leftExpiry !== rightExpiry) {
+    return rightExpiry - leftExpiry;
+  }
+  const leftHeartbeat = left.last_heartbeat_at ? Date.parse(left.last_heartbeat_at) : 0;
+  const rightHeartbeat = right.last_heartbeat_at ? Date.parse(right.last_heartbeat_at) : 0;
+  return rightHeartbeat - leftHeartbeat;
+}
+
+export async function readActiveRunLease(repoRoot: string): Promise<ActiveRunLease | null> {
+  const runtimeRoot = path.join(repoRoot, '.aop', 'runtime');
+  const candidatePaths = new Map<string, string | null>([
+    [path.join(runtimeRoot, 'default', 'run-lease.json'), 'default'],
+    [path.join(runtimeRoot, 'run-lease.json'), null],
+  ]);
+
+  try {
+    const entries = await fs.readdir(runtimeRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      candidatePaths.set(path.join(runtimeRoot, entry.name, 'run-lease.json'), entry.name);
+    }
+  } catch {
+    // Fall back to index runtime_sessions below when the runtime root is absent.
+  }
+
+  const discovered = await Promise.all(
+    [...candidatePaths.entries()].map(async ([leasePath, instanceId]) => {
+      try {
+        const raw = await fs.readFile(leasePath, 'utf8');
+        return normalizeActiveRunLease(JSON.parse(raw), instanceId);
+      } catch {
+        return null;
+      }
+    }),
+  );
+
+  const activeLease = discovered
+    .filter((lease): lease is ActiveRunLease => lease !== null)
+    .find(isLeaseFresh);
+  if (activeLease) {
+    return (
+      [...discovered]
+        .filter((lease): lease is ActiveRunLease => lease !== null && isLeaseFresh(lease))
+        .sort(compareLeases)[0] ?? activeLease
+    );
+  }
+
+  const index = await readFeaturesIndex(repoRoot);
+  const fallback = normalizeActiveRunLease(index?.runtime_sessions, 'index');
+  if (fallback && isLeaseFresh(fallback)) {
+    return fallback;
+  }
+  return null;
+}
+
+export function featureExistsInIndex(index: Record<string, unknown>, featureId: string): boolean {
+  const active = Array.isArray(index.active) ? index.active : [];
+  const blocked = Array.isArray(index.blocked) ? index.blocked : [];
+  const merged = Array.isArray(index.merged) ? index.merged : [];
+  return [...active, ...blocked, ...merged].some((entry) => entry === featureId);
+}
+
+function isRunHistoryStatus(value: unknown): value is RunHistoryStatus {
+  return (
+    value === 'active' ||
+    value === 'completed' ||
+    value === 'failed' ||
+    value === 'timeout' ||
+    value === 'interrupted'
+  );
+}
+
+export function normalizeRunHistory(value: unknown): RunHistoryEntry[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => {
+      if (!entry || typeof entry !== 'object') {
+        return null;
+      }
+      const record = entry as Record<string, unknown>;
+      if (typeof record.run_id !== 'string' || typeof record.started_at !== 'string') {
+        return null;
+      }
+      return {
+        run_id: record.run_id,
+        started_at: record.started_at,
+        ended_at: typeof record.ended_at === 'string' ? record.ended_at : null,
+        status: isRunHistoryStatus(record.status) ? record.status : 'interrupted',
+      };
+    })
+    .filter((entry): entry is RunHistoryEntry => entry !== null);
+}
+
+export function resolveRunEntry(
+  runHistory: RunHistoryEntry[],
+  runId: string | null,
+): RunHistoryEntry | null {
+  if (runHistory.length === 0) {
+    return null;
+  }
+  if (!runId) {
+    return runHistory[0] ?? null;
+  }
+  return runHistory.find((entry) => entry.run_id === runId) ?? null;
+}
+
+export function runtimeLedgerPath(repoRoot: string, runId: string): string {
+  return path.join(repoRoot, '.aop', 'runtime', 'operation-ledger', `${runId}.json`);
+}
+
+export function runtimeEventsPath(repoRoot: string, runId: string): string {
+  return path.join(repoRoot, '.aop', 'runtime', 'worker-events', `${runId}.jsonl`);
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readJsonFile<T>(
+  filePath: string,
+  maxBytes: number,
+): Promise<{ data: T; size: number }> {
+  const stats = await fs.stat(filePath);
+  if (stats.size > maxBytes) {
+    const error = new Error('file_too_large');
+    (error as { code?: string }).code = 'file_too_large';
+    throw error;
+  }
+  const raw = await fs.readFile(filePath, 'utf8');
+  return { data: JSON.parse(raw) as T, size: stats.size };
+}
+
+export async function readJsonLinesFile(
+  filePath: string,
+  maxBytes: number,
+): Promise<{ entries: unknown[]; size: number }> {
+  const stats = await fs.stat(filePath);
+  if (stats.size > maxBytes) {
+    const error = new Error('file_too_large');
+    (error as { code?: string }).code = 'file_too_large';
+    throw error;
+  }
+  const raw = await fs.readFile(filePath, 'utf8');
+  const entries: unknown[] = [];
+  for (const line of raw.replace(/\r\n/g, '\n').split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+    entries.push(JSON.parse(line));
+  }
+  return { entries, size: stats.size };
+}

package/packages/web-dashboard/src/lib/tool-catalog.ts

@@ -0,0 +1,51 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type ToolCatalogEntry = {
+  name?: unknown;
+  description?: unknown;
+};
+
+type ToolCatalog = {
+  tools?: unknown;
+};
+
+const descriptionCache = new Map<string, Promise<Map<string, string>>>();
+
+async function loadToolDescriptions(repoRoot: string): Promise<Map<string, string>> {
+  const catalogPath = path.join(repoRoot, 'agentic', 'orchestrator', 'tools', 'catalog.json');
+
+  try {
+    const raw = await fs.readFile(catalogPath, 'utf8');
+    const parsed = JSON.parse(raw) as ToolCatalog;
+    const tools = Array.isArray(parsed.tools) ? parsed.tools : [];
+    const descriptions = new Map<string, string>();
+
+    for (const entry of tools) {
+      const candidate = entry as ToolCatalogEntry;
+      if (
+        typeof candidate.name === 'string' &&
+        candidate.name.length > 0 &&
+        typeof candidate.description === 'string' &&
+        candidate.description.length > 0
+      ) {
+        descriptions.set(candidate.name, candidate.description);
+      }
+    }
+
+    return descriptions;
+  } catch {
+    return new Map<string, string>();
+  }
+}
+
+export async function readToolDescriptions(repoRoot: string): Promise<Map<string, string>> {
+  const existing = descriptionCache.get(repoRoot);
+  if (existing) {
+    return existing;
+  }
+
+  const pending = loadToolDescriptions(repoRoot);
+  descriptionCache.set(repoRoot, pending);
+  return pending;
+}