@renxqoo/renx-code 0.0.9 → 0.0.10

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

@@ -1,172 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { SkillTool } from '../skill-tool';
-import { initializeSkillLoader, resetSkillLoader } from '../skill/loader';
-import * as loaderModule from '../skill/loader';
-
-describe('SkillTool', () => {
-  let rootDir: string;
-  let skillsRoot: string;
-
-  beforeEach(async () => {
-    resetSkillLoader();
-    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-skill-tool-'));
-    skillsRoot = path.join(rootDir, 'skills');
-
-    await fs.mkdir(path.join(skillsRoot, 'test-skill'), { recursive: true });
-    await fs.mkdir(path.join(skillsRoot, 'plain-skill'), { recursive: true });
-
-    await fs.writeFile(
-      path.join(skillsRoot, 'test-skill', 'SKILL.md'),
-      `---
-name: test-skill
-description: Test workflow skill
----
-# Test Skill
-
-Use @src/app.ts.
-
-Run !\`pnpm test\`.`,
-      'utf8'
-    );
-
-    await fs.writeFile(
-      path.join(skillsRoot, 'plain-skill', 'SKILL.md'),
-      `# Plain Skill
-
-This is a plain skill without frontmatter.`,
-      'utf8'
-    );
-  });
-
-  afterEach(async () => {
-    resetSkillLoader();
-    await fs.rm(rootDir, { recursive: true, force: true });
-  });
-
-  it('includes available skills in description after loader initialization', async () => {
-    await initializeSkillLoader({ skillRoots: [skillsRoot] });
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-
-    expect(tool.description).toContain('Available skills');
-    expect(tool.description).toContain('test-skill');
-    expect(tool.description).toContain('plain-skill');
-  });
-
-  it('loads skill content by name', async () => {
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const result = await tool.execute({ name: 'test-skill' });
-
-    expect(result.success).toBe(true);
-    expect(result.output).toContain('## Skill: test-skill');
-
-    const metadata = result.metadata as {
-      name: string;
-      fileRefs: string[];
-      shellCommands: string[];
-    };
-
-    expect(metadata.name).toBe('test-skill');
-    expect(metadata.fileRefs).toContain('src/app.ts');
-    expect(metadata.shellCommands).toContain('pnpm test');
-  });
-
-  it('returns SKILL_NOT_FOUND with available skills suggestion', async () => {
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const result = await tool.execute({ name: 'missing-skill' });
-
-    expect(result.success).toBe(false);
-    expect(result.output).toContain('SKILL_NOT_FOUND');
-    expect((result.metadata as { suggestion: string }).suggestion).toContain('test-skill');
-  });
-
-  it('supports simple mode without skill list in description', () => {
-    const tool = new SkillTool({
-      includeSkillList: false,
-      loaderOptions: { skillRoots: [skillsRoot] },
-    });
-
-    expect(tool.description).not.toContain('Available skills');
-  });
-
-  it('exposes parallel-safe concurrency policy and lock key', () => {
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-
-    expect(tool.getConcurrencyMode()).toBe('parallel-safe');
-    expect(tool.getConcurrencyLockKey({ name: 'test-skill' })).toBe('skill:test-skill');
-  });
-
-  it('refreshDescription invalidates cache', async () => {
-    await initializeSkillLoader({ skillRoots: [skillsRoot] });
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const before = tool.description;
-    tool.refreshDescription();
-    const after = tool.description;
-
-    expect(before).toContain('Available skills');
-    expect(after).toContain('Available skills');
-  });
-
-  it('returns SKILL_LOAD_FAILED when metadata exists but file cannot be loaded', async () => {
-    await initializeSkillLoader({ skillRoots: [skillsRoot] });
-    await fs.rm(path.join(skillsRoot, 'test-skill', 'SKILL.md'));
-
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const result = await tool.execute({ name: 'test-skill' });
-
-    expect(result.success).toBe(false);
-    expect(result.output).toContain('SKILL_LOAD_FAILED');
-  });
-
-  it('maps unexpected initialize errors to ToolExecutionError', async () => {
-    const initSpy = vi
-      .spyOn(loaderModule, 'initializeSkillLoader')
-      .mockRejectedValueOnce(new Error('loader exploded'));
-
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const result = await tool.execute({ name: 'test-skill' });
-
-    expect(result.success).toBe(false);
-    expect(result.output).toBe('loader exploded');
-    expect(result.error?.name).toBe('ToolExecutionError');
-    initSpy.mockRestore();
-  });
-
-  it('shows empty-skill suggestions when no skills are available', async () => {
-    const emptyRoot = path.join(rootDir, 'empty-skills');
-    await fs.mkdir(emptyRoot, { recursive: true });
-
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [emptyRoot] } });
-    const result = await tool.execute({ name: 'missing-skill' });
-
-    expect(result.success).toBe(false);
-    expect((result.metadata as { suggestion: string }).suggestion).toBe(
-      'No skills are currently available.'
-    );
-    expect(result.output).toContain('No skills are currently available.');
-  });
-
-  it('renders description with no available skills', async () => {
-    const emptyRoot = path.join(rootDir, 'description-empty');
-    await fs.mkdir(emptyRoot, { recursive: true });
-    await initializeSkillLoader({ skillRoots: [emptyRoot] });
-
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [emptyRoot] } });
-    expect(tool.description).toContain('No skills are currently available.');
-  });
-
-  it('maps non-error loader failures using String(error)', async () => {
-    const initSpy = vi
-      .spyOn(loaderModule, 'initializeSkillLoader')
-      .mockRejectedValueOnce('loader string failure');
-
-    const tool = new SkillTool({ loaderOptions: { skillRoots: [skillsRoot] } });
-    const result = await tool.execute({ name: 'test-skill' });
-
-    expect(result.success).toBe(false);
-    expect(result.output).toBe('loader string failure');
-    initSpy.mockRestore();
-  });
-});

package/vendor/agent-root/src/agent/tool/__test__/task-concurrency-and-version.test.ts

@@ -1,116 +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 { TaskCreateTool } from '../task-create';
-import { TaskUpdateTool } from '../task-update';
-import { TaskGetTool } from '../task-get';
-
-function parseOutput<T>(output: string | undefined): T {
-  return JSON.parse(output || '{}') as T;
-}
-
-describe('task_update versioning and dependency integrity', () => {
-  let baseDir: string;
-  let store: TaskStore;
-  let taskCreate: TaskCreateTool;
-  let taskUpdate: TaskUpdateTool;
-  let taskGet: TaskGetTool;
-
-  beforeEach(async () => {
-    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-version-'));
-    store = new TaskStore({ baseDir });
-    taskCreate = new TaskCreateTool({ store });
-    taskUpdate = new TaskUpdateTool({ store });
-    taskGet = new TaskGetTool({ store });
-  });
-
-  afterEach(async () => {
-    await fs.rm(baseDir, { recursive: true, force: true });
-  });
-
-  it('rejects stale expected_version and accepts correct one', async () => {
-    const task = parseOutput<{ task: { id: string; version: number } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ver1',
-          subject: 'Versioned task',
-          description: 'Versioned task for optimistic lock verification.',
-        })
-      ).output
-    ).task;
-
-    const stale = await taskUpdate.execute({
-      namespace: 'ver1',
-      task_id: task.id,
-      subject: 'Versioned task updated once',
-      expected_version: task.version + 1,
-    });
-    expect(stale.success).toBe(false);
-    expect(stale.output).toContain('TASK_VERSION_CONFLICT');
-
-    const ok = await taskUpdate.execute({
-      namespace: 'ver1',
-      task_id: task.id,
-      subject: 'Versioned task updated once',
-      expected_version: task.version,
-    });
-    expect(ok.success).toBe(true);
-    const okPayload = parseOutput<{ task: { version: number } }>(ok.output);
-    expect(okPayload.task.version).toBe(task.version + 1);
-  });
-
-  it('supports adding and removing dependencies and keeps graph symmetric', async () => {
-    const a = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ver2',
-          subject: 'Task A',
-          description: 'Task A detail for dependency symmetry test.',
-        })
-      ).output
-    ).task;
-    const b = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ver2',
-          subject: 'Task B',
-          description: 'Task B detail for dependency symmetry test.',
-        })
-      ).output
-    ).task;
-
-    const added = await taskUpdate.execute({
-      namespace: 'ver2',
-      task_id: b.id,
-      add_blocked_by: [a.id],
-    });
-    expect(added.success).toBe(true);
-
-    const afterAddA = parseOutput<{ task: { blocks: string[] } }>(
-      (await taskGet.execute({ namespace: 'ver2', task_id: a.id })).output
-    );
-    const afterAddB = parseOutput<{ task: { blockedBy: string[] } }>(
-      (await taskGet.execute({ namespace: 'ver2', task_id: b.id })).output
-    );
-    expect(afterAddA.task.blocks).toContain(b.id);
-    expect(afterAddB.task.blockedBy).toContain(a.id);
-
-    const removed = await taskUpdate.execute({
-      namespace: 'ver2',
-      task_id: b.id,
-      remove_blocked_by: [a.id],
-    });
-    expect(removed.success).toBe(true);
-
-    const afterRemoveA = parseOutput<{ task: { blocks: string[] } }>(
-      (await taskGet.execute({ namespace: 'ver2', task_id: a.id })).output
-    );
-    const afterRemoveB = parseOutput<{ task: { blockedBy: string[] } }>(
-      (await taskGet.execute({ namespace: 'ver2', task_id: b.id })).output
-    );
-    expect(afterRemoveA.task.blocks).not.toContain(b.id);
-    expect(afterRemoveB.task.blockedBy).not.toContain(a.id);
-  });
-});

package/vendor/agent-root/src/agent/tool/__test__/task-create-get-list-update.test.ts

@@ -1,267 +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 { TaskCreateTool } from '../task-create';
-import { TaskGetTool } from '../task-get';
-import { TaskListTool } from '../task-list';
-import { TaskUpdateTool } from '../task-update';
-
-function parseOutput<T>(output: string | undefined): T {
-  return JSON.parse(output || '{}') as T;
-}
-
-describe('task_create/task_get/task_list/task_update', () => {
-  let baseDir: string;
-  let store: TaskStore;
-  let taskCreate: TaskCreateTool;
-  let taskGet: TaskGetTool;
-  let taskList: TaskListTool;
-  let taskUpdate: TaskUpdateTool;
-
-  beforeEach(async () => {
-    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-tools-'));
-    store = new TaskStore({ baseDir });
-    taskCreate = new TaskCreateTool({ store });
-    taskGet = new TaskGetTool({ store });
-    taskList = new TaskListTool({ store });
-    taskUpdate = new TaskUpdateTool({ store });
-  });
-
-  afterEach(async () => {
-    await fs.rm(baseDir, { recursive: true, force: true });
-  });
-
-  it('creates a task and returns full task payload', async () => {
-    const result = await taskCreate.execute({
-      namespace: 'ns1',
-      subject: 'Implement feature X',
-      description: 'Implement feature X with tests and docs.',
-      priority: 'high',
-      metadata: { module: 'auth' },
-    });
-
-    expect(result.success).toBe(true);
-    const payload = parseOutput<{
-      namespace: string;
-      task: { id: string; status: string; version: number };
-    }>(result.output);
-    expect(payload.namespace).toBe('ns1');
-    expect(payload.task.id).toContain('task_');
-    expect(payload.task.status).toBe('pending');
-    expect(payload.task.version).toBe(1);
-  });
-
-  it('rejects duplicate active subject', async () => {
-    await taskCreate.execute({
-      namespace: 'ns2',
-      subject: 'Same subject',
-      description: 'first task with same subject for duplicate detection',
-    });
-
-    const duplicate = await taskCreate.execute({
-      namespace: 'ns2',
-      subject: 'Same subject',
-      description: 'second task with same subject for duplicate detection',
-    });
-
-    expect(duplicate.success).toBe(false);
-    expect(duplicate.output).toContain('TASK_DUPLICATE_SUBJECT');
-  });
-
-  it('computes can_start and blocker summaries in task_get', async () => {
-    const taskA = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns3',
-          subject: 'Prepare architecture',
-          description: 'Prepare architecture and contracts for implementation.',
-        })
-      ).output
-    ).task;
-
-    const taskB = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns3',
-          subject: 'Implement API',
-          description: 'Implement API based on architecture and contracts.',
-        })
-      ).output
-    ).task;
-
-    const addDependency = await taskUpdate.execute({
-      namespace: 'ns3',
-      task_id: taskB.id,
-      add_blocked_by: [taskA.id],
-    });
-    expect(addDependency.success).toBe(true);
-
-    const detail = await taskGet.execute({
-      namespace: 'ns3',
-      task_id: taskB.id,
-    });
-    expect(detail.success).toBe(true);
-
-    const payload = parseOutput<{
-      task: {
-        can_start: { canStart: boolean; reason?: string };
-        blockers: Array<{ id: string }>;
-      };
-    }>(detail.output);
-
-    expect(payload.task.can_start.canStart).toBe(false);
-    expect(payload.task.can_start.reason).toContain(taskA.id);
-    expect(payload.task.blockers.map((item) => item.id)).toContain(taskA.id);
-  });
-
-  it('detects cycle dependency on update', async () => {
-    const taskA = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns4',
-          subject: 'Task A',
-          description: 'Task A detail with enough description text.',
-        })
-      ).output
-    ).task;
-    const taskB = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns4',
-          subject: 'Task B',
-          description: 'Task B detail with enough description text.',
-        })
-      ).output
-    ).task;
-
-    expect(
-      (
-        await taskUpdate.execute({
-          namespace: 'ns4',
-          task_id: taskB.id,
-          add_blocked_by: [taskA.id],
-        })
-      ).success
-    ).toBe(true);
-
-    const cycle = await taskUpdate.execute({
-      namespace: 'ns4',
-      task_id: taskA.id,
-      add_blocked_by: [taskB.id],
-    });
-
-    expect(cycle.success).toBe(false);
-    expect(cycle.output).toContain('TASK_CYCLE_DEPENDENCY');
-  });
-
-  it('supports owner=null and records status transition history accurately', async () => {
-    const created = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns5',
-          subject: 'Run migration',
-          description: 'Run migration with rollback plan and checklist.',
-        })
-      ).output
-    ).task;
-
-    const update1 = await taskUpdate.execute({
-      namespace: 'ns5',
-      task_id: created.id,
-      status: 'in_progress',
-      owner: 'main-agent',
-      updated_by: 'tester',
-    });
-    expect(update1.success).toBe(true);
-
-    const release = await taskUpdate.execute({
-      namespace: 'ns5',
-      task_id: created.id,
-      owner: null,
-      updated_by: 'tester',
-    });
-    expect(release.success).toBe(true);
-
-    const complete = await taskUpdate.execute({
-      namespace: 'ns5',
-      task_id: created.id,
-      status: 'completed',
-      updated_by: 'tester',
-    });
-    expect(complete.success).toBe(true);
-
-    const detail = await taskGet.execute({
-      namespace: 'ns5',
-      task_id: created.id,
-      include_history: true,
-    });
-    const payload = parseOutput<{
-      task: {
-        owner: string | null;
-        history: Array<{ action: string; fromStatus?: string; toStatus?: string }>;
-      };
-    }>(detail.output);
-    expect(payload.task.owner).toBeNull();
-
-    const statusEntries = payload.task.history.filter((entry) => entry.action === 'status_changed');
-    expect(statusEntries.length).toBe(2);
-    expect(statusEntries[0]).toMatchObject({
-      fromStatus: 'pending',
-      toStatus: 'in_progress',
-    });
-    expect(statusEntries[1]).toMatchObject({
-      fromStatus: 'in_progress',
-      toStatus: 'completed',
-    });
-  });
-
-  it('sorts list with critical claimable before in_progress and others', async () => {
-    const critical = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns6',
-          subject: 'Emergency fix',
-          description: 'Emergency fix in production with immediate response.',
-          priority: 'critical',
-        })
-      ).output
-    ).task;
-
-    const normal = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns6',
-          subject: 'Regular task',
-          description: 'Regular task for planned sprint implementation.',
-          priority: 'normal',
-        })
-      ).output
-    ).task;
-
-    const inProgress = parseOutput<{ task: { id: string } }>(
-      (
-        await taskCreate.execute({
-          namespace: 'ns6',
-          subject: 'In-progress task',
-          description: 'Task that will be moved to in progress.',
-          priority: 'high',
-        })
-      ).output
-    ).task;
-
-    await taskUpdate.execute({
-      namespace: 'ns6',
-      task_id: inProgress.id,
-      status: 'in_progress',
-      owner: 'agent-1',
-    });
-
-    const listed = await taskList.execute({ namespace: 'ns6' });
-    expect(listed.success).toBe(true);
-    const payload = parseOutput<{ tasks: Array<{ id: string }> }>(listed.output);
-    expect(payload.tasks[0].id).toBe(critical.id);
-    expect(payload.tasks.map((item) => item.id)).toContain(normal.id);
-  });
-});