@nogataka/smart-edit 0.0.14

package/dist/serena/tools/memory_tools.js

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+import { Tool, ToolMarkerCanEdit } from './tools_base.js';
+function bindFunction(manager, candidates) {
+    for (const key of candidates) {
+        const candidate = Reflect.get(manager, key);
+        if (typeof candidate === 'function') {
+            return candidate.bind(manager);
+        }
+    }
+    throw new Error(`Memories manager does not implement required method: ${candidates.join(' or ')}`);
+}
+function stringifyUnknown(value) {
+    if (value === undefined || value === null) {
+        return 'null';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'symbol') {
+        return value.toString();
+    }
+    if (typeof value === 'function') {
+        return '[function]';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return Object.prototype.toString.call(value);
+        }
+    }
+    return 'unknown';
+}
+function isIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.iterator in value;
+}
+async function callListMemories(manager) {
+    const listFn = bindFunction(manager, ['listMemories', 'list_memories']);
+    const raw = await listFn();
+    if (!raw) {
+        return [];
+    }
+    if (Array.isArray(raw)) {
+        return raw.map((entry) => stringifyUnknown(entry));
+    }
+    if (isIterable(raw)) {
+        const result = [];
+        for (const entry of raw) {
+            result.push(stringifyUnknown(entry));
+        }
+        return result;
+    }
+    return [stringifyUnknown(raw)];
+}
+async function callSaveMemory(manager, name, content) {
+    const saveFn = bindFunction(manager, ['saveMemory', 'save_memory']);
+    const result = await Promise.resolve(saveFn(name, content));
+    return stringifyUnknown(result);
+}
+async function callLoadMemory(manager, name) {
+    const loadFn = bindFunction(manager, ['loadMemory', 'load_memory']);
+    const result = await Promise.resolve(loadFn(name));
+    return typeof result === 'string' ? result : stringifyUnknown(result);
+}
+async function callDeleteMemory(manager, name) {
+    const deleteFn = bindFunction(manager, ['deleteMemory', 'delete_memory']);
+    const result = await Promise.resolve(deleteFn(name));
+    return stringifyUnknown(result);
+}
+export class WriteMemoryTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit]);
+    static description = "Writes a named markdown memory entry to Serena's project-specific memory store.";
+    static inputSchema = z.object({
+        memory_name: z.string().min(1, 'memory_name must not be empty'),
+        content: z.string(),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { memory_name, content, max_answer_chars = -1 } = args;
+        let limit = max_answer_chars;
+        if (limit === -1) {
+            limit = this.agent.serenaConfig.defaultMaxToolAnswerChars;
+        }
+        if (limit <= 0) {
+            throw new Error(`max_answer_chars must be positive or -1; got ${limit}`);
+        }
+        if (content.length > limit) {
+            throw new Error(`Content for ${memory_name} is too long. Max length is ${limit} characters. Please make the content shorter.`);
+        }
+        const response = await callSaveMemory(this.memoriesManager, memory_name, content);
+        return this._limitLength(response, max_answer_chars);
+    }
+}
+export class ReadMemoryTool extends Tool {
+    static description = "Reads the content of a memory file from Serena's project-specific memory store.";
+    static inputSchema = z.object({
+        memory_file_name: z.string().min(1, 'memory_file_name must not be empty'),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { memory_file_name } = args;
+        return callLoadMemory(this.memoriesManager, memory_file_name);
+    }
+}
+export class ListMemoriesTool extends Tool {
+    static description = "Lists the available memories in Serena's project-specific memory store as a JSON array.";
+    async apply(_args = {}) {
+        const memories = await callListMemories(this.memoriesManager);
+        return JSON.stringify(memories);
+    }
+}
+export class DeleteMemoryTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit]);
+    static description = "Deletes a memory file from Serena's project-specific memory store.";
+    static inputSchema = z.object({
+        memory_file_name: z.string().min(1, 'memory_file_name must not be empty')
+    });
+    async apply(args) {
+        const { memory_file_name } = args;
+        const response = await callDeleteMemory(this.memoriesManager, memory_file_name);
+        return response;
+    }
+}

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

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+import { Tool } from './tools_base.js';
+interface GetSymbolsOverviewInput {
+    relative_path: string;
+    max_answer_chars?: number;
+}
+interface FindSymbolInput {
+    name_path: string;
+    depth?: number;
+    relative_path?: string;
+    include_body?: boolean;
+    include_kinds?: number[];
+    exclude_kinds?: number[];
+    substring_matching?: boolean;
+    max_answer_chars?: number;
+}
+interface FindReferencingSymbolsInput {
+    name_path: string;
+    relative_path: string;
+    include_kinds?: number[];
+    exclude_kinds?: number[];
+    max_answer_chars?: number;
+}
+interface ReplaceSymbolBodyInput {
+    name_path: string;
+    relative_path: string;
+    body: string;
+}
+interface InsertSymbolInput {
+    name_path: string;
+    relative_path: string;
+    body: string;
+}
+export declare class RestartLanguageServerTool extends Tool {
+    static readonly markers: Set<"optional">;
+    static readonly description = "Restarts the language server. Use only on explicit user request or if the server hangs.";
+    apply(): Promise<string>;
+}
+export declare class GetSymbolsOverviewTool extends Tool {
+    static readonly markers: Set<"symbolic-read">;
+    static readonly description = "Returns a JSON array describing the top-level symbols in a file.";
+    static readonly inputSchema: z.ZodObject<{
+        relative_path: z.ZodString;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        max_answer_chars?: number | undefined;
+    }, {
+        relative_path: string;
+        max_answer_chars?: number | undefined;
+    }>;
+    apply(args: GetSymbolsOverviewInput): Promise<string>;
+}
+export declare class FindSymbolTool extends Tool {
+    static readonly markers: Set<"symbolic-read">;
+    static readonly description = "Finds symbols that match the given name path, optionally restricting by location or symbol kind.";
+    static readonly inputSchema: z.ZodObject<{
+        name_path: z.ZodString;
+        depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        relative_path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        include_body: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        include_kinds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        exclude_kinds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        substring_matching: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        depth: number;
+        include_body: boolean;
+        include_kinds: number[];
+        exclude_kinds: number[];
+        substring_matching: boolean;
+        name_path: string;
+        max_answer_chars?: number | undefined;
+    }, {
+        name_path: string;
+        relative_path?: string | undefined;
+        max_answer_chars?: number | undefined;
+        depth?: number | undefined;
+        include_body?: boolean | undefined;
+        include_kinds?: number[] | undefined;
+        exclude_kinds?: number[] | undefined;
+        substring_matching?: boolean | undefined;
+    }>;
+    apply(args: FindSymbolInput): Promise<string>;
+}
+export declare class FindReferencingSymbolsTool extends Tool {
+    static readonly markers: Set<"symbolic-read">;
+    static readonly description = "Finds symbols referencing the specified target and returns metadata including snippets.";
+    static readonly inputSchema: z.ZodObject<{
+        name_path: z.ZodString;
+        relative_path: z.ZodString;
+        include_kinds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        exclude_kinds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        include_kinds: number[];
+        exclude_kinds: number[];
+        name_path: string;
+        max_answer_chars?: number | undefined;
+    }, {
+        relative_path: string;
+        name_path: string;
+        max_answer_chars?: number | undefined;
+        include_kinds?: number[] | undefined;
+        exclude_kinds?: number[] | undefined;
+    }>;
+    apply(args: FindReferencingSymbolsInput): Promise<string>;
+}
+export declare class ReplaceSymbolBodyTool extends Tool {
+    static readonly markers: Set<"symbolic-edit">;
+    static readonly description = "Replaces the body of the specified symbol.";
+    static readonly inputSchema: z.ZodObject<{
+        name_path: z.ZodString;
+        relative_path: z.ZodString;
+        body: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }>;
+    apply(args: ReplaceSymbolBodyInput): Promise<string>;
+}
+export declare class InsertAfterSymbolTool extends Tool {
+    static readonly markers: Set<"symbolic-edit">;
+    static readonly description = "Inserts content immediately after the specified symbol.";
+    static readonly inputSchema: z.ZodObject<{
+        name_path: z.ZodString;
+        relative_path: z.ZodString;
+        body: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }>;
+    apply(args: InsertSymbolInput): Promise<string>;
+}
+export declare class InsertBeforeSymbolTool extends Tool {
+    static readonly markers: Set<"symbolic-edit">;
+    static readonly description = "Inserts content immediately before the specified symbol.";
+    static readonly inputSchema: z.ZodObject<{
+        name_path: z.ZodString;
+        relative_path: z.ZodString;
+        body: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }, {
+        relative_path: string;
+        name_path: string;
+        body: string;
+    }>;
+    apply(args: InsertSymbolInput): Promise<string>;
+}
+export {};

package/dist/serena/tools/symbol_tools.js

@@ -0,0 +1,362 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { SUCCESS_RESULT, Tool, ToolMarkerOptional, ToolMarkerSymbolicEdit, ToolMarkerSymbolicRead } from './tools_base.js';
+function isEditorSymbolMethod(value) {
+    return typeof value === 'function';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function maybeCall(target, names, ...args) {
+    for (const name of names) {
+        const candidate = Reflect.get(target, name);
+        if (typeof candidate === 'function') {
+            return candidate.apply(target, args);
+        }
+    }
+    throw new Error(`Required method not implemented. Tried: ${names.join(', ')}`);
+}
+function sanitizeSymbolDict(source) {
+    const symbolDict = { ...source };
+    const location = symbolDict.location;
+    if (isRecord(location)) {
+        const relativePath = typeof location.relative_path === 'string'
+            ? location.relative_path
+            : typeof location.relativePath === 'string'
+                ? location.relativePath
+                : undefined;
+        if (relativePath !== undefined) {
+            symbolDict.relative_path = relativePath;
+        }
+    }
+    delete symbolDict.location;
+    delete symbolDict.name;
+    return symbolDict;
+}
+function normalizeSymbolKinds(values) {
+    if (!values || values.length === 0) {
+        return undefined;
+    }
+    return values.map((value) => {
+        if (!Number.isInteger(value)) {
+            throw new Error(`Symbol kind must be an integer, got ${value}`);
+        }
+        if (value < 1 || value > 26) {
+            throw new RangeError(`Unsupported symbol kind value: ${value}`);
+        }
+        return value;
+    });
+}
+function symbolRepresentationToDict(symbol, options = {}) {
+    if (!isRecord(symbol)) {
+        throw new Error('Symbol retriever returned a non-object value.');
+    }
+    const camelCase = symbol.toDict;
+    const snakeCase = symbol.to_dict;
+    if (typeof camelCase === 'function' || typeof snakeCase === 'function') {
+        const callable = (camelCase ?? snakeCase);
+        const payload = { ...options };
+        if (payload.include_body !== undefined && payload.includeBody === undefined) {
+            payload.includeBody = payload.include_body;
+        }
+        if (payload.includeBody !== undefined && payload.include_body === undefined) {
+            payload.include_body = payload.includeBody;
+        }
+        const result = callable.call(symbol, payload);
+        if (!isRecord(result)) {
+            throw new Error('Symbol to_dict returned a non-object value.');
+        }
+        return { ...result };
+    }
+    return { ...symbol };
+}
+async function getSymbolOverview(retriever, relativePath) {
+    const raw = await Promise.resolve(maybeCall(retriever, ['getSymbolOverview', 'get_symbol_overview'], relativePath));
+    if (Array.isArray(raw)) {
+        return raw.map((entry) => {
+            if (!isRecord(entry)) {
+                throw new Error('Symbol overview entry must be an object.');
+            }
+            return { ...entry };
+        });
+    }
+    if (isRecord(raw)) {
+        const entries = raw[relativePath];
+        if (!entries) {
+            return [];
+        }
+        if (!Array.isArray(entries)) {
+            throw new Error('Symbol overview response must contain a list of entries.');
+        }
+        return entries.map((entry) => {
+            if (!isRecord(entry)) {
+                throw new Error('Symbol overview entry must be an object.');
+            }
+            return { ...entry };
+        });
+    }
+    throw new Error('Symbol overview response has an unexpected format.');
+}
+async function findSymbols(retriever, namePath, options) {
+    const payload = {
+        includeBody: options.includeBody,
+        include_body: options.includeBody,
+        includeKinds: options.includeKinds,
+        include_kinds: options.includeKinds,
+        excludeKinds: options.excludeKinds,
+        exclude_kinds: options.excludeKinds,
+        substringMatching: options.substringMatching,
+        substring_matching: options.substringMatching
+    };
+    if (options.withinRelativePath && options.withinRelativePath.length > 0) {
+        payload.withinRelativePath = options.withinRelativePath;
+        payload.within_relative_path = options.withinRelativePath;
+    }
+    const raw = await Promise.resolve(maybeCall(retriever, ['findByName', 'find_by_name'], namePath, payload));
+    if (!Array.isArray(raw)) {
+        throw new Error('find_by_name returned a non-array value.');
+    }
+    const result = [];
+    for (const entry of raw) {
+        result.push(entry);
+    }
+    return result;
+}
+async function findReferencingSymbols(retriever, namePath, relativePath, options) {
+    const payload = {
+        includeKinds: options.includeKinds,
+        include_kinds: options.includeKinds,
+        excludeKinds: options.excludeKinds,
+        exclude_kinds: options.excludeKinds,
+        includeBody: false,
+        include_body: false
+    };
+    const raw = await Promise.resolve(maybeCall(retriever, ['findReferencingSymbols', 'find_referencing_symbols'], namePath, relativePath, payload));
+    if (!Array.isArray(raw)) {
+        throw new Error('find_referencing_symbols returned a non-array value.');
+    }
+    return raw.map((entry) => {
+        if (!isRecord(entry) || typeof entry.line !== 'number' || !('symbol' in entry)) {
+            throw new Error('Reference entry must include a symbol and numeric line.');
+        }
+        return {
+            symbol: entry.symbol,
+            line: entry.line
+        };
+    });
+}
+async function resolveContentAroundLine(project, relativePath, line) {
+    const method = project.retrieveContentAroundLine ?? project.retrieve_content_around_line;
+    if (typeof method !== 'function') {
+        throw new Error('Project does not support retrieving content around a line.');
+    }
+    const result = await Promise.resolve(Reflect.apply(method, project, [
+        relativePath,
+        line,
+        1,
+        1
+    ]));
+    if (typeof result === 'string') {
+        return result;
+    }
+    if (isRecord(result)) {
+        const formatter = result.toDisplayString ?? result.to_display_string;
+        if (typeof formatter === 'function') {
+            const formattedResult = await Promise.resolve(Reflect.apply(formatter, result, []));
+            if (typeof formattedResult === 'string') {
+                return formattedResult;
+            }
+        }
+    }
+    throw new Error('Content around line must provide a string or toDisplayString() result.');
+}
+async function callEditor(editor, names, namePath, relativePath, body) {
+    const firstCandidate = Reflect.get(editor, names[0]);
+    if (isEditorSymbolMethod(firstCandidate)) {
+        await Promise.resolve(Reflect.apply(firstCandidate, editor, [namePath, relativePath, body]));
+        return;
+    }
+    const secondCandidate = Reflect.get(editor, names[1]);
+    if (isEditorSymbolMethod(secondCandidate)) {
+        await Promise.resolve(Reflect.apply(secondCandidate, editor, [namePath, relativePath, body]));
+        return;
+    }
+    throw new Error(`Code editor does not implement ${names.join(' / ')}.`);
+}
+function getSymbolRetriever(raw) {
+    if (!isRecord(raw)) {
+        throw new Error('Language server symbol retriever must be an object.');
+    }
+    return raw;
+}
+export class RestartLanguageServerTool extends Tool {
+    static markers = new Set([ToolMarkerOptional]);
+    static description = 'Restarts the language server. Use only on explicit user request or if the server hangs.';
+    async apply() {
+        await Promise.resolve(this.agent.resetLanguageServer());
+        return SUCCESS_RESULT;
+    }
+}
+export class GetSymbolsOverviewTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicRead]);
+    static description = 'Returns a JSON array describing the top-level symbols in a file.';
+    static inputSchema = z.object({
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        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, max_answer_chars = -1 } = args;
+        const projectRoot = this.getProjectRoot();
+        const filePath = path.join(projectRoot, relative_path);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File or directory ${relative_path} does not exist in the project.`);
+        }
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory()) {
+            throw new Error(`Expected a file path, but got a directory path: ${relative_path}.`);
+        }
+        const retriever = getSymbolRetriever(this.createLanguageServerSymbolRetriever());
+        const entries = await getSymbolOverview(retriever, relative_path);
+        const serialized = entries.map((entry) => sanitizeSymbolDict(symbolRepresentationToDict(entry)));
+        return this._limitLength(JSON.stringify(serialized), max_answer_chars);
+    }
+}
+export class FindSymbolTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicRead]);
+    static description = 'Finds symbols that match the given name path, optionally restricting by location or symbol kind.';
+    static inputSchema = z.object({
+        name_path: z.string().min(1, 'name_path must not be empty'),
+        depth: z
+            .number()
+            .int()
+            .min(0, 'depth must be non-negative')
+            .optional()
+            .default(0),
+        relative_path: z.string().optional().default(''),
+        include_body: z.boolean().optional().default(false),
+        include_kinds: z.array(z.number().int()).optional().default([]),
+        exclude_kinds: z.array(z.number().int()).optional().default([]),
+        substring_matching: 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 { name_path, depth = 0, relative_path = '', include_body = false, include_kinds = [], exclude_kinds = [], substring_matching = false, max_answer_chars = -1 } = args;
+        const retriever = getSymbolRetriever(this.createLanguageServerSymbolRetriever());
+        const symbols = await findSymbols(retriever, name_path, {
+            includeBody: include_body,
+            includeKinds: normalizeSymbolKinds(include_kinds),
+            excludeKinds: normalizeSymbolKinds(exclude_kinds),
+            substringMatching: substring_matching,
+            withinRelativePath: relative_path
+        });
+        const serialized = symbols.map((symbol) => sanitizeSymbolDict(symbolRepresentationToDict(symbol, {
+            depth,
+            kind: true,
+            location: true,
+            include_body: include_body,
+            includeBody: include_body
+        })));
+        return this._limitLength(JSON.stringify(serialized), max_answer_chars);
+    }
+}
+export class FindReferencingSymbolsTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicRead]);
+    static description = 'Finds symbols referencing the specified target and returns metadata including snippets.';
+    static inputSchema = z.object({
+        name_path: z.string().min(1, 'name_path must not be empty'),
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        include_kinds: z.array(z.number().int()).optional().default([]),
+        exclude_kinds: z.array(z.number().int()).optional().default([]),
+        max_answer_chars: z
+            .number()
+            .int()
+            .gte(-1, 'max_answer_chars must be -1 or a positive integer')
+            .optional()
+    });
+    async apply(args) {
+        const { name_path, relative_path, include_kinds = [], exclude_kinds = [], max_answer_chars = -1 } = args;
+        const retriever = getSymbolRetriever(this.createLanguageServerSymbolRetriever());
+        const references = await findReferencingSymbols(retriever, name_path, relative_path, {
+            includeKinds: normalizeSymbolKinds(include_kinds),
+            excludeKinds: normalizeSymbolKinds(exclude_kinds)
+        });
+        const project = this.project;
+        const serialized = [];
+        for (const reference of references) {
+            const dict = sanitizeSymbolDict(symbolRepresentationToDict(reference.symbol, {
+                depth: 0,
+                include_body: false,
+                includeBody: false,
+                kind: true,
+                location: true
+            }));
+            const relativePath = typeof dict.relative_path === 'string'
+                ? dict.relative_path
+                : typeof dict.relativePath === 'string'
+                    ? dict.relativePath
+                    : null;
+            if (!relativePath) {
+                throw new Error('Referencing symbol is missing a relative path.');
+            }
+            const content = await resolveContentAroundLine(project, relativePath, reference.line);
+            dict.content_around_reference = content;
+            serialized.push(dict);
+        }
+        return this._limitLength(JSON.stringify(serialized), max_answer_chars);
+    }
+}
+export class ReplaceSymbolBodyTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicEdit]);
+    static description = 'Replaces the body of the specified symbol.';
+    static inputSchema = z.object({
+        name_path: z.string().min(1, 'name_path must not be empty'),
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        body: z.string()
+    });
+    async apply(args) {
+        const { name_path, relative_path, body } = args;
+        const editor = this.createCodeEditor();
+        await callEditor(editor, ['replaceBody', 'replace_body'], name_path, relative_path, body);
+        return SUCCESS_RESULT;
+    }
+}
+export class InsertAfterSymbolTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicEdit]);
+    static description = 'Inserts content immediately after the specified symbol.';
+    static inputSchema = z.object({
+        name_path: z.string().min(1, 'name_path must not be empty'),
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        body: z.string()
+    });
+    async apply(args) {
+        const { name_path, relative_path, body } = args;
+        const editor = this.createCodeEditor();
+        await callEditor(editor, ['insertAfterSymbol', 'insert_after_symbol'], name_path, relative_path, body);
+        return SUCCESS_RESULT;
+    }
+}
+export class InsertBeforeSymbolTool extends Tool {
+    static markers = new Set([ToolMarkerSymbolicEdit]);
+    static description = 'Inserts content immediately before the specified symbol.';
+    static inputSchema = z.object({
+        name_path: z.string().min(1, 'name_path must not be empty'),
+        relative_path: z.string().min(1, 'relative_path must not be empty'),
+        body: z.string()
+    });
+    async apply(args) {
+        const { name_path, relative_path, body } = args;
+        const editor = this.createCodeEditor();
+        await callEditor(editor, ['insertBeforeSymbol', 'insert_before_symbol'], name_path, relative_path, body);
+        return SUCCESS_RESULT;
+    }
+}