@agentscope-ai/agentscope 0.0.2

package/src/tool/edit.test.ts

@@ -0,0 +1,83 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { Tool } from './base';
+import { Edit } from './edit';
+
+describe('Edit', () => {
+    let tmpDir: string;
+    let edit: Tool;
+
+    beforeEach(() => {
+        edit = Edit();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-test-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('replaces a unique string', () => {
+        const filePath = path.join(tmpDir, 'test.ts');
+        fs.writeFileSync(filePath, 'const x = 1;\nconst y = 2;');
+        edit.call!({
+            file_path: filePath,
+            old_string: 'const x = 1;',
+            new_string: 'const x = 42;',
+        });
+        expect(fs.readFileSync(filePath, 'utf-8')).toBe('const x = 42;\nconst y = 2;');
+    });
+
+    it('throws when old_string not found', () => {
+        const filePath = path.join(tmpDir, 'test.ts');
+        fs.writeFileSync(filePath, 'hello world');
+        expect(() =>
+            edit.call!({ file_path: filePath, old_string: 'not here', new_string: 'x' })
+        ).toThrow('not found');
+    });
+
+    it('throws when old_string is not unique and replace_all is false', () => {
+        const filePath = path.join(tmpDir, 'test.ts');
+        fs.writeFileSync(filePath, 'foo foo foo');
+        expect(() =>
+            edit.call!({ file_path: filePath, old_string: 'foo', new_string: 'bar' })
+        ).toThrow('not unique');
+    });
+
+    it('replaces all occurrences when replace_all is true', () => {
+        const filePath = path.join(tmpDir, 'test.ts');
+        fs.writeFileSync(filePath, 'foo foo foo');
+        edit.call!({
+            file_path: filePath,
+            old_string: 'foo',
+            new_string: 'bar',
+            replace_all: true,
+        });
+        expect(fs.readFileSync(filePath, 'utf-8')).toBe('bar bar bar');
+    });
+
+    it('throws when old_string equals new_string', () => {
+        const filePath = path.join(tmpDir, 'test.ts');
+        fs.writeFileSync(filePath, 'hello');
+        expect(() =>
+            edit.call!({ file_path: filePath, old_string: 'hello', new_string: 'hello' })
+        ).toThrow('must be different');
+    });
+
+    it('throws on relative path', () => {
+        expect(() =>
+            edit.call!({ file_path: 'relative.ts', old_string: 'a', new_string: 'b' })
+        ).toThrow('absolute path');
+    });
+
+    it('throws on non-existent file', () => {
+        expect(() =>
+            edit.call!({
+                file_path: path.join(tmpDir, 'nope.ts'),
+                old_string: 'a',
+                new_string: 'b',
+            })
+        ).toThrow('File not found');
+    });
+});

package/src/tool/edit.ts

@@ -0,0 +1,95 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { z } from 'zod';
+
+/**
+ * Tool for performing exact string replacements in files.
+ * Requires the file to have been read at least once before editing.
+ *
+ * @returns A Tool object with a call method that performs the edit operation based on the provided parameters, ensuring uniqueness of the old_string unless replace_all is true.
+ */
+export function Edit() {
+    return {
+        name: 'Edit',
+        description: `Performs exact string replacements in files.
+
+Usage:
+- You must use your Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`,
+        inputSchema: z.object({
+            file_path: z.string().describe('The absolute path to the file to modify'),
+            old_string: z.string().describe('The text to replace'),
+            new_string: z
+                .string()
+                .describe('The text to replace it with (must be different from old_string)'),
+            replace_all: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('Replace all occurrences of old_string (default false)'),
+        }),
+        requireUserConfirm: true,
+
+        /**
+         * Performs an exact string replacement in the specified file.
+         *
+         * @param root0 - The parameters object
+         * @param root0.file_path - Absolute path to the file to modify
+         * @param root0.old_string - The exact text to find and replace
+         * @param root0.new_string - The text to replace old_string with
+         * @param root0.replace_all - If true, replaces all occurrences; otherwise only the first
+         * @returns A success message indicating the file was updated
+         * @throws If the path is not absolute, file does not exist, strings are identical,
+         *         old_string is not found, or old_string is not unique and replace_all is false
+         */
+        call({
+            file_path,
+            old_string,
+            new_string,
+            replace_all = false,
+        }: {
+            file_path: string;
+            old_string: string;
+            new_string: string;
+            replace_all?: boolean;
+        }): string {
+            if (!path.isAbsolute(file_path)) {
+                throw new Error(`file_path must be an absolute path, got: ${file_path}`);
+            }
+
+            if (!fs.existsSync(file_path)) {
+                throw new Error(`File not found: ${file_path}`);
+            }
+
+            if (old_string === new_string) {
+                throw new Error('old_string and new_string must be different');
+            }
+
+            const content = fs.readFileSync(file_path, 'utf-8');
+            const occurrences = content.split(old_string).length - 1;
+
+            if (occurrences === 0) {
+                throw new Error(`old_string not found in file: ${file_path}`);
+            }
+
+            if (!replace_all && occurrences > 1) {
+                throw new Error(
+                    `old_string is not unique in the file (found ${occurrences} occurrences). ` +
+                        `Provide more surrounding context to make it unique, or use replace_all=true.`
+                );
+            }
+
+            const newContent = replace_all
+                ? content.split(old_string).join(new_string)
+                : content.replace(old_string, new_string);
+
+            fs.writeFileSync(file_path, newContent, 'utf-8');
+            return `The file ${file_path} has been updated successfully.`;
+        },
+    };
+}

package/src/tool/glob.test.ts

@@ -0,0 +1,63 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { Glob } from './glob';
+
+describe('Glob', () => {
+    let tmpDir: string;
+    let glob: ReturnType<typeof Glob>;
+
+    beforeEach(() => {
+        glob = Glob();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-test-'));
+        fs.writeFileSync(path.join(tmpDir, 'a.ts'), '');
+        fs.writeFileSync(path.join(tmpDir, 'b.ts'), '');
+        fs.writeFileSync(path.join(tmpDir, 'c.js'), '');
+        fs.mkdirSync(path.join(tmpDir, 'src'));
+        fs.writeFileSync(path.join(tmpDir, 'src', 'd.ts'), '');
+        fs.writeFileSync(path.join(tmpDir, 'src', 'e.tsx'), '');
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('matches *.ts files in root', () => {
+        const result = glob.call!({ pattern: '*.ts', path: tmpDir });
+        expect(result).toContain('a.ts');
+        expect(result).toContain('b.ts');
+        expect(result).not.toContain('c.js');
+        expect(result).not.toContain('d.ts');
+    });
+
+    it('matches **/*.ts recursively', () => {
+        const result = glob.call!({ pattern: '**/*.ts', path: tmpDir });
+        expect(result).toContain('a.ts');
+        expect(result).toContain('b.ts');
+        expect(result).toContain('d.ts');
+        expect(result).not.toContain('c.js');
+    });
+
+    it('matches **/*.tsx recursively', () => {
+        const result = glob.call!({ pattern: '**/*.tsx', path: tmpDir });
+        expect(result).toContain('e.tsx');
+        expect(result).not.toContain('a.ts');
+    });
+
+    it('returns message when no files match', () => {
+        const result = glob.call!({ pattern: '*.py', path: tmpDir });
+        expect(result).toContain('No files found');
+    });
+
+    it('throws on non-existent directory', () => {
+        expect(() => glob.call!({ pattern: '*.ts', path: '/nonexistent/path' })).toThrow(
+            'Directory not found'
+        );
+    });
+
+    it('uses cwd when path is not specified', () => {
+        const result = glob.call!({ pattern: '*.json' });
+        expect(typeof result).toBe('string');
+    });
+});

package/src/tool/glob.ts

@@ -0,0 +1,166 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { z } from 'zod';
+
+/**
+ * Tool for fast file pattern matching across a codebase.
+ * Supports glob patterns and returns results sorted by modification time.
+ *
+ * @returns A Tool object with a call method that performs glob matching based on the provided pattern and path.
+ */
+export function Glob() {
+    /**
+     * Matches files against a glob pattern starting from the given base directory.
+     * @param pattern - The glob pattern to match against.
+     * @param baseDir - The base directory to search from.
+     * @returns An array of matched file paths.
+     */
+    const globMatch = (pattern: string, baseDir: string): string[] => {
+        const results: string[] = [];
+        const parts = pattern.split('/');
+        matchParts(parts, 0, baseDir, results);
+        return results;
+    };
+
+    /**
+     * Recursively matches path parts against directory entries.
+     * @param parts - The split glob pattern parts.
+     * @param partIndex - The current index in the parts array.
+     * @param currentDir - The current directory being traversed.
+     * @param results - The accumulator array for matched file paths.
+     */
+    const matchParts = (
+        parts: string[],
+        partIndex: number,
+        currentDir: string,
+        results: string[]
+    ): void => {
+        if (partIndex >= parts.length) return;
+
+        const part = parts[partIndex];
+        const isLast = partIndex === parts.length - 1;
+
+        if (part === '**') {
+            if (isLast) {
+                collectAll(currentDir, results);
+            } else {
+                matchParts(parts, partIndex + 1, currentDir, results);
+                try {
+                    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            const subDir = path.join(currentDir, entry.name);
+                            matchParts(parts, partIndex, subDir, results);
+                        }
+                    }
+                } catch {
+                    // skip unreadable dirs
+                }
+            }
+        } else {
+            const regex = globPartToRegex(part);
+            try {
+                const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (regex.test(entry.name)) {
+                        const fullPath = path.join(currentDir, entry.name);
+                        if (isLast) {
+                            if (entry.isFile()) results.push(fullPath);
+                        } else if (entry.isDirectory()) {
+                            matchParts(parts, partIndex + 1, fullPath, results);
+                        }
+                    }
+                }
+            } catch {
+                // skip unreadable dirs
+            }
+        }
+    };
+
+    /**
+     * Recursively collects all files under a directory.
+     * @param dir - The directory to collect files from.
+     * @param results - The accumulator array for collected file paths.
+     */
+    const collectAll = (dir: string, results: string[]): void => {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isFile()) {
+                    results.push(fullPath);
+                } else if (entry.isDirectory()) {
+                    collectAll(fullPath, results);
+                }
+            }
+        } catch {
+            // skip unreadable dirs
+        }
+    };
+
+    /**
+     * Converts a single glob pattern part to a RegExp.
+     * @param part - The glob pattern part to convert.
+     * @returns A RegExp that matches the pattern part.
+     */
+    const globPartToRegex = (part: string): RegExp => {
+        const escaped = part
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${escaped}$`);
+    };
+
+    return {
+        name: 'Glob',
+        description: `Fast file pattern matching tool that works with any codebase size.
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
+- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.`,
+        inputSchema: z.object({
+            pattern: z.string().describe('The glob pattern to match files against'),
+            path: z
+                .string()
+                .optional()
+                .describe(
+                    'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.'
+                ),
+        }),
+        requireUserConfirm: true,
+
+        /**
+         * Finds files matching a glob pattern under the given directory.
+         *
+         * @param root0 - The parameters object
+         * @param root0.pattern - The glob pattern to match files against
+         * @param root0.path - The base directory to search in; defaults to cwd
+         * @returns A newline-separated list of matching file paths sorted by modification time,
+         *          or a no-matches message if nothing is found
+         * @throws If the base directory does not exist
+         */
+        call({ pattern, path: searchPath }: { pattern: string; path?: string }): string {
+            const baseDir = searchPath ? searchPath : process.cwd();
+
+            if (!fs.existsSync(baseDir)) {
+                throw new Error(`Directory not found: ${baseDir}`);
+            }
+
+            const matches = globMatch(pattern, baseDir);
+
+            matches.sort((a, b) => {
+                const statA = fs.statSync(a);
+                const statB = fs.statSync(b);
+                return statB.mtimeMs - statA.mtimeMs;
+            });
+
+            if (matches.length === 0) {
+                return `No files found matching pattern: ${pattern}`;
+            }
+
+            return matches.join('\n');
+        },
+    };
+}

package/src/tool/grep.test.ts

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { Tool } from './base';
+import { Grep } from './grep';
+
+describe('Grep', () => {
+    let tmpDir: string;
+    let grep: Tool;
+
+    beforeEach(() => {
+        grep = Grep();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'grep-test-'));
+        fs.writeFileSync(path.join(tmpDir, 'a.ts'), 'function hello() {}\nconst world = 1;');
+        fs.writeFileSync(path.join(tmpDir, 'b.ts'), 'function greet() {}\nconst hello = "hi";');
+        fs.writeFileSync(path.join(tmpDir, 'c.js'), 'var hello = true;');
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('returns files_with_matches by default', () => {
+        const result = grep.call!({ pattern: 'hello', path: tmpDir });
+        expect(result).toContain('a.ts');
+        expect(result).toContain('b.ts');
+        expect(result).toContain('c.js');
+    });
+
+    it('filters by type', () => {
+        const result = grep.call!({ pattern: 'hello', path: tmpDir, type: 'ts' });
+        expect(result).toContain('a.ts');
+        expect(result).toContain('b.ts');
+        expect(result).not.toContain('c.js');
+    });
+
+    it('returns content with matching lines', () => {
+        const result = grep.call!({
+            pattern: 'function',
+            path: tmpDir,
+            output_mode: 'content',
+            type: 'ts',
+        });
+        expect(result).toContain('function hello');
+        expect(result).toContain('function greet');
+    });
+
+    it('returns count mode', () => {
+        const result = grep.call!({ pattern: 'hello', path: tmpDir, output_mode: 'count' });
+        expect(result).toMatch(/\d+/);
+    });
+
+    it('is case insensitive when flag set', () => {
+        const result = grep.call!({ pattern: 'HELLO', path: tmpDir, case_insensitive: true });
+        expect(result).toContain('a.ts');
+    });
+
+    it('returns no matches message when nothing found', () => {
+        const result = grep.call!({ pattern: 'zzznomatch', path: tmpDir });
+        expect(result).toContain('No matches found');
+    });
+
+    it('respects head_limit', () => {
+        const result = grep.call!({ pattern: 'hello', path: tmpDir, head_limit: 1 });
+        expect((result as string).split('\n').length).toBe(1);
+    });
+
+    it('searches a single file directly', () => {
+        const filePath = path.join(tmpDir, 'a.ts');
+        const result = grep.call!({ pattern: 'hello', path: filePath });
+        expect(result).toContain('a.ts');
+    });
+});