@nogataka/smart-edit 0.0.14

package/dist/serena/agent.js

@@ -0,0 +1,675 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import { ensureDefaultSubprocessOptions } from '../solidlsp/util/subprocess_util.js';
+import { ToolRegistry, ToolMarkerCanEdit, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional, ToolMarkerSymbolicEdit, ToolMarkerSymbolicRead } from './tools/tools_base.js';
+import { SerenaConfig, ToolInclusionDefinition, ToolSet, getSerenaManagedInProjectDir, RegisteredTokenCountEstimator } from './config/serena_config.js';
+import { SerenaAgentContext, SerenaAgentMode } from './config/context_mode.js';
+import { createSerenaLogger, MemoryLogHandler } from './util/logging.js';
+import { SerenaPromptFactory } from './prompt_factory.js';
+import { SerenaDashboardAPI } from './dashboard.js';
+import { GuiLogViewer } from './gui_log_viewer.js';
+import { serenaVersion } from './version.js';
+import { ToolUsageStats } from './analytics.js';
+import { LanguageServerCodeEditor } from './code_editor.js';
+import { LanguageServerSymbolRetriever } from './symbol.js';
+import { Project } from './project.js';
+import { ExecuteShellCommandTool } from './tools/cmd_tools.js';
+import { ActivateProjectTool, GetCurrentConfigTool, RemoveProjectTool, SwitchModesTool } from './tools/config_tools.js';
+import { ReadFileTool, CreateTextFileTool, ListDirTool, FindFileTool, ReplaceRegexTool, DeleteLinesTool, ReplaceLinesTool, InsertAtLineTool, SearchForPatternTool } from './tools/file_tools.js';
+import { WriteMemoryTool, ReadMemoryTool, ListMemoriesTool, DeleteMemoryTool } from './tools/memory_tools.js';
+import { RestartLanguageServerTool, GetSymbolsOverviewTool, FindSymbolTool, FindReferencingSymbolsTool, ReplaceSymbolBodyTool, InsertAfterSymbolTool, InsertBeforeSymbolTool } from './tools/symbol_tools.js';
+import { CheckOnboardingPerformedTool, OnboardingTool, ThinkAboutCollectedInformationTool, ThinkAboutTaskAdherenceTool, ThinkAboutWhetherYouAreDoneTool, SummarizeChangesTool, PrepareForNewConversationTool, InitialInstructionsTool } from './tools/workflow_tools.js';
+const { logger: log, memoryHandler: defaultMemoryHandler } = createSerenaLogger({
+    name: 'serena.agent',
+    emitToConsole: true,
+    level: 'info'
+});
+const TOOL_MARKER_CANDIDATES = [
+    ToolMarkerCanEdit,
+    ToolMarkerDoesNotRequireActiveProject,
+    ToolMarkerOptional,
+    ToolMarkerSymbolicEdit,
+    ToolMarkerSymbolicRead
+];
+const IDE_ASSISTANT_CONTEXT_NAME = 'ide-assistant';
+const DEFAULT_TOOL_CLASSES = [
+    ExecuteShellCommandTool,
+    ActivateProjectTool,
+    RemoveProjectTool,
+    SwitchModesTool,
+    GetCurrentConfigTool,
+    WriteMemoryTool,
+    ReadMemoryTool,
+    ListMemoriesTool,
+    DeleteMemoryTool,
+    ReadFileTool,
+    CreateTextFileTool,
+    ListDirTool,
+    FindFileTool,
+    ReplaceRegexTool,
+    DeleteLinesTool,
+    ReplaceLinesTool,
+    InsertAtLineTool,
+    SearchForPatternTool,
+    RestartLanguageServerTool,
+    GetSymbolsOverviewTool,
+    FindSymbolTool,
+    FindReferencingSymbolsTool,
+    ReplaceSymbolBodyTool,
+    InsertAfterSymbolTool,
+    InsertBeforeSymbolTool,
+    CheckOnboardingPerformedTool,
+    OnboardingTool,
+    ThinkAboutCollectedInformationTool,
+    ThinkAboutTaskAdherenceTool,
+    ThinkAboutWhetherYouAreDoneTool,
+    SummarizeChangesTool,
+    PrepareForNewConversationTool,
+    InitialInstructionsTool
+];
+export class ProjectNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectNotFoundError';
+    }
+}
+export class LinesRead {
+    files = new Map();
+    addLinesRead(relativePath, lines) {
+        const key = formatLineRange(lines);
+        const existing = this.files.get(relativePath) ?? new Set();
+        existing.add(key);
+        this.files.set(relativePath, existing);
+    }
+    wereLinesRead(relativePath, lines) {
+        const key = formatLineRange(lines);
+        const ranges = this.files.get(relativePath);
+        if (!ranges) {
+            return false;
+        }
+        return ranges.has(key);
+    }
+    invalidateLinesRead(relativePath) {
+        this.files.delete(relativePath);
+    }
+}
+export class MemoriesManager {
+    memoryDir;
+    constructor(projectRoot) {
+        this.memoryDir = path.join(getSerenaManagedInProjectDir(projectRoot), 'memories');
+        fs.mkdirSync(this.memoryDir, { recursive: true });
+    }
+    resolveMemoryPath(name) {
+        const normalized = name.replace(/\.md$/iu, '');
+        return path.join(this.memoryDir, `${normalized}.md`);
+    }
+    loadMemory(name) {
+        const memoryPath = this.resolveMemoryPath(name);
+        if (!fs.existsSync(memoryPath)) {
+            return `Memory file ${name} not found, consider creating it with the write_memory tool if you need it.`;
+        }
+        return fs.readFileSync(memoryPath, { encoding: 'utf-8' });
+    }
+    saveMemory(name, content) {
+        const memoryPath = this.resolveMemoryPath(name);
+        fs.writeFileSync(memoryPath, content, { encoding: 'utf-8' });
+        return `Memory ${name} written.`;
+    }
+    listMemories() {
+        return fs
+            .readdirSync(this.memoryDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name.replace(/\.md$/iu, ''));
+    }
+    deleteMemory(name) {
+        const memoryPath = this.resolveMemoryPath(name);
+        if (!fs.existsSync(memoryPath)) {
+            throw new Error(`Memory ${name} not found.`);
+        }
+        fs.unlinkSync(memoryPath);
+        return `Memory ${name} deleted.`;
+    }
+}
+class AvailableTools {
+    tools;
+    toolNames;
+    toolMarkerNames;
+    constructor(tools) {
+        this.tools = Array.from(tools);
+        this.toolNames = this.tools.map((tool) => tool.getName());
+        this.toolMarkerNames = new Set();
+        for (const marker of TOOL_MARKER_CANDIDATES) {
+            if (this.tools.some((tool) => tool.hasMarker(marker))) {
+                this.toolMarkerNames.add(marker);
+            }
+        }
+    }
+    get size() {
+        return this.tools.length;
+    }
+}
+class SerializedTaskExecutor {
+    queue = Promise.resolve();
+    index = 1;
+    issue(task, metadata, timeoutLabelLogger = log) {
+        const taskName = `Task-${this.index++}[${metadata?.name ?? task.name ?? 'anonymous'}]`;
+        let resolveFn;
+        let rejectFn;
+        const resultPromise = new Promise((resolve, reject) => {
+            resolveFn = resolve;
+            rejectFn = reject;
+        });
+        const wrapped = async () => {
+            timeoutLabelLogger.info(`Scheduling ${taskName}`);
+            const start = Date.now();
+            try {
+                const value = await Promise.resolve(task());
+                resolveFn?.(value);
+            }
+            catch (error) {
+                rejectFn?.(error);
+            }
+            finally {
+                const elapsed = Date.now() - start;
+                timeoutLabelLogger.info(`${taskName} finished in ${elapsed} ms`);
+            }
+        };
+        this.queue = this.queue.then(wrapped).catch((error) => {
+            timeoutLabelLogger.error(`Error executing ${taskName}`, error);
+        });
+        return new AgentTaskHandleImpl(resultPromise, taskName);
+    }
+}
+class AgentTaskHandleImpl {
+    promise;
+    taskName;
+    constructor(promise, taskName) {
+        this.promise = promise;
+        this.taskName = taskName;
+    }
+    async result(options = {}) {
+        const { timeout } = options;
+        if (timeout === undefined || timeout === null) {
+            return this.promise;
+        }
+        return withTimeout(this.promise, timeout, this.taskName);
+    }
+}
+export class SerenaAgent {
+    serenaConfig;
+    promptFactory;
+    languageServer = null;
+    memoriesManager = null;
+    linesRead = null;
+    projectActivationCallback;
+    taskExecutor = new SerializedTaskExecutor();
+    memoryLogHandler;
+    toolRegistry = new ToolRegistry();
+    _context;
+    _modes;
+    _allTools = new Map();
+    _activeTools = new Map();
+    _exposedTools = new AvailableTools([]);
+    _baseToolSet;
+    _activeProject = null;
+    _dashboardApi = null;
+    _dashboardThread = null;
+    _dashboardPort = null;
+    _guiLogViewer = null;
+    _toolUsageStats = null;
+    disposed = false;
+    constructor(options = {}) {
+        this.serenaConfig = options.serenaConfig ?? SerenaConfig.fromConfigFile();
+        this.memoryLogHandler = options.memoryLogHandler ?? defaultMemoryHandler ?? new MemoryLogHandler();
+        this.projectActivationCallback = options.projectActivationCallback;
+        this._context = options.context ?? SerenaAgentContext.loadDefault();
+        this._modes = options.modes ?? SerenaAgentMode.loadDefaultModes();
+        this.promptFactory = new SerenaPromptFactory();
+        this.instantiateAllTools();
+        this._baseToolSet = this.computeBaseToolSet(options.project ?? null);
+        this._exposedTools = new AvailableTools(Array.from(this._allTools.values()).filter((tool) => this._baseToolSet.includesName(tool.getName())));
+        if (this.serenaConfig.recordToolUsageStats) {
+            this._toolUsageStats = new ToolUsageStats(this.serenaConfig.tokenCountEstimator ?? RegisteredTokenCountEstimator.TIKTOKEN_GPT4O);
+            log.info(`Will record tool usage statistics with token count estimator: ${this._toolUsageStats.tokenEstimatorName}.`);
+        }
+        if (this.serenaConfig.webDashboard) {
+            const dashboardApi = new SerenaDashboardAPI(this.memoryLogHandler, this._exposedTools.toolNames, this, {
+                shutdownCallback: () => this.dispose(),
+                toolUsageStats: this._toolUsageStats
+            });
+            this._dashboardApi = dashboardApi;
+            void dashboardApi
+                .runInThread()
+                .then(([thread, port]) => {
+                this._dashboardThread = thread;
+                this._dashboardPort = port;
+                if (this.serenaConfig.webDashboardOpenOnLaunch && port > 0) {
+                    this.openDashboard(`http://127.0.0.1:${port}/dashboard/index.html`);
+                }
+            })
+                .catch((error) => {
+                this._dashboardApi = null;
+                log.warn('Failed to start Serena dashboard.', error instanceof Error ? error : undefined);
+            });
+        }
+        if (this.serenaConfig.guiLogWindowEnabled) {
+            if (process.platform === 'darwin') {
+                log.warn('GUI log window is not supported on macOS');
+            }
+            else {
+                this._guiLogViewer = new GuiLogViewer('dashboard', {
+                    title: 'Serena Logs',
+                    memoryLogHandler: this.memoryLogHandler,
+                    autoOpen: false
+                });
+                void this._guiLogViewer.start().catch((error) => {
+                    log.warn('Failed to start GUI log viewer', error instanceof Error ? error : undefined);
+                });
+                this._guiLogViewer.setToolNames(this._exposedTools.toolNames);
+            }
+        }
+        log.info(`Starting Serena server (version=${serenaVersion()}, process id=${process.pid}, parent process id=${process.ppid})`);
+        log.info(`Configuration file: ${this.serenaConfig.configFilePath ?? '(not persisted)'}`);
+        log.info(`Available projects: ${this.serenaConfig.projectNames.join(', ') || '(none)'}`);
+        log.info(`Loaded tools (${this._allTools.size}): ${Array.from(this._allTools.values())
+            .map((tool) => tool.getName())
+            .join(', ')}`);
+        this.checkShellSettings();
+        this._updateActiveTools();
+        log.info(`Number of exposed tools: ${this._exposedTools.size}`);
+        if (options.project) {
+            this.activateProjectFromPathOrName(options.project).catch((error) => {
+                log.error(`Error activating project '${options.project}' at startup`, error instanceof Error ? error : undefined);
+            });
+        }
+    }
+    get context() {
+        return this._context;
+    }
+    getContext() {
+        return this._context;
+    }
+    getToolDescriptionOverride(toolName) {
+        return this._context.toolDescriptionOverrides[toolName] ?? null;
+    }
+    get toolUsageStats() {
+        return this._toolUsageStats;
+    }
+    get toolUsageStatsEnabled() {
+        return this._toolUsageStats !== null;
+    }
+    getActiveProject() {
+        return this._activeProject;
+    }
+    getActiveProjectOrThrow() {
+        const project = this.getActiveProject();
+        if (!project) {
+            throw new Error('No active project. Please activate a project first.');
+        }
+        return project;
+    }
+    getProjectRoot() {
+        const project = this.getActiveProjectOrThrow();
+        return project.projectRoot;
+    }
+    getActiveToolNames() {
+        return Array.from(this._activeTools.values())
+            .map((tool) => tool.getName())
+            .sort();
+    }
+    getActiveToolClasses() {
+        return Array.from(this._activeTools.keys());
+    }
+    getExposedToolInstances() {
+        return [...this._exposedTools.tools];
+    }
+    toolIsActive(toolClass) {
+        if (typeof toolClass === 'string') {
+            return this.getActiveToolNames().includes(toolClass);
+        }
+        return this._activeTools.has(toolClass);
+    }
+    setModes(modes) {
+        this._modes = [...modes];
+        this._updateActiveTools();
+        log.info(`Set modes to ${this._modes.map((mode) => mode.name).join(', ')}`);
+    }
+    getActiveModes() {
+        return [...this._modes];
+    }
+    createSystemPrompt() {
+        log.info('Generating system prompt with available_tools=(see exposed tools), available_markers=%s', [
+            ...this._exposedTools.toolMarkerNames
+        ]);
+        const systemPrompt = this.promptFactory.createSystemPrompt({
+            contextSystemPrompt: this.formatPrompt(this._context.prompt),
+            modeSystemPrompts: this._modes.map((mode) => this.formatPrompt(mode.prompt)),
+            availableTools: this._exposedTools.toolNames,
+            availableMarkers: this._exposedTools.toolMarkerNames
+        });
+        log.info(`System prompt:\n${systemPrompt}`);
+        return systemPrompt;
+    }
+    issueTask(task, metadata) {
+        return this.taskExecutor.issue(task, metadata);
+    }
+    async executeTask(task) {
+        const future = this.issueTask(task);
+        return future.result();
+    }
+    isUsingLanguageServer() {
+        return !this.serenaConfig.jetbrains;
+    }
+    isLanguageServerRunning() {
+        return this.languageServer?.isRunning() ?? false;
+    }
+    resetLanguageServer() {
+        const toolTimeout = this.serenaConfig.toolTimeout;
+        const lsTimeout = toolTimeout === undefined || toolTimeout === null || toolTimeout < 0
+            ? null
+            : toolTimeout < 10
+                ? (() => {
+                    throw new Error(`Tool timeout must be at least 10 seconds, but is ${toolTimeout} seconds`);
+                })()
+                : toolTimeout - 5;
+        if (this.isLanguageServerRunning() && this.languageServer) {
+            log.info(`Stopping the current language server at ${this.languageServer.getRepositoryRootPath()} ...`);
+            this.languageServer.stop();
+            this.languageServer = null;
+        }
+        const project = this.getActiveProjectOrThrow();
+        this.languageServer = project.createLanguageServer({
+            logLevel: this.serenaConfig.logLevel,
+            lsTimeout,
+            traceLspCommunication: this.serenaConfig.traceLspCommunication,
+            lsSpecificSettings: this.serenaConfig.lsSpecificSettings
+        });
+        log.info(`Starting the language server for ${resolveProjectName(project)}`);
+        this.languageServer.start();
+        if (!this.languageServer.isRunning()) {
+            throw new Error(`Failed to start the language server for ${resolveProjectName(project)} at ${project.projectRoot}`);
+        }
+    }
+    activateProjectFromPathOrName(projectRootOrName) {
+        const project = this.loadProjectFromPathOrName(projectRootOrName, true);
+        if (!project) {
+            throw new ProjectNotFoundError(`Project '${projectRootOrName}' not found: Not a valid project name or directory. Existing project names: ${this.serenaConfig.projectNames.join(', ')}`);
+        }
+        this.activateProject(project);
+        return Promise.resolve(project);
+    }
+    markFileModified(relativePath) {
+        this.linesRead?.invalidateLinesRead(relativePath);
+    }
+    recordToolUsageIfEnabled(input, toolResult, tool) {
+        if (!this._toolUsageStats) {
+            log.debug(`Tool usage statistics recording is disabled, not recording usage of '${tool.getName()}'.`);
+            return;
+        }
+        const inputStr = JSON.stringify(input);
+        const outputStr = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult);
+        log.debug(`Recording tool usage for tool '${tool.getName()}'`);
+        this._toolUsageStats.recordToolUsage(tool.getName(), inputStr, outputStr);
+    }
+    getCurrentConfigOverview() {
+        const lines = [];
+        lines.push('Current configuration:');
+        lines.push(`Serena version: ${serenaVersion()}`);
+        lines.push(`Loglevel: ${this.serenaConfig.logLevel}, trace_lsp_communication=${this.serenaConfig.traceLspCommunication}`);
+        const project = this.getActiveProject();
+        if (project) {
+            lines.push(`Active project: ${resolveProjectName(project)}`);
+        }
+        else {
+            lines.push('No active project');
+        }
+        lines.push(`Available projects:\n${this.serenaConfig.projectNames.join('\n') || '(none)'}`);
+        lines.push(`Active context: ${this._context.name}`);
+        const activeModeNames = this.getActiveModes().map((mode) => mode.name);
+        lines.push(`Active modes: ${activeModeNames.join(', ') || '(none)'}`);
+        const inactiveModes = SerenaAgentMode.listRegisteredModeNames().filter((name) => !activeModeNames.includes(name));
+        if (inactiveModes.length > 0) {
+            lines.push(`Available but not active modes: ${inactiveModes.join(', ')}`);
+        }
+        lines.push('Active tools (after all exclusions from the project, context, and modes):');
+        lines.push(chunkedList(this.getActiveToolNames(), 4));
+        const allToolNames = Array.from(this._allTools.values())
+            .map((tool) => tool.getName())
+            .sort();
+        const inactiveToolNames = allToolNames.filter((tool) => !this.getActiveToolNames().includes(tool));
+        if (inactiveToolNames.length > 0) {
+            lines.push('Available but not active tools:');
+            lines.push(chunkedList(inactiveToolNames, 4));
+        }
+        return lines.join('\n') + '\n';
+    }
+    getTool(toolClass) {
+        const tool = this._allTools.get(toolClass);
+        if (!tool) {
+            throw new Error(`Tool ${toolClass.name} is not registered.`);
+        }
+        return tool;
+    }
+    getToolByName(toolName) {
+        const toolClass = this.toolRegistry.getToolClassByName(toolName);
+        return this.getTool(toolClass);
+    }
+    printToolOverview() {
+        this.toolRegistry.printToolOverview(this._activeTools.values());
+    }
+    createLanguageServerSymbolRetriever() {
+        if (!this.isUsingLanguageServer() || !this.languageServer) {
+            throw new Error('Cannot create LanguageServerSymbolRetriever; agent is not using a language server.');
+        }
+        return new LanguageServerSymbolRetriever(this.languageServer, this);
+    }
+    createCodeEditor() {
+        if (!this.isUsingLanguageServer() || !this.languageServer) {
+            throw new Error('Cannot create CodeEditor; agent is not using a language server.');
+        }
+        const retriever = this.createLanguageServerSymbolRetriever();
+        return new LanguageServerCodeEditor(retriever, this);
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        log.info('SerenaAgent is shutting down ...');
+        if (this.languageServer?.isRunning()) {
+            log.info('Stopping the language server ...');
+            this.languageServer.saveCache();
+            this.languageServer.stop();
+        }
+        if (this._guiLogViewer) {
+            void this._guiLogViewer.stop().catch((error) => {
+                log.warn('Failed to stop GUI log viewer', error instanceof Error ? error : undefined);
+            });
+        }
+        this._dashboardThread?.stop();
+        this._dashboardThread = null;
+        this._dashboardApi = null;
+    }
+    instantiateAllTools() {
+        if (this.toolRegistry.getAllToolClasses().length === 0) {
+            this.toolRegistry.registerMany(DEFAULT_TOOL_CLASSES);
+        }
+        for (const toolClass of this.toolRegistry.getAllToolClasses()) {
+            const toolInstance = new toolClass(this);
+            this._allTools.set(toolClass, toolInstance);
+        }
+    }
+    computeBaseToolSet(initialProject) {
+        const definitions = [this.serenaConfig, this._context];
+        if (this._context.name === IDE_ASSISTANT_CONTEXT_NAME) {
+            definitions.push(...this.ideAssistantContextToolInclusionDefinitions(initialProject));
+        }
+        if (this.serenaConfig.jetbrains) {
+            definitions.push(SerenaAgentMode.fromNameInternal('jetbrains'));
+        }
+        return ToolSet.default().apply(...definitions);
+    }
+    ideAssistantContextToolInclusionDefinitions(projectRootOrName) {
+        const definitions = [];
+        if (!projectRootOrName) {
+            return definitions;
+        }
+        const project = this.loadProjectFromPathOrName(projectRootOrName, false);
+        if (!project) {
+            return definitions;
+        }
+        definitions.push(new ToolInclusionDefinition({
+            excludedTools: [ActivateProjectTool.getNameFromCls(), GetCurrentConfigTool.getNameFromCls()]
+        }));
+        definitions.push(project.projectConfig);
+        return definitions;
+    }
+    activateProject(project) {
+        log.info(`Activating ${resolveProjectName(project)} at ${project.projectRoot}`);
+        this._activeProject = project;
+        this._updateActiveTools();
+        this.memoriesManager = new MemoriesManager(project.projectRoot);
+        this.linesRead = new LinesRead();
+        if (this.isUsingLanguageServer()) {
+            this.issueTask(() => this.resetLanguageServer(), { name: 'LanguageServerInitialization' });
+        }
+        this.projectActivationCallback?.();
+    }
+    loadProjectFromPathOrName(projectRootOrName, autogenerate) {
+        const registered = this.resolveRegisteredProject(projectRootOrName);
+        if (registered) {
+            return materializeProject(registered);
+        }
+        if (autogenerate && fs.existsSync(projectRootOrName) && fs.statSync(projectRootOrName).isDirectory()) {
+            const newProject = this.serenaConfig.addProjectFromPath(projectRootOrName);
+            return materializeProject(newProject);
+        }
+        return null;
+    }
+    resolveRegisteredProject(projectRootOrName) {
+        const byName = this.serenaConfig.projects.filter((project) => project.projectName === projectRootOrName);
+        if (byName.length === 1) {
+            return byName[0];
+        }
+        if (byName.length > 1) {
+            throw new Error(`Multiple projects found with name '${projectRootOrName}'. Please activate it by location instead. Locations: ${byName
+                .map((p) => p.projectRoot)
+                .join(', ')}`);
+        }
+        const resolved = path.resolve(projectRootOrName);
+        for (const project of this.serenaConfig.projects) {
+            if (project.matchesRootPath(resolved)) {
+                return project;
+            }
+        }
+        return null;
+    }
+    checkShellSettings() {
+        if (process.platform !== 'win32') {
+            return;
+        }
+        const comspec = process.env.COMSPEC ?? '';
+        if (comspec.toLowerCase().includes('bash')) {
+            process.env.COMSPEC = '';
+            log.info(`Adjusting COMSPEC environment variable to use the default shell instead of '${comspec}'`);
+        }
+    }
+    updateGuiLogViewerToolNames() {
+        if (this._guiLogViewer) {
+            this._guiLogViewer.setToolNames(this._exposedTools.toolNames);
+        }
+        this._dashboardApi?.setToolNames(this._exposedTools.toolNames);
+    }
+    openDashboard(url) {
+        try {
+            if (process.platform === 'darwin') {
+                spawn('open', [url], ensureDefaultSubprocessOptions({ detached: true, stdio: 'ignore' })).unref();
+            }
+            else if (process.platform === 'win32') {
+                spawn('cmd', ['/c', 'start', '', url], ensureDefaultSubprocessOptions({ detached: true, stdio: 'ignore' })).unref();
+            }
+            else {
+                spawn('xdg-open', [url], ensureDefaultSubprocessOptions({ detached: true, stdio: 'ignore' })).unref();
+            }
+        }
+        catch (error) {
+            log.warn(`Failed to open dashboard automatically. Please open ${url} manually.`, error);
+        }
+    }
+    _updateActiveTools() {
+        let toolSet = this._baseToolSet.apply(...this._modes);
+        if (this._activeProject) {
+            toolSet = toolSet.apply(this._activeProject.projectConfig);
+            if (this._activeProject.projectConfig.readOnly) {
+                toolSet = toolSet.withoutEditingTools();
+            }
+        }
+        this._activeTools = new Map(Array.from(this._allTools.entries()).filter(([, tool]) => toolSet.includesName(tool.getName())));
+        log.info(`Active tools (${this._activeTools.size}): ${this.getActiveToolNames().join(', ')}`);
+        this.updateGuiLogViewerToolNames();
+    }
+    formatPrompt(template) {
+        const replacements = {
+            available_tools: this._exposedTools.toolNames.join(', '),
+            available_markers: Array.from(this._exposedTools.toolMarkerNames).join(', ')
+        };
+        return template.replace(/{{\s*([a-zA-Z_]+)\s*}}/g, (_match, key) => replacements[key] ?? '');
+    }
+}
+function materializeProject(registered) {
+    if (registered.hasProjectInstance()) {
+        const instance = registered.getProjectInstance();
+        return ensureProjectHasLanguageServer(instance, registered);
+    }
+    const project = new Project({
+        projectRoot: registered.projectRoot,
+        projectConfig: registered.projectConfig
+    });
+    registered.attachProjectInstance(project);
+    return project;
+}
+function ensureProjectHasLanguageServer(project, registered) {
+    if (typeof project.createLanguageServer === 'function') {
+        return project;
+    }
+    const fallback = new Project({
+        projectRoot: registered.projectRoot,
+        projectConfig: registered.projectConfig
+    });
+    registered.attachProjectInstance(fallback);
+    return fallback;
+}
+function resolveProjectName(project) {
+    return project.projectName ?? project.projectConfig.projectName;
+}
+function chunkedList(values, chunkSize) {
+    if (values.length === 0) {
+        return '  (none)';
+    }
+    const chunks = [];
+    for (let i = 0; i < values.length; i += chunkSize) {
+        chunks.push(`  ${values.slice(i, i + chunkSize).join(', ')}`);
+    }
+    return chunks.join('\n');
+}
+function formatLineRange([start, end]) {
+    return `${start}:${end}`;
+}
+function withTimeout(promise, timeoutMs, taskName) {
+    return new Promise((resolve, reject) => {
+        const timer = globalThis.setTimeout(() => {
+            reject(new Error(`Timeout waiting for ${taskName} after ${timeoutMs} ms`));
+        }, timeoutMs);
+        promise
+            .then((value) => {
+            globalThis.clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            globalThis.clearTimeout(timer);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+}