oxe-cc 0.9.2 → 1.0.0

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

@@ -0,0 +1,225 @@
+import crypto from 'crypto';
+import { spawnSync } from 'child_process';
+import type { EvidenceType } from '../models/evidence';
+import type { VerificationStatus } from '../models/verification-result';
+
+export type CheckType =
+  | 'unit'
+  | 'integration'
+  | 'contract'
+  | 'smoke'
+  | 'policy'
+  | 'security'
+  | 'ux_snapshot'
+  | 'performance_baseline'
+  | 'custom';
+
+export interface AcceptanceCheck {
+  id: string;
+  type: CheckType;
+  command: string | null;
+  evidence_type_expected: EvidenceType;
+  acceptance_ref: string | null;
+  description: string;
+}
+
+export interface AcceptanceCheckSuite {
+  checks: AcceptanceCheck[];
+  compiled_at: string;
+  spec_hash: string;
+  plan_hash: string;
+}
+
+export interface CheckResult {
+  check_id: string;
+  acceptance_ref: string | null;
+  status: VerificationStatus;
+  stdout: string;
+  stderr: string;
+  exit_code: number | null;
+  duration_ms: number;
+  error: string | null;
+}
+
+// Mirror of ParsedSpec/ParsedPlan (same as in graph-compiler to avoid circular deps)
+interface Criterion {
+  id: string;
+  criterion: string;
+  howToVerify: string;
+}
+
+interface ParsedSpecLike {
+  objective: string | null;
+  criteria: Criterion[];
+}
+
+interface ParsedTaskLike {
+  id: string;
+  verifyCommand: string | null;
+  aceite: string[];
+}
+
+interface ParsedPlanLike {
+  tasks: ParsedTaskLike[];
+}
+
+function inferCheckType(howToVerify: string): CheckType {
+  const v = howToVerify.toLowerCase();
+  if (v.includes('npm test') || v.includes('jest') || v.includes('vitest') || v.includes('node --test')) return 'unit';
+  if (v.includes('postman') || v.includes('newman') || v.includes('integration')) return 'integration';
+  if (v.includes('smoke') || v.includes('curl')) return 'smoke';
+  if (v.includes('eslint') || v.includes('lint') || v.includes('oxe-policy')) return 'policy';
+  if (v.includes('security') || v.includes('audit') || v.includes('trivy')) return 'security';
+  return 'custom';
+}
+
+function inferEvidenceType(checkType: CheckType): EvidenceType {
+  switch (checkType) {
+    case 'unit': return 'junit_xml';
+    case 'integration': return 'api_output';
+    case 'security': return 'security_report';
+    case 'policy': return 'log';
+    default: return 'stdout';
+  }
+}
+
+export function compile(
+  spec: ParsedSpecLike,
+  plan: ParsedPlanLike
+): AcceptanceCheckSuite {
+  const checks: AcceptanceCheck[] = [];
+  const seenRefs = new Set<string>();
+
+  // Generate checks from spec criteria
+  for (const criterion of spec.criteria) {
+    // Find the verify command from the task that references this criterion
+    const task = plan.tasks.find((t) => t.aceite.includes(criterion.id));
+    const command = task?.verifyCommand ?? null;
+    const type = inferCheckType(criterion.howToVerify);
+
+    checks.push({
+      id: `check-${criterion.id.toLowerCase()}`,
+      type,
+      command: command ?? (criterion.howToVerify.startsWith('#') ? null : criterion.howToVerify),
+      evidence_type_expected: inferEvidenceType(type),
+      acceptance_ref: criterion.id,
+      description: criterion.criterion,
+    });
+    seenRefs.add(criterion.id);
+  }
+
+  // Add checks for task verify commands not already covered
+  for (const task of plan.tasks) {
+    if (!task.verifyCommand) continue;
+    const uncovered = task.aceite.filter((ref) => !seenRefs.has(ref));
+    if (uncovered.length === 0 && checks.some((c) => c.command === task.verifyCommand)) continue;
+
+    checks.push({
+      id: `check-task-${task.id.toLowerCase()}`,
+      type: inferCheckType(task.verifyCommand),
+      command: task.verifyCommand,
+      evidence_type_expected: 'stdout',
+      acceptance_ref: uncovered[0] ?? null,
+      description: `Verify command for task ${task.id}`,
+    });
+  }
+
+  return {
+    checks,
+    compiled_at: new Date().toISOString(),
+    spec_hash: hashObject(spec),
+    plan_hash: hashObject(plan),
+  };
+}
+
+export async function runCheck(
+  check: AcceptanceCheck,
+  cwd: string,
+  timeoutMs = 60_000
+): Promise<CheckResult> {
+  if (!check.command) {
+    return {
+      check_id: check.id,
+      acceptance_ref: check.acceptance_ref,
+      status: 'skip',
+      stdout: '',
+      stderr: '',
+      exit_code: null,
+      duration_ms: 0,
+      error: null,
+    };
+  }
+
+  const start = Date.now();
+  try {
+    // Split command into program + args (simple split; no shell expansion)
+    const parts = check.command.split(/\s+/);
+    const prog = parts[0];
+    const args = parts.slice(1);
+
+    const result = spawnSync(prog, args, {
+      cwd,
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 2 * 1024 * 1024,
+    });
+
+    const duration_ms = Date.now() - start;
+    const status: VerificationStatus = result.status === 0 ? 'pass' : 'fail';
+
+    return {
+      check_id: check.id,
+      acceptance_ref: check.acceptance_ref,
+      status,
+      stdout: result.stdout ?? '',
+      stderr: result.stderr ?? '',
+      exit_code: result.status ?? null,
+      duration_ms,
+      error: result.error ? String(result.error) : null,
+    };
+  } catch (err) {
+    return {
+      check_id: check.id,
+      acceptance_ref: check.acceptance_ref,
+      status: 'error',
+      stdout: '',
+      stderr: '',
+      exit_code: null,
+      duration_ms: Date.now() - start,
+      error: String(err),
+    };
+  }
+}
+
+export async function runSuite(
+  suite: AcceptanceCheckSuite,
+  cwd: string,
+  timeoutMs = 60_000
+): Promise<CheckResult[]> {
+  const results: CheckResult[] = [];
+  for (const check of suite.checks) {
+    results.push(await runCheck(check, cwd, timeoutMs));
+  }
+  return results;
+}
+
+export function summarizeSuite(results: CheckResult[]): {
+  total: number;
+  pass: number;
+  fail: number;
+  skip: number;
+  error: number;
+  allPassed: boolean;
+} {
+  const counts = { total: results.length, pass: 0, fail: 0, skip: 0, error: 0 };
+  for (const r of results) counts[r.status]++;
+  return { ...counts, allPassed: counts.fail === 0 && counts.error === 0 };
+}
+
+function hashObject(obj: unknown): string {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(obj))
+    .digest('hex')
+    .slice(0, 12);
+}

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

@@ -0,0 +1,5 @@
+export * from './workspace-manager';
+export { InplaceWorkspaceManager } from './strategies/inplace';
+export { GitWorktreeManager } from './strategies/git-worktree';
+export { EphemeralContainerManager } from './strategies/ephemeral-container';
+export type { ContainerOptions } from './strategies/ephemeral-container';

package/packages/runtime/src/workspace/strategies/ephemeral-container.ts

@@ -0,0 +1,121 @@
+import { execFileSync, spawnSync } from 'child_process';
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+import { GitWorktreeManager } from './git-worktree';
+
+export interface ContainerOptions {
+  image: string;
+  mountPath: string;
+  extraEnv?: Record<string, string>;
+  /** Gracefully fall back to git_worktree if Docker is unavailable */
+  fallback?: boolean;
+}
+
+function isDockerAvailable(): boolean {
+  const result = spawnSync('docker', ['version', '--format', '{{.Server.Version}}'], {
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  return result.status === 0;
+}
+
+export class EphemeralContainerManager implements WorkspaceManager {
+  private readonly fallbackManager: GitWorktreeManager;
+  private containerIds = new Map<string, string>();
+  private useFallback = false;
+
+  constructor(
+    private readonly projectRoot: string,
+    private readonly opts: ContainerOptions = { image: 'node:20-alpine', mountPath: '/workspace', fallback: true }
+  ) {
+    this.fallbackManager = new GitWorktreeManager(projectRoot);
+    if (!isDockerAvailable()) {
+      if (opts.fallback !== false) {
+        this.useFallback = true;
+      } else {
+        throw new Error('Docker is not available and fallback is disabled');
+      }
+    }
+  }
+
+  get usingFallback(): boolean { return this.useFallback; }
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    if (this.useFallback) return this.fallbackManager.allocate(req);
+
+    const wsId = `ws-container-${req.work_item_id}-a${req.attempt_number}`;
+    const envArgs = Object.entries(this.opts.extraEnv ?? {}).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
+
+    const result = spawnSync('docker', [
+      'run', '-d',
+      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
+      '-w', this.opts.mountPath,
+      ...envArgs,
+      this.opts.image,
+      'sleep', '3600',
+    ], { encoding: 'utf8' });
+
+    if (result.status !== 0) {
+      if (this.opts.fallback !== false) {
+        this.useFallback = true;
+        return this.fallbackManager.allocate(req);
+      }
+      throw new Error(`docker run failed: ${result.stderr}`);
+    }
+
+    const containerId = result.stdout.trim().slice(0, 12);
+    this.containerIds.set(wsId, containerId);
+
+    return {
+      workspace_id: wsId,
+      strategy: 'ephemeral_container',
+      branch: null,
+      base_commit: null,
+      root_path: `docker:${containerId}:${this.opts.mountPath}`,
+      ttl_minutes: 60,
+    };
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    if (this.useFallback) return this.fallbackManager.snapshot(id);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) throw new Error(`Container for workspace ${id} not found`);
+
+    const tag = `oxe-snap-${crypto.randomBytes(4).toString('hex')}`;
+    execFileSync('docker', ['commit', containerId, tag]);
+
+    return {
+      snapshot_id: tag,
+      workspace_id: id,
+      commit: tag,
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
+    if (this.useFallback) return this.fallbackManager.reset(id, snapRef);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) return;
+    // Stop current container and start from snapshot
+    spawnSync('docker', ['stop', containerId]);
+    spawnSync('docker', ['rm', containerId]);
+    const result = spawnSync('docker', [
+      'run', '-d',
+      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
+      snapRef.commit,
+      'sleep', '3600',
+    ], { encoding: 'utf8' });
+    const newId = result.stdout.trim().slice(0, 12);
+    this.containerIds.set(id, newId);
+  }
+
+  async dispose(id: string): Promise<void> {
+    if (this.useFallback) return this.fallbackManager.dispose(id);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) return;
+    spawnSync('docker', ['stop', containerId], { encoding: 'utf8' });
+    spawnSync('docker', ['rm', containerId], { encoding: 'utf8' });
+    this.containerIds.delete(id);
+  }
+}

package/packages/runtime/src/workspace/strategies/git-worktree.ts

@@ -0,0 +1,77 @@
+import { execFileSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+
+export class GitWorktreeManager implements WorkspaceManager {
+  private leases = new Map<string, WorkspaceLease>();
+
+  constructor(private readonly projectRoot: string) {}
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    const wsId = `ws-${req.work_item_id}-a${req.attempt_number}`;
+    const branch = `oxe/${req.work_item_id}-attempt${req.attempt_number}`;
+    const worktreePath = path.join(this.projectRoot, '.oxe', 'workspaces', wsId);
+
+    const baseCommit = this.git(['rev-parse', 'HEAD']).trim();
+
+    fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+
+    // Create worktree on a new branch starting from HEAD
+    this.git(['worktree', 'add', worktreePath, '-b', branch]);
+
+    const lease: WorkspaceLease = {
+      workspace_id: wsId,
+      strategy: 'git_worktree',
+      branch,
+      base_commit: baseCommit,
+      root_path: worktreePath,
+      ttl_minutes: 45,
+    };
+    this.leases.set(wsId, lease);
+    return lease;
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    const lease = this.leases.get(id);
+    if (!lease || !lease.root_path) throw new Error(`Workspace ${id} not found`);
+    const commit = this.git(['rev-parse', 'HEAD'], lease.root_path).trim();
+    return {
+      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
+      workspace_id: id,
+      commit,
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
+    const lease = this.leases.get(id);
+    if (!lease) return;
+    this.git(['reset', '--hard', snapRef.commit], lease.root_path);
+  }
+
+  async dispose(id: string): Promise<void> {
+    const lease = this.leases.get(id);
+    if (!lease) return;
+    try {
+      this.git(['worktree', 'remove', lease.root_path, '--force']);
+    } catch {
+      // worktree may already be gone
+    }
+    try {
+      if (lease.branch) this.git(['branch', '-D', lease.branch]);
+    } catch {
+      // branch may already be deleted
+    }
+    this.leases.delete(id);
+  }
+
+  private git(args: string[], cwd?: string): string {
+    return execFileSync('git', args, {
+      cwd: cwd ?? this.projectRoot,
+      encoding: 'utf8',
+    });
+  }
+}

package/packages/runtime/src/workspace/strategies/inplace.ts

@@ -0,0 +1,35 @@
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+
+export class InplaceWorkspaceManager implements WorkspaceManager {
+  constructor(private readonly projectRoot: string) {}
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    return {
+      workspace_id: `ws-inplace-${req.work_item_id}-a${req.attempt_number}`,
+      strategy: 'inplace',
+      branch: null,
+      base_commit: null,
+      root_path: this.projectRoot,
+      ttl_minutes: 60,
+    };
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    return {
+      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
+      workspace_id: id,
+      commit: 'HEAD',
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(_id: string, _snapRef: SnapshotRef): Promise<void> {
+    // inplace: no filesystem isolation — reset is a no-op
+  }
+
+  async dispose(_id: string): Promise<void> {
+    // inplace: nothing to tear down
+  }
+}

package/packages/runtime/src/workspace/workspace-manager.ts

@@ -0,0 +1,15 @@
+import type { WorkspaceLease, SnapshotRef, WorkspaceStrategy } from '../models/workspace';
+
+export interface WorkspaceRequest {
+  work_item_id: string;
+  attempt_number: number;
+  strategy: WorkspaceStrategy;
+  mutation_scope: string[];
+}
+
+export interface WorkspaceManager {
+  allocate(req: WorkspaceRequest): Promise<WorkspaceLease>;
+  snapshot(id: string): Promise<SnapshotRef>;
+  reset(id: string, snapRef: SnapshotRef): Promise<void>;
+  dispose(id: string): Promise<void>;
+}

package/packages/runtime/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": false,
+    "outDir": "../../lib/runtime",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["tests/**", "node_modules/**", "dist-tests/**"]
+}

package/vscode-extension/package.json

@@ -2,7 +2,7 @@
   "name": "oxe-agents",
   "displayName": "OXE Agents",
   "description": "Agentes OXE para GitHub Copilot Chat — cada fase do ciclo como um @agente no VS Code",
-  "version": "0.9.2",
+  "version": "1.0.0",
   "publisher": "oxe-cc",
   "license": "MIT",
   "engines": {