oxe-cc 0.9.3 → 1.0.0

package/packages/runtime/src/compiler/graph-compiler.ts

@@ -0,0 +1,245 @@
+import crypto from 'crypto';
+import type { WorkspaceStrategy } from '../models/workspace';
+
+// Mirror of SDK ParsedTask / ParsedSpec / ParsedPlan interfaces
+// (avoids a hard dependency on the CJS SDK from TypeScript source)
+export interface ParsedTask {
+  id: string;
+  title: string;
+  wave: number | null;
+  dependsOn: string[];
+  files: string[];
+  verifyCommand: string | null;
+  aceite: string[];
+  done: boolean;
+  meta?: Record<string, unknown> | null;
+}
+
+export interface ParsedSpecCriterion {
+  id: string;
+  criterion: string;
+  howToVerify: string;
+}
+
+export interface ParsedSpec {
+  objective: string | null;
+  criteria: ParsedSpecCriterion[];
+}
+
+export interface ParsedPlan {
+  tasks: ParsedTask[];
+  waves: Record<number, string[]>;
+  totalTasks: number;
+}
+
+export interface Action {
+  type: 'read_code' | 'generate_patch' | 'run_tests' | 'run_lint' | 'collect_evidence' | 'custom';
+  command?: string;
+  targets?: string[];
+}
+
+export interface VerifyContract {
+  must_pass: string[];
+  acceptance_refs: string[];
+  command: string | null;
+}
+
+export interface NodePolicy {
+  requires_human_approval: boolean;
+  max_retries: number;
+}
+
+export interface GraphNode {
+  id: string;
+  title: string;
+  wave: number;
+  depends_on: string[];
+  workspace_strategy: WorkspaceStrategy;
+  mutation_scope: string[];
+  actions: Action[];
+  verify: VerifyContract;
+  policy: NodePolicy;
+}
+
+export interface GraphEdge {
+  from: string;
+  to: string;
+  type: 'dependency' | 'wave_sequence';
+}
+
+export interface Wave {
+  wave_number: number;
+  node_ids: string[];
+}
+
+export interface ExecutionGraphMetadata {
+  compiled_at: string;
+  plan_hash: string;
+  spec_hash: string;
+  node_count: number;
+  wave_count: number;
+}
+
+export interface ExecutionGraph {
+  nodes: Map<string, GraphNode>;
+  edges: GraphEdge[];
+  waves: Wave[];
+  metadata: ExecutionGraphMetadata;
+}
+
+export interface CompilerOptions {
+  default_workspace_strategy?: WorkspaceStrategy;
+  default_max_retries?: number;
+  require_approval_for_all?: boolean;
+  skip_done_tasks?: boolean;
+}
+
+export function compile(
+  plan: ParsedPlan,
+  spec: ParsedSpec,
+  options: CompilerOptions = {}
+): ExecutionGraph {
+  const {
+    default_workspace_strategy = 'git_worktree',
+    default_max_retries = 2,
+    require_approval_for_all = false,
+    skip_done_tasks = false,
+  } = options;
+
+  const nodes = new Map<string, GraphNode>();
+  const edges: GraphEdge[] = [];
+  const waveMap = new Map<number, string[]>();
+
+  for (const task of plan.tasks) {
+    if (skip_done_tasks && task.done) continue;
+
+    const waveNumber = task.wave ?? 1;
+    const node: GraphNode = {
+      id: task.id,
+      title: task.title,
+      wave: waveNumber,
+      depends_on: task.dependsOn,
+      workspace_strategy: default_workspace_strategy,
+      mutation_scope: task.files,
+      actions: buildActions(task),
+      verify: {
+        must_pass: task.verifyCommand ? ['tests'] : [],
+        acceptance_refs: task.aceite,
+        command: task.verifyCommand,
+      },
+      policy: {
+        requires_human_approval: require_approval_for_all,
+        max_retries: default_max_retries,
+      },
+    };
+
+    nodes.set(task.id, node);
+
+    for (const dep of task.dependsOn) {
+      edges.push({ from: dep, to: task.id, type: 'dependency' });
+    }
+
+    if (!waveMap.has(waveNumber)) waveMap.set(waveNumber, []);
+    waveMap.get(waveNumber)!.push(task.id);
+  }
+
+  const waves: Wave[] = Array.from(waveMap.entries())
+    .sort(([a], [b]) => a - b)
+    .map(([wave_number, node_ids]) => ({ wave_number, node_ids }));
+
+  return {
+    nodes,
+    edges,
+    waves,
+    metadata: {
+      compiled_at: new Date().toISOString(),
+      plan_hash: hashObject(plan),
+      spec_hash: hashObject(spec),
+      node_count: nodes.size,
+      wave_count: waves.length,
+    },
+  };
+}
+
+export function validateGraph(graph: ExecutionGraph): string[] {
+  const errors: string[] = [];
+  const nodeIds = new Set(graph.nodes.keys());
+
+  for (const [id, node] of graph.nodes) {
+    for (const dep of node.depends_on) {
+      if (!nodeIds.has(dep)) {
+        errors.push(`Node ${id} depends on unknown node ${dep}`);
+      }
+    }
+  }
+
+  // Detect cycles using DFS
+  const visited = new Set<string>();
+  const inStack = new Set<string>();
+
+  function hasCycle(nodeId: string): boolean {
+    if (inStack.has(nodeId)) return true;
+    if (visited.has(nodeId)) return false;
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    const node = graph.nodes.get(nodeId);
+    if (node) {
+      for (const dep of node.depends_on) {
+        if (hasCycle(dep)) return true;
+      }
+    }
+    inStack.delete(nodeId);
+    return false;
+  }
+
+  for (const id of nodeIds) {
+    if (hasCycle(id)) {
+      errors.push(`Cycle detected involving node ${id}`);
+      break;
+    }
+  }
+
+  return errors;
+}
+
+export function toSerializable(graph: ExecutionGraph): Record<string, unknown> {
+  return {
+    nodes: Object.fromEntries(graph.nodes),
+    edges: graph.edges,
+    waves: graph.waves,
+    metadata: graph.metadata,
+  };
+}
+
+export function fromSerializable(raw: Record<string, unknown>): ExecutionGraph {
+  const nodes = new Map<string, GraphNode>(
+    Object.entries(raw.nodes as Record<string, GraphNode>)
+  );
+  return {
+    nodes,
+    edges: raw.edges as GraphEdge[],
+    waves: raw.waves as Wave[],
+    metadata: raw.metadata as ExecutionGraphMetadata,
+  };
+}
+
+function buildActions(task: ParsedTask): Action[] {
+  const actions: Action[] = [];
+  if (task.files.length > 0) {
+    actions.push({ type: 'read_code', targets: task.files });
+  }
+  actions.push({ type: 'generate_patch' });
+  if (task.verifyCommand) {
+    actions.push({ type: 'run_tests', command: task.verifyCommand });
+  }
+  actions.push({ type: 'collect_evidence' });
+  return actions;
+}
+
+function hashObject(obj: unknown): string {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(obj))
+    .digest('hex')
+    .slice(0, 12);
+}

package/packages/runtime/src/compiler/index.ts

@@ -0,0 +1 @@
+export * from './graph-compiler';

package/packages/runtime/src/context/context-pack-builder.ts

@@ -0,0 +1,193 @@
+import type { WorkItem } from '../models/work-item';
+import type { Evidence } from '../models/evidence';
+import type { RunState } from '../reducers/run-state-reducer';
+
+export interface ContextArtifact {
+  id: string;
+  kind: 'evidence' | 'lesson' | 'file' | 'summary';
+  content: string;
+  relevanceScore: number;
+  tags: string[];
+}
+
+export interface LessonMetric {
+  lesson_id: string;
+  title: string;
+  tags: string[];
+  embedding?: number[];
+  content: string;
+}
+
+export interface ContextPackOptions {
+  maxArtifacts?: number;
+  maxTokensEstimate?: number;
+  deduplicateThreshold?: number;
+}
+
+export interface ContextPack {
+  work_item_id: string;
+  artifacts: ContextArtifact[];
+  total_artifacts_considered: number;
+  redundancy_removed: number;
+  built_at: string;
+}
+
+// ─── Relevance scoring ────────────────────────────────────────────────────────
+
+function scoreEvidenceRelevance(evidence: Evidence, workItem: WorkItem): number {
+  let score = 0.5;
+  const eid = evidence.evidence_id.toLowerCase();
+  const title = workItem.title.toLowerCase();
+  const scope = workItem.mutation_scope ?? [];
+
+  if (scope.some((s) => eid.includes(s.toLowerCase()))) score += 0.3;
+  if (title.split(/\s+/).some((w) => w.length > 3 && eid.includes(w))) score += 0.1;
+  if (evidence.type === 'junit_xml') score += 0.05;
+  if (evidence.type === 'diff') score += 0.05;
+
+  return Math.min(score, 1.0);
+}
+
+function scoreLessonRelevance(lesson: LessonMetric, workItem: WorkItem): number {
+  const itemTags = new Set([
+    ...workItem.mutation_scope.map((s) => s.toLowerCase()),
+    ...workItem.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3),
+  ]);
+
+  const lessonTags = lesson.tags.map((t) => t.toLowerCase());
+  const overlap = lessonTags.filter((t) => itemTags.has(t)).length;
+  const jaccard = overlap / (itemTags.size + lessonTags.length - overlap || 1);
+
+  return Math.min(0.3 + jaccard * 0.7, 1.0);
+}
+
+// ─── Redundancy elimination ───────────────────────────────────────────────────
+
+function cosineSimilarity(a: ContextArtifact, b: ContextArtifact): number {
+  const wordsA = new Set(a.content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+  const wordsB = new Set(b.content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const w of wordsA) if (wordsB.has(w)) intersection++;
+  return intersection / Math.sqrt(wordsA.size * wordsB.size);
+}
+
+function deduplicateArtifacts(artifacts: ContextArtifact[], threshold: number): { kept: ContextArtifact[]; removed: number } {
+  const kept: ContextArtifact[] = [];
+  let removed = 0;
+
+  for (const candidate of artifacts) {
+    const isDuplicate = kept.some((existing) => cosineSimilarity(candidate, existing) >= threshold);
+    if (isDuplicate) {
+      removed++;
+    } else {
+      kept.push(candidate);
+    }
+  }
+
+  return { kept, removed };
+}
+
+// ─── Token budget estimation ──────────────────────────────────────────────────
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+function applyTokenBudget(artifacts: ContextArtifact[], maxTokens: number): ContextArtifact[] {
+  let used = 0;
+  const result: ContextArtifact[] = [];
+  for (const a of artifacts) {
+    const t = estimateTokens(a.content);
+    if (used + t > maxTokens) break;
+    result.push(a);
+    used += t;
+  }
+  return result;
+}
+
+// ─── Context Pack Builder ─────────────────────────────────────────────────────
+
+export class ContextPackBuilder {
+  constructor(private readonly opts: ContextPackOptions = {}) {}
+
+  build(
+    workItem: WorkItem,
+    state: RunState,
+    evidenceItems: Evidence[],
+    evidenceContents: Map<string, string>,
+    lessons: LessonMetric[],
+  ): ContextPack {
+    const {
+      maxArtifacts = 20,
+      maxTokensEstimate = 8000,
+      deduplicateThreshold = 0.85,
+    } = this.opts;
+
+    const raw: ContextArtifact[] = [];
+
+    // Score and collect evidence
+    for (const ev of evidenceItems) {
+      const content = evidenceContents.get(ev.evidence_id) ?? '';
+      if (!content) continue;
+      raw.push({
+        id: ev.evidence_id,
+        kind: 'evidence',
+        content,
+        relevanceScore: scoreEvidenceRelevance(ev, workItem),
+        tags: [ev.type, workItem.work_item_id],
+      });
+    }
+
+    // Score and collect lessons
+    for (const lesson of lessons) {
+      raw.push({
+        id: lesson.lesson_id,
+        kind: 'lesson',
+        content: lesson.content,
+        relevanceScore: scoreLessonRelevance(lesson, workItem),
+        tags: lesson.tags,
+      });
+    }
+
+    // Add run-level summary if available
+    const completedCount = state.completedWorkItems.size;
+    if (completedCount > 0) {
+      raw.push({
+        id: `run-summary-${workItem.run_id}`,
+        kind: 'summary',
+        content: `Run progress: ${completedCount} completed, ${state.failedWorkItems.size} failed, ${state.blockedWorkItems.size} blocked.`,
+        relevanceScore: 0.4,
+        tags: ['run-context'],
+      });
+    }
+
+    const totalConsidered = raw.length;
+
+    // Sort by relevance descending
+    raw.sort((a, b) => b.relevanceScore - a.relevanceScore);
+
+    // Deduplicate
+    const { kept, removed } = deduplicateArtifacts(raw, deduplicateThreshold);
+
+    // Apply max artifacts cap
+    const capped = kept.slice(0, maxArtifacts);
+
+    // Apply token budget
+    const final = applyTokenBudget(capped, maxTokensEstimate);
+
+    return {
+      work_item_id: workItem.work_item_id,
+      artifacts: final,
+      total_artifacts_considered: totalConsidered,
+      redundancy_removed: removed,
+      built_at: new Date().toISOString(),
+    };
+  }
+
+  /** Convenience: build with no evidence, just lessons and state summary */
+  buildLightweight(workItem: WorkItem, state: RunState, lessons: LessonMetric[]): ContextPack {
+    return this.build(workItem, state, [], new Map(), lessons);
+  }
+}

package/packages/runtime/src/context/index.ts

@@ -0,0 +1 @@
+export * from './context-pack-builder';

package/packages/runtime/src/delivery/branch-manager.ts

@@ -0,0 +1,84 @@
+import { execFileSync, spawnSync } from 'child_process';
+
+export interface BranchInfo {
+  name: string;
+  current: boolean;
+  commit: string;
+}
+
+export class BranchManager {
+  constructor(private readonly projectRoot: string) {}
+
+  currentBranch(): string {
+    return this.git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  }
+
+  currentCommit(): string {
+    return this.git(['rev-parse', 'HEAD']).trim();
+  }
+
+  createSessionBranch(sessionId: string): string {
+    const name = `oxe/${sessionId}`;
+    this.git(['checkout', '-b', name]);
+    return name;
+  }
+
+  createOxeBranch(name: string, base?: string): string {
+    const fullName = name.startsWith('oxe/') ? name : `oxe/${name}`;
+    if (base) {
+      this.git(['checkout', '-b', fullName, base]);
+    } else {
+      this.git(['checkout', '-b', fullName]);
+    }
+    return fullName;
+  }
+
+  switchTo(branchName: string): void {
+    this.git(['checkout', branchName]);
+  }
+
+  deleteBranch(name: string, force = false): void {
+    const flag = force ? '-D' : '-d';
+    this.git(['branch', flag, name]);
+  }
+
+  listOxeBranches(): BranchInfo[] {
+    const raw = this.git(['branch', '--list', 'oxe/*', '--format=%(refname:short) %(objectname:short) %(HEAD)']);
+    return raw
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const parts = line.trim().split(/\s+/);
+        return {
+          name: parts[0],
+          commit: parts[1] ?? '',
+          current: parts[2] === '*',
+        };
+      });
+  }
+
+  mergeWorktreeBranch(worktreeBranch: string, targetBranch: string): void {
+    const saved = this.currentBranch();
+    try {
+      this.git(['checkout', targetBranch]);
+      this.git(['merge', '--no-ff', worktreeBranch, '-m', `oxe: merge ${worktreeBranch}`]);
+    } finally {
+      try { this.git(['checkout', saved]); } catch { /* best effort */ }
+    }
+  }
+
+  branchExists(name: string): boolean {
+    const result = spawnSync('git', ['rev-parse', '--verify', name], {
+      cwd: this.projectRoot,
+      encoding: 'utf8',
+    });
+    return result.status === 0;
+  }
+
+  private git(args: string[]): string {
+    return execFileSync('git', args, {
+      cwd: this.projectRoot,
+      encoding: 'utf8',
+    });
+  }
+}