@renxqoo/renx-code 0.0.9 → 0.0.12

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

@@ -1,225 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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'
-      );
-    });
-  });
-});