@renxqoo/renx-code 0.0.9 → 0.0.12

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

@@ -1,391 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { TaskStore, getTaskStore } from '../task-store';
-import { createEmptyNamespaceState } from '../task-types';
-
-describe('TaskStore', () => {
-  let tempDir: string;
-  let store: TaskStore;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'task-store-test-'));
-    store = new TaskStore({ baseDir: tempDir });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe('constructor', () => {
-    it('creates store with default options', () => {
-      const store = new TaskStore();
-      expect(store).toBeDefined();
-      expect(store.baseDir).toContain('.renx');
-    });
-
-    it('creates store with custom baseDir', () => {
-      const store = new TaskStore({ baseDir: '/custom/path' });
-      // On Windows, path.resolve converts /custom/path to D:\custom\path
-      expect(path.isAbsolute(store.baseDir)).toBe(true);
-      expect(store.baseDir).toContain('custom');
-      expect(store.baseDir).toContain('path');
-    });
-
-    it('creates store with custom now function', () => {
-      const mockNow = vi.fn().mockReturnValue(1234567890);
-      const store = new TaskStore({ now: mockNow });
-      expect(store).toBeDefined();
-    });
-  });
-
-  describe('normalizeNamespace', () => {
-    it('returns default for undefined', () => {
-      expect(store.normalizeNamespace(undefined)).toBe('default');
-    });
-
-    it('returns default for empty string', () => {
-      expect(store.normalizeNamespace('')).toBe('default');
-    });
-
-    it('returns default for whitespace-only string', () => {
-      expect(store.normalizeNamespace('   ')).toBe('default');
-    });
-
-    it('returns trimmed namespace', () => {
-      expect(store.normalizeNamespace('  test  ')).toBe('test');
-    });
-
-    it('accepts valid namespace characters', () => {
-      expect(store.normalizeNamespace('test-namespace')).toBe('test-namespace');
-      expect(store.normalizeNamespace('test_namespace')).toBe('test_namespace');
-      expect(store.normalizeNamespace('test.namespace')).toBe('test.namespace');
-      expect(store.normalizeNamespace('test123')).toBe('test123');
-    });
-
-    it('throws for invalid namespace characters', () => {
-      expect(() => store.normalizeNamespace('test namespace')).toThrow('TASK_INVALID_NAMESPACE');
-      expect(() => store.normalizeNamespace('test@namespace')).toThrow('TASK_INVALID_NAMESPACE');
-      expect(() => store.normalizeNamespace('test#namespace')).toThrow('TASK_INVALID_NAMESPACE');
-      expect(() => store.normalizeNamespace('test/namespace')).toThrow('TASK_INVALID_NAMESPACE');
-      expect(() => store.normalizeNamespace('test\\namespace')).toThrow('TASK_INVALID_NAMESPACE');
-    });
-  });
-
-  describe('getNamespaceFilePath', () => {
-    it('returns correct file path', () => {
-      const filePath = store.getNamespaceFilePath('test-namespace');
-      expect(filePath).toBe(path.join(tempDir, 'test-namespace.json'));
-    });
-
-    it('handles default namespace', () => {
-      const filePath = store.getNamespaceFilePath('default');
-      expect(filePath).toBe(path.join(tempDir, 'default.json'));
-    });
-  });
-
-  describe('getState', () => {
-    it('returns empty state for new namespace', async () => {
-      const state = await store.getState('test-namespace');
-
-      expect(state.namespace).toBe('test-namespace');
-      expect(state.tasks).toEqual({});
-      expect(state.agentRuns).toEqual({});
-      expect(state.graph.adjacency).toEqual({});
-      expect(state.graph.reverse).toEqual({});
-      expect(state.schemaVersion).toBe(1);
-    });
-
-    it('returns default namespace state', async () => {
-      const state = await store.getState();
-
-      expect(state.namespace).toBe('default');
-    });
-
-    it('returns cached state', async () => {
-      // First call creates the state
-      const state1 = await store.getState('test-namespace');
-
-      // Second call should return cached state
-      const state2 = await store.getState('test-namespace');
-
-      expect(state1).toEqual(state2);
-    });
-
-    it('returns state from file', async () => {
-      // Create a state file manually
-      const state = createEmptyNamespaceState('test-namespace');
-      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,
-        },
-      };
-
-      const filePath = store.getNamespaceFilePath('test-namespace');
-      await fs.writeFile(filePath, JSON.stringify(state, null, 2));
-
-      const loadedState = await store.getState('test-namespace');
-
-      expect(loadedState.tasks).toHaveProperty('task_1');
-      expect(loadedState.tasks.task_1.subject).toBe('Test Task');
-    });
-
-    it('handles corrupted state file', async () => {
-      const filePath = store.getNamespaceFilePath('test-namespace');
-      await fs.writeFile(filePath, 'invalid json');
-
-      await expect(store.getState('test-namespace')).rejects.toThrow('TASK_STORE_IO_ERROR');
-    });
-
-    it('handles state file with missing fields', async () => {
-      const filePath = store.getNamespaceFilePath('test-namespace');
-      await fs.writeFile(filePath, JSON.stringify({ namespace: 'test-namespace' }));
-
-      const state = await store.getState('test-namespace');
-
-      expect(state.namespace).toBe('test-namespace');
-      expect(state.tasks).toEqual({});
-      expect(state.agentRuns).toEqual({});
-    });
-  });
-
-  describe('updateState', () => {
-    it('updates state and returns result', async () => {
-      const { state, result } = await store.updateState('test-namespace', (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';
-      });
-
-      expect(result).toBe('created');
-      expect(state.tasks).toHaveProperty('task_1');
-      expect(state.tasks.task_1.subject).toBe('Test Task');
-    });
-
-    it('persists state to file', async () => {
-      await store.updateState('test-namespace', (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 filePath = store.getNamespaceFilePath('test-namespace');
-      const fileContent = await fs.readFile(filePath, 'utf8');
-      const parsed = JSON.parse(fileContent);
-
-      expect(parsed.tasks).toHaveProperty('task_1');
-    });
-
-    it('handles async updater', async () => {
-      const { state, result } = await store.updateState('test-namespace', async (state) => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        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 'async-created';
-      });
-
-      expect(result).toBe('async-created');
-      expect(state.tasks).toHaveProperty('task_1');
-    });
-
-    it('handles updater errors', async () => {
-      await expect(
-        store.updateState('test-namespace', () => {
-          throw new Error('Updater error');
-        })
-      ).rejects.toThrow('Updater error');
-    });
-
-    it('releases lock on error', async () => {
-      // First update fails
-      await expect(
-        store.updateState('test-namespace', () => {
-          throw new Error('First error');
-        })
-      ).rejects.toThrow('First error');
-
-      // Second update should succeed (lock was released)
-      const { result } = await store.updateState('test-namespace', () => {
-        return 'success';
-      });
-
-      expect(result).toBe('success');
-    });
-
-    it('handles concurrent updates', async () => {
-      const results: string[] = [];
-
-      const update1 = store.updateState('test-namespace', async (_state) => {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        results.push('update1');
-        return 'result1';
-      });
-
-      const update2 = store.updateState('test-namespace', async (_state) => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        results.push('update2');
-        return 'result2';
-      });
-
-      const [result1, result2] = await Promise.all([update1, update2]);
-
-      expect(result1.result).toBe('result1');
-      expect(result2.result).toBe('result2');
-      // Both updates should have completed
-      expect(results).toHaveLength(2);
-      expect(results).toContain('update1');
-      expect(results).toContain('update2');
-    });
-
-    it('uses custom now function', async () => {
-      const mockNow = vi.fn().mockReturnValue(1234567890);
-      const store = new TaskStore({ baseDir: tempDir, now: mockNow });
-
-      await store.updateState('test-namespace', (_state) => {
-        return 'result';
-      });
-
-      expect(mockNow).toHaveBeenCalled();
-    });
-  });
-
-  describe('file operations', () => {
-    it('creates base directory on first access', async () => {
-      const newDir = path.join(tempDir, 'new-dir');
-      const store = new TaskStore({ baseDir: newDir });
-
-      await store.getState('test-namespace');
-
-      const stats = await fs.stat(newDir);
-      expect(stats.isDirectory()).toBe(true);
-    });
-
-    it('handles permission errors on directory creation', async () => {
-      // Skip on Windows as chmod doesn't work the same way
-      if (process.platform === 'win32') {
-        return;
-      }
-      const restrictedDir = path.join(tempDir, 'restricted');
-      await fs.mkdir(restrictedDir, { recursive: true });
-      await fs.chmod(restrictedDir, 0o000);
-
-      try {
-        const store = new TaskStore({ baseDir: path.join(restrictedDir, 'subdir') });
-        await expect(store.getState('test-namespace')).rejects.toThrow();
-      } finally {
-        await fs.chmod(restrictedDir, 0o755);
-      }
-    });
-
-    it('handles permission errors on file write', async () => {
-      const filePath = store.getNamespaceFilePath('test-namespace');
-      await fs.writeFile(filePath, '{}');
-      await fs.chmod(filePath, 0o000);
-
-      try {
-        await expect(store.updateState('test-namespace', () => 'result')).rejects.toThrow();
-      } finally {
-        await fs.chmod(filePath, 0o644);
-      }
-    });
-  });
-});
-
-describe('getTaskStore', () => {
-  it('returns same store for same baseDir', () => {
-    const store1 = getTaskStore({ baseDir: '/tmp/test' });
-    const store2 = getTaskStore({ baseDir: '/tmp/test' });
-
-    expect(store1).toBe(store2);
-  });
-
-  it('returns different store for different baseDir', () => {
-    const store1 = getTaskStore({ baseDir: '/tmp/test1' });
-    const store2 = getTaskStore({ baseDir: '/tmp/test2' });
-
-    expect(store1).not.toBe(store2);
-  });
-
-  it('returns same store for equivalent baseDir', () => {
-    const store1 = getTaskStore({ baseDir: '/tmp/test' });
-    const store2 = getTaskStore({ baseDir: '/tmp/test/' });
-
-    expect(store1).toBe(store2);
-  });
-});

package/vendor/agent-root/src/agent/tool/__test__/task-subagent-config-integration.test.ts

@@ -1,176 +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 { TaskTool } from '../task';
-import { TaskStore } from '../task-store';
-import type { SubagentRunnerAdapter } from '../task-runner-adapter';
-import type { AgentRunEntity } from '../task-types';
-
-function parseOutput<T>(output: string | undefined): T {
-  return JSON.parse(output || '{}') as T;
-}
-
-function makeRun(agentId: string): AgentRunEntity {
-  const now = Date.now();
-  return {
-    agentId,
-    status: 'running',
-    subagentType: 'Plan',
-    prompt: 'p',
-    createdAt: now,
-    startedAt: now,
-    updatedAt: now,
-    metadata: {},
-    version: 1,
-  };
-}
-
-describe('task subagent config integration', () => {
-  let baseDir: string;
-  let store: TaskStore;
-
-  beforeEach(async () => {
-    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-subagent-config-'));
-    store = new TaskStore({ baseDir });
-  });
-
-  afterEach(async () => {
-    await fs.rm(baseDir, { recursive: true, force: true });
-  });
-
-  it('injects default tools and systemPrompt from subagent config', async () => {
-    const captured: Array<{ allowedTools?: string[]; systemPrompt?: string }> = [];
-    const runner: SubagentRunnerAdapter = {
-      start: async (_ns, input) => {
-        captured.push({
-          allowedTools: input.allowedTools,
-          systemPrompt: input.systemPrompt,
-        });
-        return makeRun('agent-default-config');
-      },
-      poll: async () => null,
-      cancel: async () => null,
-    };
-
-    const tool = new TaskTool({ store, runner });
-    const result = await tool.execute({
-      namespace: 'ns1',
-      subagent_type: 'Plan',
-      prompt: 'build plan',
-      run_in_background: true,
-    });
-    expect(result.success).toBe(true);
-    const firstCapture = captured[0];
-    if (!firstCapture) {
-      throw new Error('expected captured task config');
-    }
-    expect(firstCapture.allowedTools).toContain('glob');
-    expect(firstCapture.allowedTools).toContain('grep');
-    expect(firstCapture.allowedTools).toContain('file_read');
-    expect(firstCapture.systemPrompt).toContain('planning specialist');
-  });
-
-  it('filters requested allowed_tools through config whitelist', async () => {
-    const captured: Array<{ allowedTools?: string[]; systemPrompt?: string }> = [];
-    const runner: SubagentRunnerAdapter = {
-      start: async (_ns, input) => {
-        captured.push({
-          allowedTools: input.allowedTools,
-          systemPrompt: input.systemPrompt,
-        });
-        return makeRun('agent-filtered-config');
-      },
-      poll: async () => null,
-      cancel: async () => null,
-    };
-
-    const tool = new TaskTool({ store, runner });
-    const result = await tool.execute({
-      namespace: 'ns2',
-      subagent_type: 'Plan',
-      prompt: 'plan with narrowed tools',
-      run_in_background: true,
-      allowed_tools: ['glob', 'bash', 'write_file'],
-    });
-    expect(result.success).toBe(true);
-    const firstCapture = captured[0];
-    if (!firstCapture) {
-      throw new Error('expected captured task config');
-    }
-    expect(firstCapture.allowedTools).toEqual(['glob']);
-
-    const payload = parseOutput<{ agent_run: { agentId: string } }>(result.output);
-    expect(payload.agent_run.agentId).toBe('agent-filtered-config');
-  });
-
-  it('injects find-skills defaults (skill + bash) and skill-discovery prompt', async () => {
-    const captured: Array<{ allowedTools?: string[]; systemPrompt?: string }> = [];
-    const runner: SubagentRunnerAdapter = {
-      start: async (_ns, input) => {
-        captured.push({
-          allowedTools: input.allowedTools,
-          systemPrompt: input.systemPrompt,
-        });
-        return makeRun('agent-find-skills-config');
-      },
-      poll: async () => null,
-      cancel: async () => null,
-    };
-
-    const tool = new TaskTool({ store, runner });
-    const result = await tool.execute({
-      namespace: 'ns3',
-      subagent_type: 'find-skills',
-      prompt: 'find and install skill for code review',
-      run_in_background: true,
-    });
-
-    expect(result.success).toBe(true);
-    const firstCapture = captured[0];
-    if (!firstCapture) {
-      throw new Error('expected captured task config');
-    }
-    expect(firstCapture.allowedTools).toEqual(['skill', 'bash']);
-    expect(firstCapture.systemPrompt).toContain('Skill Discovery and Installation Specialist');
-    expect(firstCapture.systemPrompt).toContain('Check local skills first');
-    expect(firstCapture.systemPrompt).toContain('load the **`find-skills`** skill');
-  });
-
-  it('injects Restore defaults and absolute-path rollback prompt', async () => {
-    const captured: Array<{ allowedTools?: string[]; systemPrompt?: string }> = [];
-    const runner: SubagentRunnerAdapter = {
-      start: async (_ns, input) => {
-        captured.push({
-          allowedTools: input.allowedTools,
-          systemPrompt: input.systemPrompt,
-        });
-        return makeRun('agent-restore-config');
-      },
-      poll: async () => null,
-      cancel: async () => null,
-    };
-
-    const tool = new TaskTool({ store, runner });
-    const result = await tool.execute({
-      namespace: 'ns4',
-      subagent_type: 'Restore',
-      prompt: 'restore D:\\work\\coding-agent-v2\\src\\renx\\tool\\write-file.ts',
-      run_in_background: true,
-    });
-
-    expect(result.success).toBe(true);
-    const firstCapture = captured[0];
-    if (!firstCapture) {
-      throw new Error('expected captured task config');
-    }
-    expect(firstCapture.allowedTools).toEqual([
-      'glob',
-      'file_read',
-      'file_history_list',
-      'file_history_restore',
-    ]);
-    expect(firstCapture.systemPrompt).toContain('absolute file paths');
-    expect(firstCapture.systemPrompt).toContain('Do not use file_edit or write_file');
-  });
-});

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

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getTaskSubagentConfig, resolveTaskSubagentTools } from '../task-subagent-config';
-import type { SubagentType } from '../task-types';
-
-const ALL_TYPES: SubagentType[] = [
-  'Bash',
-  'general-purpose',
-  'Explore',
-  'Restore',
-  'Plan',
-  'research-agent',
-  'find-skills',
-];
-
-describe('task-subagent-config', () => {
-  it('returns config for every supported subagent type', () => {
-    for (const type of ALL_TYPES) {
-      const config = getTaskSubagentConfig(type);
-      expect(config.tools.length).toBeGreaterThan(0);
-      expect(config.systemPrompt.length).toBeGreaterThan(0);
-    }
-  });
-
-  it('returns cloned tool arrays to avoid accidental shared mutation', () => {
-    const first = getTaskSubagentConfig('Plan');
-    const second = getTaskSubagentConfig('Plan');
-    first.tools.push('unexpected_tool');
-    expect(second.tools).not.toContain('unexpected_tool');
-  });
-
-  it('uses defaults when requested tools are empty or undefined', () => {
-    const defaults = getTaskSubagentConfig('general-purpose').tools;
-    expect(resolveTaskSubagentTools('general-purpose')).toEqual(defaults);
-    expect(resolveTaskSubagentTools('general-purpose', [])).toEqual(defaults);
-  });
-
-  it('narrows requested tools by config whitelist and falls back to defaults', () => {
-    expect(resolveTaskSubagentTools('Plan', ['glob', 'bash'])).toEqual(['glob']);
-
-    const defaults = getTaskSubagentConfig('Plan').tools;
-    expect(resolveTaskSubagentTools('Plan', ['bash', 'write_file'])).toEqual(defaults);
-  });
-
-  it('defines find-skills as local-first skill workflow with bash fallback', () => {
-    const config = getTaskSubagentConfig('find-skills');
-
-    expect(config.tools).toEqual(['skill', 'bash']);
-    expect(config.systemPrompt).toContain('Check local skills first');
-    expect(config.systemPrompt).toContain('load the **`find-skills`** skill');
-    expect(config.systemPrompt).toContain('Use `bash` only for the required installation command');
-    expect(config.systemPrompt).toContain('retry using the `skill` tool');
-  });
-
-  it('defines Restore as a narrow rollback workflow using explicit file paths', () => {
-    const config = getTaskSubagentConfig('Restore');
-
-    expect(config.tools).toEqual([
-      'glob',
-      'file_read',
-      'file_history_list',
-      'file_history_restore',
-    ]);
-    expect(config.systemPrompt).toContain('file restoration specialist');
-    expect(config.systemPrompt).toContain('Prefer exact absolute file paths');
-    expect(config.systemPrompt).toContain('Do not use file_edit or write_file');
-    expect(config.systemPrompt).toContain('file_history_restore');
-  });
-});