@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/tool/__test__/task-errors.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest';
+import { buildTaskFailure, buildTaskSuccess, parsePrefixedError } from '../task-errors';
+import { ToolExecutionError } from '../error';
+
+describe('buildTaskFailure', () => {
+  it('builds failure result with code and message', () => {
+    const result = buildTaskFailure('TASK_NOT_FOUND', 'Task not found');
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('TASK_NOT_FOUND: Task not found');
+    expect(result.error).toBeInstanceOf(ToolExecutionError);
+    expect(result.error!.message).toBe('TASK_NOT_FOUND: Task not found');
+    expect(result.metadata).toEqual({
+      error: 'TASK_NOT_FOUND',
+      message: 'Task not found',
+    });
+  });
+
+  it('builds failure result with details', () => {
+    const result = buildTaskFailure('TASK_FAILED', 'Task failed', {
+      taskId: 'task_1',
+      retryCount: 3,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('TASK_FAILED: Task failed');
+    expect(result.metadata).toEqual({
+      error: 'TASK_FAILED',
+      message: 'Task failed',
+      taskId: 'task_1',
+      retryCount: 3,
+    });
+  });
+
+  it('builds failure result with empty details', () => {
+    const result = buildTaskFailure('ERROR', 'Error message', {});
+
+    expect(result.success).toBe(false);
+    expect(result.metadata).toEqual({
+      error: 'ERROR',
+      message: 'Error message',
+    });
+  });
+
+  it('builds failure result with undefined details', () => {
+    const result = buildTaskFailure('ERROR', 'Error message', undefined);
+
+    expect(result.success).toBe(false);
+    expect(result.metadata).toEqual({
+      error: 'ERROR',
+      message: 'Error message',
+    });
+  });
+
+  it('handles empty code', () => {
+    const result = buildTaskFailure('', 'Error message');
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe(': Error message');
+  });
+
+  it('handles empty message', () => {
+    const result = buildTaskFailure('ERROR', '');
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('ERROR: ');
+  });
+
+  it('handles special characters in code and message', () => {
+    const result = buildTaskFailure('ERROR_CODE', 'Error: "test" & <value>');
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('ERROR_CODE: Error: "test" & <value>');
+  });
+});
+
+describe('buildTaskSuccess', () => {
+  it('builds success result with payload', () => {
+    const payload = { taskId: 'task_1', status: 'completed' };
+    const result = buildTaskSuccess(payload);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe(JSON.stringify(payload));
+    expect(result.metadata).toEqual(payload);
+  });
+
+  it('builds success result with empty payload', () => {
+    const result = buildTaskSuccess({});
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('{}');
+    expect(result.metadata).toEqual({});
+  });
+
+  it('builds success result with nested payload', () => {
+    const payload = {
+      task: {
+        id: 'task_1',
+        status: 'completed',
+        result: { value: 42 },
+      },
+    };
+    const result = buildTaskSuccess(payload);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe(JSON.stringify(payload));
+    expect(result.metadata).toEqual(payload);
+  });
+
+  it('builds success result with array payload', () => {
+    const payload = { items: [1, 2, 3] };
+    const result = buildTaskSuccess(payload);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe(JSON.stringify(payload));
+    expect(result.metadata).toEqual(payload);
+  });
+
+  it('builds success result with null values', () => {
+    const payload = { value: null, other: undefined };
+    const result = buildTaskSuccess(payload);
+
+    expect(result.success).toBe(true);
+    // undefined values are omitted in JSON.stringify
+    expect(result.output).toBe('{"value":null}');
+  });
+
+  it('builds success result with special characters', () => {
+    const payload = { message: 'Success: "test" & <value>' };
+    const result = buildTaskSuccess(payload);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe(JSON.stringify(payload));
+  });
+});
+
+describe('parsePrefixedError', () => {
+  it('parses error with code prefix', () => {
+    const result = parsePrefixedError('TASK_NOT_FOUND: Task not found');
+
+    expect(result.code).toBe('TASK_NOT_FOUND');
+    expect(result.detail).toBe('Task not found');
+  });
+
+  it('parses error with complex code', () => {
+    const result = parsePrefixedError(
+      'TASK_INVALID_NAMESPACE: namespace allows only [a-zA-Z0-9._-]'
+    );
+
+    expect(result.code).toBe('TASK_INVALID_NAMESPACE');
+    expect(result.detail).toBe('namespace allows only [a-zA-Z0-9._-]');
+  });
+
+  it('parses error with numbers in code', () => {
+    const result = parsePrefixedError('ERROR_404: Not found');
+
+    expect(result.code).toBe('ERROR_404');
+    expect(result.detail).toBe('Not found');
+  });
+
+  it('returns default for error without code prefix', () => {
+    const result = parsePrefixedError('Task not found');
+
+    expect(result.code).toBe('TASK_OPERATION_FAILED');
+    expect(result.detail).toBe('Task not found');
+  });
+
+  it('returns default for error with lowercase prefix', () => {
+    const result = parsePrefixedError('task_not_found: Task not found');
+
+    expect(result.code).toBe('TASK_OPERATION_FAILED');
+    expect(result.detail).toBe('task_not_found: Task not found');
+  });
+
+  it('returns default for error with short code', () => {
+    const result = parsePrefixedError('AB: Short code');
+
+    expect(result.code).toBe('TASK_OPERATION_FAILED');
+    expect(result.detail).toBe('AB: Short code');
+  });
+
+  it('returns default for empty string', () => {
+    const result = parsePrefixedError('');
+
+    expect(result.code).toBe('TASK_OPERATION_FAILED');
+    expect(result.detail).toBe('');
+  });
+
+  it('handles error with multiple colons', () => {
+    const result = parsePrefixedError('ERROR_CODE: Message: with colons');
+
+    expect(result.code).toBe('ERROR_CODE');
+    expect(result.detail).toBe('Message: with colons');
+  });
+
+  it('handles error with whitespace after colon', () => {
+    const result = parsePrefixedError('ERROR_CODE:   Message with spaces');
+
+    expect(result.code).toBe('ERROR_CODE');
+    // \s* in regex matches all whitespace, so leading spaces are trimmed
+    expect(result.detail).toBe('Message with spaces');
+  });
+
+  it('handles error with no detail after colon', () => {
+    const result = parsePrefixedError('ERROR_CODE:');
+
+    expect(result.code).toBe('ERROR_CODE');
+    expect(result.detail).toBe('');
+  });
+
+  it('handles error with special characters in detail', () => {
+    const result = parsePrefixedError('ERROR_CODE: Error: "test" & <value>');
+
+    expect(result.code).toBe('ERROR_CODE');
+    expect(result.detail).toBe('Error: "test" & <value>');
+  });
+
+  it('handles error with newlines in detail', () => {
+    // The regex doesn't match newlines, so it returns default
+    const result = parsePrefixedError('ERROR_CODE: Line 1\nLine 2');
+
+    expect(result.code).toBe('TASK_OPERATION_FAILED');
+    expect(result.detail).toBe('ERROR_CODE: Line 1\nLine 2');
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/task-output-blocking.test.ts

@@ -0,0 +1,223 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { TaskStore } from '../task-store';
+import { InProcessMockRunnerAdapter } from '../task-runner-adapter';
+import { TaskTool } from '../task';
+import { TaskOutputTool } from '../task-output';
+import type { AgentRunEntity } from '../task-types';
+import type { SubagentRunnerAdapter } from '../task-runner-adapter';
+
+function parseOutput<T>(output: string | undefined): T {
+  return JSON.parse(output || '{}') as T;
+}
+
+function makeRun(overrides: Partial<AgentRunEntity> = {}): AgentRunEntity {
+  const now = Date.now();
+  return {
+    agentId: overrides.agentId || 'agent-x',
+    status: overrides.status || 'running',
+    subagentType: overrides.subagentType || 'Plan',
+    prompt: overrides.prompt || 'p',
+    description: overrides.description,
+    model: overrides.model,
+    maxTurns: overrides.maxTurns,
+    allowedTools: overrides.allowedTools,
+    linkedTaskId: overrides.linkedTaskId,
+    output: overrides.output,
+    error: overrides.error,
+    progress: overrides.progress,
+    createdAt: overrides.createdAt || now,
+    startedAt: overrides.startedAt || now,
+    endedAt: overrides.endedAt,
+    updatedAt: overrides.updatedAt || now,
+    outputFile: overrides.outputFile,
+    metadata: overrides.metadata || {},
+    version: overrides.version || 1,
+  };
+}
+
+describe('task_output blocking semantics', () => {
+  let baseDir: string;
+  let store: TaskStore;
+  let runner: InProcessMockRunnerAdapter;
+  let taskTool: TaskTool;
+  let taskOutput: TaskOutputTool;
+
+  beforeEach(async () => {
+    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-output-'));
+    store = new TaskStore({ baseDir });
+    runner = new InProcessMockRunnerAdapter(store, { completionDelayMs: 200 });
+    taskTool = new TaskTool({ store, runner });
+    taskOutput = new TaskOutputTool({ store, runner });
+  });
+
+  afterEach(async () => {
+    await fs.rm(baseDir, { recursive: true, force: true });
+  });
+
+  it('uses block=true by default when block is omitted', async () => {
+    const started = await taskTool.execute({
+      namespace: 'out1',
+      subagent_type: 'general-purpose',
+      prompt: 'Default blocking behavior check',
+      run_in_background: true,
+    });
+    const run = parseOutput<{ agent_run: { agentId: string } }>(started.output).agent_run;
+
+    const t0 = Date.now();
+    const result = await taskOutput.execute({
+      namespace: 'out1',
+      agent_id: run.agentId,
+      timeout_ms: 3000,
+    });
+    const elapsed = Date.now() - t0;
+
+    expect(result.success).toBe(true);
+    const payload = parseOutput<{ completed: boolean; agent_run: { status: string } }>(
+      result.output
+    );
+    expect(payload.completed).toBe(true);
+    expect(payload.agent_run.status).toBe('completed');
+    expect(elapsed).toBeGreaterThanOrEqual(120);
+  });
+
+  it('returns quickly in non-blocking mode and can report running state', async () => {
+    const started = await taskTool.execute({
+      namespace: 'out2',
+      subagent_type: 'general-purpose',
+      prompt: 'Non-blocking behavior check',
+      run_in_background: true,
+    });
+    const run = parseOutput<{ agent_run: { agentId: string } }>(started.output).agent_run;
+
+    const t0 = Date.now();
+    const result = await taskOutput.execute({
+      namespace: 'out2',
+      agent_id: run.agentId,
+      block: false,
+    });
+    const elapsed = Date.now() - t0;
+
+    expect(result.success).toBe(true);
+    const payload = parseOutput<{ agent_run: { status: string; output?: string } }>(result.output);
+    expect(['running', 'completed']).toContain(payload.agent_run.status);
+    if (payload.agent_run.status === 'running') {
+      expect(payload.agent_run.output).toBeUndefined();
+    }
+    expect(elapsed).toBeLessThan(120);
+  });
+
+  it('hides output for in-progress run but keeps completion output', async () => {
+    const partialRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async (_namespace, agentId) => {
+        if (agentId === 'agent-running') {
+          return makeRun({
+            agentId,
+            status: 'running',
+            output: 'partial content',
+          });
+        }
+        return makeRun({
+          agentId,
+          status: 'completed',
+          output: 'final content',
+          endedAt: Date.now(),
+        });
+      },
+      cancel: async () => null,
+    };
+
+    const outputTool = new TaskOutputTool({ store, runner: partialRunner });
+
+    const running = await outputTool.execute({
+      namespace: 'out3',
+      agent_id: 'agent-running',
+      block: false,
+    });
+    const runningPayload = parseOutput<{ agent_run: { status: string; output?: string } }>(
+      running.output
+    );
+    expect(runningPayload.agent_run.status).toBe('running');
+    expect(runningPayload.agent_run.output).toBeUndefined();
+
+    const completed = await outputTool.execute({
+      namespace: 'out3',
+      agent_id: 'agent-completed',
+      block: false,
+    });
+    const completedPayload = parseOutput<{ agent_run: { status: string; output?: string } }>(
+      completed.output
+    );
+    expect(completedPayload.agent_run.status).toBe('completed');
+    expect(completedPayload.agent_run.output).toBe('final content');
+  });
+
+  it('reports failure to parent agent and never leaks failed output', async () => {
+    const failedRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () =>
+        makeRun({
+          agentId: 'agent-failed',
+          status: 'failed',
+          output: 'internal stack trace',
+          error: 'compile failed',
+          endedAt: Date.now(),
+        }),
+      cancel: async () => null,
+    };
+    const outputTool = new TaskOutputTool({ store, runner: failedRunner });
+    const failed = await outputTool.execute({
+      namespace: 'out4',
+      agent_id: 'agent-failed',
+    });
+
+    expect(failed.success).toBe(true);
+    const payload = parseOutput<{
+      completed: boolean;
+      agent_run: { status: string; output?: string; error?: string };
+    }>(failed.output);
+    expect(payload.completed).toBe(true);
+    expect(payload.agent_run.status).toBe('failed');
+    expect(payload.agent_run.output).toBeUndefined();
+    expect(payload.agent_run.error).toBe('compile failed');
+  });
+
+  it('fills default error text for terminal failed/timed_out/cancelled without error', async () => {
+    const statuses: Array<'failed' | 'timed_out' | 'cancelled'> = [
+      'failed',
+      'timed_out',
+      'cancelled',
+    ];
+
+    for (const status of statuses) {
+      const runnerWithoutError: SubagentRunnerAdapter = {
+        start: async () => makeRun(),
+        poll: async () =>
+          makeRun({
+            agentId: `agent-${status}`,
+            status,
+            output: 'must hide',
+            error: undefined,
+            endedAt: Date.now(),
+          }),
+        cancel: async () => null,
+      };
+
+      const outputTool = new TaskOutputTool({ store, runner: runnerWithoutError });
+      const result = await outputTool.execute({
+        namespace: 'out5',
+        agent_id: `agent-${status}`,
+      });
+
+      const payload = parseOutput<{
+        agent_run: { status: string; output?: string; error?: string };
+      }>(result.output);
+      expect(payload.agent_run.status).toBe(status);
+      expect(payload.agent_run.output).toBeUndefined();
+      expect(payload.agent_run.error).toBe(`Agent run ${status}`);
+    }
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/task-output.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { TaskOutputTool } from '../task-output';
+import { TaskStore } from '../task-store';
+import type { ToolExecutionContext } from '../types';
+
+describe('TaskOutputTool', () => {
+  let tempDir: string;
+  let store: TaskStore;
+  let tool: TaskOutputTool;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'task-output-test-'));
+    store = new TaskStore({ baseDir: tempDir });
+    tool = new TaskOutputTool({ store });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('name and description', () => {
+    it('has correct name', () => {
+      expect(tool.name).toBe('task_output');
+    });
+
+    it('has description', () => {
+      expect(tool.description).toBeTruthy();
+    });
+  });
+
+  describe('parameters', () => {
+    it('has task_id parameter', () => {
+      const schema = tool.parameters;
+      expect(schema).toBeDefined();
+    });
+  });
+
+  describe('execute', () => {
+    it('returns error when neither agent_id nor task_id is provided', async () => {
+      const result = await tool.execute({});
+
+      expect(result.success).toBe(false);
+      expect(result.output).toContain('TASK_OUTPUT_TARGET_REQUIRED');
+    });
+
+    it('returns error for non-existent task', async () => {
+      const result = await tool.execute({ task_id: 'non-existent' });
+
+      expect(result.success).toBe(false);
+      expect(result.output).toContain('TASK_NOT_FOUND');
+    });
+
+    it('returns error for task without linked agent run', async () => {
+      await store.updateState('default', (state) => {
+        state.tasks.task_1 = {
+          id: 'task_1',
+          subject: 'Test Task',
+          description: 'Test description',
+          activeForm: 'Testing',
+          status: 'pending',
+          priority: 'normal',
+          owner: null,
+          blockedBy: [],
+          blocks: [],
+          progress: 0,
+          checkpoints: [],
+          retryConfig: { maxRetries: 3, retryDelayMs: 5000, backoffMultiplier: 2, retryOn: [] },
+          retryCount: 0,
+          tags: [],
+          metadata: {},
+          history: [],
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          version: 1,
+        };
+        return 'created';
+      });
+
+      const result = await tool.execute({ task_id: 'task_1' });
+
+      expect(result.success).toBe(false);
+      expect(result.output).toContain('AGENT_RUN_NOT_FOUND');
+    });
+
+    it('returns error for non-existent agent run', async () => {
+      const result = await tool.execute({ agent_id: 'non-existent', block: false });
+
+      expect(result.success).toBe(false);
+      expect(result.output).toContain('AGENT_RUN_NOT_FOUND');
+    });
+
+    it('handles task with context', async () => {
+      const context: ToolExecutionContext = {
+        toolCallId: 'call_1',
+        loopIndex: 1,
+        agent: {},
+      };
+
+      const result = await tool.execute({ task_id: 'non-existent' }, context);
+
+      expect(result.success).toBe(false);
+    });
+
+    it('handles task with invalid task_id parameter', async () => {
+      const result = await tool.execute({ task_id: '' });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('handles task with namespace', async () => {
+      const result = await tool.execute({ task_id: 'non-existent', namespace: 'custom' });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('handles task with block=false', async () => {
+      const result = await tool.execute({ agent_id: 'non-existent', block: false });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('handles task with timeout_ms', async () => {
+      const result = await tool.execute({ agent_id: 'non-existent', timeout_ms: 1000 });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('handles task with poll_interval_ms', async () => {
+      const result = await tool.execute({ agent_id: 'non-existent', poll_interval_ms: 100 });
+
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('shouldConfirm', () => {
+    it('returns false', () => {
+      expect(tool.shouldConfirm({ task_id: 'task_1' })).toBe(false);
+    });
+  });
+
+  describe('getConfirmDetails', () => {
+    it('returns null', () => {
+      expect(tool.getConfirmDetails({ task_id: 'task_1' })).toBeNull();
+    });
+  });
+
+  describe('getConcurrencyMode', () => {
+    it('returns parallel-safe', () => {
+      expect(tool.getConcurrencyMode()).toBe('parallel-safe');
+    });
+  });
+
+  describe('getConcurrencyLockKey', () => {
+    it('returns lock key based on task_id', () => {
+      expect(tool.getConcurrencyLockKey({ task_id: 'task_1' })).toBe('taskns:default:agent:task_1');
+    });
+
+    it('returns different lock keys for different task_ids', () => {
+      expect(tool.getConcurrencyLockKey({ task_id: 'task_1' })).not.toBe(
+        tool.getConcurrencyLockKey({ task_id: 'task_2' })
+      );
+    });
+
+    it('returns lock key based on agent_id', () => {
+      expect(tool.getConcurrencyLockKey({ agent_id: 'agent_1' })).toBe(
+        'taskns:default:agent:agent_1'
+      );
+    });
+
+    it('returns lock key with custom namespace', () => {
+      const tool = new TaskOutputTool({ store, defaultNamespace: 'custom' });
+      expect(tool.getConcurrencyLockKey({ task_id: 'task_1' })).toBe('taskns:custom:agent:task_1');
+    });
+
+    it('returns lock key with namespace from args', () => {
+      expect(tool.getConcurrencyLockKey({ task_id: 'task_1', namespace: 'custom' })).toBe(
+        'taskns:custom:agent:task_1'
+      );
+    });
+  });
+});