@nogataka/smart-edit 0.0.14

package/dist/serena/project.d.ts

@@ -0,0 +1,62 @@
+import { type PathMatcher } from './util/file_system.js';
+import { MatchedConsecutiveLines } from './text_utils.js';
+import { ProjectConfig, type ProjectLike } from './config/serena_config.js';
+import { SolidLanguageServer } from '../solidlsp/ls.js';
+import type { Language } from '../solidlsp/ls_config.js';
+export interface ProjectSearchOptions {
+    pattern: string;
+    relative_path?: string;
+    context_lines_before?: number;
+    context_lines_after?: number;
+    paths_include_glob?: string;
+    paths_exclude_glob?: string;
+}
+export interface CreateLanguageServerOptions {
+    logLevel: number;
+    lsTimeout: number | null;
+    traceLspCommunication: boolean;
+    lsSpecificSettings: Record<string, unknown>;
+}
+export declare class Project implements ProjectLike {
+    readonly projectRoot: string;
+    readonly projectConfig: ProjectConfig;
+    readonly isNewlyCreated: boolean;
+    private readonly ignoredPatterns;
+    private readonly ignoreMatcher;
+    private readonly languageMatcher;
+    constructor(init: {
+        projectRoot: string;
+        projectConfig: ProjectConfig;
+        isNewlyCreated?: boolean;
+    });
+    static load(projectRoot: string, autogenerate?: boolean): Project;
+    get projectName(): string;
+    get project_name(): string;
+    get language(): Language;
+    pathToSerenaDataFolder(): string;
+    path_to_serena_data_folder(): string;
+    pathToProjectYml(): string;
+    path_to_project_yml(): string;
+    readFile(relativePath: string): string;
+    read_file(relativePath: string): string;
+    getIgnoreSpec(): PathMatcher;
+    get_ignore_spec(): PathMatcher;
+    isIgnoredPath(candidate: string, ignoreNonSourceFiles?: boolean): boolean;
+    is_ignored_path(candidate: string, ignore_non_source_files?: boolean): boolean;
+    isPathInProject(candidate: string): boolean;
+    is_path_in_project(candidate: string): boolean;
+    relativePathExists(relativePath: string): boolean;
+    relative_path_exists(relativePath: string): boolean;
+    validateRelativePath(relativePath: string): void;
+    validate_relative_path(relativePath: string): void;
+    gatherSourceFiles(relativePath?: string): string[];
+    gather_source_files(relativePath?: string): string[];
+    searchSourceFilesForPattern(options: ProjectSearchOptions): MatchedConsecutiveLines[];
+    search_source_files_for_pattern(pattern: string, relative_path?: string, context_lines_before?: number, context_lines_after?: number, paths_include_glob?: string, paths_exclude_glob?: string): MatchedConsecutiveLines[];
+    retrieveContentAroundLine(relativeFilePath: string, line: number, contextLinesBefore?: number, contextLinesAfter?: number): MatchedConsecutiveLines;
+    retrieve_content_around_line(relative_file_path: string, line: number, context_lines_before?: number, context_lines_after?: number): MatchedConsecutiveLines;
+    createLanguageServer(options: CreateLanguageServerOptions): SolidLanguageServer;
+    private ensureSerenaDataGitignore;
+    private _isIgnoredRelativePath;
+    private resolveLanguageMatcher;
+}

package/dist/serena/project.js

@@ -0,0 +1,321 @@
+import { Buffer } from 'node:buffer';
+import fs from 'node:fs';
+import path from 'node:path';
+import ignore from 'ignore';
+import { createSerenaLogger } from './util/logging.js';
+import { GitignoreParser, matchPath } from './util/file_system.js';
+import { MatchedConsecutiveLines, searchFiles } from './text_utils.js';
+import { DEFAULT_TOOL_TIMEOUT, ProjectConfig } from './config/serena_config.js';
+import { SERENA_MANAGED_DIR_IN_HOME, SERENA_MANAGED_DIR_NAME } from './constants.js';
+import { SolidLanguageServer } from '../solidlsp/ls.js';
+import { getLanguageFilenameMatcher } from '../solidlsp/ls_config.js';
+const { logger: log } = createSerenaLogger({ name: 'serena.project', emitToConsole: true, level: 'info' });
+class IgnoreMatcher {
+    engine;
+    constructor(patterns) {
+        this.engine = ignore();
+        if (patterns.length > 0) {
+            this.engine.add(patterns);
+        }
+    }
+    ignores(candidate) {
+        if (!candidate) {
+            return false;
+        }
+        return this.engine.ignores(candidate);
+    }
+}
+function normalizePattern(pattern) {
+    return pattern.replace(/\\/g, '/');
+}
+function toPosixRelative(relativePath) {
+    const replaced = relativePath.split(path.sep).join('/');
+    if (replaced === '.' || replaced === './') {
+        return '';
+    }
+    return replaced.replace(/^\.\//u, '');
+}
+function ensureDirectoryExists(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+function safeStat(candidate) {
+    try {
+        return fs.statSync(candidate);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+export class Project {
+    projectRoot;
+    projectConfig;
+    isNewlyCreated;
+    ignoredPatterns;
+    ignoreMatcher;
+    languageMatcher;
+    constructor(init) {
+        this.projectRoot = path.resolve(init.projectRoot);
+        this.projectConfig = init.projectConfig;
+        this.isNewlyCreated = init.isNewlyCreated ?? false;
+        this.ensureSerenaDataGitignore();
+        const patterns = new Set();
+        for (const pattern of this.projectConfig.ignoredPaths) {
+            if (pattern) {
+                patterns.add(normalizePattern(pattern));
+            }
+        }
+        if (this.projectConfig.ignoreAllFilesInGitignore) {
+            const parser = new GitignoreParser(this.projectRoot);
+            for (const spec of parser.getIgnoreSpecs()) {
+                log.debug(`Adding ${spec.patterns.length} patterns from ${spec.filePath} to ignored paths.`);
+                for (const pattern of spec.patterns) {
+                    patterns.add(normalizePattern(pattern));
+                }
+            }
+        }
+        this.ignoredPatterns = Array.from(patterns);
+        this.ignoreMatcher = new IgnoreMatcher(this.ignoredPatterns);
+        this.languageMatcher = this.resolveLanguageMatcher(this.projectConfig.language);
+    }
+    static load(projectRoot, autogenerate = true) {
+        const resolvedRoot = path.resolve(projectRoot);
+        if (!fs.existsSync(resolvedRoot)) {
+            throw new Error(`Project root not found: ${resolvedRoot}`);
+        }
+        const projectConfig = ProjectConfig.load(resolvedRoot, autogenerate);
+        return new Project({ projectRoot: resolvedRoot, projectConfig });
+    }
+    get projectName() {
+        return this.projectConfig.projectName;
+    }
+    get project_name() {
+        return this.projectName;
+    }
+    get language() {
+        return this.projectConfig.language;
+    }
+    pathToSerenaDataFolder() {
+        return path.join(this.projectRoot, SERENA_MANAGED_DIR_NAME);
+    }
+    path_to_serena_data_folder() {
+        return this.pathToSerenaDataFolder();
+    }
+    pathToProjectYml() {
+        return path.join(this.projectRoot, ProjectConfig.relPathToProjectYml());
+    }
+    path_to_project_yml() {
+        return this.pathToProjectYml();
+    }
+    readFile(relativePath) {
+        const absolutePath = path.resolve(this.projectRoot, relativePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`File not found: ${absolutePath}`);
+        }
+        const encoding = this.projectConfig.encoding;
+        if (!Buffer.isEncoding(encoding)) {
+            throw new Error(`Unsupported file encoding '${encoding}' for ${absolutePath}`);
+        }
+        return fs.readFileSync(absolutePath, { encoding });
+    }
+    read_file(relativePath) {
+        return this.readFile(relativePath);
+    }
+    getIgnoreSpec() {
+        return this.ignoreMatcher;
+    }
+    get_ignore_spec() {
+        return this.getIgnoreSpec();
+    }
+    isIgnoredPath(candidate, ignoreNonSourceFiles = false) {
+        const absolutePath = path.isAbsolute(candidate)
+            ? path.resolve(candidate)
+            : path.resolve(this.projectRoot, candidate);
+        if (!absolutePath.startsWith(`${this.projectRoot}${path.sep}`) && absolutePath !== this.projectRoot) {
+            log.warn(`Path ${absolutePath} is not relative to the project root ${this.projectRoot} and will be ignored.`);
+            return true;
+        }
+        const relative = path.relative(this.projectRoot, absolutePath);
+        return this._isIgnoredRelativePath(relative, ignoreNonSourceFiles);
+    }
+    is_ignored_path(candidate, ignore_non_source_files = false) {
+        return this.isIgnoredPath(candidate, ignore_non_source_files);
+    }
+    isPathInProject(candidate) {
+        const absolutePath = path.isAbsolute(candidate)
+            ? path.resolve(candidate)
+            : path.resolve(this.projectRoot, candidate);
+        const relative = path.relative(this.projectRoot, absolutePath);
+        return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    }
+    is_path_in_project(candidate) {
+        return this.isPathInProject(candidate);
+    }
+    relativePathExists(relativePath) {
+        const absolutePath = path.resolve(this.projectRoot, relativePath);
+        return fs.existsSync(absolutePath);
+    }
+    relative_path_exists(relativePath) {
+        return this.relativePathExists(relativePath);
+    }
+    validateRelativePath(relativePath) {
+        if (!this.isPathInProject(relativePath)) {
+            throw new Error(`${relativePath} points to path outside of the repository root; cannot access for safety reasons`);
+        }
+        if (this.isIgnoredPath(relativePath)) {
+            throw new Error(`Path ${relativePath} is ignored; cannot access for safety reasons`);
+        }
+    }
+    validate_relative_path(relativePath) {
+        this.validateRelativePath(relativePath);
+    }
+    gatherSourceFiles(relativePath = '') {
+        const startPath = path.resolve(this.projectRoot, relativePath);
+        if (!fs.existsSync(startPath)) {
+            throw new Error(`Relative path ${startPath} not found.`);
+        }
+        const stats = safeStat(startPath);
+        if (!stats) {
+            throw new Error(`Failed to stat path: ${startPath}`);
+        }
+        if (stats.isFile()) {
+            return [toPosixRelative(path.relative(this.projectRoot, startPath))];
+        }
+        const queue = [startPath];
+        const results = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = fs.readdirSync(current, { withFileTypes: true });
+            }
+            catch (error) {
+                log.warn(`Skipping directory ${current} during source discovery`, error);
+                continue;
+            }
+            for (const entry of entries) {
+                const absoluteEntryPath = path.join(current, entry.name);
+                const entryStats = safeStat(absoluteEntryPath);
+                if (!entryStats) {
+                    log.warn(`File ${absoluteEntryPath} not found (possibly symlink), skipping in gatherSourceFiles.`);
+                    continue;
+                }
+                const relativeEntryPath = path.relative(this.projectRoot, absoluteEntryPath);
+                if (entryStats.isDirectory()) {
+                    if (!this.isIgnoredPath(relativeEntryPath)) {
+                        queue.push(absoluteEntryPath);
+                    }
+                    continue;
+                }
+                if (entryStats.isFile()) {
+                    try {
+                        if (!this.isIgnoredPath(relativeEntryPath, true)) {
+                            results.push(toPosixRelative(relativeEntryPath));
+                        }
+                    }
+                    catch (error) {
+                        log.warn(`Skipping file ${absoluteEntryPath} during source discovery`, error);
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    gather_source_files(relativePath = '') {
+        return this.gatherSourceFiles(relativePath);
+    }
+    searchSourceFilesForPattern(options) {
+        const { pattern, relative_path = '', context_lines_before = 0, context_lines_after = 0, paths_include_glob, paths_exclude_glob } = options;
+        const relativeFilePaths = this.gatherSourceFiles(relative_path);
+        return searchFiles(relativeFilePaths, pattern, {
+            rootPath: this.projectRoot,
+            contextLinesBefore: context_lines_before,
+            contextLinesAfter: context_lines_after,
+            pathsIncludeGlob: paths_include_glob ?? null,
+            pathsExcludeGlob: paths_exclude_glob ?? null
+        });
+    }
+    search_source_files_for_pattern(pattern, relative_path = '', context_lines_before = 0, context_lines_after = 0, paths_include_glob, paths_exclude_glob) {
+        return this.searchSourceFilesForPattern({
+            pattern,
+            relative_path,
+            context_lines_before,
+            context_lines_after,
+            paths_include_glob,
+            paths_exclude_glob
+        });
+    }
+    retrieveContentAroundLine(relativeFilePath, line, contextLinesBefore = 0, contextLinesAfter = 0) {
+        const fileContents = this.readFile(relativeFilePath);
+        return MatchedConsecutiveLines.fromFileContents({
+            fileContents,
+            line,
+            contextLinesBefore,
+            contextLinesAfter,
+            sourceFilePath: relativeFilePath
+        });
+    }
+    retrieve_content_around_line(relative_file_path, line, context_lines_before = 0, context_lines_after = 0) {
+        return this.retrieveContentAroundLine(relative_file_path, line, context_lines_before, context_lines_after);
+    }
+    createLanguageServer(options) {
+        const lsTimeout = options.lsTimeout === undefined ? DEFAULT_TOOL_TIMEOUT - 5 : options.lsTimeout;
+        return SolidLanguageServer.create({
+            codeLanguage: this.projectConfig.language,
+            traceLspCommunication: options.traceLspCommunication,
+            startIndependentLspProcess: true,
+            ignoredPaths: this.projectConfig.ignoredPaths
+        }, { level: options.logLevel }, this.projectRoot, {
+            timeout: lsTimeout,
+            solidlspSettings: {
+                lsSpecificSettings: options.lsSpecificSettings ?? {},
+                solidlspDir: SERENA_MANAGED_DIR_IN_HOME,
+                projectDataRelativePath: SERENA_MANAGED_DIR_NAME
+            }
+        });
+    }
+    ensureSerenaDataGitignore() {
+        const gitignorePath = path.join(this.pathToSerenaDataFolder(), '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            return;
+        }
+        ensureDirectoryExists(path.dirname(gitignorePath));
+        log.info(`Creating .gitignore file in ${gitignorePath}`);
+        fs.writeFileSync(gitignorePath, `/${SolidLanguageServer.CACHE_FOLDER_NAME}\n`, {
+            encoding: 'utf-8'
+        });
+    }
+    _isIgnoredRelativePath(relativePath, ignoreNonSourceFiles = true) {
+        const normalizedRelative = toPosixRelative(path.normalize(relativePath));
+        const absolutePath = path.resolve(this.projectRoot, normalizedRelative);
+        if (!fs.existsSync(absolutePath)) {
+            log.warn(`File ${absolutePath} not found while evaluating ignore rules; treating as ignored.`);
+            return true;
+        }
+        const stats = fs.statSync(absolutePath);
+        if (stats.isFile() && ignoreNonSourceFiles) {
+            if (this.languageMatcher && !this.languageMatcher.isRelevantFilename(path.basename(absolutePath))) {
+                return true;
+            }
+        }
+        const parts = normalizedRelative.split('/');
+        if (parts.length > 0 && parts[0] === '.git') {
+            return true;
+        }
+        return matchPath(normalizedRelative, this.ignoreMatcher, this.projectRoot);
+    }
+    resolveLanguageMatcher(language) {
+        try {
+            return getLanguageFilenameMatcher(language);
+        }
+        catch (error) {
+            log.warn(`Failed to resolve filename matcher for language ${language}`, error);
+            return null;
+        }
+    }
+}

package/dist/serena/prompt_factory.d.ts

@@ -0,0 +1,20 @@
+import { PromptFactory, type CreateOnboardingPromptParams, type CreateSystemPromptParams } from './generated/generated_prompt_factory.js';
+import type { PromptFactoryBaseOptions } from '../interprompt/prompt_factory.js';
+export interface SerenaPromptFactoryOptions extends Partial<PromptFactoryBaseOptions> {
+    userPromptDir?: string;
+    internalPromptDir?: string;
+}
+export type CreateSystemPromptOptions = CreateSystemPromptParams;
+export type CreateOnboardingPromptOptions = CreateOnboardingPromptParams;
+export declare class SerenaPromptFactory extends PromptFactory {
+    private readonly searchDirectories;
+    constructor(options?: SerenaPromptFactoryOptions);
+    getPromptDirectories(): string[];
+    createSystemPrompt(options: CreateSystemPromptOptions): string;
+    listPromptTemplateNames(): string[];
+    getPromptTemplateParameters(name: string): string[];
+    renderPrompt(name: string, params: Record<string, unknown>): string;
+    hasPromptTemplate(name: string, langCode?: string): boolean;
+    listPromptListNames(): string[];
+    getPromptListByName(name: string): string[];
+}

package/dist/serena/prompt_factory.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import { PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL } from './constants.js';
+import { PromptFactory } from './generated/generated_prompt_factory.js';
+export class SerenaPromptFactory extends PromptFactory {
+    searchDirectories;
+    constructor(options = {}) {
+        const userPromptDir = options.userPromptDir ?? PROMPT_TEMPLATES_DIR_IN_USER_HOME;
+        const internalPromptDir = options.internalPromptDir ?? PROMPT_TEMPLATES_DIR_INTERNAL;
+        fs.mkdirSync(userPromptDir, { recursive: true });
+        const promptsDir = [userPromptDir, internalPromptDir];
+        super({
+            promptsDir,
+            langCode: options.langCode,
+            fallbackMode: options.fallbackMode
+        });
+        this.searchDirectories = [...promptsDir];
+    }
+    getPromptDirectories() {
+        return [...this.searchDirectories];
+    }
+    createSystemPrompt(options) {
+        return super.createSystemPrompt(options);
+    }
+    listPromptTemplateNames() {
+        return this.promptCollection.getPromptTemplateNames();
+    }
+    getPromptTemplateParameters(name) {
+        return this.promptCollection.getPromptTemplateParameters(name);
+    }
+    renderPrompt(name, params) {
+        return this.renderPromptTemplate(name, params);
+    }
+    hasPromptTemplate(name, langCode = this.langCode) {
+        return this.promptCollection.hasPromptTemplate(name, langCode);
+    }
+    listPromptListNames() {
+        return this.promptCollection.getPromptListNames();
+    }
+    getPromptListByName(name) {
+        return this.getPromptList(name).items;
+    }
+}

package/dist/serena/resources/config/contexts/agent.yml

@@ -0,0 +1,8 @@
+description: All tools except InitialInstructionsTool for agent context
+prompt: |
+  You are running in agent context where the system prompt is provided externally. You should use symbolic
+  tools when possible for code understanding and modification.
+excluded_tools:
+  - initial_instructions
+
+tool_description_overrides: {}

package/dist/serena/resources/config/contexts/chatgpt.yml

@@ -0,0 +1,28 @@
+description: A configuration specific for chatgpt, which has a limit of 30 tools and requires short descriptions.
+prompt: |
+  You are running in desktop app context where the tools give you access to the code base as well as some
+  access to the file system, if configured. You interact with the user through a chat interface that is separated
+  from the code base. As a consequence, if you are in interactive mode, your communication with the user should
+  involve high-level thinking and planning as well as some summarization of any code edits that you make.
+  For viewing the code edits the user will view them in a separate code editor window, and the back-and-forth
+  between the chat and the code editor should be minimized as well as facilitated by you.
+  If complex changes have been made, advise the user on how to review them in the code editor.
+  If complex relationships that the user asked for should be visualized or explained, consider creating
+  a diagram in addition to your text-based communication. Note that in the chat interface you have various rendering
+  options for text, html, and mermaid diagrams, as has been explained to you in your initial instructions.
+excluded_tools: []
+included_optional_tools:
+  - switch_modes
+
+tool_description_overrides:
+  find_symbol: |
+    Retrieves symbols matching `name_path` in a file.
+    Use `depth > 0` to include children. `name_path` can be: "foo": any symbol named "foo"; "foo/bar": "bar" within "foo"; "/foo/bar": only top-level "foo/bar"
+  replace_regex: |
+    Replaces text using regular expressions. Preferred for smaller edits where symbol-level tools aren't appropriate.
+    Use wildcards (.*?) to match large sections efficiently: "beginning.*?end" instead of specifying exact content.
+    Essential for multi-line replacements.
+  search_for_pattern: |
+    Flexible pattern search across codebase. Prefer symbolic operations when possible.
+    Uses DOTALL matching. Use non-greedy quantifiers (.*?) to avoid over-matching.
+    Supports file filtering via globs and code-only restriction.

package/dist/serena/resources/config/contexts/codex.yml

@@ -0,0 +1,27 @@
+description: Non-symbolic editing tools and general shell tool are excluded
+prompt: |
+  You are running in IDE assistant context where file operations, basic (line-based) edits and reads, 
+  and shell commands are handled by your own, internal tools.
+  The initial instructions and the current config inform you on which tools are available to you,
+  and how to use them.
+  Don't attempt to use any excluded tools, instead rely on your own internal tools
+  for achieving the basic file or shell operations.
+  
+  If serena's tools can be used for achieving your task, 
+  you should prioritize them. In particular, it is important that you avoid reading entire source code files,
+  unless it is strictly necessary! Instead, for exploring and reading code in a token-efficient manner, 
+  you should use serena's overview and symbolic search tools. The call of the read_file tool on an entire source code 
+  file should only happen in exceptional cases, usually you should first explore the file (by itself or as part of exploring
+  the directory containing it) using the symbol_overview tool, and then make targeted reads using find_symbol and other symbolic tools.
+  For non-code files or for reads where you don't know the symbol's name path you can use the patterns searching tool,
+  using the read_file as a last resort.
+
+excluded_tools:
+  - create_text_file
+  - read_file
+  - execute_shell_command
+  - prepare_for_new_conversation
+  - replace_regex
+
+
+tool_description_overrides: {}

package/dist/serena/resources/config/contexts/context.template.yml

@@ -0,0 +1,11 @@
+# See Serena's documentation for more details on concept of contexts.
+description: Description of the context, not used in the code.
+prompt: Prompt that will form part of the system prompt/initial instructions for agents started in this context.
+excluded_tools: []
+
+# several tools are excluded by default and have to be explicitly included by the user
+included_optional_tools: []
+
+# mapping of tool names to an override of their descriptions (the default description is the docstring of the Tool's apply method).
+# Sometimes, tool descriptions are too long (e.g., for ChatGPT), or users may want to override them for another reason.
+tool_description_overrides: {}

package/dist/serena/resources/config/contexts/desktop-app.yml

@@ -0,0 +1,17 @@
+description: All tools included for desktop app context
+prompt: |
+  You are running in desktop app context where the tools give you access to the code base as well as some
+  access to the file system, if configured. You interact with the user through a chat interface that is separated
+  from the code base. As a consequence, if you are in interactive mode, your communication with the user should
+  involve high-level thinking and planning as well as some summarization of any code edits that you make.
+  For viewing the code edits the user will view them in a separate code editor window, and the back-and-forth
+  between the chat and the code editor should be minimized as well as facilitated by you.
+  If complex changes have been made, advise the user on how to review them in the code editor.
+  If complex relationships that the user asked for should be visualized or explained, consider creating
+  a diagram in addition to your text-based communication. Note that in the chat interface you have various rendering
+  options for text, html, and mermaid diagrams, as has been explained to you in your initial instructions.
+excluded_tools: []
+included_optional_tools:
+  - switch_modes
+
+tool_description_overrides: {}

package/dist/serena/resources/config/contexts/ide-assistant.yml

@@ -0,0 +1,26 @@
+description: Non-symbolic editing tools and general shell tool are excluded
+prompt: |
+  You are running in IDE assistant context where file operations, basic (line-based) edits and reads, 
+  and shell commands are handled by your own, internal tools.
+  The initial instructions and the current config inform you on which tools are available to you,
+  and how to use them.
+  Don't attempt to use any excluded tools, instead rely on your own internal tools
+  for achieving the basic file or shell operations.
+  
+  If serena's tools can be used for achieving your task, 
+  you should prioritize them. In particular, it is important that you avoid reading entire source code files,
+  unless it is strictly necessary! Instead, for exploring and reading code in a token-efficient manner, 
+  you should use serena's overview and symbolic search tools. 
+  Before reading a full file, it is usually best to first explore the file using the symbol_overview tool, 
+  and then make targeted reads using find_symbol and other symbolic tools.
+  For non-code files or for reads where you don't know the symbol's name path, you can use the pattern searching tool,
+  and read full files only as a last resort.
+
+excluded_tools:
+  - create_text_file
+  - read_file
+  - execute_shell_command
+  - prepare_for_new_conversation
+  - replace_regex
+
+tool_description_overrides: {}

package/dist/serena/resources/config/contexts/oaicompat-agent.yml

@@ -0,0 +1,8 @@
+description: All tools except InitialInstructionsTool for agent context, uses OpenAI compatible tool definitions
+prompt: |
+  You are running in agent context where the system prompt is provided externally. You should use symbolic
+  tools when possible for code understanding and modification.
+excluded_tools:
+  - initial_instructions
+
+tool_description_overrides: {}

package/dist/serena/resources/config/internal_modes/jetbrains.yml

@@ -0,0 +1,15 @@
+description: JetBrains tools replace language server-based tools
+prompt: |
+  You have access to the very powerful JetBrains tools for symbolic operations:
+    * `jet_brains_find_symbol` replaces `find_symbol`
+    * `jet_brains_find_referencing_symbols` replaces `find_referencing_symbols`
+    * `jet_brains_get_symbols_overview` replaces `get_symbols_overview`
+excluded_tools:
+  - find_symbol
+  - find_referencing_symbols
+  - get_symbols_overview
+  - restart_language_server
+included_optional_tools:
+  - jet_brains_find_symbol
+  - jet_brains_find_referencing_symbols
+  - jet_brains_get_symbols_overview