@nogataka/smart-edit 0.0.14

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

@@ -0,0 +1,162 @@
+import { type ZodTypeAny } from 'zod';
+import type { SerenaAgentMode } from '../config/context_mode.js';
+import type { Language } from '../../solidlsp/ls_config.js';
+import type { SerenaPromptFactory } from '../prompt_factory.js';
+import type { SolidLanguageServer } from '../../solidlsp/ls.js';
+import type { LanguageServerSymbolRetriever } from '../symbol.js';
+import type { LanguageServerCodeEditor } from '../code_editor.js';
+import type { LinesRead } from '../agent.js';
+export declare function assertIsBufferEncoding(value: string): asserts value is BufferEncoding;
+export declare const SUCCESS_RESULT = "OK";
+export declare const ToolMarkerCanEdit: "can-edit";
+export declare const ToolMarkerDoesNotRequireActiveProject: "does-not-require-active-project";
+export declare const ToolMarkerOptional: "optional";
+export declare const ToolMarkerSymbolicRead: "symbolic-read";
+export declare const ToolMarkerSymbolicEdit: "symbolic-edit";
+export type ToolMarker = typeof ToolMarkerCanEdit | typeof ToolMarkerDoesNotRequireActiveProject | typeof ToolMarkerOptional | typeof ToolMarkerSymbolicRead | typeof ToolMarkerSymbolicEdit;
+export interface SerenaConfigLike {
+    defaultMaxToolAnswerChars: number;
+    toolTimeout: number;
+    projectNames: string[];
+    removeProject?(projectName: string): void;
+}
+export interface ProjectConfigLike {
+    encoding: string;
+    language?: Language | {
+        value: string;
+    } | string;
+    initialPrompt?: string;
+    projectName?: string;
+}
+export interface ProjectLike {
+    projectRoot: string;
+    projectConfig: ProjectConfigLike;
+    isNewlyCreated?: boolean;
+    pathToProjectYml?: () => string;
+}
+export type PromptFactoryLike = SerenaPromptFactory;
+export interface MemoriesManagerLike {
+    listMemories(): string[] | Promise<string[]> | Iterable<unknown> | Promise<Iterable<unknown>>;
+    list_memories?(): string[] | Promise<string[]> | Iterable<unknown> | Promise<Iterable<unknown>>;
+    saveMemory?(name: string, content: string): string | Promise<string>;
+    save_memory?(name: string, content: string): string | Promise<string>;
+    loadMemory?(name: string): string | Promise<string>;
+    load_memory?(name: string): string | Promise<string>;
+    deleteMemory?(name: string): string | Promise<string>;
+    delete_memory?(name: string): string | Promise<string>;
+}
+export type LinesReadLike = LinesRead;
+export type LanguageServerLike = SolidLanguageServer;
+export type CodeEditorLike = LanguageServerCodeEditor;
+export type LanguageServerSymbolRetrieverLike = LanguageServerSymbolRetriever;
+export interface IssueTaskMetadata {
+    name?: string;
+}
+export interface AgentTaskHandle<T> {
+    result(options?: {
+        timeout?: number;
+    }): Promise<T>;
+}
+export interface SerenaAgentLike {
+    readonly promptFactory: PromptFactoryLike;
+    readonly memoriesManager: MemoriesManagerLike | null;
+    readonly serenaConfig: SerenaConfigLike;
+    readonly languageServer: LanguageServerLike | null;
+    readonly linesRead: LinesReadLike | null;
+    getProjectRoot(): string;
+    getActiveProject(): ProjectLike | null;
+    getActiveProjectOrThrow(): ProjectLike;
+    getActiveToolNames(): string[];
+    toolIsActive(toolClass: ToolClass | string): boolean;
+    isUsingLanguageServer(): boolean;
+    isLanguageServerRunning(): boolean;
+    resetLanguageServer(): void | Promise<void>;
+    activateProjectFromPathOrName(project: string): Promise<ProjectLike>;
+    setModes(modes: SerenaAgentMode[]): void | Promise<void>;
+    getCurrentConfigOverview(): string | Promise<string>;
+    createLanguageServerSymbolRetriever(): LanguageServerSymbolRetrieverLike;
+    createCodeEditor(): CodeEditorLike;
+    recordToolUsageIfEnabled(args: Record<string, unknown>, result: string | Record<string, unknown>, tool: Tool): void | Promise<void>;
+    issueTask<T>(task: () => Promise<T> | T, metadata?: IssueTaskMetadata): AgentTaskHandle<T>;
+}
+export type ToolApplyFunction<Input = Record<string, unknown>, Output = string> = (input: Input) => Promise<Output> | Output;
+export interface ToolApplyMetadata {
+    inputSchema: ZodTypeAny;
+    outputSchema?: ZodTypeAny;
+    structuredOutput?: boolean;
+    description?: string;
+}
+export interface ToolExecutionOptions {
+    logCall?: boolean;
+    catchExceptions?: boolean;
+    maxAnswerChars?: number;
+}
+export type ToolClass<T extends Tool = Tool> = (new (agent: SerenaAgentLike) => T) & typeof Tool;
+export declare abstract class Component {
+    protected readonly agent: SerenaAgentLike;
+    constructor(agent: SerenaAgentLike);
+    getProjectRoot(): string;
+    protected get promptFactory(): PromptFactoryLike;
+    protected get memoriesManager(): MemoriesManagerLike;
+    protected createLanguageServerSymbolRetriever(): LanguageServerSymbolRetrieverLike;
+    protected get project(): ProjectLike;
+    protected createCodeEditor(): CodeEditorLike;
+    protected get linesRead(): LinesReadLike;
+}
+export declare abstract class Tool extends Component {
+    protected static readonly markers: ReadonlySet<ToolMarker>;
+    static readonly inputSchema: ZodTypeAny;
+    static readonly outputSchema: ZodTypeAny | undefined;
+    static readonly structuredOutput: boolean | undefined;
+    static readonly description: string | undefined;
+    abstract apply(args: unknown): Promise<string>;
+    static getNameFromCls(): string;
+    getName(): string;
+    static hasMarker(marker: ToolMarker): boolean;
+    hasMarker(marker: ToolMarker): boolean;
+    getApplyFn(): ToolApplyFunction<Record<string, unknown>, string>;
+    static canEdit(): boolean;
+    static getToolDescription(): string;
+    getApplyDocstring(): string;
+    static getApplyFnMetadata(): ToolApplyMetadata;
+    getApplyFnMetadata(): ToolApplyMetadata;
+    protected _limitLength(result: string, maxAnswerChars: number): string;
+    isActive(): boolean;
+    applyEx(args?: Record<string, unknown>, options?: ToolExecutionOptions): Promise<string>;
+}
+declare class EditedFileContextImpl {
+    private readonly project;
+    private readonly absolutePath;
+    private readonly originalContent;
+    private updatedContent;
+    constructor(relativePath: string, agent: SerenaAgentLike);
+    getOriginalContent(): string;
+    setUpdatedContent(content: string): void;
+    commit(): Promise<void>;
+}
+export declare class EditedFileContext {
+    static use<T>(relativePath: string, agent: SerenaAgentLike, handler: (context: EditedFileContextImpl) => Promise<T> | T): Promise<T>;
+}
+declare class ToolRegistryImpl {
+    private readonly toolMap;
+    registerToolClass(toolClass: ToolClass): void;
+    registerMany(toolClasses: Iterable<ToolClass>): void;
+    getToolClassByName(toolName: string): ToolClass;
+    getAllToolClasses(): ToolClass[];
+    getToolClassesDefaultEnabled(): ToolClass[];
+    getToolClassesOptional(): ToolClass[];
+    getToolNamesDefaultEnabled(): string[];
+    getToolNamesOptional(): string[];
+    getToolNames(): string[];
+    isValidToolName(toolName: string): boolean;
+    printToolOverview(tools?: Iterable<ToolClass | Tool>, options?: {
+        includeOptional?: boolean;
+        onlyOptional?: boolean;
+    }): void;
+    /** @internal */
+    resetForTesting(): void;
+}
+declare const ToolRegistrySingleton: typeof ToolRegistryImpl;
+export type ToolRegistry = InstanceType<typeof ToolRegistryImpl>;
+export { ToolRegistrySingleton as ToolRegistry };
+export declare function registerToolClass(toolClass: ToolClass): void;

package/dist/serena/tools/tools_base.js

@@ -0,0 +1,378 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { createSerenaLogger } from '../util/logging.js';
+import { singleton } from '../util/class_decorators.js';
+const { logger: log } = createSerenaLogger({ name: 'serena.tools.base' });
+export function assertIsBufferEncoding(value) {
+    if (!Buffer.isEncoding(value)) {
+        throw new Error(`Unsupported file encoding '${value}'`);
+    }
+}
+function resolveProjectEncoding(encodingValue) {
+    const candidate = encodingValue ?? 'utf-8';
+    assertIsBufferEncoding(candidate);
+    return candidate;
+}
+export const SUCCESS_RESULT = 'OK';
+export const ToolMarkerCanEdit = 'can-edit';
+export const ToolMarkerDoesNotRequireActiveProject = 'does-not-require-active-project';
+export const ToolMarkerOptional = 'optional';
+export const ToolMarkerSymbolicRead = 'symbolic-read';
+export const ToolMarkerSymbolicEdit = 'symbolic-edit';
+function formatDictionary(value) {
+    const parts = Object.entries(value).map(([key, val]) => {
+        try {
+            return `${key}=${JSON.stringify(val)}`;
+        }
+        catch {
+            return `${key}=${String(val)}`;
+        }
+    });
+    return `{${parts.join(', ')}}`;
+}
+function describeError(error) {
+    if (error instanceof Error && typeof error.message === 'string' && error.message.length > 0) {
+        return error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function isSolidLspTerminationError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    if (!('isLanguageServerTerminated' in error)) {
+        return false;
+    }
+    const candidate = error.isLanguageServerTerminated;
+    return typeof candidate === 'function';
+}
+export class Component {
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    getProjectRoot() {
+        return this.agent.getProjectRoot();
+    }
+    get promptFactory() {
+        return this.agent.promptFactory;
+    }
+    get memoriesManager() {
+        const manager = this.agent.memoriesManager;
+        if (!manager) {
+            throw new Error('Memories manager is not initialized.');
+        }
+        return manager;
+    }
+    createLanguageServerSymbolRetriever() {
+        if (!this.agent.isUsingLanguageServer()) {
+            throw new Error('Cannot create LanguageServerSymbolRetriever; agent is not in language server mode.');
+        }
+        return this.agent.createLanguageServerSymbolRetriever();
+    }
+    get project() {
+        return this.agent.getActiveProjectOrThrow();
+    }
+    createCodeEditor() {
+        return this.agent.createCodeEditor();
+    }
+    get linesRead() {
+        const value = this.agent.linesRead;
+        if (!value) {
+            throw new Error('linesRead not initialized on agent.');
+        }
+        return value;
+    }
+}
+export class Tool extends Component {
+    static markers = new Set();
+    static inputSchema = z.object({}).passthrough();
+    static outputSchema;
+    static structuredOutput;
+    static description;
+    static getNameFromCls() {
+        const name = this.name.endsWith('Tool') ? this.name.slice(0, -4) : this.name;
+        const snake = name
+            .replace(/([A-Z]+)/g, '_$1')
+            .replace(/^_/, '')
+            .toLowerCase();
+        return snake;
+    }
+    getName() {
+        return this.constructor.getNameFromCls();
+    }
+    static hasMarker(marker) {
+        return this.markers.has(marker);
+    }
+    hasMarker(marker) {
+        return this.constructor.hasMarker(marker);
+    }
+    getApplyFn() {
+        const applyFn = this.apply;
+        if (!applyFn) {
+            throw new Error(`apply not defined in ${this.constructor.name}. Did you forget to implement it?`);
+        }
+        return applyFn.bind(this);
+    }
+    static canEdit() {
+        return this.hasMarker(ToolMarkerCanEdit) || this.hasMarker(ToolMarkerSymbolicEdit);
+    }
+    static getToolDescription() {
+        return (this.description ?? '').trim();
+    }
+    getApplyDocstring() {
+        const metadata = this.getApplyFnMetadata();
+        return metadata.description ?? '';
+    }
+    static getApplyFnMetadata() {
+        return {
+            inputSchema: this.inputSchema,
+            outputSchema: this.outputSchema,
+            structuredOutput: this.structuredOutput,
+            description: this.getToolDescription()
+        };
+    }
+    getApplyFnMetadata() {
+        return this.constructor.getApplyFnMetadata();
+    }
+    _limitLength(result, maxAnswerChars) {
+        let limit = maxAnswerChars;
+        if (limit === -1 || limit === undefined || limit === null) {
+            limit = this.agent.serenaConfig.defaultMaxToolAnswerChars;
+        }
+        if (limit <= 0) {
+            throw new Error(`Must be positive or the default (-1), got: maxAnswerChars=${limit}`);
+        }
+        if (result.length > limit) {
+            return `The answer is too long (${result.length} characters). Please try a more specific tool query or raise the max_answer_chars parameter.`;
+        }
+        return result;
+    }
+    isActive() {
+        return this.agent.toolIsActive(this.constructor);
+    }
+    async applyEx(args = {}, options = {}) {
+        const { logCall = true, catchExceptions = true, maxAnswerChars = -1 } = options;
+        const applyFn = this.getApplyFn();
+        const metadata = this.getApplyFnMetadata();
+        const validatedArgs = metadata.inputSchema !== undefined ? metadata.inputSchema.parse(args) : args;
+        const task = async () => {
+            try {
+                if (!this.isActive()) {
+                    return `Error: Tool '${this.getName()}' is not active. Active tools: ${this.agent.getActiveToolNames().join(', ')}`;
+                }
+            }
+            catch (error) {
+                return `RuntimeError while checking if tool ${this.getName()} is active: ${describeError(error)}`;
+            }
+            if (logCall) {
+                log.info(`${this.getName()}: ${formatDictionary(validatedArgs)}`);
+            }
+            try {
+                if (!this.hasMarker(ToolMarkerDoesNotRequireActiveProject)) {
+                    const activeProject = this.agent.getActiveProject();
+                    if (!activeProject) {
+                        const projects = this.agent.serenaConfig.projectNames;
+                        return [
+                            `Error: No active project. Ask the user to provide the project path or to select a project from this list of known projects:`,
+                            projects.join(', ') || '(none)'
+                        ].join(' ');
+                    }
+                    if (this.agent.isUsingLanguageServer() && !this.agent.isLanguageServerRunning()) {
+                        log.info('Language server is not running. Starting it ...');
+                        await Promise.resolve(this.agent.resetLanguageServer());
+                    }
+                }
+                let result;
+                try {
+                    const output = await Promise.resolve(applyFn(validatedArgs));
+                    result = typeof output === 'string' ? output : String(output);
+                }
+                catch (error) {
+                    if (isSolidLspTerminationError(error)) {
+                        log.error(`Language server terminated while executing tool (${describeError(error)}). Restarting the language server and retrying ...`);
+                        await Promise.resolve(this.agent.resetLanguageServer());
+                        const retryOutput = await Promise.resolve(applyFn(validatedArgs));
+                        result = typeof retryOutput === 'string' ? retryOutput : String(retryOutput);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                const limited = this._limitLength(result, maxAnswerChars);
+                await Promise.resolve(this.agent.recordToolUsageIfEnabled(validatedArgs, limited, this));
+                if (logCall) {
+                    log.info(`Result: ${limited}`);
+                }
+                try {
+                    const languageServer = this.agent.languageServer;
+                    if (languageServer) {
+                        await Promise.resolve(languageServer.saveCache());
+                    }
+                }
+                catch (error) {
+                    log.error(`Error saving language server cache: ${describeError(error)}`);
+                }
+                return limited;
+            }
+            catch (error) {
+                if (!catchExceptions) {
+                    throw error;
+                }
+                const message = `Error executing tool: ${describeError(error)}`;
+                log.error(message, error instanceof Error ? error : undefined);
+                if (logCall) {
+                    log.info(`Result: ${message}`);
+                }
+                return message;
+            }
+        };
+        const future = this.agent.issueTask(task, { name: this.constructor.name });
+        return future.result({ timeout: this.agent.serenaConfig.toolTimeout });
+    }
+}
+class EditedFileContextImpl {
+    project;
+    absolutePath;
+    originalContent;
+    updatedContent = null;
+    constructor(relativePath, agent) {
+        const project = agent.getActiveProject();
+        if (!project) {
+            throw new Error('No active project configured.');
+        }
+        this.project = project;
+        this.absolutePath = path.join(project.projectRoot, relativePath);
+        if (!fs.existsSync(this.absolutePath) || !fs.statSync(this.absolutePath).isFile()) {
+            throw new Error(`File ${this.absolutePath} does not exist.`);
+        }
+        const encoding = resolveProjectEncoding(project.projectConfig.encoding);
+        this.originalContent = fs.readFileSync(this.absolutePath, { encoding });
+    }
+    getOriginalContent() {
+        return this.originalContent;
+    }
+    setUpdatedContent(content) {
+        this.updatedContent = content;
+    }
+    async commit() {
+        if (this.updatedContent === null) {
+            return;
+        }
+        const encoding = resolveProjectEncoding(this.project.projectConfig.encoding);
+        await fs.promises.writeFile(this.absolutePath, this.updatedContent, { encoding });
+        log.info(`Updated content written to ${this.absolutePath}`);
+    }
+}
+export class EditedFileContext {
+    static async use(relativePath, agent, handler) {
+        const context = new EditedFileContextImpl(relativePath, agent);
+        const result = await handler(context);
+        await context.commit();
+        return result;
+    }
+}
+class ToolRegistryImpl {
+    toolMap = new Map();
+    registerToolClass(toolClass) {
+        const toolName = toolClass.getNameFromCls();
+        if (this.toolMap.has(toolName)) {
+            throw new Error(`Duplicate tool name found: ${toolName}. Tool classes must have unique names.`);
+        }
+        this.toolMap.set(toolName, {
+            toolClass,
+            isOptional: toolClass.hasMarker(ToolMarkerOptional),
+            toolName
+        });
+    }
+    registerMany(toolClasses) {
+        for (const toolClass of toolClasses) {
+            this.registerToolClass(toolClass);
+        }
+    }
+    getToolClassByName(toolName) {
+        const entry = this.toolMap.get(toolName);
+        if (!entry) {
+            throw new Error(`Tool ${toolName} is not registered.`);
+        }
+        return entry.toolClass;
+    }
+    getAllToolClasses() {
+        return Array.from(this.toolMap.values(), (entry) => entry.toolClass);
+    }
+    getToolClassesDefaultEnabled() {
+        return Array.from(this.toolMap.values())
+            .filter((entry) => !entry.isOptional)
+            .map((entry) => entry.toolClass);
+    }
+    getToolClassesOptional() {
+        return Array.from(this.toolMap.values())
+            .filter((entry) => entry.isOptional)
+            .map((entry) => entry.toolClass);
+    }
+    getToolNamesDefaultEnabled() {
+        return Array.from(this.toolMap.values())
+            .filter((entry) => !entry.isOptional)
+            .map((entry) => entry.toolName);
+    }
+    getToolNamesOptional() {
+        return Array.from(this.toolMap.values())
+            .filter((entry) => entry.isOptional)
+            .map((entry) => entry.toolName);
+    }
+    getToolNames() {
+        return Array.from(this.toolMap.keys());
+    }
+    isValidToolName(toolName) {
+        return this.toolMap.has(toolName);
+    }
+    printToolOverview(tools, options = {}) {
+        let selection = tools;
+        if (!selection) {
+            if (options.onlyOptional) {
+                selection = this.getToolClassesOptional();
+            }
+            else if (options.includeOptional) {
+                selection = this.getAllToolClasses();
+            }
+            else {
+                selection = this.getToolClassesDefaultEnabled();
+            }
+        }
+        const catalog = new Map();
+        for (const tool of selection) {
+            if (typeof tool === 'function') {
+                catalog.set(tool.getNameFromCls(), tool);
+            }
+            else {
+                catalog.set(tool.getName(), tool);
+            }
+        }
+        const sortedNames = Array.from(catalog.keys()).sort();
+        for (const toolName of sortedNames) {
+            const item = catalog.get(toolName);
+            if (!item) {
+                continue;
+            }
+            const toolClass = typeof item === 'function' ? item : item.constructor;
+            const description = toolClass.getToolDescription();
+            console.log(` * \`${toolName}\`: ${description}`);
+        }
+    }
+    /** @internal */
+    resetForTesting() {
+        this.toolMap.clear();
+    }
+}
+const ToolRegistrySingleton = singleton(ToolRegistryImpl);
+export { ToolRegistrySingleton as ToolRegistry };
+export function registerToolClass(toolClass) {
+    const registry = new ToolRegistrySingleton();
+    registry.registerToolClass(toolClass);
+}

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

@@ -0,0 +1,35 @@
+import { Tool } from './tools_base.js';
+export declare class CheckOnboardingPerformedTool extends Tool {
+    static readonly description = "Checks whether project onboarding was already performed.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class OnboardingTool extends Tool {
+    static readonly description = "Provides onboarding instructions (project structure, essential tasks, etc.) when onboarding has not been performed.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class ThinkAboutCollectedInformationTool extends Tool {
+    static readonly description = "Encourages the agent to reflect on whether the gathered information is sufficient and relevant.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class ThinkAboutTaskAdherenceTool extends Tool {
+    static readonly description = "Guides the agent to confirm alignment with the current task before making code changes.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class ThinkAboutWhetherYouAreDoneTool extends Tool {
+    static readonly description = "Helps determine whether the requested task is fully completed.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class SummarizeChangesTool extends Tool {
+    static readonly markers: Set<"optional">;
+    static readonly description = "Provides guidelines for summarizing codebase changes after completing a task.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class PrepareForNewConversationTool extends Tool {
+    static readonly description = "Provides instructions to prepare for continuing work in a new conversation context.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}
+export declare class InitialInstructionsTool extends Tool {
+    static readonly markers: Set<"does-not-require-active-project" | "optional">;
+    static readonly description = "Returns the initial system instructions for the current project when they cannot be provided via the system prompt.";
+    apply(_args?: Record<string, unknown>): Promise<string>;
+}