@nogataka/smart-edit 0.0.14

package/dist/serena/text_utils.js

@@ -0,0 +1,267 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createSerenaLogger } from './util/logging.js';
+const { logger: log } = createSerenaLogger({ name: 'serena.text_utils' });
+export var LineType;
+(function (LineType) {
+    LineType["MATCH"] = "match";
+    LineType["BEFORE_MATCH"] = "prefix";
+    LineType["AFTER_MATCH"] = "postfix";
+})(LineType || (LineType = {}));
+export class TextLine {
+    lineNumber;
+    lineContent;
+    matchType;
+    constructor(options) {
+        this.lineNumber = options.lineNumber;
+        this.lineContent = options.lineContent;
+        this.matchType = options.matchType;
+    }
+    getDisplayPrefix() {
+        return this.matchType === LineType.MATCH ? '  >' : '...';
+    }
+    formatLine(includeLineNumbers = true) {
+        let prefix = this.getDisplayPrefix();
+        if (includeLineNumbers) {
+            const lineNum = String(this.lineNumber).padStart(4, ' ');
+            prefix = `${prefix}${lineNum}`;
+        }
+        return `${prefix}:${this.lineContent}`;
+    }
+}
+export class MatchedConsecutiveLines {
+    lines;
+    sourceFilePath;
+    linesBeforeMatched;
+    matchedLines;
+    linesAfterMatched;
+    constructor(options) {
+        if (!options.lines.length) {
+            throw new Error('At least one matched line is required.');
+        }
+        this.lines = options.lines;
+        this.sourceFilePath = options.sourceFilePath;
+        this.linesBeforeMatched = [];
+        this.matchedLines = [];
+        this.linesAfterMatched = [];
+        for (const line of options.lines) {
+            if (line.matchType === LineType.BEFORE_MATCH) {
+                this.linesBeforeMatched.push(line);
+            }
+            else if (line.matchType === LineType.MATCH) {
+                this.matchedLines.push(line);
+            }
+            else if (line.matchType === LineType.AFTER_MATCH) {
+                this.linesAfterMatched.push(line);
+            }
+        }
+        if (this.matchedLines.length === 0) {
+            throw new Error('At least one matched line is required.');
+        }
+    }
+    get startLine() {
+        return this.lines[0]?.lineNumber ?? 0;
+    }
+    get endLine() {
+        return this.lines[this.lines.length - 1]?.lineNumber ?? 0;
+    }
+    get numMatchedLines() {
+        return this.matchedLines.length;
+    }
+    toDisplayString(includeLineNumbers = true) {
+        return this.lines.map((line) => line.formatLine(includeLineNumbers)).join('\n');
+    }
+    static fromFileContents(options) {
+        const { fileContents, line, contextLinesBefore = 0, contextLinesAfter = 0, sourceFilePath } = options;
+        const lineContents = splitIntoLinesPreservingEnding(fileContents);
+        const startLine = Math.max(0, line - contextLinesBefore);
+        const endLine = Math.min(lineContents.length - 1, line + contextLinesAfter);
+        const lines = [];
+        for (let index = startLine; index <= endLine; index += 1) {
+            const matchType = index < line
+                ? LineType.BEFORE_MATCH
+                : index > line
+                    ? LineType.AFTER_MATCH
+                    : LineType.MATCH;
+            lines.push(new TextLine({
+                lineNumber: index,
+                lineContent: lineContents[index] ?? '',
+                matchType
+            }));
+        }
+        return new MatchedConsecutiveLines({ lines, sourceFilePath });
+    }
+}
+const DEFAULT_FILE_READER = (absolutePath) => {
+    return fs.readFileSync(absolutePath, 'utf-8');
+};
+export function searchFiles(relativeFilePaths, pattern, options = {}) {
+    const { rootPath = '', fileReader = DEFAULT_FILE_READER, contextLinesBefore = 0, contextLinesAfter = 0, pathsIncludeGlob, pathsExcludeGlob } = options;
+    const filteredPaths = relativeFilePaths.filter((candidate) => {
+        if (pathsIncludeGlob && !globMatch(pathsIncludeGlob, candidate)) {
+            log.debug(`Skipping ${candidate}: does not match include pattern ${pathsIncludeGlob}`);
+            return false;
+        }
+        if (pathsExcludeGlob && globMatch(pathsExcludeGlob, candidate)) {
+            log.debug(`Skipping ${candidate}: matches exclude pattern ${pathsExcludeGlob}`);
+            return false;
+        }
+        return true;
+    });
+    log.info(`Processing ${filteredPaths.length} files.`);
+    const matches = [];
+    const skipped = [];
+    for (const relativePath of filteredPaths) {
+        try {
+            const absolutePath = rootPath ? path.join(rootPath, relativePath) : relativePath;
+            const fileContents = fileReader(absolutePath);
+            const results = searchText(fileContents, pattern, {
+                contextLinesBefore,
+                contextLinesAfter
+            }).map((item) => new MatchedConsecutiveLines({
+                lines: item.lines,
+                sourceFilePath: relativePath
+            }));
+            if (results.length > 0) {
+                log.debug(`Found ${results.length} matches in ${relativePath}`);
+            }
+            matches.push(...results);
+        }
+        catch (error) {
+            skipped.push({ path: relativePath, error });
+        }
+    }
+    if (skipped.length > 0) {
+        log.debug(`Failed to read ${skipped.length} files`, skipped);
+    }
+    log.info(`Found ${matches.length} total matches across ${filteredPaths.length} files`);
+    return matches;
+}
+function searchText(content, pattern, options = {}) {
+    const { contextLinesBefore = 0, contextLinesAfter = 0 } = options;
+    let regex;
+    try {
+        regex = new RegExp(pattern, 'gms');
+    }
+    catch (error) {
+        throw new Error(`Invalid regular expression pattern: ${error.message}`);
+    }
+    const matches = [];
+    const lines = splitIntoLinesPreservingEnding(content);
+    const lineOffsets = computeLineOffsets(content);
+    for (const match of content.matchAll(regex)) {
+        if (match.index === undefined) {
+            continue;
+        }
+        const startIndex = match.index;
+        const endIndex = startIndex + match[0].length;
+        const startLine = findLineNumberForOffset(lineOffsets, startIndex);
+        const endLine = findLineNumberForOffset(lineOffsets, Math.max(startIndex, endIndex - 1));
+        const beforeStart = Math.max(0, startLine - contextLinesBefore);
+        const afterEnd = Math.min(lines.length - 1, endLine + contextLinesAfter);
+        const consecutiveLines = [];
+        for (let lineNumber = beforeStart; lineNumber <= afterEnd; lineNumber += 1) {
+            const matchType = lineNumber < startLine
+                ? LineType.BEFORE_MATCH
+                : lineNumber > endLine
+                    ? LineType.AFTER_MATCH
+                    : LineType.MATCH;
+            consecutiveLines.push(new TextLine({
+                lineNumber,
+                lineContent: lines[lineNumber] ?? '',
+                matchType
+            }));
+        }
+        matches.push(new MatchedConsecutiveLines({ lines: consecutiveLines }));
+    }
+    return matches;
+}
+function splitIntoLinesPreservingEnding(input) {
+    if (input.length === 0) {
+        return [''];
+    }
+    const parts = input.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;
+}
+function computeLineOffsets(content) {
+    const offsets = [0];
+    for (let index = 0; index < content.length; index += 1) {
+        if (content[index] === '\n') {
+            offsets.push(index + 1);
+        }
+    }
+    return offsets;
+}
+function findLineNumberForOffset(lineOffsets, offset) {
+    let low = 0;
+    let high = lineOffsets.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const start = lineOffsets[mid];
+        if (start === undefined) {
+            break;
+        }
+        const nextStart = lineOffsets[mid + 1];
+        if (offset < start) {
+            high = mid - 1;
+        }
+        else if (nextStart !== undefined && offset >= nextStart) {
+            low = mid + 1;
+        }
+        else {
+            return mid;
+        }
+    }
+    return Math.max(0, lineOffsets.length - 1);
+}
+function globMatch(pattern, candidate) {
+    if (!pattern) {
+        return true;
+    }
+    const normalizedCandidate = candidate.split(path.sep).join('/');
+    const regex = globToRegExp(pattern);
+    return regex.test(normalizedCandidate);
+}
+function globToRegExp(pattern) {
+    let escaped = '';
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (!char) {
+            continue;
+        }
+        if (char === '*') {
+            escaped += '.*';
+        }
+        else if (char === '?') {
+            escaped += '.';
+        }
+        else if (char === '\\') {
+            index += 1;
+            if (index < pattern.length) {
+                const nextChar = pattern[index];
+                if (nextChar) {
+                    escaped += escapeRegExpChar(nextChar);
+                }
+                else {
+                    escaped += '\\\\';
+                }
+            }
+            else {
+                escaped += '\\\\';
+            }
+        }
+        else {
+            escaped += escapeRegExpChar(char);
+        }
+    }
+    return new RegExp(`^${escaped}$`);
+}
+function escapeRegExpChar(char) {
+    return char.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { Tool } from './tools_base.js';
+interface ExecuteShellCommandInput {
+    command: string;
+    cwd?: string;
+    capture_stderr?: boolean;
+    max_answer_chars?: number;
+}
+export declare class ExecuteShellCommandTool extends Tool {
+    static readonly markers: Set<"can-edit">;
+    static readonly description = "Executes a shell command and returns its stdout/stderr output as JSON.";
+    static readonly inputSchema: z.ZodObject<{
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        capture_stderr: z.ZodOptional<z.ZodBoolean>;
+        max_answer_chars: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        cwd?: string | undefined;
+        capture_stderr?: boolean | undefined;
+        max_answer_chars?: number | undefined;
+    }, {
+        command: string;
+        cwd?: string | undefined;
+        capture_stderr?: boolean | undefined;
+        max_answer_chars?: number | undefined;
+    }>;
+    apply(args: ExecuteShellCommandInput): Promise<string>;
+    private resolveWorkingDirectory;
+}
+export {};

package/dist/serena/tools/cmd_tools.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { executeShellCommand } from '../util/shell.js';
+import { Tool, ToolMarkerCanEdit } from './tools_base.js';
+const DEFAULT_CAPTURE_STDERR = true;
+export class ExecuteShellCommandTool extends Tool {
+    static markers = new Set([ToolMarkerCanEdit]);
+    static description = 'Executes a shell command and returns its stdout/stderr output as JSON.';
+    static inputSchema = z.object({
+        command: z.string().min(1, 'command must not be empty'),
+        cwd: z.string().optional(),
+        capture_stderr: 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 { command, cwd, capture_stderr = DEFAULT_CAPTURE_STDERR, max_answer_chars = -1 } = args;
+        const resolvedCwd = this.resolveWorkingDirectory(cwd);
+        const result = await executeShellCommand(command, {
+            cwd: resolvedCwd,
+            captureStderr: capture_stderr
+        });
+        const payload = JSON.stringify({
+            stdout: result.stdout,
+            stderr: result.stderr ?? null,
+            return_code: result.returnCode,
+            cwd: result.cwd
+        });
+        return this._limitLength(payload, max_answer_chars);
+    }
+    resolveWorkingDirectory(cwd) {
+        if (!cwd) {
+            return this.getProjectRoot();
+        }
+        if (path.isAbsolute(cwd)) {
+            return cwd;
+        }
+        const resolved = path.join(this.getProjectRoot(), cwd);
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+            throw new Error(`Specified a relative working directory (${cwd}), but the resulting path is not a directory: ${resolved}`);
+        }
+        return resolved;
+    }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Tool } from './tools_base.js';
+interface ActivateProjectInput {
+    project: string;
+}
+interface RemoveProjectInput {
+    project_name: string;
+}
+interface SwitchModesInput {
+    modes: string[];
+}
+export declare class ActivateProjectTool extends Tool {
+    static readonly markers: Set<"does-not-require-active-project">;
+    static readonly description = "Activates a project by name or path.";
+    static readonly inputSchema: z.ZodObject<{
+        project: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        project: string;
+    }, {
+        project: string;
+    }>;
+    apply(args: ActivateProjectInput): Promise<string>;
+}
+export declare class RemoveProjectTool extends Tool {
+    static readonly markers: Set<"does-not-require-active-project" | "optional">;
+    static readonly description = "Removes a project from the Serena configuration.";
+    static readonly inputSchema: z.ZodObject<{
+        project_name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        project_name: string;
+    }, {
+        project_name: string;
+    }>;
+    apply(args: RemoveProjectInput): Promise<string>;
+}
+export declare class SwitchModesTool extends Tool {
+    static readonly markers: Set<"optional">;
+    static readonly description = "Activates the desired agent modes by name.";
+    static readonly inputSchema: z.ZodObject<{
+        modes: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        modes: string[];
+    }, {
+        modes: string[];
+    }>;
+    apply(args: SwitchModesInput): Promise<string>;
+}
+export declare class GetCurrentConfigTool extends Tool {
+    static readonly description = "Displays the current configuration of the agent, including projects, tools, contexts, and modes.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare const CONFIG_TOOL_CLASSES: (typeof ActivateProjectTool | typeof RemoveProjectTool | typeof SwitchModesTool | typeof GetCurrentConfigTool)[];
+export {};

package/dist/serena/tools/config_tools.js

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+import { SerenaAgentMode } from '../config/context_mode.js';
+import { Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional } from './tools_base.js';
+function stringifyUnknown(value, fallback = 'unknown') {
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint' || typeof value === 'symbol') {
+        return String(value);
+    }
+    if (typeof value === 'function') {
+        return '[function]';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return Object.prototype.toString.call(value);
+        }
+    }
+    return fallback;
+}
+function isIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.iterator in value;
+}
+function resolveLanguageName(language) {
+    if (typeof language === 'string') {
+        return language;
+    }
+    if (language && typeof language === 'object' && 'value' in language) {
+        const value = language.value;
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (value !== undefined && value !== null) {
+            return stringifyUnknown(value);
+        }
+    }
+    return stringifyUnknown(language);
+}
+function resolveProjectName(project) {
+    const fromConfig = project.projectConfig.projectName ?? project.projectConfig.project_name;
+    if (fromConfig && typeof fromConfig === 'string') {
+        return fromConfig;
+    }
+    const directName = project.projectName;
+    if (typeof directName === 'string' && directName.length > 0) {
+        return directName;
+    }
+    const snakeCaseName = project.project_name;
+    if (typeof snakeCaseName === 'string' && snakeCaseName.length > 0) {
+        return snakeCaseName;
+    }
+    return 'unknown';
+}
+function resolveInitialPrompt(projectConfig) {
+    const prompt = projectConfig.initialPrompt ?? projectConfig.initial_prompt;
+    if (typeof prompt === 'string' && prompt.trim().length > 0) {
+        return prompt;
+    }
+    return '';
+}
+function resolveProjectYamlPath(project) {
+    const camelCase = project.pathToProjectYml;
+    if (typeof camelCase === 'function') {
+        return camelCase();
+    }
+    const snakeCase = project.path_to_project_yml;
+    if (typeof snakeCase === 'function') {
+        return snakeCase();
+    }
+    return undefined;
+}
+async function listAvailableMemories(manager) {
+    const raw = await Promise.resolve(manager.listMemories());
+    if (!raw) {
+        return [];
+    }
+    if (Array.isArray(raw)) {
+        return raw.map((entry) => stringifyUnknown(entry));
+    }
+    if (isIterable(raw)) {
+        const result = [];
+        for (const item of raw) {
+            result.push(stringifyUnknown(item));
+        }
+        return result;
+    }
+    return [stringifyUnknown(raw)];
+}
+export class ActivateProjectTool extends Tool {
+    static markers = new Set([ToolMarkerDoesNotRequireActiveProject]);
+    static description = 'Activates a project by name or path.';
+    static inputSchema = z.object({
+        project: z.string().min(1, 'project must not be empty')
+    });
+    async apply(args) {
+        const activeProject = await Promise.resolve(this.agent.activateProjectFromPathOrName(args.project));
+        const isNewlyCreated = Boolean(activeProject.isNewlyCreated ??
+            activeProject.is_newly_created ??
+            false);
+        const projectName = resolveProjectName(activeProject);
+        const language = resolveLanguageName(activeProject.projectConfig.language);
+        const projectYamlPath = resolveProjectYamlPath(activeProject);
+        let result = '';
+        if (isNewlyCreated) {
+            result =
+                `Created and activated a new project with name '${projectName}' at ${activeProject.projectRoot}, language: ${language}. ` +
+                    "You can activate this project later by name.\n";
+            if (projectYamlPath) {
+                result += `The project's Serena configuration is in ${projectYamlPath}. In particular, you may want to edit the project name and the initial prompt.`;
+            }
+        }
+        else {
+            result = `Activated existing project with name '${projectName}' at ${activeProject.projectRoot}, language: ${language}`;
+        }
+        const initialPrompt = resolveInitialPrompt(activeProject.projectConfig);
+        if (initialPrompt.length > 0) {
+            result += `\nAdditional project information:\n ${initialPrompt}`;
+        }
+        const memoriesManager = this.memoriesManager;
+        const memories = await listAvailableMemories(memoriesManager);
+        result +=
+            `\nAvailable memories:\n ${JSON.stringify(memories)}` +
+                'You should not read these memories directly, but rather use the `read_memory` tool to read them later if needed for the task.';
+        const activeTools = this.agent.getActiveToolNames();
+        result += `\nAvailable tools:\n ${JSON.stringify(activeTools)}`;
+        return result;
+    }
+}
+export class RemoveProjectTool extends Tool {
+    static markers = new Set([ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional]);
+    static description = 'Removes a project from the Serena configuration.';
+    static inputSchema = z.object({
+        project_name: z.string().min(1, 'project_name must not be empty')
+    });
+    async apply(args) {
+        const config = this.agent.serenaConfig;
+        if (typeof config.removeProject !== 'function') {
+            throw new Error('Removing projects is not supported by the active Serena configuration.');
+        }
+        await Promise.resolve(config.removeProject.call(config, args.project_name));
+        return `Successfully removed project '${args.project_name}' from configuration.`;
+    }
+}
+export class SwitchModesTool extends Tool {
+    static markers = new Set([ToolMarkerOptional]);
+    static description = 'Activates the desired agent modes by name.';
+    static inputSchema = z.object({
+        modes: z.array(z.string().min(1, 'mode name must not be empty')).min(1, 'at least one mode must be provided')
+    });
+    async apply(args) {
+        const modeInstances = args.modes.map((modeName) => SerenaAgentMode.load(modeName));
+        await Promise.resolve(this.agent.setModes(modeInstances));
+        let result = `Successfully activated modes: ${modeInstances.map((mode) => mode.name).join(', ')}` + '\n';
+        result += modeInstances.map((mode) => mode.prompt).join('\n') + '\n';
+        result += `Currently active tools: ${this.agent.getActiveToolNames().join(', ')}`;
+        return result;
+    }
+}
+export class GetCurrentConfigTool extends Tool {
+    static description = 'Displays the current configuration of the agent, including projects, tools, contexts, and modes.';
+    async apply(_args = {}) {
+        return Promise.resolve(this.agent.getCurrentConfigOverview());
+    }
+}
+export const CONFIG_TOOL_CLASSES = [
+    ActivateProjectTool,
+    RemoveProjectTool,
+    SwitchModesTool,
+    GetCurrentConfigTool
+];