oxe-cc 0.9.2 → 1.0.0

package/packages/runtime/src/plugins/plugin-abi.ts

@@ -0,0 +1,95 @@
+import type { WorkspaceRequest, WorkspaceManager } from '../workspace/workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../models/workspace';
+import type { VerificationResult } from '../models/verification-result';
+
+// ─── ToolProvider ────────────────────────────────────────────────────────────
+
+export interface ToolInvocationInput {
+  action_type: string;
+  work_item_id: string;
+  run_id: string;
+  attempt_id: string;
+  params: Record<string, unknown>;
+  workspace_root: string;
+}
+
+export interface ToolInvocationResult {
+  success: boolean;
+  output: string;
+  evidence_paths: string[];
+  side_effects_applied: string[];
+  error?: string;
+}
+
+export interface ToolProvider {
+  readonly name: string;
+  readonly kind: 'read' | 'mutation' | 'verification' | 'analysis' | 'external_operation';
+  readonly idempotent: boolean;
+  supports(actionType: string): boolean;
+  invoke(input: ToolInvocationInput): Promise<ToolInvocationResult>;
+}
+
+// ─── WorkspaceProvider ───────────────────────────────────────────────────────
+
+export interface WorkspaceProvider extends WorkspaceManager {
+  readonly name: string;
+  supportsStrategy(strategy: string): boolean;
+}
+
+// ─── VerifierProvider ────────────────────────────────────────────────────────
+
+export interface VerificationInput {
+  check_id: string;
+  check_type: string;
+  command: string | null;
+  work_item_id: string;
+  workspace_root: string;
+  evidence_dir: string;
+}
+
+export interface VerifierProvider {
+  readonly name: string;
+  supports(checkType: string): boolean;
+  execute(input: VerificationInput): Promise<VerificationResult>;
+}
+
+// ─── ContextProvider ─────────────────────────────────────────────────────────
+
+export interface ContextRequest {
+  work_item_id: string;
+  run_id: string;
+  decision_type: 'execute' | 'verify' | 'plan' | 'review';
+  artifact_paths: string[];
+  project_root: string;
+}
+
+export interface PluginContextArtifact {
+  source: string;
+  weight: number;
+  reason: string;
+  content?: string;
+}
+
+export interface PluginContextArtifacts {
+  included: PluginContextArtifact[];
+  excluded: Array<{ source: string; reason: string }>;
+  total_weight: number;
+}
+
+export interface ContextProvider {
+  readonly name: string;
+  collect(input: ContextRequest): Promise<PluginContextArtifacts>;
+}
+
+// ─── OxePlugin (unified) ─────────────────────────────────────────────────────
+
+export interface OxePlugin {
+  readonly name: string;
+  readonly version?: string;
+  toolProviders?: ToolProvider[];
+  workspaceProviders?: WorkspaceProvider[];
+  verifierProviders?: VerifierProvider[];
+  contextProviders?: ContextProvider[];
+  /** Legacy lifecycle hooks (compatible with oxe-plugins.cjs) */
+  hooks?: Record<string, (ctx: Record<string, unknown>) => Promise<void> | void>;
+}

package/packages/runtime/src/plugins/plugin-registry.ts

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import type {
+  OxePlugin,
+  ToolProvider,
+  WorkspaceProvider,
+  VerifierProvider,
+  ContextProvider,
+} from './plugin-abi';
+
+export class PluginRegistry {
+  private plugins: OxePlugin[] = [];
+
+  register(plugin: OxePlugin): void {
+    if (this.plugins.some((p) => p.name === plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    this.plugins.push(plugin);
+  }
+
+  unregister(name: string): void {
+    this.plugins = this.plugins.filter((p) => p.name !== name);
+  }
+
+  loadFromDirectory(dir: string): string[] {
+    if (!fs.existsSync(dir)) return [];
+    const loaded: string[] = [];
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith('.cjs') && !file.endsWith('.js')) continue;
+      const fullPath = path.resolve(dir, file);
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require(fullPath) as OxePlugin | { default?: OxePlugin };
+        const plugin = 'default' in mod && mod.default ? mod.default : (mod as OxePlugin);
+        if (plugin && plugin.name) {
+          this.register(plugin);
+          loaded.push(plugin.name);
+        }
+      } catch {
+        // skip invalid plugin files
+      }
+    }
+    return loaded;
+  }
+
+  toolProviderFor(actionType: string): ToolProvider | null {
+    for (const plugin of this.plugins) {
+      const provider = plugin.toolProviders?.find((p) => p.supports(actionType));
+      if (provider) return provider;
+    }
+    return null;
+  }
+
+  workspaceProviderFor(strategy: string): WorkspaceProvider | null {
+    for (const plugin of this.plugins) {
+      const provider = plugin.workspaceProviders?.find((p) => p.supportsStrategy(strategy));
+      if (provider) return provider;
+    }
+    return null;
+  }
+
+  verifierProviderFor(checkType: string): VerifierProvider | null {
+    for (const plugin of this.plugins) {
+      const provider = plugin.verifierProviders?.find((p) => p.supports(checkType));
+      if (provider) return provider;
+    }
+    return null;
+  }
+
+  contextProviderFor(name: string): ContextProvider | null {
+    for (const plugin of this.plugins) {
+      const provider = plugin.contextProviders?.find((p) => p.name === name);
+      if (provider) return provider;
+    }
+    return null;
+  }
+
+  allContextProviders(): ContextProvider[] {
+    return this.plugins.flatMap((p) => p.contextProviders ?? []);
+  }
+
+  allToolProviders(): ToolProvider[] {
+    return this.plugins.flatMap((p) => p.toolProviders ?? []);
+  }
+
+  async runHook(
+    hookName: string,
+    ctx: Record<string, unknown>
+  ): Promise<void> {
+    for (const plugin of this.plugins) {
+      const hook = plugin.hooks?.[hookName];
+      if (hook) await hook(ctx);
+    }
+  }
+
+  list(): Array<{ name: string; version?: string; providers: string[] }> {
+    return this.plugins.map((p) => ({
+      name: p.name,
+      version: p.version,
+      providers: [
+        ...(p.toolProviders?.map((tp) => `tool:${tp.name}`) ?? []),
+        ...(p.workspaceProviders?.map((wp) => `workspace:${wp.name}`) ?? []),
+        ...(p.verifierProviders?.map((vp) => `verifier:${vp.name}`) ?? []),
+        ...(p.contextProviders?.map((cp) => `context:${cp.name}`) ?? []),
+      ],
+    }));
+  }
+}
+
+let _globalRegistry: PluginRegistry | null = null;
+
+export function globalRegistry(): PluginRegistry {
+  if (!_globalRegistry) _globalRegistry = new PluginRegistry();
+  return _globalRegistry;
+}
+
+export function resetGlobalRegistry(): void {
+  _globalRegistry = null;
+}

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

@@ -0,0 +1 @@
+export * from './policy-engine';

package/packages/runtime/src/policy/policy-engine.ts

@@ -0,0 +1,113 @@
+export type PolicyAction = 'allow' | 'deny' | 'require_human_gate';
+
+export interface PolicyWhenClause {
+  tool?: string;
+  env?: string;
+  kind?: string;
+}
+
+export interface PolicyAssertClause {
+  diff_within_scope?: boolean;
+}
+
+export interface PolicyRule {
+  id: string;
+  when: PolicyWhenClause;
+  assert?: PolicyAssertClause;
+  action: PolicyAction;
+}
+
+export interface PolicyContext {
+  tool: string;
+  env?: string;
+  kind?: string;
+  mutation_scope?: string[];
+  affected_paths?: string[];
+}
+
+export interface PolicyDecision {
+  allowed: boolean;
+  gate_required: boolean;
+  reason: string;
+  rule_id: string | null;
+}
+
+const ALLOW_ALL: PolicyDecision = {
+  allowed: true,
+  gate_required: false,
+  reason: 'no matching policy — default allow',
+  rule_id: null,
+};
+
+export class PolicyEngine {
+  constructor(private readonly rules: PolicyRule[] = []) {}
+
+  evaluate(ctx: PolicyContext): PolicyDecision {
+    for (const rule of this.rules) {
+      if (!this.matches(rule.when, ctx)) continue;
+
+      if (rule.assert) {
+        const assertFailed = this.checkAssert(rule.assert, ctx);
+        if (assertFailed) {
+          return {
+            allowed: false,
+            gate_required: false,
+            reason: `Assert failed for rule ${rule.id}: ${assertFailed}`,
+            rule_id: rule.id,
+          };
+        }
+      }
+
+      switch (rule.action) {
+        case 'allow':
+          return { allowed: true, gate_required: false, reason: `Allowed by rule ${rule.id}`, rule_id: rule.id };
+        case 'deny':
+          return { allowed: false, gate_required: false, reason: `Denied by rule ${rule.id}`, rule_id: rule.id };
+        case 'require_human_gate':
+          return { allowed: true, gate_required: true, reason: `Gate required by rule ${rule.id}`, rule_id: rule.id };
+      }
+    }
+    return ALLOW_ALL;
+  }
+
+  private matches(when: PolicyWhenClause, ctx: PolicyContext): boolean {
+    if (when.tool && when.tool !== ctx.tool) return false;
+    if (when.env && when.env !== ctx.env) return false;
+    if (when.kind && when.kind !== ctx.kind) return false;
+    return true;
+  }
+
+  private checkAssert(assert: PolicyAssertClause, ctx: PolicyContext): string | null {
+    if (assert.diff_within_scope === true) {
+      const scope = ctx.mutation_scope ?? [];
+      const affected = ctx.affected_paths ?? [];
+      if (scope.length === 0) return null; // no scope declared — pass
+      const outsideScope = affected.filter(
+        (p) => !scope.some((s) => p.startsWith(s) || s.startsWith(p))
+      );
+      if (outsideScope.length > 0) {
+        return `paths outside mutation scope: ${outsideScope.join(', ')}`;
+      }
+    }
+    return null;
+  }
+
+  withRule(rule: PolicyRule): PolicyEngine {
+    return new PolicyEngine([...this.rules, rule]);
+  }
+
+  static fromConfig(config: { policies?: PolicyRule[] }): PolicyEngine {
+    return new PolicyEngine(config.policies ?? []);
+  }
+
+  static fromConfigFile(configPath: string): PolicyEngine {
+    try {
+      // Dynamic require to avoid bundling issues
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const cfg = require(configPath) as { policies?: PolicyRule[] };
+      return PolicyEngine.fromConfig(cfg);
+    } catch {
+      return new PolicyEngine();
+    }
+  }
+}

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

@@ -0,0 +1 @@
+export * from './projection-engine';

package/packages/runtime/src/projection/projection-engine.ts

@@ -0,0 +1,249 @@
+import type { RunState } from '../reducers/run-state-reducer';
+import type { ExecutionGraph } from '../compiler/graph-compiler';
+import type { VerificationResult } from '../models/verification-result';
+import type { CheckResult } from '../verification/verification-compiler';
+
+function isoToDate(iso: string | null | undefined): string {
+  if (!iso) return '—';
+  return iso.slice(0, 10);
+}
+
+function statusIcon(status: string): string {
+  switch (status) {
+    case 'completed': return '✓';
+    case 'failed': return '✗';
+    case 'blocked': return '⊘';
+    case 'running': return '⟳';
+    default: return '○';
+  }
+}
+
+function verifyIcon(status: string): string {
+  switch (status) {
+    case 'pass': return '✓ PASS';
+    case 'fail': return '✗ FAIL';
+    case 'skip': return '— SKIP';
+    case 'error': return '! ERROR';
+    default: return status;
+  }
+}
+
+export class ProjectionEngine {
+  projectPlan(state: RunState, graph: ExecutionGraph): string {
+    const run = state.run;
+    const lines: string[] = [
+      '# OXE — Plano de Execução',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Resumo',
+      '',
+      `- **Run:** ${run?.run_id ?? '—'}`,
+      `- **Status:** ${run?.status ?? 'sem run'}`,
+      `- **Iniciado em:** ${isoToDate(run?.started_at)}`,
+      `- **Nós:** ${graph.metadata.node_count} tarefas em ${graph.metadata.wave_count} onda(s)`,
+      '',
+      '## Ondas e tarefas',
+      '',
+    ];
+
+    for (const wave of graph.waves) {
+      lines.push(`### Onda ${wave.wave_number}`);
+      lines.push('');
+      lines.push('| ID | Título | Status | Dependências |');
+      lines.push('|----|--------|--------|--------------|');
+      for (const nodeId of wave.node_ids) {
+        const node = graph.nodes.get(nodeId);
+        const wItem = state.workItems.get(nodeId);
+        const status = wItem?.status ?? 'pending';
+        const deps = node?.depends_on.join(', ') || '—';
+        lines.push(`| ${nodeId} | ${node?.title ?? nodeId} | ${statusIcon(status)} ${status} | ${deps} |`);
+      }
+      lines.push('');
+    }
+
+    if (state.completedWorkItems.size > 0 || state.failedWorkItems.size > 0) {
+      lines.push('## Progresso');
+      lines.push('');
+      lines.push(`- **Concluídos:** ${[...state.completedWorkItems].join(', ') || '—'}`);
+      lines.push(`- **Falhos:** ${[...state.failedWorkItems].join(', ') || '—'}`);
+      lines.push(`- **Bloqueados:** ${[...state.blockedWorkItems].join(', ') || '—'}`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  projectVerify(
+    state: RunState,
+    results: VerificationResult[],
+    checkResults?: CheckResult[]
+  ): string {
+    const run = state.run;
+    const lines: string[] = [
+      '# OXE — Verificação',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Auditoria de pré-execução',
+      '',
+      `- **Run:** ${run?.run_id ?? '—'}`,
+      `- **Iniciado em:** ${isoToDate(run?.started_at)}`,
+      `- **Concluído em:** ${isoToDate(run?.ended_at)}`,
+      `- **Status:** ${run?.status ?? '—'}`,
+      '',
+    ];
+
+    if (results.length > 0) {
+      lines.push('## Critérios de aceite');
+      lines.push('');
+      lines.push('| ID | Check | Status | Evidências |');
+      lines.push('|----|-------|--------|------------|');
+      for (const r of results) {
+        const evidenceList = r.evidence_refs.join(', ') || '—';
+        lines.push(`| ${r.check_id} | ${r.summary ?? r.check_id} | ${verifyIcon(r.status)} | ${evidenceList} |`);
+      }
+      lines.push('');
+    }
+
+    if (checkResults && checkResults.length > 0) {
+      lines.push('## Resultados dos checks executados');
+      lines.push('');
+      lines.push('| Check | Aceite | Status | Duração |');
+      lines.push('|-------|--------|--------|---------|');
+      for (const cr of checkResults) {
+        lines.push(`| ${cr.check_id} | ${cr.acceptance_ref ?? '—'} | ${verifyIcon(cr.status)} | ${cr.duration_ms}ms |`);
+      }
+      lines.push('');
+    }
+
+    const passed = results.filter((r) => r.status === 'pass').length;
+    const failed = results.filter((r) => r.status === 'fail').length;
+    const allPass = failed === 0 && results.length > 0;
+
+    lines.push('## Conclusão');
+    lines.push('');
+    lines.push(`- **Total de critérios:** ${results.length}`);
+    lines.push(`- **Aprovados:** ${passed}`);
+    lines.push(`- **Reprovados:** ${failed}`);
+    lines.push('');
+    lines.push(allPass
+      ? '> ✓ **Verificação concluída com sucesso.** Todos os critérios foram atendidos.'
+      : `> ✗ **Verificação com falhas.** ${failed} critério(s) não atendido(s).`);
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  projectState(state: RunState): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+    const blocked = [...state.blockedWorkItems];
+
+    const lines: string[] = [
+      '# OXE — Estado',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Fase atual',
+      '',
+      `- **Status da run:** ${run?.status ?? 'sem run ativa'}`,
+      `- **Run ID:** ${run?.run_id ?? '—'}`,
+      `- **Modo:** ${run?.mode ?? '—'}`,
+      '',
+      '## Runtime operacional',
+      '',
+      `- **runtime_status:** ${run?.status ?? '—'}`,
+      `- **active_run_ref:** ${run?.run_id ?? '—'}`,
+      '',
+      '## Progresso',
+      '',
+      `- **Concluídos (${completed.length}):** ${completed.join(', ') || '—'}`,
+      `- **Falhos (${failed.length}):** ${failed.join(', ') || '—'}`,
+      `- **Bloqueados (${blocked.length}):** ${blocked.join(', ') || '—'}`,
+      '',
+      `- **lifecycleStatus:** ${run?.status === 'completed' ? 'closed' : run?.status === 'running' ? 'executing' : 'pending_execute'}`,
+      '',
+    ];
+
+    return lines.join('\n');
+  }
+
+  projectRunSummary(state: RunState): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+    const blocked = [...state.blockedWorkItems];
+    const totalAttempts = [...state.attempts.values()].reduce((s, a) => s + a.length, 0);
+
+    const lines: string[] = [
+      `## Run Summary — ${run?.run_id ?? 'unknown'}`,
+      '',
+      `**Status:** ${run?.status ?? '—'}  `,
+      `**Mode:** ${run?.mode ?? '—'}  `,
+      `**Started:** ${isoToDate(run?.started_at)}  `,
+      `**Ended:** ${isoToDate(run?.ended_at)}  `,
+      '',
+      `**Completed:** ${completed.length} tasks  `,
+      `**Failed:** ${failed.length} tasks  `,
+      `**Blocked:** ${blocked.length} tasks  `,
+      `**Total attempts:** ${totalAttempts}  `,
+      '',
+    ];
+
+    if (completed.length > 0) {
+      lines.push(`**✓ Completed:** ${completed.join(', ')}`);
+    }
+    if (failed.length > 0) {
+      lines.push(`**✗ Failed:** ${failed.join(', ')}`);
+    }
+    if (blocked.length > 0) {
+      lines.push(`**⊘ Blocked:** ${blocked.join(', ')}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  projectPRSummary(state: RunState, graph: ExecutionGraph): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+
+    const lines: string[] = [
+      '## Summary',
+      '',
+    ];
+
+    if (completed.length > 0) {
+      for (const id of completed) {
+        const node = graph.nodes.get(id);
+        lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
+      }
+    }
+
+    if (failed.length > 0) {
+      lines.push('');
+      lines.push('**⚠️ Incomplete tasks:**');
+      for (const id of failed) {
+        const node = graph.nodes.get(id);
+        lines.push(`- ✗ ${node?.title ?? id} (\`${id}\`)`);
+      }
+    }
+
+    lines.push('');
+    lines.push('## Test plan');
+    lines.push('');
+
+    for (const wave of graph.waves) {
+      lines.push(`- [ ] Wave ${wave.wave_number}: ${wave.node_ids.join(', ')}`);
+    }
+
+    lines.push('');
+    lines.push(`**Run:** \`${run?.run_id ?? '—'}\` | **Status:** ${run?.status ?? '—'}`);
+    lines.push('');
+    lines.push('🤖 Generated with [OXE Runtime](https://github.com/propagno/oxe-build)');
+
+    return lines.join('\n');
+  }
+}

package/packages/runtime/src/reducers/debug-reducer.ts

@@ -0,0 +1,36 @@
+import type { OxeEvent } from '../events/envelope';
+import { createEmptyRunState, applyEventExported as applyEvent } from './run-state-reducer';
+import type { RunState } from './run-state-reducer';
+
+export interface ReplayStep {
+  index: number;
+  event: OxeEvent;
+  state: RunState;
+}
+
+export function* stepReplay(events: OxeEvent[]): Generator<ReplayStep> {
+  let state = createEmptyRunState();
+  for (let i = 0; i < events.length; i++) {
+    state = applyEvent(state, events[i]);
+    yield { index: i, event: events[i], state };
+  }
+}
+
+export function replayUntil(
+  events: OxeEvent[],
+  predicate: (step: ReplayStep) => boolean
+): ReplayStep | null {
+  for (const step of stepReplay(events)) {
+    if (predicate(step)) return step;
+  }
+  return null;
+}
+
+export function replaySlice(events: OxeEvent[], from: number, to: number): ReplayStep[] {
+  const steps: ReplayStep[] = [];
+  for (const step of stepReplay(events)) {
+    if (step.index >= from && step.index <= to) steps.push(step);
+    if (step.index > to) break;
+  }
+  return steps;
+}

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

@@ -0,0 +1,2 @@
+export * from './run-state-reducer';
+export * from './debug-reducer';