oxe-cc 1.5.1 → 1.7.0

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

@@ -237,6 +237,86 @@ export class ContextPackBuilder {
     return this.build(workItem, state, [], new Map(), lessons);
   }
 
+  /**
+   * Remove artifacts with lowest relevance until the pack fits within targetTokens.
+   * Artifacts already sorted by relevance; we trim the tail.
+   */
+  compact(pack: ContextPack, targetTokens: number): ContextPack {
+    if (estimateTokens(pack.artifacts.map((a) => a.content).join('\n')) <= targetTokens) {
+      return pack;
+    }
+    const sorted = [...pack.artifacts].sort((a, b) => b.relevanceScore - a.relevanceScore);
+    const trimmed: ContextArtifact[] = [];
+    let used = 0;
+    for (const artifact of sorted) {
+      const t = estimateTokens(artifact.content);
+      if (used + t > targetTokens) break;
+      trimmed.push(artifact);
+      used += t;
+    }
+    return {
+      ...pack,
+      artifacts: trimmed,
+      redundancy_removed: pack.redundancy_removed + (pack.artifacts.length - trimmed.length),
+    };
+  }
+
+  /**
+   * Merge groups of similar artifacts (cosine similarity >= threshold) into single
+   * combined artifacts to reduce redundancy without discarding information entirely.
+   */
+  microCompact(artifacts: ContextArtifact[], similarityThreshold = 0.7): ContextArtifact[] {
+    const merged: ContextArtifact[] = [];
+    const used = new Set<number>();
+
+    for (let i = 0; i < artifacts.length; i++) {
+      if (used.has(i)) continue;
+      const group: ContextArtifact[] = [artifacts[i]];
+      for (let j = i + 1; j < artifacts.length; j++) {
+        if (!used.has(j) && cosineSimilarity(artifacts[i], artifacts[j]) >= similarityThreshold) {
+          group.push(artifacts[j]);
+          used.add(j);
+        }
+      }
+      used.add(i);
+      if (group.length === 1) {
+        merged.push(group[0]);
+      } else {
+        const combinedContent = group
+          .map((a) => a.content)
+          .join('\n---\n')
+          .slice(0, 4000);
+        merged.push({
+          id: group[0].id,
+          kind: group[0].kind,
+          content: combinedContent,
+          relevanceScore: group.reduce((s, a) => s + a.relevanceScore, 0) / group.length,
+          tags: [...new Set(group.flatMap((a) => a.tags))],
+        });
+      }
+    }
+    return merged;
+  }
+
+  /**
+   * Automatically compact a pack to fit within hardLimitTokens.
+   * First applies microCompact (lossless merging), then compact (trimming by relevance).
+   */
+  autoCompact(pack: ContextPack, hardLimitTokens: number): ContextPack {
+    const currentTokens = estimateTokens(pack.artifacts.map((a) => a.content).join('\n'));
+    if (currentTokens <= hardLimitTokens) return pack;
+
+    const microCompacted = this.microCompact(pack.artifacts);
+    const removedByMicro = pack.artifacts.length - microCompacted.length;
+
+    const interim: ContextPack = {
+      ...pack,
+      artifacts: microCompacted,
+      redundancy_removed: pack.redundancy_removed + removedByMicro,
+    };
+    return this.compact(interim, hardLimitTokens);
+  }
+
   /**
    * Filter artifacts to those whose path-like tags are within mutation_scope.
    * L0/L1 tiers apply the filter; L2/L3 skip it (full access).

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

@@ -20,6 +20,11 @@ export const EVENT_TYPES = [
   'RunCompleted',
   'RetroPublished',
   'LessonPromoted',
+  'RunAborted',
+  'RollbackExecuted',
+  'RollbackFailed',
+  'TaskErrorBoundaryTripped',
+  'WorkspaceDisposeFailed',
 ] as const;
 
 export type EventType = (typeof EVENT_TYPES)[number];

package/packages/runtime/src/executor/action-tool-map.ts

@@ -0,0 +1,46 @@
+import type { Action } from '../compiler/graph-compiler';
+import { ALL_BUILT_IN_SCHEMAS, BUILT_IN_TOOLS } from './built-in-tools';
+import type { ToolSchema } from './stream-completion';
+
+const READ_TOOLS: ToolSchema[] = [
+  BUILT_IN_TOOLS.read_file.schema,
+  BUILT_IN_TOOLS.glob.schema,
+  BUILT_IN_TOOLS.grep.schema,
+];
+
+const PATCH_TOOLS: ToolSchema[] = [
+  BUILT_IN_TOOLS.read_file.schema,
+  BUILT_IN_TOOLS.write_file.schema,
+  BUILT_IN_TOOLS.patch_file.schema,
+];
+
+const RUN_TOOLS: ToolSchema[] = [BUILT_IN_TOOLS.run_command.schema];
+
+const EVIDENCE_TOOLS: ToolSchema[] = [
+  BUILT_IN_TOOLS.read_file.schema,
+  BUILT_IN_TOOLS.glob.schema,
+  BUILT_IN_TOOLS.run_command.schema,
+];
+
+const ACTION_TOOL_MAP: Record<Action['type'], ToolSchema[]> = {
+  read_code: READ_TOOLS,
+  generate_patch: PATCH_TOOLS,
+  run_tests: RUN_TOOLS,
+  run_lint: RUN_TOOLS,
+  collect_evidence: EVIDENCE_TOOLS,
+  custom: ALL_BUILT_IN_SCHEMAS,
+};
+
+export function selectToolsForActions(actions: Action[]): ToolSchema[] {
+  const seen = new Set<string>();
+  const result: ToolSchema[] = [];
+  for (const action of actions) {
+    for (const tool of ACTION_TOOL_MAP[action.type] ?? ALL_BUILT_IN_SCHEMAS) {
+      if (!seen.has(tool.function.name)) {
+        seen.add(tool.function.name);
+        result.push(tool);
+      }
+    }
+  }
+  return result;
+}

package/packages/runtime/src/executor/built-in-tools.ts

@@ -0,0 +1,276 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import type { ToolSchema } from './stream-completion';
+
+export interface BuiltInToolHandler {
+  schema: ToolSchema;
+  idempotent: boolean;
+  execute(args: Record<string, unknown>, cwd: string): Promise<string>;
+}
+
+// ─── read_file ────────────────────────────────────────────────────────────────
+
+const readFile: BuiltInToolHandler = {
+  idempotent: true,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the contents of a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to workspace root' },
+          offset: { type: 'integer', description: 'Line to start reading from (1-based)' },
+          limit: { type: 'integer', description: 'Maximum number of lines to read' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const filePath = path.resolve(cwd, String(args.path));
+    if (!fs.existsSync(filePath)) return `Error: file not found: ${args.path}`;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const offset = typeof args.offset === 'number' ? args.offset - 1 : 0;
+    const limit = typeof args.limit === 'number' ? args.limit : lines.length;
+    return lines.slice(offset, offset + limit).join('\n');
+  },
+};
+
+// ─── write_file ───────────────────────────────────────────────────────────────
+
+const writeFile: BuiltInToolHandler = {
+  idempotent: false,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file (creates or overwrites)',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to workspace root' },
+          content: { type: 'string', description: 'Content to write' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const filePath = path.resolve(cwd, String(args.path));
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, String(args.content), 'utf8');
+    return `Written ${String(args.content).length} bytes to ${args.path}`;
+  },
+};
+
+// ─── patch_file ───────────────────────────────────────────────────────────────
+
+const patchFile: BuiltInToolHandler = {
+  idempotent: false,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'patch_file',
+      description: 'Replace an exact string in a file with new content',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to workspace root' },
+          old_string: { type: 'string', description: 'Exact string to replace' },
+          new_string: { type: 'string', description: 'Replacement string' },
+        },
+        required: ['path', 'old_string', 'new_string'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const filePath = path.resolve(cwd, String(args.path));
+    if (!fs.existsSync(filePath)) return `Error: file not found: ${args.path}`;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const oldStr = String(args.old_string);
+    if (!content.includes(oldStr)) return `Error: old_string not found in ${args.path}`;
+    const updated = content.replace(oldStr, String(args.new_string));
+    fs.writeFileSync(filePath, updated, 'utf8');
+    return `Patched ${args.path}`;
+  },
+};
+
+// ─── glob ─────────────────────────────────────────────────────────────────────
+
+const glob: BuiltInToolHandler = {
+  idempotent: true,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'glob',
+      description: 'List files matching a glob pattern within the workspace',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Glob pattern, e.g. src/**/*.ts' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const results = globSync(String(args.pattern), cwd);
+    return results.length ? results.join('\n') : '(no files matched)';
+  },
+};
+
+function globSync(pattern: string, root: string): string[] {
+  const results: string[] = [];
+  const parts = pattern.split('/');
+  function walk(dir: string, remaining: string[]): void {
+    if (!fs.existsSync(dir)) return;
+    const [head, ...tail] = remaining;
+    if (!head) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const matches = micromatch(entry.name, head);
+      if (!matches) continue;
+      const full = path.join(dir, entry.name);
+      if (tail.length === 0) {
+        results.push(path.relative(root, full).replace(/\\/g, '/'));
+      } else if (entry.isDirectory()) {
+        if (head === '**') {
+          walk(full, remaining);
+          walk(full, tail);
+        } else {
+          walk(full, tail);
+        }
+      }
+    }
+  }
+  walk(root, parts);
+  return results;
+}
+
+function micromatch(name: string, pattern: string): boolean {
+  if (pattern === '**') return true;
+  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]') + '$');
+  return regex.test(name);
+}
+
+// ─── grep ─────────────────────────────────────────────────────────────────────
+
+const grep: BuiltInToolHandler = {
+  idempotent: true,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'grep',
+      description: 'Search for a regex pattern in files',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Regex pattern to search for' },
+          path: { type: 'string', description: 'File or directory to search in (relative to workspace)' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const searchRoot = args.path ? path.resolve(cwd, String(args.path)) : cwd;
+    const regex = new RegExp(String(args.pattern));
+    const results: string[] = [];
+    grepDir(searchRoot, regex, cwd, results);
+    return results.length ? results.slice(0, 200).join('\n') : '(no matches)';
+  },
+};
+
+function grepDir(dir: string, regex: RegExp, root: string, out: string[]): void {
+  if (!fs.existsSync(dir)) return;
+  const stat = fs.statSync(dir);
+  if (stat.isFile()) {
+    grepFile(dir, regex, root, out);
+    return;
+  }
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+      grepDir(full, regex, root, out);
+    } else if (entry.isFile()) {
+      grepFile(full, regex, root, out);
+    }
+  }
+}
+
+function grepFile(filePath: string, regex: RegExp, root: string, out: string[]): void {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    content.split('\n').forEach((line, i) => {
+      if (regex.test(line)) {
+        out.push(`${path.relative(root, filePath).replace(/\\/g, '/')}:${i + 1}: ${line}`);
+      }
+    });
+  } catch { /* skip binary or unreadable files */ }
+}
+
+// ─── run_command ──────────────────────────────────────────────────────────────
+
+const runCommand: BuiltInToolHandler = {
+  idempotent: false,
+  schema: {
+    type: 'function',
+    function: {
+      name: 'run_command',
+      description: 'Run a shell command in the workspace directory',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Shell command to execute' },
+          timeout_ms: { type: 'integer', description: 'Timeout in milliseconds (default 30000)' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  async execute(args, cwd) {
+    const command = String(args.command);
+    const timeoutMs = typeof args.timeout_ms === 'number' ? args.timeout_ms : 30_000;
+    return runShell(command, cwd, timeoutMs);
+  },
+};
+
+function runShell(command: string, cwd: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve) => {
+    const isWin = process.platform === 'win32';
+    const shell = isWin ? 'cmd' : 'sh';
+    const shellArgs = isWin ? ['/c', command] : ['-c', command];
+    const proc = spawn(shell, shellArgs, { cwd, stdio: 'pipe' });
+    const out: Buffer[] = [];
+    let timedOut = false;
+
+    const timer = setTimeout(() => { timedOut = true; proc.kill('SIGTERM'); }, timeoutMs);
+
+    proc.stdout.on('data', (c: Buffer) => out.push(c));
+    proc.stderr.on('data', (c: Buffer) => out.push(c));
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      const text = Buffer.concat(out).toString('utf8').trim();
+      if (timedOut) resolve(`[timed out after ${timeoutMs}ms]\n${text}`);
+      else resolve(code === 0 ? text || '(no output)' : `[exit ${code}]\n${text}`);
+    });
+    proc.on('error', (err) => { clearTimeout(timer); resolve(`[error] ${err}`); });
+  });
+}
+
+// ─── Registry ─────────────────────────────────────────────────────────────────
+
+export const BUILT_IN_TOOLS: Record<string, BuiltInToolHandler> = {
+  read_file: readFile,
+  write_file: writeFile,
+  patch_file: patchFile,
+  glob,
+  grep,
+  run_command: runCommand,
+};
+
+export const ALL_BUILT_IN_SCHEMAS: ToolSchema[] = Object.values(BUILT_IN_TOOLS).map((t) => t.schema);

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

@@ -0,0 +1,6 @@
+export { LlmTaskExecutor } from './llm-task-executor';
+export type { LlmProviderConfig, LlmExecutorEvent, LlmExecutorEventType } from './llm-task-executor';
+export { buildNodePrompt } from './node-prompt-builder';
+export { selectToolsForActions } from './action-tool-map';
+export { BUILT_IN_TOOLS, ALL_BUILT_IN_SCHEMAS } from './built-in-tools';
+export type { BuiltInToolHandler } from './built-in-tools';

package/packages/runtime/src/executor/llm-task-executor.ts

@@ -0,0 +1,194 @@
+import type { GraphNode } from '../compiler/graph-compiler';
+import type { WorkspaceLease } from '../models/workspace';
+import type { TaskExecutor, TaskResult } from '../scheduler/scheduler';
+import type { PluginRegistry } from '../plugins/plugin-registry';
+import { streamCompletion } from './stream-completion';
+import type { ChatMessage, ToolCall, ToolSchema } from './stream-completion';
+import { BUILT_IN_TOOLS } from './built-in-tools';
+import { selectToolsForActions } from './action-tool-map';
+import { buildNodePrompt } from './node-prompt-builder';
+
+export interface LlmProviderConfig {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+  maxTokens?: number;
+  maxTurns?: number;
+  timeoutMs?: number;
+  systemPrompt?: string;
+}
+
+export type LlmExecutorEventType =
+  | 'turn_start'
+  | 'turn_complete'
+  | 'tool_call'
+  | 'tool_result'
+  | 'executor_complete';
+
+export interface LlmExecutorEvent {
+  type: LlmExecutorEventType;
+  nodeId: string;
+  attempt: number;
+  detail?: Record<string, unknown>;
+}
+
+const DEFAULT_SYSTEM_PROMPT =
+  'You are a precise software engineering agent. Use the tools provided to complete the task. ' +
+  'When the task is done, summarize what was accomplished in your final message without calling any tools.';
+
+export class LlmTaskExecutor implements TaskExecutor {
+  constructor(
+    private readonly provider: LlmProviderConfig,
+    private readonly registry?: PluginRegistry,
+    private readonly onProgress?: (event: LlmExecutorEvent) => void,
+  ) {}
+
+  async execute(
+    node: GraphNode,
+    lease: WorkspaceLease,
+    runId: string,
+    attempt: number,
+  ): Promise<TaskResult> {
+    const prompt = buildNodePrompt(node, lease, runId, attempt);
+    const tools = selectToolsForActions(node.actions);
+    const cwd = lease.root_path;
+    const maxTurns = this.provider.maxTurns ?? 10;
+    const systemPrompt = this.provider.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+
+    const messages: ChatMessage[] = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: prompt },
+    ];
+
+    let finalOutput = '';
+    const evidencePaths: string[] = [];
+
+    for (let turn = 0; turn < maxTurns; turn++) {
+      this.emit({ type: 'turn_start', nodeId: node.id, attempt, detail: { turn } });
+
+      let response;
+      try {
+        response = await streamCompletion({
+          baseUrl: this.provider.baseUrl,
+          apiKey: this.provider.apiKey,
+          model: this.provider.model,
+          messages,
+          tools: tools.length > 0 ? tools : undefined,
+          maxTokens: this.provider.maxTokens,
+          timeoutMs: this.provider.timeoutMs,
+        });
+      } catch (err) {
+        return { success: false, failure_class: 'env', evidence: evidencePaths, output: String(err) };
+      }
+
+      this.emit({ type: 'turn_complete', nodeId: node.id, attempt, detail: { turn, finish_reason: response.finish_reason } });
+
+      if (response.content) finalOutput = response.content;
+
+      if (!response.tool_calls.length) break;
+
+      messages.push({
+        role: 'assistant',
+        content: response.content || null,
+        tool_calls: response.tool_calls,
+      });
+
+      // Partition: idempotent tools run concurrently, mutations run serially
+      const [concurrent, serial] = partitionToolCalls(response.tool_calls, tools);
+
+      const concurrentResults = await Promise.all(
+        concurrent.map((tc) => this.invokeToolCall(tc, cwd, node, evidencePaths)),
+      );
+      const serialResults: ChatMessage[] = [];
+      for (const tc of serial) {
+        serialResults.push(await this.invokeToolCall(tc, cwd, node, evidencePaths));
+      }
+
+      messages.push(...concurrentResults, ...serialResults);
+    }
+
+    return {
+      success: true,
+      failure_class: null,
+      evidence: evidencePaths,
+      output: finalOutput,
+    };
+  }
+
+  private async invokeToolCall(
+    tc: ToolCall,
+    cwd: string,
+    node: GraphNode,
+    evidencePaths: string[],
+  ): Promise<ChatMessage> {
+    this.emit({ type: 'tool_call', nodeId: node.id, attempt: 0, detail: { tool: tc.function.name } });
+
+    let args: Record<string, unknown> = {};
+    try {
+      args = JSON.parse(tc.function.arguments || '{}');
+    } catch {
+      // malformed args — pass empty
+    }
+
+    let result: string;
+    const builtIn = BUILT_IN_TOOLS[tc.function.name];
+    if (builtIn) {
+      try {
+        result = await builtIn.execute(args, cwd);
+        if (tc.function.name === 'write_file' || tc.function.name === 'patch_file') {
+          if (typeof args.path === 'string') evidencePaths.push(args.path);
+        }
+      } catch (err) {
+        result = `[tool error] ${err}`;
+      }
+    } else {
+      // Delegate to plugin registry
+      const provider = this.registry?.toolProviderFor(tc.function.name);
+      if (provider) {
+        try {
+          const res = await provider.invoke({
+            action_type: tc.function.name,
+            work_item_id: node.id,
+            run_id: '',
+            attempt_id: '',
+            params: args,
+            workspace_root: cwd,
+          });
+          result = res.output || (res.success ? 'done' : res.error ?? 'failed');
+          evidencePaths.push(...res.evidence_paths);
+        } catch (err) {
+          result = `[plugin error] ${err}`;
+        }
+      } else {
+        result = `[unknown tool: ${tc.function.name}]`;
+      }
+    }
+
+    this.emit({ type: 'tool_result', nodeId: node.id, attempt: 0, detail: { tool: tc.function.name, length: result.length } });
+
+    return {
+      role: 'tool',
+      tool_call_id: tc.id,
+      name: tc.function.name,
+      content: result,
+    };
+  }
+
+  private emit(event: LlmExecutorEvent): void {
+    this.onProgress?.(event);
+  }
+}
+
+function partitionToolCalls(
+  toolCalls: ToolCall[],
+  schemas: ToolSchema[],
+): [ToolCall[], ToolCall[]] {
+  const idempotentNames = new Set(
+    schemas
+      .map((s) => s.function.name)
+      .filter((name) => BUILT_IN_TOOLS[name]?.idempotent ?? true),
+  );
+  const concurrent = toolCalls.filter((tc) => idempotentNames.has(tc.function.name));
+  const serial = toolCalls.filter((tc) => !idempotentNames.has(tc.function.name));
+  return [concurrent, serial];
+}

package/packages/runtime/src/executor/node-prompt-builder.ts

@@ -0,0 +1,45 @@
+import type { GraphNode } from '../compiler/graph-compiler';
+import type { WorkspaceLease } from '../models/workspace';
+
+export function buildNodePrompt(
+  node: GraphNode,
+  lease: WorkspaceLease,
+  runId: string,
+  attempt: number,
+): string {
+  const lines: string[] = [
+    `# Tarefa: ${node.title}`,
+    '',
+    `**Run:** ${runId} | **Attempt:** ${attempt}`,
+    `**Workspace:** ${lease.root_path}`,
+  ];
+
+  if (node.mutation_scope.length > 0) {
+    lines.push(`**Escopo de mutação:** ${node.mutation_scope.join(', ')}`);
+  }
+
+  if (node.actions.length > 0) {
+    lines.push('', '## Ações requeridas');
+    for (const action of node.actions) {
+      let line = `- ${action.type}`;
+      if (action.command) line += `: \`${action.command}\``;
+      if (action.targets?.length) line += ` em ${action.targets.join(', ')}`;
+      lines.push(line);
+    }
+  }
+
+  if (node.verify.must_pass.length > 0) {
+    lines.push('', '## Critérios de aceite');
+    for (const criterion of node.verify.must_pass) {
+      lines.push(`- ${criterion}`);
+    }
+  }
+
+  if (node.verify.command) {
+    lines.push('', `**Verificação:** \`${node.verify.command}\``);
+  }
+
+  lines.push('', 'Execute as ações acima usando as ferramentas disponíveis e confirme o resultado.');
+
+  return lines.join('\n');
+}