@nogataka/smart-edit 0.0.14

package/dist/serena/tools/file_tools.js

@@ -0,0 +1,511 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { searchFiles } from '../text_utils.js';
+import { scanDirectory } from '../util/file_system.js';
+import { EditedFileContext, SUCCESS_RESULT, Tool, ToolMarkerCanEdit, ToolMarkerOptional, assertIsBufferEncoding } from './tools_base.js';
+export { SUCCESS_RESULT } from './tools_base.js';
+function resolveProjectEncoding(project) {
+    const encodingValue = project.projectConfig.encoding ?? 'utf-8';
+    assertIsBufferEncoding(encodingValue);
+    return encodingValue;
+}
+export class ReadFileTool extends Tool {
+    static description = 'Reads a file within the project directory.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        start_line: z
+            .number()
+            .int()
+            .min(0, 'start_line must be non-negative')
+            .optional()
+            .default(0),
+        end_line: z
+            .number()
+            .int()
+            .min(0, 'end_line must be non-negative')
+            .nullable()
+            .optional(),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { relative_path, start_line = 0, end_line = null, max_answer_chars = -1 } = args;
+        const project = this.project;
+        await validateRelativePath(project, relative_path, this.getProjectRoot());
+        const fileContents = await readProjectFile(project, relative_path, this.getProjectRoot());
+        const lines = splitIntoLines(fileContents);
+        let selected;
+        if (end_line === null || end_line === undefined) {
+            selected = lines.slice(start_line);
+        }
+        else {
+            recordLinesRead(this.linesRead, relative_path, [start_line, end_line]);
+            selected = lines.slice(start_line, end_line + 1);
+        }
+        const result = selected.join('\n');
+        return this._limitLength(result, max_answer_chars);
+    }
+}
+export class CreateTextFileTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit]);
+    static description = 'Creates or overwrites a text file in the project directory.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        content: z.string()
+    });
+    async apply(args) {
+        const { relative_path, content } = args;
+        const projectRoot = this.getProjectRoot();
+        const absolutePath = path.resolve(projectRoot, relative_path);
+        const exists = fs.existsSync(absolutePath);
+        if (exists) {
+            await validateRelativePath(this.project, relative_path, projectRoot);
+        }
+        else if (!isPathInsideRoot(absolutePath, projectRoot)) {
+            throw new Error(`Cannot create file outside of the project directory, got relative_path='${relative_path}'`);
+        }
+        await fs.promises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fs.promises.writeFile(absolutePath, content, { encoding: 'utf-8' });
+        let answer = `File created: ${relative_path}.`;
+        if (exists) {
+            answer += ' Overwrote existing file.';
+        }
+        return JSON.stringify(answer);
+    }
+}
+export class ListDirTool extends Tool {
+    static description = 'Lists files and directories for a given relative path. Honors gitignore rules when requested.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        recursive: z.boolean(),
+        skip_ignored_files: z.boolean().optional(),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { relative_path, recursive, skip_ignored_files = false, max_answer_chars = -1 } = args;
+        const project = this.project;
+        const pathExists = await projectRelativePathExists(project, relative_path, this.getProjectRoot());
+        if (!pathExists) {
+            const payload = JSON.stringify({
+                error: `Directory not found: ${relative_path}`,
+                project_root: this.getProjectRoot(),
+                hint: 'Check if the path is correct relative to the project root'
+            });
+            return this._limitLength(payload, max_answer_chars);
+        }
+        await validateRelativePath(project, relative_path, this.getProjectRoot());
+        const targetPath = path.join(this.getProjectRoot(), relative_path);
+        const predicate = skip_ignored_files ? projectIgnorePredicate(project) : undefined;
+        const result = scanDirectory(targetPath, recursive, this.getProjectRoot(), predicate, predicate);
+        const payload = JSON.stringify({
+            dirs: result.directories,
+            files: result.files
+        });
+        return this._limitLength(payload, max_answer_chars);
+    }
+}
+export class FindFileTool extends Tool {
+    static description = 'Finds files within a directory tree that match a filename mask while respecting ignored paths.';
+    static inputSchema = z.object({
+        file_mask: z.string().min(1, 'file_mask must not be empty'),
+        relative_path: z.string().min(1, 'relative_path must not be empty')
+    });
+    async apply(args) {
+        const { file_mask, relative_path } = args;
+        const project = this.project;
+        await validateRelativePath(project, relative_path, this.getProjectRoot());
+        const dirToScan = path.join(this.getProjectRoot(), relative_path);
+        const ignorePredicate = projectIgnorePredicate(project);
+        const { files } = scanDirectory(dirToScan, true, this.getProjectRoot(), ignorePredicate, (absolutePath) => {
+            if (ignorePredicate?.(absolutePath)) {
+                return true;
+            }
+            const filename = path.basename(absolutePath);
+            return !matchesFileMask(file_mask, filename);
+        });
+        return JSON.stringify({ files });
+    }
+}
+export class ReplaceRegexTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit]);
+    static description = 'Replaces one or more regex matches within a file. Falls back to Python-style DOTALL matching.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        regex: z.string().min(1, 'regex must not be empty'),
+        repl: z.string(),
+        allow_multiple_occurrences: z.boolean().optional()
+    });
+    async apply(args) {
+        const { relative_path, regex, repl, allow_multiple_occurrences = false } = args;
+        await validateRelativePath(this.project, relative_path, this.getProjectRoot());
+        return EditedFileContext.use(relative_path, this.agent, (context) => {
+            const original = context.getOriginalContent();
+            let count = 0;
+            let compiled;
+            try {
+                compiled = new RegExp(regex, 'gms');
+            }
+            catch (error) {
+                throw new Error(`Invalid regex '${regex}': ${error.message}`);
+            }
+            const updated = original.replace(compiled, () => {
+                count += 1;
+                return repl;
+            });
+            if (count === 0) {
+                return `Error: No matches found for regex '${regex}' in file '${relative_path}'.`;
+            }
+            if (!allow_multiple_occurrences && count > 1) {
+                return (`Error: Regex '${regex}' matches ${count} occurrences in file '${relative_path}'. ` +
+                    'Please revise the regex to be more specific or enable allow_multiple_occurrences if this is expected.');
+            }
+            context.setUpdatedContent(updated);
+            return SUCCESS_RESULT;
+        });
+    }
+}
+export class DeleteLinesTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit, ToolMarkerOptional]);
+    static description = 'Deletes a range of lines within a file. Requires the same lines to be read beforehand.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        start_line: z
+            .number()
+            .int()
+            .min(0, 'start_line must be non-negative'),
+        end_line: z
+            .number()
+            .int()
+            .min(0, 'end_line must be non-negative')
+    });
+    async apply(args) {
+        const { relative_path, start_line, end_line } = args;
+        if (!linesWereRead(this.linesRead, relative_path, [start_line, end_line])) {
+            const toolName = ReadFileTool.getNameFromCls();
+            return `Error: Must call \`${toolName}\` first to read exactly the affected lines.`;
+        }
+        const editor = this.createCodeEditor();
+        await callEditorMethod(editor, ['deleteLines', 'delete_lines'], relative_path, start_line, end_line);
+        return SUCCESS_RESULT;
+    }
+}
+export class ReplaceLinesTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit, ToolMarkerOptional]);
+    static description = 'Replaces a range of lines within a file. Requires the range to be read beforehand.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        start_line: z
+            .number()
+            .int()
+            .min(0, 'start_line must be non-negative'),
+        end_line: z
+            .number()
+            .int()
+            .min(0, 'end_line must be non-negative'),
+        content: z.string()
+    });
+    async apply(args) {
+        const { relative_path, start_line, end_line, content } = args;
+        const normalizedContent = content.endsWith('\n') ? content : `${content}\n`;
+        const deleteTool = getToolInstance(this.agent, DeleteLinesTool);
+        const deleteResult = await Promise.resolve(deleteTool.apply({ relative_path, start_line, end_line }));
+        if (deleteResult !== SUCCESS_RESULT) {
+            return deleteResult;
+        }
+        const insertTool = getToolInstance(this.agent, InsertAtLineTool);
+        await Promise.resolve(insertTool.apply({ relative_path, line: start_line, content: normalizedContent }));
+        return SUCCESS_RESULT;
+    }
+}
+export class InsertAtLineTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit, ToolMarkerOptional]);
+    static description = 'Inserts content at a specific line. The insertion will push existing content down.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        line: z
+            .number()
+            .int()
+            .min(0, 'line must be non-negative'),
+        content: z.string()
+    });
+    async apply(args) {
+        const { relative_path, line, content } = args;
+        const normalizedContent = content.endsWith('\n') ? content : `${content}\n`;
+        const editor = this.createCodeEditor();
+        await callEditorMethod(editor, ['insertAtLine', 'insert_at_line'], relative_path, line, normalizedContent);
+        return SUCCESS_RESULT;
+    }
+}
+export class SearchForPatternTool extends Tool {
+    static description = 'Searches files for a substring/regex pattern, returning grouped matches with optional context.';
+    static inputSchema = z.object({
+        substring_pattern: z.string().min(1, 'substring_pattern must not be empty'),
+        context_lines_before: z
+            .number()
+            .int()
+            .min(0, 'context_lines_before must be non-negative')
+            .optional()
+            .default(0),
+        context_lines_after: z
+            .number()
+            .int()
+            .min(0, 'context_lines_after must be non-negative')
+            .optional()
+            .default(0),
+        paths_include_glob: z.string().optional(),
+        paths_exclude_glob: z.string().optional(),
+        relative_path: z.string().optional().default(''),
+        restrict_search_to_code_files: z.boolean().optional().default(false),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { substring_pattern, context_lines_before = 0, context_lines_after = 0, paths_include_glob, paths_exclude_glob, relative_path = '', restrict_search_to_code_files = false, max_answer_chars = -1 } = args;
+        const absolutePath = path.join(this.getProjectRoot(), relative_path);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`Relative path ${relative_path} does not exist.`);
+        }
+        let matches;
+        const project = this.project;
+        if (restrict_search_to_code_files) {
+            matches = await searchWithProjectSourceFiles(project, {
+                pattern: substring_pattern,
+                relative_path,
+                context_lines_before,
+                context_lines_after,
+                paths_include_glob,
+                paths_exclude_glob
+            });
+        }
+        else {
+            let relativePathsToSearch;
+            if (fs.statSync(absolutePath).isFile()) {
+                relativePathsToSearch = [relative_path];
+            }
+            else {
+                const ignorePredicate = projectIgnorePredicate(project);
+                const { files } = scanDirectory(absolutePath, true, this.getProjectRoot(), ignorePredicate, ignorePredicate);
+                relativePathsToSearch = files;
+            }
+            matches = searchFiles(relativePathsToSearch, substring_pattern, {
+                rootPath: this.getProjectRoot(),
+                contextLinesBefore: context_lines_before,
+                contextLinesAfter: context_lines_after,
+                pathsIncludeGlob: paths_include_glob,
+                pathsExcludeGlob: paths_exclude_glob
+            });
+        }
+        const grouped = new Map();
+        for (const match of matches) {
+            const key = match.sourceFilePath ?? relative_path ?? '';
+            if (!grouped.has(key)) {
+                grouped.set(key, []);
+            }
+            grouped.get(key).push(match.toDisplayString(true));
+        }
+        const payload = JSON.stringify(Object.fromEntries(grouped));
+        return this._limitLength(payload, max_answer_chars);
+    }
+}
+function splitIntoLines(content) {
+    const parts = content.split('\n');
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const current = parts[index];
+        if (current?.endsWith('\r')) {
+            parts[index] = current.slice(0, -1);
+        }
+    }
+    return parts;
+}
+async function validateRelativePath(project, relativePath, projectRoot) {
+    if (typeof project.validateRelativePath === 'function') {
+        await Promise.resolve(project.validateRelativePath(relativePath));
+        return;
+    }
+    if (typeof project.validate_relative_path === 'function') {
+        await Promise.resolve(project.validate_relative_path(relativePath));
+        return;
+    }
+    if (!isPathInsideRoot(path.resolve(projectRoot, relativePath), projectRoot)) {
+        throw new Error(`Path '${relativePath}' escapes the project root.`);
+    }
+}
+async function readProjectFile(project, relativePath, projectRoot) {
+    if (typeof project.readFile === 'function') {
+        return Promise.resolve(project.readFile(relativePath));
+    }
+    if (typeof project.read_file === 'function') {
+        return Promise.resolve(project.read_file(relativePath));
+    }
+    const absolutePath = path.resolve(projectRoot, relativePath);
+    const encoding = resolveProjectEncoding(project);
+    return fs.promises.readFile(absolutePath, { encoding });
+}
+async function projectRelativePathExists(project, relativePath, projectRoot) {
+    if (typeof project.relativePathExists === 'function') {
+        return Promise.resolve(project.relativePathExists(relativePath));
+    }
+    if (typeof project.relative_path_exists === 'function') {
+        return Promise.resolve(project.relative_path_exists(relativePath));
+    }
+    const candidate = path.resolve(projectRoot, relativePath);
+    return fs.existsSync(candidate);
+}
+function projectIgnorePredicate(project) {
+    if (typeof project.isIgnoredPath === 'function') {
+        const fn = project.isIgnoredPath.bind(project);
+        return (absolutePath) => fn(absolutePath);
+    }
+    if (typeof project.is_ignored_path === 'function') {
+        const fn = project.is_ignored_path.bind(project);
+        return (absolutePath) => fn(absolutePath);
+    }
+    return undefined;
+}
+function matchesFileMask(mask, filename) {
+    let pattern = '';
+    for (let index = 0; index < mask.length; index += 1) {
+        const char = mask[index];
+        if (!char) {
+            continue;
+        }
+        if (char === '*') {
+            pattern += '.*';
+        }
+        else if (char === '?') {
+            pattern += '.';
+        }
+        else if (char === '\\') {
+            index += 1;
+            if (index < mask.length) {
+                const nextChar = mask[index];
+                if (nextChar) {
+                    pattern += escapeRegExpChar(nextChar);
+                }
+                else {
+                    pattern += '\\\\';
+                }
+            }
+            else {
+                pattern += '\\\\';
+            }
+        }
+        else {
+            pattern += escapeRegExpChar(char);
+        }
+    }
+    const regex = new RegExp(`^${pattern}$`);
+    return regex.test(filename);
+}
+function recordLinesRead(tracker, relativePath, range) {
+    if (!tracker) {
+        return;
+    }
+    if (typeof tracker.addLinesRead === 'function') {
+        tracker.addLinesRead(relativePath, range);
+    }
+    else if (typeof tracker.add_lines_read === 'function') {
+        tracker.add_lines_read(relativePath, range);
+    }
+}
+function linesWereRead(tracker, relativePath, range) {
+    if (!tracker) {
+        return false;
+    }
+    if (typeof tracker.wereLinesRead === 'function') {
+        return tracker.wereLinesRead(relativePath, range);
+    }
+    if (typeof tracker.were_lines_read === 'function') {
+        return tracker.were_lines_read(relativePath, range);
+    }
+    return false;
+}
+function isPathInsideRoot(candidatePath, root) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidatePath);
+    const relative = path.relative(normalizedRoot, normalizedCandidate);
+    return !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+async function callEditorMethod(editor, methodCandidates, ...args) {
+    for (const candidate of methodCandidates) {
+        const method = editor[candidate];
+        if (typeof method === 'function') {
+            const callable = method;
+            await Promise.resolve(callable.apply(editor, args));
+            return;
+        }
+    }
+    throw new Error(`Code editor does not implement any of the expected methods: ${methodCandidates.join(', ')}`);
+}
+function getToolInstance(agent, toolClass) {
+    const lookupAgent = agent;
+    if (typeof lookupAgent.getTool === 'function') {
+        return lookupAgent.getTool(toolClass);
+    }
+    if (typeof lookupAgent.get_tool === 'function') {
+        return lookupAgent.get_tool(toolClass);
+    }
+    const FallbackCtor = toolClass;
+    return new FallbackCtor(agent);
+}
+async function searchWithProjectSourceFiles(project, options) {
+    if (typeof project.searchSourceFilesForPattern === 'function') {
+        const result = project.searchSourceFilesForPattern(options);
+        return Promise.resolve(result);
+    }
+    if (typeof project.search_source_files_for_pattern === 'function') {
+        const result = project.search_source_files_for_pattern(options.pattern, options.relative_path, options.context_lines_before, options.context_lines_after, options.paths_include_glob, options.paths_exclude_glob);
+        return Promise.resolve(result);
+    }
+    const relativePaths = projectRelativePathList(project, options.relative_path ?? '');
+    return searchFiles(relativePaths, options.pattern, {
+        rootPath: (project.projectRoot ?? projectRootFallback(project)) ?? '',
+        contextLinesBefore: options.context_lines_before,
+        contextLinesAfter: options.context_lines_after,
+        pathsIncludeGlob: options.paths_include_glob ?? undefined,
+        pathsExcludeGlob: options.paths_exclude_glob ?? undefined
+    });
+}
+function projectRelativePathList(project, relativePath) {
+    const projectRoot = project.projectRoot ?? projectRootFallback(project);
+    if (!projectRoot) {
+        return [];
+    }
+    const absolute = path.join(projectRoot, relativePath);
+    const predicate = projectIgnorePredicate(project);
+    if (fs.existsSync(absolute)) {
+        const stats = fs.statSync(absolute);
+        if (stats.isFile()) {
+            return [relativePath];
+        }
+        if (stats.isDirectory()) {
+            const { files } = scanDirectory(absolute, true, projectRoot, predicate, predicate);
+            return files;
+        }
+    }
+    return [];
+}
+function projectRootFallback(project) {
+    if (typeof project.projectRoot === 'string') {
+        return project.projectRoot;
+    }
+    const candidate = project.project_root;
+    if (typeof candidate === 'string') {
+        return candidate;
+    }
+    return undefined;
+}
+function escapeRegExpChar(char) {
+    return char.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}

package/dist/serena/tools/index.d.ts

@@ -0,0 +1,7 @@
+export * from './cmd_tools.js';
+export * from './config_tools.js';
+export * from './file_tools.js';
+export * from './memory_tools.js';
+export * from './symbol_tools.js';
+export * from './tools_base.js';
+export * from './workflow_tools.js';

package/dist/serena/tools/index.js

@@ -0,0 +1,7 @@
+export * from './cmd_tools.js';
+export * from './config_tools.js';
+export * from './file_tools.js';
+export * from './memory_tools.js';
+export * from './symbol_tools.js';
+export * from './tools_base.js';
+export * from './workflow_tools.js';

package/dist/serena/tools/memory_tools.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { Tool } from './tools_base.js';
+interface WriteMemoryInput {
+    memory_name: string;
+    content: string;
+    max_answer_chars?: number;
+}
+interface MemoryNameInput {
+    memory_file_name: string;
+    max_answer_chars?: number;
+}
+export declare class WriteMemoryTool extends Tool {
+    static readonly markers: Set<"can-edit">;
+    static readonly description = "Writes a named markdown memory entry to Serena's project-specific memory store.";
+    static readonly inputSchema: z.ZodObject<{
+        memory_name: z.ZodString;
+        content: z.ZodString;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        memory_name: string;
+        max_answer_chars?: number | undefined;
+    }, {
+        content: string;
+        memory_name: string;
+        max_answer_chars?: number | undefined;
+    }>;
+    apply(args: WriteMemoryInput): Promise<string>;
+}
+export declare class ReadMemoryTool extends Tool {
+    static readonly description = "Reads the content of a memory file from Serena's project-specific memory store.";
+    static readonly inputSchema: z.ZodObject<{
+        memory_file_name: z.ZodString;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        memory_file_name: string;
+        max_answer_chars?: number | undefined;
+    }, {
+        memory_file_name: string;
+        max_answer_chars?: number | undefined;
+    }>;
+    apply(args: MemoryNameInput): Promise<string>;
+}
+export declare class ListMemoriesTool extends Tool {
+    static readonly description = "Lists the available memories in Serena's project-specific memory store as a JSON array.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class DeleteMemoryTool extends Tool {
+    static readonly markers: Set<"can-edit">;
+    static readonly description = "Deletes a memory file from Serena's project-specific memory store.";
+    static readonly inputSchema: z.ZodObject<{
+        memory_file_name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        memory_file_name: string;
+    }, {
+        memory_file_name: string;
+    }>;
+    apply(args: MemoryNameInput): Promise<string>;
+}
+export {};