@nogataka/smart-edit 0.0.14

package/dist/serena/code_editor.d.ts

@@ -0,0 +1,42 @@
+import { PositionInFile } from './symbol.js';
+import type { JetBrainsSymbol, LanguageServerSymbol, LanguageServerSymbolRetriever, Symbol as SerenaSymbol } from './symbol.js';
+import type { SerenaAgent } from './agent.js';
+interface EditedFile {
+    getContents(): string;
+    deleteTextBetweenPositions(start: PositionInFile, end: PositionInFile): void;
+    insertTextAtPosition(position: PositionInFile, text: string): void;
+}
+export declare abstract class CodeEditor<TSymbol extends SerenaSymbol> {
+    protected readonly projectRoot: string;
+    protected readonly agent: SerenaAgent | null;
+    constructor(projectRoot: string, agent?: SerenaAgent | null);
+    protected abstract openFile(relativePath: string): Promise<EditedFile>;
+    protected abstract findUniqueSymbol(namePath: string, relativeFilePath: string): Promise<TSymbol> | TSymbol;
+    protected withEditedFile(relativePath: string, handler: (file: EditedFile) => Promise<void> | void): Promise<void>;
+    replaceBody(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    replace_body(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    protected static countLeadingNewlines(text: string): number;
+    protected static countTrailingNewlines(text: string): number;
+    insertAfterSymbol(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    insert_after_symbol(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    insertBeforeSymbol(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    insert_before_symbol(namePath: string, relativeFilePath: string, body: string): Promise<void>;
+    insertAtLine(relativePath: string, line: number, content: string): Promise<void>;
+    insert_at_line(relativePath: string, line: number, content: string): Promise<void>;
+    deleteLines(relativePath: string, startLine: number, endLine: number): Promise<void>;
+    delete_lines(relativePath: string, startLine: number, endLine: number): Promise<void>;
+    deleteSymbol(namePath: string, relativeFilePath: string): Promise<void>;
+    delete_symbol(namePath: string, relativeFilePath: string): Promise<void>;
+}
+export declare class LanguageServerCodeEditor extends CodeEditor<LanguageServerSymbol> {
+    private readonly symbolRetriever;
+    constructor(symbolRetriever: LanguageServerSymbolRetriever, agent?: SerenaAgent | null);
+    protected openFile(relativePath: string): Promise<EditedFile>;
+    protected findUniqueSymbol(namePath: string, relativeFilePath: string): LanguageServerSymbol;
+}
+export declare class JetBrainsCodeEditor extends CodeEditor<JetBrainsSymbol> {
+    constructor(projectRoot: string, agent?: SerenaAgent | null);
+    protected openFile(_relativePath: string): Promise<EditedFile>;
+    protected findUniqueSymbol(_namePath: string, _relativeFilePath: string): JetBrainsSymbol;
+}
+export {};

package/dist/serena/code_editor.js

@@ -0,0 +1,239 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { JetBrainsCodeEditorNotAvailableError, PositionInFile } from './symbol.js';
+function assertNonNegative(value, description) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${description} must be a non-negative integer.`);
+    }
+}
+function positionToOffset(text, position) {
+    assertNonNegative(position.line, 'Position line');
+    assertNonNegative(position.col, 'Position column');
+    let line = 0;
+    let column = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (line === position.line && column === position.col) {
+            return index;
+        }
+        const char = text[index];
+        if (char === '\n') {
+            line += 1;
+            column = 0;
+            continue;
+        }
+        if (char === '\r') {
+            continue;
+        }
+        column += 1;
+    }
+    if (line === position.line && column === position.col) {
+        return text.length;
+    }
+    throw new Error(`Position (${position.line}, ${position.col}) is out of bounds for provided content.`);
+}
+class InMemoryEditedFile {
+    contents;
+    constructor(contents) {
+        this.contents = contents;
+    }
+    getContents() {
+        return this.contents;
+    }
+    deleteTextBetweenPositions(start, end) {
+        const startOffset = positionToOffset(this.contents, start);
+        const endOffset = positionToOffset(this.contents, end);
+        if (endOffset < startOffset) {
+            throw new Error('End position must not precede start position.');
+        }
+        this.contents = `${this.contents.slice(0, startOffset)}${this.contents.slice(endOffset)}`;
+    }
+    insertTextAtPosition(position, text) {
+        const offset = positionToOffset(this.contents, position);
+        this.contents = `${this.contents.slice(0, offset)}${text}${this.contents.slice(offset)}`;
+    }
+}
+export class CodeEditor {
+    projectRoot;
+    agent;
+    constructor(projectRoot, agent = null) {
+        this.projectRoot = projectRoot;
+        this.agent = agent;
+    }
+    async withEditedFile(relativePath, handler) {
+        const editedFile = await this.openFile(relativePath);
+        await handler(editedFile);
+        const absolutePath = path.resolve(this.projectRoot, relativePath);
+        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fs.writeFile(absolutePath, editedFile.getContents(), { encoding: 'utf-8' });
+        this.agent?.markFileModified(relativePath);
+    }
+    async replaceBody(namePath, relativeFilePath, body) {
+        const symbol = await this.findUniqueSymbol(namePath, relativeFilePath);
+        const startPos = symbol.getBodyStartPositionOrRaise();
+        const endPos = symbol.getBodyEndPositionOrRaise();
+        const trimmedBody = body.trim();
+        await this.withEditedFile(relativeFilePath, (editedFile) => {
+            editedFile.deleteTextBetweenPositions(startPos, endPos);
+            editedFile.insertTextAtPosition(startPos, trimmedBody);
+        });
+    }
+    async replace_body(namePath, relativeFilePath, body) {
+        await this.replaceBody(namePath, relativeFilePath, body);
+    }
+    static countLeadingNewlines(text) {
+        let count = 0;
+        for (const char of text) {
+            if (char === '\n') {
+                count += 1;
+            }
+            else if (char === '\r') {
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+        return count;
+    }
+    static countTrailingNewlines(text) {
+        let count = 0;
+        for (let index = text.length - 1; index >= 0; index -= 1) {
+            const char = text[index];
+            if (char === '\n') {
+                count += 1;
+            }
+            else if (char === '\r') {
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+        return count;
+    }
+    async insertAfterSymbol(namePath, relativeFilePath, body) {
+        const symbol = await this.findUniqueSymbol(namePath, relativeFilePath);
+        const endPos = symbol.getBodyEndPositionOrRaise();
+        let normalizedBody = body;
+        if (!normalizedBody.endsWith('\n')) {
+            normalizedBody += '\n';
+        }
+        const originalLeading = CodeEditor.countLeadingNewlines(normalizedBody);
+        normalizedBody = normalizedBody.replace(/^[\r\n]+/u, '');
+        const minimumEmptyLines = symbol.isNeighbouringDefinitionSeparatedByEmptyLine() ? 1 : 0;
+        const leadingEmptyLines = Math.max(minimumEmptyLines, originalLeading);
+        if (leadingEmptyLines > 0) {
+            normalizedBody = `${'\n'.repeat(leadingEmptyLines)}${normalizedBody}`;
+        }
+        normalizedBody = normalizedBody.replace(/[\r\n]+$/u, '') + '\n';
+        const insertPosition = new PositionInFile({ line: endPos.line, col: endPos.col });
+        await this.withEditedFile(relativeFilePath, (editedFile) => {
+            editedFile.insertTextAtPosition(insertPosition, normalizedBody);
+        });
+    }
+    async insert_after_symbol(namePath, relativeFilePath, body) {
+        await this.insertAfterSymbol(namePath, relativeFilePath, body);
+    }
+    async insertBeforeSymbol(namePath, relativeFilePath, body) {
+        const symbol = await this.findUniqueSymbol(namePath, relativeFilePath);
+        const startPos = symbol.getBodyStartPositionOrRaise();
+        let normalizedBody = body.replace(/\s+$/u, '') + '\n';
+        const originalTrailing = CodeEditor.countTrailingNewlines(normalizedBody);
+        const minimumTrailing = symbol.isNeighbouringDefinitionSeparatedByEmptyLine() ? 1 : 0;
+        const trailing = Math.max(minimumTrailing, Math.max(0, originalTrailing - 1));
+        if (trailing > 0) {
+            normalizedBody += '\n'.repeat(trailing);
+        }
+        await this.withEditedFile(relativeFilePath, (editedFile) => {
+            editedFile.insertTextAtPosition(new PositionInFile({ line: startPos.line, col: 0 }), normalizedBody);
+        });
+    }
+    async insert_before_symbol(namePath, relativeFilePath, body) {
+        await this.insertBeforeSymbol(namePath, relativeFilePath, body);
+    }
+    async insertAtLine(relativePath, line, content) {
+        assertNonNegative(line, 'line');
+        await this.withEditedFile(relativePath, (editedFile) => {
+            editedFile.insertTextAtPosition(new PositionInFile({ line, col: 0 }), content);
+        });
+    }
+    async insert_at_line(relativePath, line, content) {
+        await this.insertAtLine(relativePath, line, content);
+    }
+    async deleteLines(relativePath, startLine, endLine) {
+        assertNonNegative(startLine, 'start_line');
+        assertNonNegative(endLine, 'end_line');
+        if (endLine < startLine) {
+            throw new Error('end_line must not be less than start_line.');
+        }
+        await this.withEditedFile(relativePath, (editedFile) => {
+            const start = new PositionInFile({ line: startLine, col: 0 });
+            const end = new PositionInFile({ line: endLine + 1, col: 0 });
+            editedFile.deleteTextBetweenPositions(start, end);
+        });
+    }
+    async delete_lines(relativePath, startLine, endLine) {
+        await this.deleteLines(relativePath, startLine, endLine);
+    }
+    async deleteSymbol(namePath, relativeFilePath) {
+        const symbol = await this.findUniqueSymbol(namePath, relativeFilePath);
+        const startPos = symbol.getBodyStartPositionOrRaise();
+        const endPos = symbol.getBodyEndPositionOrRaise();
+        await this.withEditedFile(relativeFilePath, (editedFile) => {
+            editedFile.deleteTextBetweenPositions(startPos, endPos);
+        });
+    }
+    async delete_symbol(namePath, relativeFilePath) {
+        await this.deleteSymbol(namePath, relativeFilePath);
+    }
+}
+export class LanguageServerCodeEditor extends CodeEditor {
+    symbolRetriever;
+    constructor(symbolRetriever, agent = null) {
+        super(symbolRetriever.get_language_server().getRepositoryRootPath(), agent);
+        this.symbolRetriever = symbolRetriever;
+    }
+    async openFile(relativePath) {
+        const absolutePath = path.resolve(this.projectRoot, relativePath);
+        const buffer = await fs.readFile(absolutePath, { encoding: 'utf-8' }).catch((error) => {
+            if (error.code === 'ENOENT') {
+                throw new Error(`File not found: ${relativePath}`);
+            }
+            throw error;
+        });
+        return new InMemoryEditedFile(buffer);
+    }
+    findUniqueSymbol(namePath, relativeFilePath) {
+        const matches = this.symbolRetriever.find_by_name(namePath, false, undefined, undefined, false, relativeFilePath);
+        if (matches.length === 0) {
+            throw new Error(`No symbol with name ${namePath} found in file ${relativeFilePath}`);
+        }
+        if (matches.length > 1) {
+            const locations = matches
+                .map((symbol) => symbol.location.to_dict())
+                .map((location) => JSON.stringify(location))
+                .join(', ');
+            throw new Error(`Found multiple symbols with name ${namePath} in file ${relativeFilePath}. Their locations are: [${locations}]`);
+        }
+        const [match] = matches;
+        if (!match) {
+            throw new Error(`Invariant violation while retrieving symbol ${namePath} in ${relativeFilePath}`);
+        }
+        return match;
+    }
+}
+export class JetBrainsCodeEditor extends CodeEditor {
+    constructor(projectRoot, agent = null) {
+        super(projectRoot, agent);
+        throw new JetBrainsCodeEditorNotAvailableError();
+    }
+    // The following methods exist to satisfy the abstract contract but will never be executed
+    // because the constructor throws immediately.
+    /* c8 ignore start */
+    openFile(_relativePath) {
+        throw new JetBrainsCodeEditorNotAvailableError();
+    }
+    findUniqueSymbol(_namePath, _relativeFilePath) {
+        throw new JetBrainsCodeEditorNotAvailableError();
+    }
+}

package/dist/serena/config/context_mode.d.ts

@@ -0,0 +1,41 @@
+import type { ToolInclusionDefinitionInit } from './serena_config.js';
+import { ToolInclusionDefinition } from './serena_config.js';
+export declare class SerenaAgentMode extends ToolInclusionDefinition {
+    readonly name: string;
+    readonly prompt: string;
+    readonly description: string;
+    constructor(init: ToolInclusionDefinitionInit & {
+        name: string;
+        prompt: string;
+        description?: string;
+    });
+    static fromYaml(yamlPath: string): SerenaAgentMode;
+    static getPath(name: string): string;
+    static fromName(name: string): SerenaAgentMode;
+    static fromNameInternal(name: string): SerenaAgentMode;
+    static listRegisteredModeNames(includeUserModes?: boolean): string[];
+    static listCustomModeNames(): string[];
+    static loadDefaultModes(): SerenaAgentMode[];
+    static load(nameOrPath: string): SerenaAgentMode;
+    printOverview(): void;
+}
+export declare class SerenaAgentContext extends ToolInclusionDefinition {
+    readonly name: string;
+    readonly prompt: string;
+    readonly description: string;
+    readonly toolDescriptionOverrides: Record<string, string>;
+    constructor(init: ToolInclusionDefinitionInit & {
+        name: string;
+        prompt: string;
+        description?: string;
+        toolDescriptionOverrides?: Record<string, string>;
+    });
+    static fromYaml(yamlPath: string): SerenaAgentContext;
+    static getPath(name: string): string;
+    static fromName(name: string): SerenaAgentContext;
+    static load(nameOrPath: string): SerenaAgentContext;
+    static listRegisteredContextNames(includeUserContexts?: boolean): string[];
+    static listCustomContextNames(): string[];
+    static loadDefault(): SerenaAgentContext;
+    printOverview(): void;
+}

package/dist/serena/config/context_mode.js

@@ -0,0 +1,239 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { DEFAULT_CONTEXT, DEFAULT_MODES, INTERNAL_MODE_YAMLS_DIR, SERENAS_OWN_CONTEXT_YAMLS_DIR, SERENAS_OWN_MODE_YAMLS_DIR, USER_CONTEXT_YAMLS_DIR, USER_MODE_YAMLS_DIR } from '../constants.js';
+import { loadYaml } from '../util/general.js';
+import { ToolInclusionDefinition } from './serena_config.js';
+const STRING_ARRAY_SCHEMA = z
+    .union([z.array(z.union([z.string(), z.number(), z.boolean()])), z.string(), z.number(), z.boolean(), z.null()])
+    .optional()
+    .transform((value) => {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            if (typeof item === 'number' || typeof item === 'boolean') {
+                return String(item);
+            }
+            return null;
+        })
+            .filter((item) => item !== null);
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return [String(value)];
+    }
+    return [];
+});
+const OPTIONAL_NAME_SCHEMA = z
+    .union([z.string(), z.number()])
+    .optional()
+    .transform((value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = String(value).trim();
+    return normalized.length > 0 ? normalized : undefined;
+});
+const OPTIONAL_TEXT_SCHEMA = z
+    .union([z.string(), z.number()])
+    .optional()
+    .transform((value) => {
+    if (value === undefined) {
+        return '';
+    }
+    return String(value);
+});
+const TOOL_DESCRIPTION_OVERRIDES_SCHEMA = z
+    .record(z.union([z.string(), z.number()]))
+    .optional()
+    .transform((value) => {
+    if (!value) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, raw]) => [key, String(raw)]));
+});
+const MODE_YAML_SCHEMA = z
+    .object({
+    name: OPTIONAL_NAME_SCHEMA,
+    prompt: OPTIONAL_TEXT_SCHEMA,
+    description: OPTIONAL_TEXT_SCHEMA,
+    excluded_tools: STRING_ARRAY_SCHEMA,
+    included_optional_tools: STRING_ARRAY_SCHEMA
+})
+    .passthrough();
+const CONTEXT_YAML_SCHEMA = MODE_YAML_SCHEMA.extend({
+    tool_description_overrides: TOOL_DESCRIPTION_OVERRIDES_SCHEMA
+});
+export class SerenaAgentMode extends ToolInclusionDefinition {
+    name;
+    prompt;
+    description;
+    constructor(init) {
+        super(init);
+        this.name = init.name;
+        this.prompt = init.prompt;
+        this.description = init.description ?? '';
+    }
+    static fromYaml(yamlPath) {
+        const data = loadYaml(yamlPath);
+        if (!data || typeof data !== 'object') {
+            throw new Error(`Invalid mode YAML: ${yamlPath}`);
+        }
+        const plain = data;
+        const parsedResult = MODE_YAML_SCHEMA.safeParse(plain);
+        if (!parsedResult.success) {
+            throw new Error(formatYamlZodIssues(yamlPath, parsedResult.error));
+        }
+        const parsed = parsedResult.data;
+        const name = parsed.name ?? path.parse(yamlPath).name;
+        return new SerenaAgentMode({
+            name,
+            prompt: parsed.prompt,
+            description: parsed.description,
+            excludedTools: parsed.excluded_tools,
+            includedOptionalTools: parsed.included_optional_tools
+        });
+    }
+    static getPath(name) {
+        const filename = `${name}.yml`;
+        const custom = path.join(USER_MODE_YAMLS_DIR, filename);
+        if (fs.existsSync(custom)) {
+            return custom;
+        }
+        const own = path.join(SERENAS_OWN_MODE_YAMLS_DIR, filename);
+        if (!fs.existsSync(own)) {
+            throw new Error(`Mode ${name} not found in ${USER_MODE_YAMLS_DIR} or in ${SERENAS_OWN_MODE_YAMLS_DIR}. Available modes:\n${this.listRegisteredModeNames().join(', ')}`);
+        }
+        return own;
+    }
+    static fromName(name) {
+        const modePath = this.getPath(name);
+        return this.fromYaml(modePath);
+    }
+    static fromNameInternal(name) {
+        const internalPath = path.join(INTERNAL_MODE_YAMLS_DIR, `${name}.yml`);
+        if (!fs.existsSync(internalPath)) {
+            throw new Error(`Internal mode '${name}' not found in ${INTERNAL_MODE_YAMLS_DIR}`);
+        }
+        return this.fromYaml(internalPath);
+    }
+    static listRegisteredModeNames(includeUserModes = true) {
+        const own = listYamlFiles(SERENAS_OWN_MODE_YAMLS_DIR).filter((file) => file !== 'mode.template');
+        const user = includeUserModes ? listYamlFiles(USER_MODE_YAMLS_DIR) : [];
+        return Array.from(new Set([...own, ...user])).sort();
+    }
+    static listCustomModeNames() {
+        return listYamlFiles(USER_MODE_YAMLS_DIR);
+    }
+    static loadDefaultModes() {
+        return DEFAULT_MODES.map((mode) => this.fromName(mode));
+    }
+    static load(nameOrPath) {
+        if (nameOrPath.endsWith('.yml')) {
+            return this.fromYaml(nameOrPath);
+        }
+        return this.fromName(nameOrPath);
+    }
+    printOverview() {
+        console.log(`${this.name}:\n ${this.description}`);
+        if (this.excludedTools.length > 0) {
+            console.log(` excluded tools:\n  ${this.excludedTools.sort().join(', ')}`);
+        }
+    }
+}
+export class SerenaAgentContext extends ToolInclusionDefinition {
+    name;
+    prompt;
+    description;
+    toolDescriptionOverrides;
+    constructor(init) {
+        super(init);
+        this.name = init.name;
+        this.prompt = init.prompt;
+        this.description = init.description ?? '';
+        this.toolDescriptionOverrides = { ...(init.toolDescriptionOverrides ?? {}) };
+    }
+    static fromYaml(yamlPath) {
+        const data = loadYaml(yamlPath);
+        if (!data || typeof data !== 'object') {
+            throw new Error(`Invalid context YAML: ${yamlPath}`);
+        }
+        const plain = data;
+        const parsedResult = CONTEXT_YAML_SCHEMA.safeParse(plain);
+        if (!parsedResult.success) {
+            throw new Error(formatYamlZodIssues(yamlPath, parsedResult.error));
+        }
+        const parsed = parsedResult.data;
+        const name = parsed.name ?? path.parse(yamlPath).name;
+        return new SerenaAgentContext({
+            name,
+            prompt: parsed.prompt,
+            description: parsed.description,
+            toolDescriptionOverrides: parsed.tool_description_overrides,
+            excludedTools: parsed.excluded_tools,
+            includedOptionalTools: parsed.included_optional_tools
+        });
+    }
+    static getPath(name) {
+        const filename = `${name}.yml`;
+        const custom = path.join(USER_CONTEXT_YAMLS_DIR, filename);
+        if (fs.existsSync(custom)) {
+            return custom;
+        }
+        const own = path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, filename);
+        if (!fs.existsSync(own)) {
+            throw new Error(`Context ${name} not found in ${USER_CONTEXT_YAMLS_DIR} or in ${SERENAS_OWN_CONTEXT_YAMLS_DIR}. Available contexts:\n${this.listRegisteredContextNames().join(', ')}`);
+        }
+        return own;
+    }
+    static fromName(name) {
+        const contextPath = this.getPath(name);
+        return this.fromYaml(contextPath);
+    }
+    static load(nameOrPath) {
+        if (nameOrPath.endsWith('.yml')) {
+            return this.fromYaml(nameOrPath);
+        }
+        return this.fromName(nameOrPath);
+    }
+    static listRegisteredContextNames(includeUserContexts = true) {
+        const own = listYamlFiles(SERENAS_OWN_CONTEXT_YAMLS_DIR);
+        const user = includeUserContexts ? listYamlFiles(USER_CONTEXT_YAMLS_DIR) : [];
+        return Array.from(new Set([...own, ...user])).sort();
+    }
+    static listCustomContextNames() {
+        return listYamlFiles(USER_CONTEXT_YAMLS_DIR);
+    }
+    static loadDefault() {
+        return this.fromName(DEFAULT_CONTEXT);
+    }
+    printOverview() {
+        console.log(`${this.name}:\n ${this.description}`);
+        if (this.excludedTools.length > 0) {
+            console.log(` excluded tools:\n  ${this.excludedTools.sort().join(', ')}`);
+        }
+    }
+}
+function formatYamlZodIssues(filePath, error) {
+    const details = error.issues
+        .map((issue) => {
+        const pathSegment = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+        return `${pathSegment}: ${issue.message}`;
+    })
+        .join('; ');
+    return `Invalid YAML structure detected in ${filePath}: ${details}`;
+}
+function listYamlFiles(directory) {
+    if (!fs.existsSync(directory)) {
+        return [];
+    }
+    return fs
+        .readdirSync(directory)
+        .filter((file) => file.endsWith('.yml'))
+        .map((file) => path.parse(file).name);
+}