oxe-cc 1.2.1 → 1.4.0

package/packages/runtime/src/events/bus.ts

@@ -1,92 +1,92 @@
-import type { OxeEvent } from './envelope';
-import type { EventType } from './catalog';
-import path from 'path';
-import fs from 'fs';
-
-export type EventInput = Partial<Omit<OxeEvent, 'type'>> & { type: EventType };
-
-interface OperationalEvent {
-  event_id?: string;
-  type?: string;
-  timestamp?: string;
-  session_id?: string | null;
-  run_id?: string | null;
-  task_id?: string | null;
-  work_item_id?: string | null;
-  attempt_id?: string | null;
-  causation_id?: string | null;
-  correlation_id?: string | null;
-  payload?: Record<string, unknown>;
-}
-
-function loadOperationalModule(): {
-  appendEvent: (projectRoot: string, sessionId: string | null, event: Record<string, unknown>) => OperationalEvent;
-  readEvents: (projectRoot: string, sessionId: string | null) => OperationalEvent[];
-} {
-  const candidates = [
-    path.resolve(__dirname, '../../../bin/lib/oxe-operational.cjs'),
-    path.resolve(__dirname, '../../../../bin/lib/oxe-operational.cjs'),
-    path.resolve(__dirname, '../../../../../bin/lib/oxe-operational.cjs'),
-  ];
-  for (const candidate of candidates) {
-    if (!fs.existsSync(candidate)) continue;
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    return require(candidate) as {
-      appendEvent: (projectRoot: string, sessionId: string | null, event: Record<string, unknown>) => OperationalEvent;
-      readEvents: (projectRoot: string, sessionId: string | null) => OperationalEvent[];
-    };
-  }
-  throw new Error(`Unable to locate oxe-operational.cjs from ${__dirname}`);
-}
-
-const operational = loadOperationalModule();
-
-function fromOperationalEvent(raw: OperationalEvent): OxeEvent {
-  return {
-    id: String(raw.event_id || ''),
-    type: String(raw.type || 'RunStarted') as EventType,
-    timestamp: String(raw.timestamp || new Date().toISOString()),
-    session_id: raw.session_id ?? null,
-    run_id: raw.run_id ?? null,
-    work_item_id: raw.work_item_id ?? raw.task_id ?? null,
-    attempt_id: raw.attempt_id ?? null,
-    causation_id: raw.causation_id ?? null,
-    correlation_id: raw.correlation_id ?? null,
-    payload: raw.payload && typeof raw.payload === 'object' ? raw.payload : {},
-  };
-}
-
-export function appendEvent(
-  projectRoot: string,
-  sessionId: string | null,
-  input: EventInput,
-  causationId?: string
-): OxeEvent {
-  const event = operational.appendEvent(projectRoot, sessionId, {
-    event_id: input.id,
-    type: input.type,
-    timestamp: input.timestamp,
-    run_id: input.run_id ?? null,
-    work_item_id: input.work_item_id ?? null,
-    attempt_id: input.attempt_id ?? null,
-    causation_id: input.causation_id ?? causationId ?? null,
-    correlation_id: input.correlation_id ?? null,
-    payload: input.payload && typeof input.payload === 'object' ? input.payload : {},
-  });
-  return fromOperationalEvent(event);
-}
-
-export function readEvents(
-  projectRoot: string,
-  sessionId: string | null
-): OxeEvent[] {
-  return operational.readEvents(projectRoot, sessionId).map(fromOperationalEvent);
-}
-
-export function filterByRun(events: OxeEvent[], runId: string): OxeEvent[] {
-  return events.filter((e) => e.run_id === runId);
-}
-
-export function filterByWorkItem(events: OxeEvent[], workItemId: string): OxeEvent[] {
-  return events.filter((e) => e.work_item_id === workItemId);
-}
+import type { OxeEvent } from './envelope';
+import type { EventType } from './catalog';
+import path from 'path';
+import fs from 'fs';
+
+export type EventInput = Partial<Omit<OxeEvent, 'type'>> & { type: EventType };
+
+interface OperationalEvent {
+  event_id?: string;
+  type?: string;
+  timestamp?: string;
+  session_id?: string | null;
+  run_id?: string | null;
+  task_id?: string | null;
+  work_item_id?: string | null;
+  attempt_id?: string | null;
+  causation_id?: string | null;
+  correlation_id?: string | null;
+  payload?: Record<string, unknown>;
+}
+
+function loadOperationalModule(): {
+  appendEvent: (projectRoot: string, sessionId: string | null, event: Record<string, unknown>) => OperationalEvent;
+  readEvents: (projectRoot: string, sessionId: string | null) => OperationalEvent[];
+} {
+  const candidates = [
+    path.resolve(__dirname, '../../../bin/lib/oxe-operational.cjs'),
+    path.resolve(__dirname, '../../../../bin/lib/oxe-operational.cjs'),
+    path.resolve(__dirname, '../../../../../bin/lib/oxe-operational.cjs'),
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(candidate) as {
+      appendEvent: (projectRoot: string, sessionId: string | null, event: Record<string, unknown>) => OperationalEvent;
+      readEvents: (projectRoot: string, sessionId: string | null) => OperationalEvent[];
+    };
+  }
+  throw new Error(`Unable to locate oxe-operational.cjs from ${__dirname}`);
+}
+
+const operational = loadOperationalModule();
+
+function fromOperationalEvent(raw: OperationalEvent): OxeEvent {
+  return {
+    id: String(raw.event_id || ''),
+    type: String(raw.type || 'RunStarted') as EventType,
+    timestamp: String(raw.timestamp || new Date().toISOString()),
+    session_id: raw.session_id ?? null,
+    run_id: raw.run_id ?? null,
+    work_item_id: raw.work_item_id ?? raw.task_id ?? null,
+    attempt_id: raw.attempt_id ?? null,
+    causation_id: raw.causation_id ?? null,
+    correlation_id: raw.correlation_id ?? null,
+    payload: raw.payload && typeof raw.payload === 'object' ? raw.payload : {},
+  };
+}
+
+export function appendEvent(
+  projectRoot: string,
+  sessionId: string | null,
+  input: EventInput,
+  causationId?: string
+): OxeEvent {
+  const event = operational.appendEvent(projectRoot, sessionId, {
+    event_id: input.id,
+    type: input.type,
+    timestamp: input.timestamp,
+    run_id: input.run_id ?? null,
+    work_item_id: input.work_item_id ?? null,
+    attempt_id: input.attempt_id ?? null,
+    causation_id: input.causation_id ?? causationId ?? null,
+    correlation_id: input.correlation_id ?? null,
+    payload: input.payload && typeof input.payload === 'object' ? input.payload : {},
+  });
+  return fromOperationalEvent(event);
+}
+
+export function readEvents(
+  projectRoot: string,
+  sessionId: string | null
+): OxeEvent[] {
+  return operational.readEvents(projectRoot, sessionId).map(fromOperationalEvent);
+}
+
+export function filterByRun(events: OxeEvent[], runId: string): OxeEvent[] {
+  return events.filter((e) => e.run_id === runId);
+}
+
+export function filterByWorkItem(events: OxeEvent[], workItemId: string): OxeEvent[] {
+  return events.filter((e) => e.work_item_id === workItemId);
+}

package/packages/runtime/src/events/catalog.ts

@@ -1,29 +1,29 @@
-export const EVENT_TYPES = [
-  'SessionCreated',
-  'RunStarted',
-  'GraphCompiled',
-  'WorkItemReady',
-  'WorkspaceAllocated',
-  'AttemptStarted',
-  'ToolInvoked',
-  'ToolCompleted',
-  'ToolFailed',
-  'EvidenceCollected',
-  'PolicyEvaluated',
-  'GateRequested',
-  'GateResolved',
-  'VerificationStarted',
-  'VerificationCompleted',
-  'RetryScheduled',
-  'WorkItemCompleted',
-  'WorkItemBlocked',
-  'RunCompleted',
-  'RetroPublished',
-  'LessonPromoted',
-] as const;
-
-export type EventType = (typeof EVENT_TYPES)[number];
-
-export function isValidEventType(type: string): type is EventType {
-  return (EVENT_TYPES as readonly string[]).includes(type);
-}
+export const EVENT_TYPES = [
+  'SessionCreated',
+  'RunStarted',
+  'GraphCompiled',
+  'WorkItemReady',
+  'WorkspaceAllocated',
+  'AttemptStarted',
+  'ToolInvoked',
+  'ToolCompleted',
+  'ToolFailed',
+  'EvidenceCollected',
+  'PolicyEvaluated',
+  'GateRequested',
+  'GateResolved',
+  'VerificationStarted',
+  'VerificationCompleted',
+  'RetryScheduled',
+  'WorkItemCompleted',
+  'WorkItemBlocked',
+  'RunCompleted',
+  'RetroPublished',
+  'LessonPromoted',
+] as const;
+
+export type EventType = (typeof EVENT_TYPES)[number];
+
+export function isValidEventType(type: string): type is EventType {
+  return (EVENT_TYPES as readonly string[]).includes(type);
+}

package/packages/runtime/src/events/envelope.ts

@@ -1,14 +1,14 @@
-import type { EventType } from './catalog';
-
-export interface OxeEvent {
-  id: string;
-  type: EventType;
-  timestamp: string;
-  session_id: string | null;
-  run_id: string | null;
-  work_item_id: string | null;
-  attempt_id: string | null;
-  causation_id: string | null;
-  correlation_id: string | null;
-  payload: Record<string, unknown>;
-}
+import type { EventType } from './catalog';
+
+export interface OxeEvent {
+  id: string;
+  type: EventType;
+  timestamp: string;
+  session_id: string | null;
+  run_id: string | null;
+  work_item_id: string | null;
+  attempt_id: string | null;
+  causation_id: string | null;
+  correlation_id: string | null;
+  payload: Record<string, unknown>;
+}

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

@@ -1,3 +1,3 @@
-export * from './catalog';
-export * from './envelope';
-export * from './bus';
+export * from './catalog';
+export * from './envelope';
+export * from './bus';

package/packages/runtime/src/evidence/evidence-store.ts

@@ -1,130 +1,130 @@
-import crypto from 'crypto';
-import path from 'path';
-import fs from 'fs';
-import type { Evidence, EvidenceType } from '../models/evidence';
-
-export interface EvidenceCollectOptions {
-  work_item_id: string;
-  run_id: string;
-  attempt_number: number;
-}
-
-export interface EvidenceContent {
-  evidence: Evidence;
-  content: Buffer;
-}
-
-const EXT_MAP: Record<EvidenceType, string> = {
-  diff: 'patch',
-  stdout: 'txt',
-  stderr: 'txt',
-  junit_xml: 'xml',
-  coverage: 'json',
-  screenshot: 'png',
-  trace: 'json',
-  log: 'txt',
-  security_report: 'json',
-  api_output: 'json',
-  summary: 'json',
-};
-
-export class EvidenceStore {
-  constructor(private readonly projectRoot: string) {}
-
-  private evidenceDir(runId: string, workItemId: string, attemptNumber: number): string {
-    return path.join(
-      this.projectRoot,
-      '.oxe',
-      'evidence',
-      'runs',
-      runId,
-      workItemId,
-      `attempt-${attemptNumber}`
-    );
-  }
-
-  private indexPath(runId: string, workItemId: string, attemptNumber: number): string {
-    return path.join(this.evidenceDir(runId, workItemId, attemptNumber), 'index.json');
-  }
-
-  private readIndex(runId: string, workItemId: string, attemptNumber: number): Evidence[] {
-    const p = this.indexPath(runId, workItemId, attemptNumber);
-    if (!fs.existsSync(p)) return [];
-    try {
-      return JSON.parse(fs.readFileSync(p, 'utf8')) as Evidence[];
-    } catch {
-      return [];
-    }
-  }
-
-  private writeIndex(runId: string, workItemId: string, attemptNumber: number, items: Evidence[]): void {
-    fs.writeFileSync(this.indexPath(runId, workItemId, attemptNumber), JSON.stringify(items, null, 2), 'utf8');
-  }
-
-  async collect(
-    type: EvidenceType,
-    content: Buffer | string,
-    opts: EvidenceCollectOptions
-  ): Promise<Evidence> {
-    const { work_item_id, run_id, attempt_number } = opts;
-    const dir = this.evidenceDir(run_id, work_item_id, attempt_number);
-    fs.mkdirSync(dir, { recursive: true });
-
-    const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
-    const checksum = crypto.createHash('sha256').update(buf).digest('hex').slice(0, 16);
-    const ext = EXT_MAP[type] ?? 'bin';
-
-    const existing = this.readIndex(run_id, work_item_id, attempt_number);
-    const seq = existing.filter((e) => e.type === type).length + 1;
-    const filename = seq === 1 ? `${type}.${ext}` : `${type}-${seq}.${ext}`;
-    const filePath = path.join(dir, filename);
-
-    fs.writeFileSync(filePath, buf);
-
-    const evidence: Evidence = {
-      evidence_id: `ev-${run_id}-${work_item_id}-a${attempt_number}-${type}-${seq}`,
-      attempt_id: `${work_item_id}-a${attempt_number}`,
-      type,
-      path: path.relative(this.projectRoot, filePath),
-      checksum,
-      created_at: new Date().toISOString(),
-    };
-
-    this.writeIndex(run_id, work_item_id, attempt_number, [...existing, evidence]);
-    return evidence;
-  }
-
-  async list(opts: EvidenceCollectOptions): Promise<Evidence[]> {
-    return this.readIndex(opts.run_id, opts.work_item_id, opts.attempt_number);
-  }
-
-  async get(evidenceId: string, opts: EvidenceCollectOptions): Promise<EvidenceContent | null> {
-    const items = this.readIndex(opts.run_id, opts.work_item_id, opts.attempt_number);
-    const ev = items.find((e) => e.evidence_id === evidenceId);
-    if (!ev) return null;
-    const absPath = path.join(this.projectRoot, ev.path);
-    if (!fs.existsSync(absPath)) return null;
-    return { evidence: ev, content: fs.readFileSync(absPath) };
-  }
-
-  async listByRun(runId: string): Promise<Evidence[]> {
-    const runDir = path.join(this.projectRoot, '.oxe', 'evidence', 'runs', runId);
-    if (!fs.existsSync(runDir)) return [];
-    const all: Evidence[] = [];
-    for (const workItem of fs.readdirSync(runDir)) {
-      const wiDir = path.join(runDir, workItem);
-      for (const attempt of fs.readdirSync(wiDir)) {
-        const indexPath = path.join(wiDir, attempt, 'index.json');
-        if (fs.existsSync(indexPath)) {
-          try {
-            const items = JSON.parse(fs.readFileSync(indexPath, 'utf8')) as Evidence[];
-            all.push(...items);
-          } catch {
-            // skip corrupt index
-          }
-        }
-      }
-    }
-    return all;
-  }
-}
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import type { Evidence, EvidenceType } from '../models/evidence';
+
+export interface EvidenceCollectOptions {
+  work_item_id: string;
+  run_id: string;
+  attempt_number: number;
+}
+
+export interface EvidenceContent {
+  evidence: Evidence;
+  content: Buffer;
+}
+
+const EXT_MAP: Record<EvidenceType, string> = {
+  diff: 'patch',
+  stdout: 'txt',
+  stderr: 'txt',
+  junit_xml: 'xml',
+  coverage: 'json',
+  screenshot: 'png',
+  trace: 'json',
+  log: 'txt',
+  security_report: 'json',
+  api_output: 'json',
+  summary: 'json',
+};
+
+export class EvidenceStore {
+  constructor(private readonly projectRoot: string) {}
+
+  private evidenceDir(runId: string, workItemId: string, attemptNumber: number): string {
+    return path.join(
+      this.projectRoot,
+      '.oxe',
+      'evidence',
+      'runs',
+      runId,
+      workItemId,
+      `attempt-${attemptNumber}`
+    );
+  }
+
+  private indexPath(runId: string, workItemId: string, attemptNumber: number): string {
+    return path.join(this.evidenceDir(runId, workItemId, attemptNumber), 'index.json');
+  }
+
+  private readIndex(runId: string, workItemId: string, attemptNumber: number): Evidence[] {
+    const p = this.indexPath(runId, workItemId, attemptNumber);
+    if (!fs.existsSync(p)) return [];
+    try {
+      return JSON.parse(fs.readFileSync(p, 'utf8')) as Evidence[];
+    } catch {
+      return [];
+    }
+  }
+
+  private writeIndex(runId: string, workItemId: string, attemptNumber: number, items: Evidence[]): void {
+    fs.writeFileSync(this.indexPath(runId, workItemId, attemptNumber), JSON.stringify(items, null, 2), 'utf8');
+  }
+
+  async collect(
+    type: EvidenceType,
+    content: Buffer | string,
+    opts: EvidenceCollectOptions
+  ): Promise<Evidence> {
+    const { work_item_id, run_id, attempt_number } = opts;
+    const dir = this.evidenceDir(run_id, work_item_id, attempt_number);
+    fs.mkdirSync(dir, { recursive: true });
+
+    const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
+    const checksum = crypto.createHash('sha256').update(buf).digest('hex').slice(0, 16);
+    const ext = EXT_MAP[type] ?? 'bin';
+
+    const existing = this.readIndex(run_id, work_item_id, attempt_number);
+    const seq = existing.filter((e) => e.type === type).length + 1;
+    const filename = seq === 1 ? `${type}.${ext}` : `${type}-${seq}.${ext}`;
+    const filePath = path.join(dir, filename);
+
+    fs.writeFileSync(filePath, buf);
+
+    const evidence: Evidence = {
+      evidence_id: `ev-${run_id}-${work_item_id}-a${attempt_number}-${type}-${seq}`,
+      attempt_id: `${work_item_id}-a${attempt_number}`,
+      type,
+      path: path.relative(this.projectRoot, filePath),
+      checksum,
+      created_at: new Date().toISOString(),
+    };
+
+    this.writeIndex(run_id, work_item_id, attempt_number, [...existing, evidence]);
+    return evidence;
+  }
+
+  async list(opts: EvidenceCollectOptions): Promise<Evidence[]> {
+    return this.readIndex(opts.run_id, opts.work_item_id, opts.attempt_number);
+  }
+
+  async get(evidenceId: string, opts: EvidenceCollectOptions): Promise<EvidenceContent | null> {
+    const items = this.readIndex(opts.run_id, opts.work_item_id, opts.attempt_number);
+    const ev = items.find((e) => e.evidence_id === evidenceId);
+    if (!ev) return null;
+    const absPath = path.join(this.projectRoot, ev.path);
+    if (!fs.existsSync(absPath)) return null;
+    return { evidence: ev, content: fs.readFileSync(absPath) };
+  }
+
+  async listByRun(runId: string): Promise<Evidence[]> {
+    const runDir = path.join(this.projectRoot, '.oxe', 'evidence', 'runs', runId);
+    if (!fs.existsSync(runDir)) return [];
+    const all: Evidence[] = [];
+    for (const workItem of fs.readdirSync(runDir)) {
+      const wiDir = path.join(runDir, workItem);
+      for (const attempt of fs.readdirSync(wiDir)) {
+        const indexPath = path.join(wiDir, attempt, 'index.json');
+        if (fs.existsSync(indexPath)) {
+          try {
+            const items = JSON.parse(fs.readFileSync(indexPath, 'utf8')) as Evidence[];
+            all.push(...items);
+          } catch {
+            // skip corrupt index
+          }
+        }
+      }
+    }
+    return all;
+  }
+}

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

@@ -1 +1 @@
-export * from './evidence-store';
+export * from './evidence-store';