agentic-orchestrator 0.1.26 → 0.1.28

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

@@ -0,0 +1,182 @@
+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 TERMINAL_FEATURE_STATUSES = new Set(['merged', 'failed', 'stopped']);
+
+export type DiffChangeType = 'added' | 'modified' | 'deleted' | 'renamed' | 'unknown';
+
+export interface DiffFileDescriptor {
+  path: string;
+  oldPath: string | null;
+  newPath: string | null;
+  changeType: DiffChangeType;
+}
+
+function stripPrefix(value: string): string {
+  return value.replace(/^[ab]\//, '');
+}
+
+export function parseDiffFileDescriptors(rawDiff: string): DiffFileDescriptor[] {
+  const normalized = rawDiff.replace(/\r\n/g, '\n');
+  if (normalized.trim().length === 0) {
+    return [];
+  }
+
+  const descriptors: DiffFileDescriptor[] = [];
+  const lines = normalized.split('\n');
+  let current: DiffFileDescriptor | null = null;
+
+  const pushCurrent = () => {
+    if (!current) {
+      return;
+    }
+    const pathCandidate = current.newPath ?? current.oldPath ?? current.path;
+    descriptors.push({
+      ...current,
+      path: pathCandidate,
+    });
+    current = null;
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      pushCurrent();
+      const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+      const oldPath = match ? stripPrefix(match[1]) : null;
+      const newPath = match ? stripPrefix(match[2]) : null;
+      current = {
+        path: newPath ?? oldPath ?? 'unknown',
+        oldPath,
+        newPath,
+        changeType: 'modified',
+      };
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith('new file mode')) {
+      current.changeType = 'added';
+      continue;
+    }
+    if (line.startsWith('deleted file mode')) {
+      current.changeType = 'deleted';
+      continue;
+    }
+    if (line.startsWith('rename from ')) {
+      current.changeType = 'renamed';
+      current.oldPath = line.slice('rename from '.length).trim();
+      continue;
+    }
+    if (line.startsWith('rename to ')) {
+      current.changeType = 'renamed';
+      current.newPath = line.slice('rename to '.length).trim();
+      continue;
+    }
+    if (line.startsWith('--- ')) {
+      const value = line.slice(4).trim();
+      current.oldPath = value === '/dev/null' ? null : stripPrefix(value);
+      continue;
+    }
+    if (line.startsWith('+++ ')) {
+      const value = line.slice(4).trim();
+      current.newPath = value === '/dev/null' ? null : stripPrefix(value);
+      continue;
+    }
+  }
+
+  pushCurrent();
+  return descriptors.map((entry) => {
+    const changeType =
+      entry.changeType === 'modified' && !entry.oldPath && entry.newPath
+        ? 'added'
+        : entry.changeType === 'modified' && entry.oldPath && !entry.newPath
+          ? 'deleted'
+          : entry.changeType;
+    return {
+      ...entry,
+      changeType,
+    };
+  });
+}
+
+export function inferLanguageFromPath(filePath: string): string {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith('.ts') || lower.endsWith('.tsx')) {
+    return 'typescript';
+  }
+  if (lower.endsWith('.js') || lower.endsWith('.jsx') || lower.endsWith('.mjs')) {
+    return 'javascript';
+  }
+  if (lower.endsWith('.json')) {
+    return 'json';
+  }
+  if (lower.endsWith('.md')) {
+    return 'markdown';
+  }
+  if (lower.endsWith('.yml') || lower.endsWith('.yaml')) {
+    return 'yaml';
+  }
+  if (lower.endsWith('.css')) {
+    return 'css';
+  }
+  if (lower.endsWith('.html')) {
+    return 'html';
+  }
+  if (lower.endsWith('.go')) {
+    return 'go';
+  }
+  if (lower.endsWith('.rs')) {
+    return 'rust';
+  }
+  if (lower.endsWith('.py')) {
+    return 'python';
+  }
+  if (lower.endsWith('.java')) {
+    return 'java';
+  }
+  if (lower.endsWith('.sh') || lower.endsWith('.bash')) {
+    return 'shell';
+  }
+  return 'plaintext';
+}
+
+export function normalizeLimit(value: string | null, fallback: number, max: number): number {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+export function normalizeRoleFilter(value: string | null): 'planner' | 'builder' | 'qa' | null {
+  if (value === 'planner' || value === 'builder' || value === 'qa') {
+    return value;
+  }
+  return null;
+}
+
+export function isEditableTarget(target: EventTarget | null): boolean {
+  const element = target as {
+    tagName?: unknown;
+    isContentEditable?: unknown;
+    closest?: (selector: string) => unknown;
+  } | null;
+  if (!element) {
+    return false;
+  }
+  if (typeof element.closest === 'function' && element.closest('.monaco-editor')) {
+    return true;
+  }
+  const tagName = typeof element.tagName === 'string' ? element.tagName.toLowerCase() : '';
+  if (tagName === 'input' || tagName === 'textarea') {
+    return true;
+  }
+  if (element.isContentEditable === true) {
+    return true;
+  }
+  return false;
+}

package/packages/web-dashboard/src/lib/review-workspace-logic.ts

@@ -0,0 +1,64 @@
+import type { AgentLogEntry, AgentSessionCluster } from '@/lib/types.js';
+
+const TERMINAL_STATUSES = new Set(['merged', 'failed', 'stopped']);
+export const DEFAULT_LOG_STREAM_CAP = 200;
+
+function hasActiveSession(value: string | undefined): boolean {
+  return Boolean(value) && value !== 'unknown' && value !== 'unassigned' && value !== 'none';
+}
+
+function hasActiveClusterSession(cluster: AgentSessionCluster | undefined): boolean {
+  return Boolean(
+    cluster &&
+    (hasActiveSession(cluster.orchestrator_session_id) ||
+      hasActiveSession(cluster.planner_session_id) ||
+      hasActiveSession(cluster.builder_session_id) ||
+      hasActiveSession(cluster.qa_session_id)),
+  );
+}
+
+export interface ConsoleSendEligibilityInput {
+  status: string;
+  cluster: AgentSessionCluster | undefined;
+  hasActiveRuntimeSession: boolean;
+  submitting: boolean;
+  message: string;
+  nowMs: number;
+  lastMessageSentAtMs: number;
+  minIntervalMs?: number;
+}
+
+export function isConsoleSendAllowed(input: ConsoleSendEligibilityInput): boolean {
+  const minIntervalMs = input.minIntervalMs ?? 1000;
+  if (
+    TERMINAL_STATUSES.has(input.status) ||
+    !input.hasActiveRuntimeSession ||
+    !hasActiveClusterSession(input.cluster)
+  ) {
+    return false;
+  }
+  if (input.submitting || input.message.trim().length === 0) {
+    return false;
+  }
+  return input.nowMs - input.lastMessageSentAtMs >= minIntervalMs;
+}
+
+export function appendCappedLogEntries(
+  current: AgentLogEntry[],
+  incoming: AgentLogEntry[],
+  cap = DEFAULT_LOG_STREAM_CAP,
+): AgentLogEntry[] {
+  if (incoming.length === 0) {
+    return current;
+  }
+  const next = [...current, ...incoming];
+  return next.slice(Math.max(0, next.length - Math.max(1, cap)));
+}
+
+export function stepHunkIndex(current: number, direction: -1 | 1, hunkCount: number): number {
+  const maxIndex = Math.max(0, hunkCount - 1);
+  if (direction < 0) {
+    return Math.max(0, current - 1);
+  }
+  return Math.min(maxIndex, current + 1);
+}

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

@@ -1,11 +1,138 @@
 export type RoleStatus = 'ready' | 'running' | 'blocked' | 'done' | 'unknown';
 
+export type AgentRuntimeRole = 'planner' | 'builder' | 'qa' | 'orchestrator' | string;
+
 export interface AgentPipelineStatus {
   planner: RoleStatus;
   builder: RoleStatus;
   qa: RoleStatus;
 }
 
+export interface AgentLogEntry {
+  id: string;
+  timestamp: string;
+  actor: string;
+  role: AgentRuntimeRole;
+  text: string;
+}
+
+export interface WorkerEventEntry {
+  ts: string;
+  role: string;
+  output_types: string[];
+  patch_count: number;
+  plan_submission_count: number;
+  request_count: number;
+  note_count: number;
+  valid: boolean;
+  error_code: string | null;
+  provider: string;
+  model: string;
+  elapsed_ms?: number;
+  feature_id?: string;
+  event_type?: string;
+  execution_mode?: 'deterministic' | 'interactive';
+  run_id?: string;
+}
+
+export type FeatureExecutionMode = 'deterministic' | 'interactive';
+
+export interface FeatureCheckpoint {
+  checkpoint_id: string;
+  timestamp: string;
+  files_changed: string[];
+  validation_status: 'valid' | 'invalid' | 'skipped';
+  violations: string[];
+  severity?: 'info' | 'warning' | 'error' | 'critical';
+  diff_snapshot: string;
+}
+
+export interface FeatureCheckpointDiff {
+  checkpoint: FeatureCheckpoint;
+  diff: string;
+}
+
+export interface FeatureCheckpointComparisonFile {
+  path: string;
+  status: 'added' | 'removed' | 'changed' | 'unchanged';
+}
+
+export interface FeatureCheckpointComparison {
+  from_checkpoint_id: string;
+  to_checkpoint_id: string;
+  from_timestamp: string | null;
+  to_timestamp: string | null;
+  summary: {
+    added: number;
+    removed: number;
+    changed: number;
+    unchanged: number;
+  };
+  files: FeatureCheckpointComparisonFile[];
+  from_diff: string;
+  to_diff: string;
+}
+
+export interface InteractivePerformanceLatestCheckpoint {
+  feature_id: string;
+  checkpoint_id: string;
+  trigger: string;
+  validation_status: 'valid' | 'invalid' | 'skipped';
+  checkpoint_latency_ms: number;
+  validation_latency_ms: number;
+  diff_capture_latency_ms: number;
+  files_changed: number;
+  recorded_at: string;
+}
+
+export interface InteractiveExecutionModeMetrics {
+  interactive_iterations: number;
+  deterministic_iterations: number;
+  interactive_avg_elapsed_ms: number | null;
+  deterministic_avg_elapsed_ms: number | null;
+  interactive_avg_request_count: number | null;
+  deterministic_avg_request_count: number | null;
+  context_request_reduction_ratio: number | null;
+}
+
+export interface InteractivePerformanceMetrics {
+  updated_at: string | null;
+  checkpoint_count: number;
+  valid_count: number;
+  invalid_count: number;
+  skipped_count: number;
+  avg_files_changed: number | null;
+  avg_checkpoint_latency_ms: number | null;
+  p95_checkpoint_latency_ms: number | null;
+  avg_validation_latency_ms: number | null;
+  p95_validation_latency_ms: number | null;
+  avg_diff_capture_latency_ms: number | null;
+  latest: InteractivePerformanceLatestCheckpoint | null;
+  execution_modes: InteractiveExecutionModeMetrics;
+}
+
+export interface AgentSessionCluster {
+  orchestrator_session_id: string;
+  planner_session_id: string;
+  builder_session_id: string;
+  qa_session_id: string;
+}
+
+export interface FileDiffPayload {
+  path: string;
+  language: string;
+  change_type: 'added' | 'modified' | 'deleted' | 'renamed' | 'unknown';
+  original: string;
+  modified: string;
+}
+
+export interface RawLogFileMeta {
+  filename: string;
+  role: 'planner' | 'builder' | 'qa';
+  timestamp: string;
+  size_bytes: number;
+}
+
 export interface CostSummary {
   feature_id: string;
   tokens_used: number;
@@ -104,6 +231,7 @@ export interface FeatureSummary {
   revision_of?: number | null;
   revision_reason?: string | null;
   role_status?: AgentPipelineStatus;
+  cluster?: AgentSessionCluster;
   gate_retry_count?: number;
   last_retry_at?: string | null;
   locks_held?: string[];
@@ -175,6 +303,9 @@ export interface FeatureDetail {
   cost?: CostSummary | null;
   qa_test_index?: QaTestIndex | null;
   review_brief?: ReviewBrief | null;
+  log_entries?: AgentLogEntry[];
+  execution_mode?: FeatureExecutionMode | null;
+  checkpoints?: FeatureCheckpoint[];
 }
 
 export interface DashboardStatusPayload {