@renxqoo/renx-code 0.0.4 → 0.0.6

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

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

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

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