oxe-cc 1.0.0 → 1.3.0

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

@@ -1,193 +1,259 @@
-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);
-  }
-}
+import type { WorkItem } from '../models/work-item';
+import type { Evidence } from '../models/evidence';
+import type { RunState } from '../reducers/run-state-reducer';
+import type { ContextProfile } from './context-profiles';
+import type { AutonomyTier } from '../policy/policy-engine';
+
+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;
+}
+
+// ─── Quality scoring ─────────────────────────────────────────────────────────
+
+export interface ContextQualityScore {
+  completeness: number;
+  relevance_mean: number;
+  redundancy: number;
+  recency_score: number;
+  overall: number;
+}
+
+export function scorePackQuality(pack: ContextPack, profile: ContextProfile): ContextQualityScore {
+  const expectedKinds = Object.keys(profile.artifact_kind_weights) as ContextArtifact['kind'][];
+  const presentKinds = new Set(pack.artifacts.map((a) => a.kind));
+  const completeness = expectedKinds.length > 0
+    ? expectedKinds.filter((k) => presentKinds.has(k)).length / expectedKinds.length
+    : 0;
+
+  const relevance_mean = pack.artifacts.length > 0
+    ? pack.artifacts.reduce((sum, a) => sum + a.relevanceScore, 0) / pack.artifacts.length
+    : 0;
+
+  const total = pack.total_artifacts_considered;
+  const redundancy = total > 0 ? 1 - (pack.artifacts.length / total) : 0;
+
+  const ageMs = Date.now() - new Date(pack.built_at).getTime();
+  const maxAgeMs = 24 * 60 * 60 * 1000;
+  const recency_score = Math.max(0, 1 - ageMs / maxAgeMs);
+
+  const overall = Math.min(1,
+    0.3 * completeness +
+    0.35 * relevance_mean +
+    0.1 * (1 - redundancy) +
+    0.25 * recency_score
+  );
+
+  return {
+    completeness: Math.round(completeness * 100) / 100,
+    relevance_mean: Math.round(relevance_mean * 100) / 100,
+    redundancy: Math.round(redundancy * 100) / 100,
+    recency_score: Math.round(recency_score * 100) / 100,
+    overall: Math.round(overall * 100) / 100,
+  };
+}
+
+// ─── 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);
+  }
+
+  /**
+   * Filter artifacts to those whose path-like tags are within mutation_scope.
+   * L0/L1 tiers apply the filter; L2/L3 skip it (full access).
+   */
+  filterByMutationScope(
+    artifacts: ContextArtifact[],
+    mutationScope: string[],
+    autonomyTier: AutonomyTier
+  ): ContextArtifact[] {
+    if (autonomyTier === 'L2' || autonomyTier === 'L3') return artifacts;
+    const scope = mutationScope.map((s) => s.toLowerCase());
+    return artifacts.filter((a) => {
+      const pathTags = a.tags.filter((t) => t.includes('/') || t.includes('\\'));
+      if (pathTags.length === 0) return true;
+      return pathTags.some((tag) =>
+        scope.some((s) => tag.toLowerCase().includes(s) || s.includes(tag.toLowerCase()))
+      );
+    });
+  }
+}

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

@@ -0,0 +1,197 @@
+import path from 'path';
+import fs from 'fs';
+import type { ContextPack, ContextArtifact, ContextQualityScore } from './context-pack-builder';
+
+export interface ContextPackMeta {
+  pack_id: string;
+  work_item_id: string;
+  run_id: string;
+  built_at: string;
+  artifact_count: number;
+  estimated_tokens: number;
+  stale: boolean;
+  stale_reason: string | null;
+}
+
+export interface ContextPackDiff {
+  added: string[];
+  removed: string[];
+  score_changed: Array<{ id: string; before: number; after: number }>;
+}
+
+function packPath(projectRoot: string, runId: string, workItemId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, `context-pack-${workItemId}.json`);
+}
+
+function metaIndexPath(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'context-packs.index.json');
+}
+
+function estimateTokens(pack: ContextPack): number {
+  return Math.ceil(pack.artifacts.reduce((sum, a) => sum + a.content.length, 0) / 4);
+}
+
+export function savePack(
+  projectRoot: string,
+  runId: string,
+  pack: ContextPack
+): ContextPackMeta {
+  const p = packPath(projectRoot, runId, pack.work_item_id);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(pack, null, 2), 'utf8');
+
+  const meta: ContextPackMeta = {
+    pack_id: `cp-${runId}-${pack.work_item_id}`,
+    work_item_id: pack.work_item_id,
+    run_id: runId,
+    built_at: pack.built_at,
+    artifact_count: pack.artifacts.length,
+    estimated_tokens: estimateTokens(pack),
+    stale: false,
+    stale_reason: null,
+  };
+
+  updateMetaIndex(projectRoot, runId, meta);
+  return meta;
+}
+
+export function loadPack(
+  projectRoot: string,
+  runId: string,
+  workItemId: string
+): ContextPack | null {
+  const p = packPath(projectRoot, runId, workItemId);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as ContextPack;
+  } catch {
+    return null;
+  }
+}
+
+export function markStale(
+  projectRoot: string,
+  runId: string,
+  workItemId: string,
+  reason: string
+): void {
+  const index = loadMetaIndex(projectRoot, runId);
+  const meta = index.find((m) => m.work_item_id === workItemId);
+  if (!meta) return;
+  meta.stale = true;
+  meta.stale_reason = reason;
+  saveMetaIndex(projectRoot, runId, index);
+}
+
+export function isStale(
+  projectRoot: string,
+  runId: string,
+  workItemId: string
+): boolean {
+  const index = loadMetaIndex(projectRoot, runId);
+  return index.find((m) => m.work_item_id === workItemId)?.stale ?? false;
+}
+
+export function diffPacks(before: ContextPack, after: ContextPack): ContextPackDiff {
+  const beforeIds = new Set(before.artifacts.map((a) => a.id));
+  const afterIds = new Set(after.artifacts.map((a) => a.id));
+  const beforeMap = new Map(before.artifacts.map((a) => [a.id, a]));
+  const afterMap = new Map(after.artifacts.map((a) => [a.id, a]));
+
+  const added = [...afterIds].filter((id) => !beforeIds.has(id));
+  const removed = [...beforeIds].filter((id) => !afterIds.has(id));
+
+  const score_changed: ContextPackDiff['score_changed'] = [];
+  for (const id of afterIds) {
+    if (!beforeIds.has(id)) continue;
+    const bScore = beforeMap.get(id)!.relevanceScore;
+    const aScore = afterMap.get(id)!.relevanceScore;
+    if (Math.abs(bScore - aScore) > 0.05) {
+      score_changed.push({ id, before: bScore, after: aScore });
+    }
+  }
+
+  return { added, removed, score_changed };
+}
+
+export function listPackMeta(projectRoot: string, runId: string): ContextPackMeta[] {
+  return loadMetaIndex(projectRoot, runId);
+}
+
+// ─── ContextPackRef — link pack to a specific execution attempt ───────────────
+
+export interface ContextPackRef {
+  ref_id: string;
+  pack_id: string;
+  attempt_id: string;
+  work_item_id: string;
+  run_id: string;
+  artifacts_used: string[];
+  quality: ContextQualityScore;
+  linked_at: string;
+}
+
+function packRefPath(projectRoot: string, runId: string, attemptId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, `context-ref-${attemptId}.json`);
+}
+
+export function linkPackToAttempt(
+  projectRoot: string,
+  runId: string,
+  attemptId: string,
+  pack: ContextPack,
+  quality: ContextQualityScore
+): ContextPackRef {
+  const ref: ContextPackRef = {
+    ref_id: `ref-${runId}-${attemptId}`,
+    pack_id: `cp-${runId}-${pack.work_item_id}`,
+    attempt_id: attemptId,
+    work_item_id: pack.work_item_id,
+    run_id: runId,
+    artifacts_used: pack.artifacts.map((a) => a.id),
+    quality,
+    linked_at: new Date().toISOString(),
+  };
+  const p = packRefPath(projectRoot, runId, attemptId);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(ref, null, 2), 'utf8');
+  return ref;
+}
+
+export function getPackRefForAttempt(
+  projectRoot: string,
+  runId: string,
+  attemptId: string
+): ContextPackRef | null {
+  const p = packRefPath(projectRoot, runId, attemptId);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as ContextPackRef;
+  } catch {
+    return null;
+  }
+}
+
+function loadMetaIndex(projectRoot: string, runId: string): ContextPackMeta[] {
+  const p = metaIndexPath(projectRoot, runId);
+  if (!fs.existsSync(p)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as ContextPackMeta[];
+  } catch {
+    return [];
+  }
+}
+
+function saveMetaIndex(projectRoot: string, runId: string, index: ContextPackMeta[]): void {
+  const p = metaIndexPath(projectRoot, runId);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(index, null, 2), 'utf8');
+}
+
+function updateMetaIndex(projectRoot: string, runId: string, meta: ContextPackMeta): void {
+  const index = loadMetaIndex(projectRoot, runId);
+  const idx = index.findIndex((m) => m.work_item_id === meta.work_item_id);
+  if (idx >= 0) index[idx] = meta;
+  else index.push(meta);
+  saveMetaIndex(projectRoot, runId, index);
+}