nine-hundred 0.0.1

package/dist/agent/tools/exec_tool/index.js

@@ -0,0 +1,44 @@
+import { execFile } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const OUTSIDE_CWD_ERROR = 'Can only execute commands inside the current working directory.';
+async function resolveWorkingDirectory(cwd) {
+    const root = await realpath(process.cwd());
+    const requestedCwd = path.resolve(root, cwd);
+    const targetCwd = await realpath(requestedCwd);
+    const relativePath = path.relative(root, targetCwd);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(OUTSIDE_CWD_ERROR);
+    }
+    const stats = await stat(targetCwd);
+    if (!stats.isDirectory()) {
+        throw new Error('Working directory must be a directory.');
+    }
+    return targetCwd;
+}
+function formatOutput(stdout, stderr) {
+    return `Exit code: 0\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`;
+}
+export async function execTool(command, cwd = '.') {
+    if (!command.trim()) {
+        throw new Error('Command is required.');
+    }
+    const targetCwd = await resolveWorkingDirectory(cwd);
+    try {
+        const { stdout, stderr } = await execFileAsync('/bin/sh', ['-c', command], {
+            cwd: targetCwd,
+            timeout: 10_000,
+            maxBuffer: 1024 * 1024,
+        });
+        return formatOutput(stdout, stderr);
+    }
+    catch (error) {
+        const execError = error;
+        const stdout = execError.stdout ?? '';
+        const stderr = execError.stderr ?? '';
+        const code = execError.code ?? 'unknown';
+        throw new Error(`Command failed with exit code ${code}.\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`, { cause: error });
+    }
+}

package/dist/agent/tools/load_skill_tool/index.js

@@ -0,0 +1,5 @@
+import { loadSkillByName } from '../../../agent/skills.js';
+export function loadSkillTool(skillName, registry) {
+    const trimmedSkillName = skillName.trim();
+    return loadSkillByName(trimmedSkillName, registry);
+}

package/dist/agent/tools/load_skill_tool/load_skill_tool.test.js

@@ -0,0 +1,122 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { loadSkillsFromRoot, loadSkillByName } from '../../../agent/skills.js';
+import { loadSkillTool } from './index.js';
+let tempRoot;
+let skillsRoot;
+async function writeSkill(folderName, markdown) {
+    const skillDir = path.join(skillsRoot, folderName);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(path.join(skillDir, 'SKILL.md'), markdown);
+}
+beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-load-skill-'));
+    skillsRoot = path.join(tempRoot, 'skills');
+    await mkdir(skillsRoot);
+});
+afterEach(async () => {
+    vi.restoreAllMocks();
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('loadSkillTool', () => {
+    it('loads skill summaries from SKILL.md frontmatter in name order', async () => {
+        await writeSkill('beta-folder', `---
+name: beta
+description: Beta skill.
+---
+
+# Beta
+`);
+        await writeSkill('alpha-folder', `---
+name: alpha
+description: Alpha skill.
+---
+
+# Alpha
+`);
+        const registry = loadSkillsFromRoot(skillsRoot);
+        expect(registry.skills.map(({ name, description }) => ({ name, description }))).toEqual([
+            { name: 'alpha', description: 'Alpha skill.' },
+            { name: 'beta', description: 'Beta skill.' },
+        ]);
+    });
+    it('loads the full SKILL.md for a named skill', async () => {
+        const markdown = `---
+name: alpha
+description: Alpha skill.
+---
+
+# Alpha
+
+Full skill content.
+`;
+        await writeSkill('alpha-folder', markdown);
+        const registry = loadSkillsFromRoot(skillsRoot);
+        expect(loadSkillByName('alpha', registry)).toBe(markdown);
+    });
+    it('loads skill content when called', async () => {
+        const markdown = `---
+name: alpha
+description: Alpha skill.
+---
+
+# Alpha
+`;
+        await writeSkill('alpha-folder', markdown);
+        const registry = loadSkillsFromRoot(skillsRoot);
+        expect(loadSkillTool('alpha', registry)).toBe(markdown);
+    });
+    it('rejects empty skill names', async () => {
+        const registry = loadSkillsFromRoot(skillsRoot);
+        expect(() => loadSkillTool('', registry)).toThrow('Skill name is required.');
+        expect(() => loadSkillTool('   ', registry)).toThrow('Skill name is required.');
+    });
+    it('rejects unknown skills and includes available skill names', async () => {
+        await writeSkill('alpha-folder', `---
+name: alpha
+description: Alpha skill.
+---
+
+# Alpha
+`);
+        const registry = loadSkillsFromRoot(skillsRoot);
+        expect(() => loadSkillTool('missing', registry)).toThrow('Unknown skill: missing. Available skills: alpha.');
+    });
+    it('rejects skill files missing name', async () => {
+        await writeSkill('alpha-folder', `---
+description: Alpha skill.
+---
+
+# Alpha
+`);
+        expect(() => loadSkillsFromRoot(skillsRoot)).toThrow('Skill file is missing name:');
+    });
+    it('rejects skill files missing description', async () => {
+        await writeSkill('alpha-folder', `---
+name: alpha
+---
+
+# Alpha
+`);
+        expect(() => loadSkillsFromRoot(skillsRoot)).toThrow('Skill file is missing description:');
+    });
+    it('rejects duplicate skill names', async () => {
+        await writeSkill('alpha-one', `---
+name: alpha
+description: Alpha one.
+---
+
+# Alpha One
+`);
+        await writeSkill('alpha-two', `---
+name: alpha
+description: Alpha two.
+---
+
+# Alpha Two
+`);
+        expect(() => loadSkillsFromRoot(skillsRoot)).toThrow('Duplicate skill name: alpha');
+    });
+});

package/dist/agent/tools/memory_create_tool/index.js

@@ -0,0 +1,8 @@
+import { checkpointer } from '../../../db/checkpointer.js';
+export async function memoryCreateTool(type, content, keywords, importance, sessionId) {
+    const db = checkpointer.db;
+    const stmt = db.prepare(`INSERT INTO memory (type, content, keywords, importance, session_id)
+    VALUES (?, ?, ?, ?, ?)`);
+    stmt.run(type, content, keywords ? JSON.stringify(keywords) : null, importance ?? 3, sessionId ?? null);
+    return 'Memory saved successfully.';
+}

package/dist/agent/tools/memory_create_tool/memory_create_tool.test.js

@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { memoryCreateTool } from './index.js';
+const { prepareMock, runMock } = vi.hoisted(() => ({
+    prepareMock: vi.fn(),
+    runMock: vi.fn(),
+}));
+vi.mock('@/db/checkpointer.js', () => ({
+    checkpointer: {
+        db: {
+            prepare: prepareMock,
+        },
+    },
+}));
+beforeEach(() => {
+    prepareMock.mockReset();
+    runMock.mockReset();
+    prepareMock.mockReturnValue({ run: runMock });
+});
+describe('memoryCreateTool', () => {
+    it('inserts a memory with all fields provided', async () => {
+        const result = await memoryCreateTool('fact', 'User likes hiking', ['hiking', 'outdoor'], 5, 'thread-123');
+        expect(result).toBe('Memory saved successfully.');
+        expect(prepareMock).toHaveBeenCalledWith(`INSERT INTO memory (type, content, keywords, importance, session_id)
+    VALUES (?, ?, ?, ?, ?)`);
+        expect(runMock).toHaveBeenCalledWith('fact', 'User likes hiking', JSON.stringify(['hiking', 'outdoor']), 5, 'thread-123');
+    });
+    it('uses default importance when not provided', async () => {
+        await memoryCreateTool('preference', 'User prefers dark mode');
+        expect(runMock).toHaveBeenCalledWith('preference', 'User prefers dark mode', null, 3, null);
+    });
+    it('uses default importance when importance is undefined', async () => {
+        await memoryCreateTool('skill', 'User knows Python', ['python'], undefined, undefined);
+        expect(runMock).toHaveBeenCalledWith('skill', 'User knows Python', JSON.stringify(['python']), 3, null);
+    });
+    it('handles null keywords correctly', async () => {
+        await memoryCreateTool('event', 'User joined the team');
+        expect(runMock).toHaveBeenCalledWith('event', 'User joined the team', null, 3, null);
+    });
+    it('handles empty keywords array', async () => {
+        await memoryCreateTool('fact', 'Empty keywords', []);
+        expect(runMock).toHaveBeenCalledWith('fact', 'Empty keywords', JSON.stringify([]), 3, null);
+    });
+    it('handles special characters in content', async () => {
+        const content = 'User said: "Hello, world!" \n New line \t tab';
+        await memoryCreateTool('fact', content, ['quote', 'newline']);
+        expect(runMock).toHaveBeenCalledWith('fact', content, JSON.stringify(['quote', 'newline']), 3, null);
+    });
+    it('wraps database errors', async () => {
+        runMock.mockImplementation(() => {
+            throw new Error('database is locked');
+        });
+        await expect(memoryCreateTool('fact', 'test')).rejects.toThrow('database is locked');
+    });
+});

package/dist/agent/tools/memory_delete_tool/index.js

@@ -0,0 +1,10 @@
+import { checkpointer } from '../../../db/checkpointer.js';
+export async function memoryDeleteTool(id) {
+    const db = checkpointer.db;
+    const stmt = db.prepare('DELETE FROM memory WHERE id = ?');
+    const result = stmt.run(id);
+    if (result.changes === 0) {
+        return `No memory found with id ${id}.`;
+    }
+    return `Memory ${id} deleted successfully.`;
+}

package/dist/agent/tools/memory_delete_tool/memory_delete_tool.test.js

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { memoryDeleteTool } from './index.js';
+const { prepareMock, runMock } = vi.hoisted(() => ({
+    prepareMock: vi.fn(),
+    runMock: vi.fn(),
+}));
+vi.mock('@/db/checkpointer.js', () => ({
+    checkpointer: {
+        db: {
+            prepare: prepareMock,
+        },
+    },
+}));
+beforeEach(() => {
+    prepareMock.mockReset();
+    runMock.mockReset();
+    prepareMock.mockReturnValue({ run: runMock });
+});
+describe('memoryDeleteTool', () => {
+    it('deletes an existing memory', async () => {
+        runMock.mockReturnValue({ changes: 1 });
+        const result = await memoryDeleteTool(42);
+        expect(result).toBe('Memory 42 deleted successfully.');
+        expect(prepareMock).toHaveBeenCalledWith('DELETE FROM memory WHERE id = ?');
+        expect(runMock).toHaveBeenCalledWith(42);
+    });
+    it('returns not-found message when id does not exist', async () => {
+        runMock.mockReturnValue({ changes: 0 });
+        const result = await memoryDeleteTool(999);
+        expect(result).toBe('No memory found with id 999.');
+        expect(runMock).toHaveBeenCalledWith(999);
+    });
+    it('wraps database errors', async () => {
+        runMock.mockImplementation(() => {
+            throw new Error('database is locked');
+        });
+        await expect(memoryDeleteTool(1)).rejects.toThrow('database is locked');
+    });
+});

package/dist/agent/tools/memory_retrieve_tool/index.js

@@ -0,0 +1,61 @@
+import { checkpointer } from '../../../db/checkpointer.js';
+export async function memoryRetrieveTool(query, limit = 10) {
+    const db = checkpointer.db;
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        throw new Error('Search query is required.');
+    }
+    // 拆分为独立关键词，空格/逗号/顿号分隔均可
+    const keywords = trimmedQuery
+        .split(/[\s,，、]+/)
+        .map((k) => k.trim())
+        .filter(Boolean);
+    if (keywords.length === 0) {
+        throw new Error('Search query is required.');
+    }
+    // 构建 OR 条件：每个关键词匹配 content 或 keywords 列
+    const conditions = keywords
+        .map(() => '(m.content LIKE ? OR m.keywords LIKE ?)')
+        .join(' OR ');
+    const params = keywords.flatMap((k) => [`%${k}%`, `%${k}%`]);
+    try {
+        const stmt = db.prepare(`
+      SELECT
+        m.id,
+        m.type,
+        m.content,
+        m.keywords,
+        m.importance,
+        m.session_id,
+        m.created_at
+      FROM memory m
+      WHERE ${conditions}
+      ORDER BY m.importance DESC, m.created_at DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(...params, limit);
+        if (rows.length === 0) {
+            return 'No matching memories found.';
+        }
+        const lines = [`Found ${rows.length} memory(s):`, ''];
+        for (const row of rows) {
+            lines.push(`[ID: ${row.id}] Type: ${row.type} | Importance: ${row.importance}`);
+            lines.push(`Content: ${row.content}`);
+            if (row.keywords) {
+                lines.push(`Keywords: ${row.keywords}`);
+            }
+            if (row.session_id) {
+                lines.push(`Session: ${row.session_id}`);
+            }
+            lines.push(`Created: ${row.created_at}`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Memory retrieval failed: ${error.message}`);
+        }
+        throw new Error('Memory retrieval failed due to an unknown error.');
+    }
+}

package/dist/agent/tools/memory_retrieve_tool/memory_retrieve_tool.test.js

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { memoryRetrieveTool } from './index.js';
+const { prepareMock } = vi.hoisted(() => ({
+    prepareMock: vi.fn(),
+}));
+vi.mock('@/db/checkpointer.js', () => ({
+    checkpointer: {
+        db: {
+            prepare: prepareMock,
+        },
+    },
+}));
+beforeEach(() => {
+    prepareMock.mockReset();
+});
+function createMockStmt(rows) {
+    return {
+        all: vi.fn().mockReturnValue(rows),
+    };
+}
+describe('memoryRetrieveTool', () => {
+    it('returns formatted memories when matches found', async () => {
+        const rows = [
+            {
+                id: 1,
+                type: 'preference',
+                content: '喜欢健身',
+                keywords: '["健身","爱好"]',
+                importance: 4,
+                session_id: 's1',
+                created_at: '2025-01-01T00:00:00Z',
+            },
+        ];
+        prepareMock.mockReturnValue(createMockStmt(rows));
+        const result = await memoryRetrieveTool('健身');
+        expect(result).toContain('Found 1 memory(s):');
+        expect(result).toContain('[ID: 1] Type: preference | Importance: 4');
+        expect(result).toContain('Content: 喜欢健身');
+        expect(result).toContain('Keywords: ["健身","爱好"]');
+        expect(result).toContain('Session: s1');
+        expect(result).toContain('Created: 2025-01-01T00:00:00Z');
+    });
+    it('returns no-match message when result is empty', async () => {
+        prepareMock.mockReturnValue(createMockStmt([]));
+        await expect(memoryRetrieveTool('不存在的关键词')).resolves.toBe('No matching memories found.');
+    });
+    it('rejects empty query', async () => {
+        await expect(memoryRetrieveTool('')).rejects.toThrow('Search query is required.');
+        await expect(memoryRetrieveTool('   ')).rejects.toThrow('Search query is required.');
+    });
+    it('splits query into multiple keywords and uses OR conditions', async () => {
+        const rows = [
+            { id: 1, type: 'fact', content: 'a', keywords: null, importance: 3, session_id: null, created_at: '2025-01-01T00:00:00Z' },
+            { id: 2, type: 'fact', content: 'b', keywords: null, importance: 3, session_id: null, created_at: '2025-01-01T00:00:00Z' },
+        ];
+        prepareMock.mockReturnValue(createMockStmt(rows));
+        await memoryRetrieveTool('关键词1 关键词2');
+        const sql = prepareMock.mock.calls[0][0];
+        expect(sql).toContain("(m.content LIKE ? OR m.keywords LIKE ?)");
+        expect(sql).toContain(" OR ");
+        expect(sql).toContain('ORDER BY m.importance DESC, m.created_at DESC');
+        expect(sql).toContain('LIMIT ?');
+    });
+    it('respects custom limit', async () => {
+        prepareMock.mockReturnValue(createMockStmt([]));
+        await memoryRetrieveTool('测试', 5);
+        const stmt = prepareMock.mock.results[0].value;
+        expect(stmt.all).toHaveBeenCalledWith('%测试%', '%测试%', 5);
+    });
+    it('wraps database errors', async () => {
+        prepareMock.mockImplementation(() => {
+            throw new Error('database is locked');
+        });
+        await expect(memoryRetrieveTool('测试')).rejects.toThrow('Memory retrieval failed: database is locked');
+    });
+    it('omits optional fields when null', async () => {
+        const rows = [
+            {
+                id: 1,
+                type: 'fact',
+                content: '简洁内容',
+                keywords: null,
+                importance: 3,
+                session_id: null,
+                created_at: '2025-01-01T00:00:00Z',
+            },
+        ];
+        prepareMock.mockReturnValue(createMockStmt(rows));
+        const result = await memoryRetrieveTool('测试');
+        expect(result).toContain('Content: 简洁内容');
+        expect(result).not.toContain('Keywords:');
+        expect(result).not.toContain('Session:');
+    });
+    it('handles comma and顿号 separated keywords', async () => {
+        prepareMock.mockReturnValue(createMockStmt([]));
+        await memoryRetrieveTool('关键词1,关键词2、关键词3');
+        const sql = prepareMock.mock.calls[0][0];
+        // 3 个关键词应生成 3 组 OR 条件
+        const orCount = (sql.match(/\(m\.content LIKE \? OR m\.keywords LIKE \?\)/g) || []).length;
+        expect(orCount).toBe(3);
+    });
+});

package/dist/agent/tools/profile_update_tool/index.js

@@ -0,0 +1,30 @@
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import * as os from 'node:os';
+import path from 'node:path';
+function getProfileDir() {
+    return path.join(os.homedir(), '.900', '.data');
+}
+function getProfilePath() {
+    return path.join(getProfileDir(), 'profile.md');
+}
+const MIN_CONTENT_RATIO = 0.5;
+export async function profileUpdateTool(content) {
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+        throw new Error('Profile content is required.');
+    }
+    const profileDir = getProfileDir();
+    const profilePath = getProfilePath();
+    await mkdir(profileDir, { recursive: true });
+    if (existsSync(profilePath)) {
+        const existingContent = await readFile(profilePath, 'utf8');
+        if (existingContent.length > 0 && trimmedContent.length < existingContent.length * MIN_CONTENT_RATIO) {
+            throw new Error(`Profile update rejected: new content (${trimmedContent.length} chars) is significantly shorter than existing content (${existingContent.length} chars). Please include the full profile content, not just the changes.`);
+        }
+        const backupPath = path.join(profileDir, `profile.${Date.now()}.md`);
+        await copyFile(profilePath, backupPath);
+    }
+    await writeFile(profilePath, trimmedContent, 'utf8');
+    return 'Profile updated successfully.';
+}

package/dist/agent/tools/profile_update_tool/profile_update_tool.test.js

@@ -0,0 +1,49 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { profileUpdateTool } from './index.js';
+let originalCwd;
+let tempRoot;
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-profile-'));
+    process.chdir(tempRoot);
+    vi.stubEnv('HOME', tempRoot);
+    vi.stubEnv('USERPROFILE', tempRoot);
+});
+afterEach(async () => {
+    process.chdir(originalCwd);
+    vi.unstubAllEnvs();
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('profileUpdateTool', () => {
+    it('creates profile file when it does not exist', async () => {
+        const content = 'Name: lyvvq\nHobby: hiking';
+        const result = await profileUpdateTool(content);
+        expect(result).toBe('Profile updated successfully.');
+        await expect(readFile(path.join(tempRoot, '.900', '.data', 'profile.md'), 'utf8')).resolves.toBe(content);
+    });
+    it('backs up existing file before updating', async () => {
+        const profileDir = path.join(tempRoot, '.900', '.data');
+        await mkdir(profileDir, { recursive: true });
+        await writeFile(path.join(profileDir, 'profile.md'), 'old content', 'utf8');
+        const result = await profileUpdateTool('new content');
+        expect(result).toBe('Profile updated successfully.');
+        await expect(readFile(path.join(profileDir, 'profile.md'), 'utf8')).resolves.toBe('new content');
+        const files = await readdir(profileDir);
+        const backups = files.filter((f) => f.startsWith('profile.') && f.endsWith('.md') && f !== 'profile.md');
+        expect(backups.length).toBe(1);
+        await expect(readFile(path.join(profileDir, backups[0]), 'utf8')).resolves.toBe('old content');
+    });
+    it('trims content before writing', async () => {
+        const result = await profileUpdateTool('  trimmed content  \n\n');
+        expect(result).toBe('Profile updated successfully.');
+        await expect(readFile(path.join(tempRoot, '.900', '.data', 'profile.md'), 'utf8')).resolves.toBe('trimmed content');
+    });
+    it('rejects empty content', async () => {
+        await expect(profileUpdateTool('')).rejects.toThrow('Profile content is required.');
+        await expect(profileUpdateTool('   ')).rejects.toThrow('Profile content is required.');
+        await expect(profileUpdateTool('\n\n')).rejects.toThrow('Profile content is required.');
+    });
+});

package/dist/agent/tools/read_file_tool/index.js

@@ -0,0 +1,24 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import * as os from 'node:os';
+import path from 'node:path';
+const TOOL_OUTPUT_DIR = path.join(os.homedir(), '.900', '.tool_output');
+function resolveToolOutputPath(inputPath) {
+    const normalized = path.normalize(inputPath);
+    if (normalized === '.tool_output' || normalized.startsWith('.tool_output' + path.sep)) {
+        const rest = normalized.slice('.tool_output'.length + 1);
+        return path.join(TOOL_OUTPUT_DIR, rest);
+    }
+    return inputPath;
+}
+export async function readFileTool(filePath) {
+    if (!filePath.trim()) {
+        throw new Error('File path is required.');
+    }
+    const resolvedPath = resolveToolOutputPath(filePath);
+    const target = await realpath(path.resolve(resolvedPath));
+    const stats = await stat(target);
+    if (!stats.isFile()) {
+        throw new Error('Can only read regular files.');
+    }
+    return readFile(target, 'utf8');
+}

package/dist/agent/tools/read_file_tool/read_file_tool.test.js

@@ -0,0 +1,43 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { readFileTool } from './index.js';
+let originalCwd;
+let tempRoot;
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-read-file-'));
+    process.chdir(tempRoot);
+});
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('readFileTool', () => {
+    it('reads a file by absolute path', async () => {
+        const filePath = path.join(tempRoot, 'hello.txt');
+        await writeFile(filePath, 'hello argos');
+        await expect(readFileTool(filePath)).resolves.toBe('hello argos');
+    });
+    it('reads a nested file', async () => {
+        const nestedDir = path.join(tempRoot, 'nested');
+        const filePath = path.join(nestedDir, 'hello.txt');
+        await mkdir(nestedDir);
+        await writeFile(filePath, 'nested hello');
+        await expect(readFileTool(filePath)).resolves.toBe('nested hello');
+    });
+    it('reads a file by relative path', async () => {
+        await writeFile('hello-relative.txt', 'hello relative');
+        await expect(readFileTool('hello-relative.txt')).resolves.toBe('hello relative');
+    });
+    it('rejects directories', async () => {
+        const dirPath = path.join(tempRoot, 'nested');
+        await mkdir(dirPath);
+        await expect(readFileTool(dirPath)).rejects.toThrow('Can only read regular files.');
+    });
+    it('rejects empty paths', async () => {
+        await expect(readFileTool('')).rejects.toThrow('File path is required.');
+        await expect(readFileTool('   ')).rejects.toThrow('File path is required.');
+    });
+});

package/dist/agent/tools/run_js_tool/index.js

@@ -0,0 +1,48 @@
+import { execFile } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const OUTSIDE_CWD_ERROR = 'Can only execute JavaScript inside the current working directory.';
+const NODE_NOT_FOUND_MESSAGE = 'Node.js is required to run JavaScript code, but the "node" executable was not found. Please install Node.js and try again.';
+async function resolveWorkingDirectory(cwd) {
+    const root = await realpath(process.cwd());
+    const requestedCwd = path.resolve(root, cwd);
+    const targetCwd = await realpath(requestedCwd);
+    const relativePath = path.relative(root, targetCwd);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(OUTSIDE_CWD_ERROR);
+    }
+    const stats = await stat(targetCwd);
+    if (!stats.isDirectory()) {
+        throw new Error('Working directory must be a directory.');
+    }
+    return targetCwd;
+}
+function formatSuccess(stdout, stderr) {
+    return `Exit code: 0\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`;
+}
+function formatFailure(code, stdout, stderr) {
+    return `JavaScript execution failed with exit code ${code}.\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`;
+}
+export async function runJsTool(code, cwd = '.') {
+    if (!code.trim()) {
+        throw new Error('JavaScript code is required.');
+    }
+    const targetCwd = await resolveWorkingDirectory(cwd);
+    try {
+        const { stdout, stderr } = await execFileAsync('node', ['-e', code], {
+            cwd: targetCwd,
+            timeout: 10_000,
+            maxBuffer: 1024 * 1024,
+        });
+        return formatSuccess(stdout, stderr);
+    }
+    catch (error) {
+        const execError = error;
+        if (execError.code === 'ENOENT') {
+            return NODE_NOT_FOUND_MESSAGE;
+        }
+        return formatFailure(execError.code ?? 'unknown', execError.stdout ?? '', execError.stderr ?? '');
+    }
+}