@nogataka/smart-edit 0.0.14

package/dist/serena/resources/serena_config.template.yml

@@ -0,0 +1,85 @@
+gui_log_window: False
+# whether to open a graphical window with Serena's logs.
+# This is mainly supported on Windows and (partly) on Linux; not available on macOS.
+# If you want to see the logs in a web browser, use the `web_dashboard` option instead.
+# Limitations: doesn't seem to work with the community version of Claude Desktop for Linux
+# Might also cause problems with some MCP clients - if you have any issues, try disabling this
+
+# Being able to inspect logs is useful both for troubleshooting and for monitoring the tool calls,
+# especially when using the agno playground, since the tool calls are not always shown,
+# and the input params are never shown in the agno UI.
+# When used as MCP server for Claude Desktop, the logs are primarily for troubleshooting.
+# Note: unfortunately, the various entities starting the Serena server or agent do so in
+# mysterious ways, often starting multiple instances of the process without shutting down
+# previous instances. This can lead to multiple log windows being opened, and only the last
+# window being updated. Since we can't control how agno or Claude Desktop start Serena,
+# we have to live with this limitation for now.
+
+web_dashboard: True
+# whether to open the Serena web dashboard (which will be accessible through your web browser) that
+# shows Serena's current session logs - as an alternative to the GUI log window which
+# is supported on all platforms.
+
+web_dashboard_open_on_launch: True
+# whether to open a browser window with the web dashboard when Serena starts (provided that web_dashboard
+# is enabled). If set to False, you can still open the dashboard manually by navigating to
+# http://localhost:24282/dashboard/ in your web browser (24282 = 0x5EDA, SErena DAshboard).
+# If you have multiple instances running, a higher port will be used; try port 24283, 24284, etc.
+
+log_level: 20
+# the minimum log level for the GUI log window and the dashboard (10 = debug, 20 = info, 30 = warning, 40 = error)
+
+trace_lsp_communication: False
+# whether to trace the communication between Serena and the language servers.
+# This is useful for debugging language server issues.
+
+ls_specific_settings: {}
+# Added on 23.08.2025
+# Advanced configuration option allowing to configure language server implementation specific options. Maps the language
+# (same entry as in project.yml) to the options.
+# Have a look at the docstring of the constructors of the LS implementations within solidlsp (e.g., for C# or PHP) to see which options are available.
+# No documentation on options means no options are available.
+#
+
+tool_timeout: 240
+# timeout, in seconds, after which tool executions are terminated
+
+excluded_tools: []
+# list of tools to be globally excluded
+
+included_optional_tools: []
+# list of optional tools (which are disabled by default) to be included
+
+jetbrains: False
+# whether to enable JetBrains mode and use tools based on the Serena JetBrains IDE plugin
+# instead of language server-based tools
+# NOTE: The plugin is yet unreleased. This is for Serena developers only.
+
+
+default_max_tool_answer_chars: 150000
+# Used as default for tools where the apply method has a default maximal answer length.
+# Even though the value of the max_answer_chars can be changed when calling the tool, it may make sense to adjust this default
+# through the global configuration.
+
+record_tool_usage_stats:  False
+# whether to record tool usage statistics, they will be shown in the web dashboard if recording is active.
+
+token_count_estimator: TIKTOKEN_GPT4O
+# Only relevant if `record_tool_usage` is True; the name of the token count estimator to use for tool usage statistics.
+# See the `RegisteredTokenCountEstimator` enum for available options.
+#
+# Note: some token estimators (like tiktoken) may require downloading data files
+# on the first run, which can take some time and require internet access. Others, like the Anthropic ones, may require an API key
+# and rate limits may apply.
+
+
+# MANAGED BY SERENA, KEEP AT THE BOTTOM OF THE YAML AND DON'T EDIT WITHOUT NEED
+# The list of registered projects.
+# To add a project, within a chat, simply ask Serena to "activate the project /path/to/project" or,
+# if the project was previously added, "activate the project <project name>".
+# By default, the project's name will be the name of the directory containing the project, but you may change it
+# by editing the (auto-generated) project configuration file `/path/project/project/.smart-edit/project.yml` file.
+# If you want to maintain full control of the project configuration, create the project.yml file manually and then
+# instruct Serena to activate the project by its path for first-time activation.
+# NOTE: Make sure there are no name collisions in the names of registered projects.
+projects: []

package/dist/serena/symbol.d.ts

@@ -0,0 +1,199 @@
+import type { SerenaAgent } from './agent.js';
+import type { SolidLanguageServer, ReferenceInSymbol, UnifiedSymbolInformation } from '../solidlsp/ls.js';
+export interface LspPosition {
+    line: number;
+    character: number;
+}
+export declare enum SymbolKind {
+    File = 1,
+    Module = 2,
+    Namespace = 3,
+    Package = 4,
+    Class = 5,
+    Method = 6,
+    Property = 7,
+    Field = 8,
+    Constructor = 9,
+    Enum = 10,
+    Interface = 11,
+    Function = 12,
+    Variable = 13,
+    Constant = 14,
+    String = 15,
+    Number = 16,
+    Boolean = 17,
+    Array = 18,
+    Object = 19,
+    Key = 20,
+    Null = 21,
+    EnumMember = 22,
+    Struct = 23,
+    Event = 24,
+    Operator = 25,
+    TypeParameter = 26
+}
+export interface LanguageServerSymbolLocationInit {
+    relativePath: string | null;
+    line: number | null;
+    column: number | null;
+}
+export declare class LanguageServerSymbolLocation {
+    readonly relativePath: string | null;
+    readonly line: number | null;
+    readonly column: number | null;
+    constructor(init: LanguageServerSymbolLocationInit);
+    toDict(options?: {
+        includeRelativePath?: boolean;
+    }): Record<string, unknown>;
+    to_dict(options?: {
+        include_relative_path?: boolean;
+    }): Record<string, unknown>;
+    hasPositionInFile(): boolean;
+    has_position_in_file(): boolean;
+}
+export interface PositionInFileInit {
+    line: number;
+    col: number;
+}
+export declare class PositionInFile {
+    readonly line: number;
+    readonly col: number;
+    constructor(init: PositionInFileInit);
+    toLspPosition(): LspPosition;
+    to_lsp_position(): LspPosition;
+}
+export declare abstract class Symbol {
+    abstract getBodyStartPosition(): PositionInFile | null;
+    abstract getBodyEndPosition(): PositionInFile | null;
+    abstract isNeighbouringDefinitionSeparatedByEmptyLine(): boolean;
+    getBodyStartPositionOrRaise(): PositionInFile;
+    getBodyEndPositionOrRaise(): PositionInFile;
+    get_body_start_position(): PositionInFile | null;
+    get_body_end_position(): PositionInFile | null;
+    get_body_start_position_or_raise(): PositionInFile;
+    get_body_end_position_or_raise(): PositionInFile;
+    is_neighbouring_definition_separated_by_empty_line(): boolean;
+}
+export interface SymbolRangeLike {
+    start?: {
+        line: number;
+        character: number;
+    };
+    end?: {
+        line: number;
+        character: number;
+    };
+}
+export interface SymbolLocationLike {
+    relativePath?: string | null;
+    range?: SymbolRangeLike;
+}
+export declare class LanguageServerSymbol extends Symbol {
+    private static readonly NAME_PATH_SEPARATOR;
+    private readonly symbolRoot;
+    constructor(symbolRoot: UnifiedSymbolInformation);
+    static matchNamePath(namePath: string, symbolNamePathParts: string[], substringMatching: boolean): boolean;
+    get name(): string;
+    get kind(): string;
+    get symbolKind(): SymbolKind;
+    get relativePath(): string | null;
+    get location(): LanguageServerSymbolLocation;
+    get body(): string | undefined;
+    get line(): number | null;
+    get column(): number | null;
+    isNeighbouringDefinitionSeparatedByEmptyLine(): boolean;
+    getBodyStartPosition(): PositionInFile | null;
+    getBodyEndPosition(): PositionInFile | null;
+    getBodyLineNumbers(): [number | null, number | null];
+    getBodyStartPositionOrRaise(): PositionInFile;
+    getBodyEndPositionOrRaise(): PositionInFile;
+    get_name_path(): string;
+    getNamePath(): string;
+    getNamePathParts(): string[];
+    get_name_path_parts(): string[];
+    iterChildren(): IterableIterator<LanguageServerSymbol>;
+    iter_children(): IterableIterator<LanguageServerSymbol>;
+    iterAncestors(upToSymbolKind?: SymbolKind): IterableIterator<LanguageServerSymbol>;
+    iter_ancestors(upToSymbolKind?: SymbolKind): IterableIterator<LanguageServerSymbol>;
+    getParent(): LanguageServerSymbol | null;
+    get_parent(): LanguageServerSymbol | null;
+    find(namePath: string, options?: {
+        substringMatching?: boolean;
+        includeKinds?: SymbolKind[] | number[];
+        excludeKinds?: SymbolKind[] | number[];
+    }): LanguageServerSymbol[];
+    find_symbols(namePath: string, substringMatching?: boolean, includeKinds?: SymbolKind[] | number[], excludeKinds?: SymbolKind[] | number[]): LanguageServerSymbol[];
+    toDict(options?: {
+        kind?: boolean;
+        location?: boolean;
+        depth?: number;
+        includeBody?: boolean;
+        includeChildrenBody?: boolean;
+        includeRelativePath?: boolean;
+    }): Record<string, unknown>;
+    to_dict(options?: {
+        kind?: boolean;
+        location?: boolean;
+        depth?: number;
+        include_body?: boolean;
+        include_children_body?: boolean;
+        include_relative_path?: boolean;
+    }): Record<string, unknown>;
+    private collectChildren;
+}
+export declare class ReferenceInLanguageServerSymbol {
+    readonly symbol: LanguageServerSymbol;
+    readonly line: number;
+    readonly character: number;
+    constructor(init: {
+        symbol: LanguageServerSymbol;
+        line: number;
+        character: number;
+    });
+    static fromLspReference(reference: ReferenceInSymbol): ReferenceInLanguageServerSymbol;
+    get_relative_path(): string | null;
+}
+export interface SymbolOverviewEntry {
+    name_path: string;
+    kind: number;
+}
+export interface FindSymbolOptions {
+    includeBody?: boolean;
+    includeKinds?: number[] | SymbolKind[];
+    excludeKinds?: number[] | SymbolKind[];
+    substringMatching?: boolean;
+    withinRelativePath?: string | null;
+}
+export declare class LanguageServerSymbolRetriever {
+    private _langServer;
+    private readonly agent;
+    constructor(langServer: SolidLanguageServer, agent?: SerenaAgent | null);
+    setLanguageServer(langServer: SolidLanguageServer): void;
+    set_language_server(langServer: SolidLanguageServer): void;
+    getLanguageServer(): SolidLanguageServer;
+    get_language_server(): SolidLanguageServer;
+    findByName(namePath: string, options?: FindSymbolOptions): LanguageServerSymbol[];
+    find_by_name(namePath: string, includeBody?: boolean, includeKinds?: number[] | SymbolKind[], excludeKinds?: number[] | SymbolKind[], substringMatching?: boolean, withinRelativePath?: string | null): LanguageServerSymbol[];
+    getDocumentSymbols(relativePath: string): LanguageServerSymbol[];
+    get_document_symbols(relativePath: string): LanguageServerSymbol[];
+    findByLocation(location: LanguageServerSymbolLocation): LanguageServerSymbol | null;
+    find_by_location(location: LanguageServerSymbolLocation): LanguageServerSymbol | null;
+    findReferencingSymbols(namePath: string, relativeFilePath: string, options?: FindSymbolOptions): ReferenceInLanguageServerSymbol[];
+    find_referencing_symbols(namePath: string, relativeFilePath: string, includeBody?: boolean, includeKinds?: number[] | SymbolKind[], excludeKinds?: number[] | SymbolKind[]): ReferenceInLanguageServerSymbol[];
+    findReferencingSymbolsByLocation(location: LanguageServerSymbolLocation, options?: FindSymbolOptions): ReferenceInLanguageServerSymbol[];
+    find_referencing_symbols_by_location(location: LanguageServerSymbolLocation, includeBody?: boolean, includeKinds?: number[] | SymbolKind[], excludeKinds?: number[] | SymbolKind[]): ReferenceInLanguageServerSymbol[];
+    private static symbolOverviewFromSymbol;
+    getSymbolOverview(relativePath: string): Record<string, SymbolOverviewEntry[]>;
+    get_symbol_overview(relativePath: string): Record<string, SymbolOverviewEntry[]>;
+}
+export declare class JetBrainsSymbol extends Symbol {
+    private readonly data;
+    constructor(symbolDict: Record<string, unknown>);
+    private ensureTextRange;
+    getBodyStartPosition(): PositionInFile | null;
+    getBodyEndPosition(): PositionInFile | null;
+    isNeighbouringDefinitionSeparatedByEmptyLine(): boolean;
+}
+export declare class JetBrainsCodeEditorNotAvailableError extends Error {
+    constructor();
+}