@nogataka/smart-edit 0.1.0 → 1.0.1

package/dist/{serena → smart-edit}/mcp.d.ts

@@ -5,23 +5,23 @@ import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
 import { type Implementation } from '@modelcontextprotocol/sdk/types.js';
 import { type IncomingMessage, type ServerResponse, type Server as HttpServer } from 'node:http';
 import type { URL as NodeURLType } from 'node:url';
-import { SerenaAgentContext, SerenaAgentMode } from './config/context_mode.js';
-import { SerenaConfig } from './config/serena_config.js';
-import { createSerenaLogger } from './util/logging.js';
+import { SmartEditAgentContext, SmartEditAgentMode } from './config/context_mode.js';
+import { SmartEditConfig } from './config/smart_edit_config.js';
+import { createSmartEditLogger } from './util/logging.js';
 import type { MemoryLogHandler } from './util/logging.js';
-import type { SerenaAgentLike, Tool } from './tools/tools_base.js';
-export interface SerenaMCPRequestContext {
-    agent: SerenaAgentLike;
+import type { SmartEditAgentLike, Tool } from './tools/tools_base.js';
+export interface SmartEditMCPRequestContext {
+    agent: SmartEditAgentLike;
 }
-export interface SerenaAgentFactoryOptions {
+export interface SmartEditAgentFactoryOptions {
     project: string | null;
-    serenaConfig: SerenaConfig;
-    context: SerenaAgentContext;
-    modes: SerenaAgentMode[];
+    smartEditConfig: SmartEditConfig;
+    context: SmartEditAgentContext;
+    modes: SmartEditAgentMode[];
     memoryLogHandler?: MemoryLogHandler | null;
 }
-export type SerenaAgentFactory = (options: SerenaAgentFactoryOptions) => SerenaAgentLike;
-export interface SerenaMCPServerOptions {
+export type SmartEditAgentFactory = (options: SmartEditAgentFactoryOptions) => SmartEditAgentLike;
+export interface SmartEditMCPServerOptions {
     host?: string;
     port?: number;
     modes?: Iterable<string>;
@@ -34,35 +34,35 @@ export interface SerenaMCPServerOptions {
     serverInfo?: Implementation;
     serverOptions?: ServerOptions;
 }
-export type SerenaHttpRequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export interface SerenaHttpServerOptions extends SerenaMCPServerOptions {
+export type SmartEditHttpRequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export interface SmartEditHttpServerOptions extends SmartEditMCPServerOptions {
     path?: string;
     transportOptions?: Partial<StreamableHTTPServerTransportOptions>;
     sessionIdGenerator?: (() => string) | null;
 }
-export interface SerenaHttpServerInstance {
+export interface SmartEditHttpServerInstance {
     httpServer: HttpServer;
     transport: StreamableHTTPServerTransport;
     mcpServer: McpServer;
     url: NodeURLType;
     close(): Promise<void>;
 }
-export interface SerenaGrpcServerOptions extends SerenaMCPServerOptions {
+export interface SmartEditGrpcServerOptions extends SmartEditMCPServerOptions {
     address?: string;
 }
-export declare abstract class SerenaMCPFactory {
-    protected readonly context: SerenaAgentContext;
+export declare abstract class SmartEditMCPFactory {
+    protected readonly context: SmartEditAgentContext;
     protected readonly project: string | null;
     private agent;
     private requestContext;
     protected constructor(context?: string, project?: string | null);
-    protected getAgent(): SerenaAgentLike;
-    protected setAgent(agent: SerenaAgentLike): void;
-    protected getRequestContext(): SerenaMCPRequestContext;
+    protected getAgent(): SmartEditAgentLike;
+    protected setAgent(agent: SmartEditAgentLike): void;
+    protected getRequestContext(): SmartEditMCPRequestContext;
     protected abstract instantiateAgent(options: {
-        serenaConfig: SerenaConfig;
-        modes: SerenaAgentMode[];
-    }): SerenaAgentLike;
+        smartEditConfig: SmartEditConfig;
+        modes: SmartEditAgentMode[];
+    }): SmartEditAgentLike;
     protected abstract iterTools(): Iterable<Tool>;
     protected abstract getInitialInstructions(): string;
     protected isOpenAiCompatibleContext(): boolean;
@@ -82,37 +82,37 @@ export declare abstract class SerenaMCPFactory {
     private isIterable;
     protected registerTools(server: McpServer, openAiToolCompatible: boolean): void;
     private registerTool;
-    createMcpServer(options?: SerenaMCPServerOptions): McpServer;
-    protected getLogger(): ReturnType<typeof createSerenaLogger>['logger'];
+    createMcpServer(options?: SmartEditMCPServerOptions): McpServer;
+    protected getLogger(): ReturnType<typeof createSmartEditLogger>['logger'];
 }
-export interface SerenaMCPFactorySingleProcessOptions {
+export interface SmartEditMCPFactorySingleProcessOptions {
     context?: string;
     project?: string | null;
     memoryLogHandler?: MemoryLogHandler | null;
-    agentFactory?: SerenaAgentFactory;
+    agentFactory?: SmartEditAgentFactory;
 }
-export declare class SerenaMCPFactorySingleProcess extends SerenaMCPFactory {
+export declare class SmartEditMCPFactorySingleProcess extends SmartEditMCPFactory {
     private readonly memoryLogHandler;
     private readonly agentFactory?;
     private cachedTools;
-    constructor(options?: SerenaMCPFactorySingleProcessOptions);
-    protected instantiateAgent({ serenaConfig, modes }: {
-        serenaConfig: SerenaConfig;
-        modes: SerenaAgentMode[];
-    }): SerenaAgentLike;
+    constructor(options?: SmartEditMCPFactorySingleProcessOptions);
+    protected instantiateAgent({ smartEditConfig, modes }: {
+        smartEditConfig: SmartEditConfig;
+        modes: SmartEditAgentMode[];
+    }): SmartEditAgentLike;
     protected iterTools(): Iterable<Tool>;
     protected getInitialInstructions(): string;
 }
-export declare function createSerenaHttpRequestHandler({ transport, path, defaultHost }: {
+export declare function createSmartEditHttpRequestHandler({ transport, path, defaultHost }: {
     transport: StreamableHTTPServerTransport;
     path?: string;
     defaultHost?: string;
-}): SerenaHttpRequestHandler;
-export declare function createSerenaHttpServer(factory: SerenaMCPFactory, options?: SerenaHttpServerOptions): Promise<SerenaHttpServerInstance>;
-export interface SerenaStdioServerInstance {
+}): SmartEditHttpRequestHandler;
+export declare function createSmartEditHttpServer(factory: SmartEditMCPFactory, options?: SmartEditHttpServerOptions): Promise<SmartEditHttpServerInstance>;
+export interface SmartEditStdioServerInstance {
     transport: StdioServerTransport;
     mcpServer: McpServer;
     close(): Promise<void>;
 }
-export declare function createSerenaStdioServer(factory: SerenaMCPFactory, options?: SerenaMCPServerOptions): Promise<SerenaStdioServerInstance>;
-export declare function createSerenaGrpcServer(_factory: SerenaMCPFactory, _options?: SerenaGrpcServerOptions): Promise<never>;
+export declare function createSmartEditStdioServer(factory: SmartEditMCPFactory, options?: SmartEditMCPServerOptions): Promise<SmartEditStdioServerInstance>;
+export declare function createSmartEditGrpcServer(_factory: SmartEditMCPFactory, _options?: SmartEditGrpcServerOptions): Promise<never>;

package/dist/{serena → smart-edit}/mcp.js

@@ -8,15 +8,15 @@ import { URL as NodeURL } from 'node:url';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { DEFAULT_CONTEXT, DEFAULT_MODES } from './constants.js';
-import { SerenaAgentContext, SerenaAgentMode } from './config/context_mode.js';
-import { SerenaConfig } from './config/serena_config.js';
+import { SmartEditAgentContext, SmartEditAgentMode } from './config/context_mode.js';
+import { SmartEditConfig } from './config/smart_edit_config.js';
 import { createRequire } from 'node:module';
 import { showFatalExceptionSafe } from './util/exception.js';
-import { createSerenaLogger } from './util/logging.js';
-import { SerenaAgent } from './agent.js';
+import { createSmartEditLogger } from './util/logging.js';
+import { SmartEditAgent } from './agent.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
-const { logger: log } = createSerenaLogger({ name: 'smart-edit.mcp' });
+const { logger: log } = createSmartEditLogger({ name: 'smart-edit.mcp' });
 function unwrapZodObject(schema) {
     if (!schema) {
         return undefined;
@@ -202,9 +202,9 @@ function registerToolWithServer(server, options) {
         registered.update({ outputSchema: options.outputSchema });
     }
     const serverWithTracking = server;
-    serverWithTracking.__serenaRegisteredTools ??= new Map();
+    serverWithTracking.__smartEditRegisteredTools ??= new Map();
     const annotations = options.annotations && Object.keys(options.annotations).length > 0 ? options.annotations : undefined;
-    serverWithTracking.__serenaRegisteredTools.set(options.name, {
+    serverWithTracking.__smartEditRegisteredTools.set(options.name, {
         description: options.description,
         annotations,
         _meta: undefined,
@@ -212,18 +212,18 @@ function registerToolWithServer(server, options) {
     });
     return registered;
 }
-export class SerenaMCPFactory {
+export class SmartEditMCPFactory {
     context;
     project;
     agent = null;
     requestContext = null;
     constructor(context = DEFAULT_CONTEXT, project = null) {
-        this.context = SerenaAgentContext.load(context);
+        this.context = SmartEditAgentContext.load(context);
         this.project = project ?? null;
     }
     getAgent() {
         if (!this.agent) {
-            throw new Error('Serena agent has not been instantiated yet.');
+            throw new Error('Smart-Edit agent has not been instantiated yet.');
         }
         return this.agent;
     }
@@ -323,7 +323,7 @@ export class SerenaMCPFactory {
         return names.map((name) => ({
             uri: this.formatMemoryUri(name),
             name,
-            description: 'Serena project memory entry',
+            description: 'Smart-Edit project memory entry',
             mimeType: 'text/markdown'
         }));
     }
@@ -333,9 +333,9 @@ export class SerenaMCPFactory {
         }
         return [
             {
-                name: 'serena-memory',
-                uriTemplate: 'serena://memory/{name}',
-                description: 'Template for accessing Serena project memory entries',
+                name: 'smart-edit-memory',
+                uriTemplate: 'smart-edit://memory/{name}',
+                description: 'Template for accessing Smart-Edit project memory entries',
                 mimeType: 'text/markdown'
             }
         ];
@@ -360,10 +360,10 @@ export class SerenaMCPFactory {
         };
     }
     parseMemoryUri(uri) {
-        if (!uri.toLowerCase().startsWith('serena://memory/')) {
+        if (!uri.toLowerCase().startsWith('smart-edit://memory/')) {
             return null;
         }
-        const suffix = uri.slice('serena://memory/'.length);
+        const suffix = uri.slice('smart-edit://memory/'.length);
         if (!suffix) {
             return null;
         }
@@ -375,7 +375,7 @@ export class SerenaMCPFactory {
         }
     }
     formatMemoryUri(name) {
-        return `serena://memory/${encodeURIComponent(name)}`;
+        return `smart-edit://memory/${encodeURIComponent(name)}`;
     }
     async listMemories(manager) {
         const listFn = this.bindManagerFunction(manager, ['listMemories', 'list_memories']);
@@ -474,9 +474,9 @@ export class SerenaMCPFactory {
             : undefined;
         const annotations = openAiToolCompatible
             ? {
-                'serena/openaiToolCompatible': true,
-                ...(inputJsonSchema ? { 'serena/openaiToolInputSchema': inputJsonSchema } : {}),
-                ...(outputJsonSchema ? { 'serena/openaiToolOutputSchema': outputJsonSchema } : {})
+                'smart-edit/openaiToolCompatible': true,
+                ...(inputJsonSchema ? { 'smart-edit/openaiToolInputSchema': inputJsonSchema } : {}),
+                ...(outputJsonSchema ? { 'smart-edit/openaiToolOutputSchema': outputJsonSchema } : {})
             }
             : undefined;
         const callback = async (args, extra) => {
@@ -552,7 +552,7 @@ export class SerenaMCPFactory {
     }
     createMcpServer(options = {}) {
         try {
-            const config = SerenaConfig.fromConfigFile();
+            const config = SmartEditConfig.fromConfigFile();
             if (options.enableWebDashboard !== undefined && options.enableWebDashboard !== null) {
                 config.webDashboard = options.enableWebDashboard;
             }
@@ -571,9 +571,9 @@ export class SerenaMCPFactory {
                 config.toolTimeout = options.toolTimeout;
             }
             const modesInput = options.modes ? Array.from(options.modes) : Array.from(DEFAULT_MODES);
-            const modes = modesInput.map((mode) => SerenaAgentMode.load(mode));
+            const modes = modesInput.map((mode) => SmartEditAgentMode.load(mode));
             const agent = this.instantiateAgent({
-                serenaConfig: config,
+                smartEditConfig: config,
                 modes
             });
             this.setAgent(agent);
@@ -606,7 +606,7 @@ const LOG_LEVEL_MAP = {
     ERROR: 40,
     CRITICAL: 50
 };
-export class SerenaMCPFactorySingleProcess extends SerenaMCPFactory {
+export class SmartEditMCPFactorySingleProcess extends SmartEditMCPFactory {
     memoryLogHandler;
     agentFactory;
     cachedTools = null;
@@ -615,21 +615,21 @@ export class SerenaMCPFactorySingleProcess extends SerenaMCPFactory {
         this.memoryLogHandler = options.memoryLogHandler ?? null;
         this.agentFactory =
             options.agentFactory ??
-                ((factoryOptions) => new SerenaAgent({
+                ((factoryOptions) => new SmartEditAgent({
                     project: factoryOptions.project,
-                    serenaConfig: factoryOptions.serenaConfig,
+                    smartEditConfig: factoryOptions.smartEditConfig,
                     context: factoryOptions.context,
                     modes: factoryOptions.modes,
                     memoryLogHandler: factoryOptions.memoryLogHandler ?? undefined
                 }));
     }
-    instantiateAgent({ serenaConfig, modes }) {
+    instantiateAgent({ smartEditConfig, modes }) {
         if (!this.agentFactory) {
-            throw new Error('SerenaAgent factory not provided. Inject a factory via SerenaMCPFactorySingleProcessOptions.agentFactory once the agent implementation is available.');
+            throw new Error('SmartEditAgent factory not provided. Inject a factory via SmartEditMCPFactorySingleProcessOptions.agentFactory once the agent implementation is available.');
         }
         const agent = this.agentFactory({
             project: this.project,
-            serenaConfig,
+            smartEditConfig,
             context: this.context,
             modes,
             memoryLogHandler: this.memoryLogHandler
@@ -710,7 +710,7 @@ function respondWithJson(res, statusCode, body) {
     });
     res.end(JSON.stringify(body));
 }
-export function createSerenaHttpRequestHandler({ transport, path, defaultHost }) {
+export function createSmartEditHttpRequestHandler({ transport, path, defaultHost }) {
     const normalizedPath = normalizeHttpPath(path);
     const fallbackHost = defaultHost ?? '127.0.0.1';
     return async (req, res) => {
@@ -793,7 +793,7 @@ function deriveServerUrl(address, path, fallbackHost) {
     const resolvedHost = host === '::' || host === '0.0.0.0' ? fallbackHost : host;
     return new NodeURL(`http://${resolvedHost}:${address.port}${path}`);
 }
-export async function createSerenaHttpServer(factory, options = {}) {
+export async function createSmartEditHttpServer(factory, options = {}) {
     const host = options.host ?? '127.0.0.1';
     const port = options.port ?? 0;
     const path = normalizeHttpPath(options.path);
@@ -807,7 +807,7 @@ export async function createSerenaHttpServer(factory, options = {}) {
     });
     const mcpServer = factory.createMcpServer(options);
     await mcpServer.connect(httpTransport);
-    const handler = createSerenaHttpRequestHandler({
+    const handler = createSmartEditHttpRequestHandler({
         transport: httpTransport,
         path,
         defaultHost: host
@@ -829,7 +829,7 @@ export async function createSerenaHttpServer(factory, options = {}) {
         }
     };
 }
-class SerenaStdioServerTransport extends StdioServerTransport {
+class SmartEditStdioServerTransport extends StdioServerTransport {
     stdin;
     handleStreamEnd;
     handleStreamClose;
@@ -881,8 +881,8 @@ class SerenaStdioServerTransport extends StdioServerTransport {
         this.onerror?.(new Error(message));
     }
 }
-export async function createSerenaStdioServer(factory, options = {}) {
-    const transport = new SerenaStdioServerTransport();
+export async function createSmartEditStdioServer(factory, options = {}) {
+    const transport = new SmartEditStdioServerTransport();
     const mcpServer = factory.createMcpServer(options);
     await mcpServer.connect(transport);
     return {
@@ -893,12 +893,12 @@ export async function createSerenaStdioServer(factory, options = {}) {
         }
     };
 }
-export async function createSerenaGrpcServer(_factory, _options = {}) {
+export async function createSmartEditGrpcServer(_factory, _options = {}) {
     try {
         await import('@grpc/grpc-js');
     }
     catch (error) {
-        throw new Error('gRPCトランスポートPoCは未実装です。@grpc/grpc-js を導入後に createSerenaGrpcServer を拡張してください。', { cause: error });
+        throw new Error('gRPCトランスポートPoCは未実装です。@grpc/grpc-js を導入後に createSmartEditGrpcServer を拡張してください。', { cause: error });
     }
-    throw new Error('gRPCトランスポートPoCは未実装です。HTTPモードのPoCは createSerenaHttpServer を利用してください。');
+    throw new Error('gRPCトランスポートPoCは未実装です。HTTPモードのPoCは createSmartEditHttpServer を利用してください。');
 }

package/dist/{serena → smart-edit}/project.d.ts

@@ -1,8 +1,8 @@
 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';
+import { ProjectConfig, type ProjectLike } from './config/smart_edit_config.js';
+import { SmartLanguageServer } from '../smart-lsp/ls.js';
+import type { Language } from '../smart-lsp/ls_config.js';
 export interface ProjectSearchOptions {
     pattern: string;
     relative_path?: string;
@@ -33,8 +33,8 @@ export declare class Project implements ProjectLike {
     get projectName(): string;
     get project_name(): string;
     get language(): Language;
-    pathToSerenaDataFolder(): string;
-    path_to_serena_data_folder(): string;
+    pathToSmartEditDataFolder(): string;
+    path_to_smart_edit_data_folder(): string;
     pathToProjectYml(): string;
     path_to_project_yml(): string;
     readFile(relativePath: string): string;
@@ -55,8 +55,8 @@ export declare class Project implements ProjectLike {
     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;
+    createLanguageServer(options: CreateLanguageServerOptions): SmartLanguageServer;
+    private ensureSmartEditDataGitignore;
     private _isIgnoredRelativePath;
     private resolveLanguageMatcher;
 }

package/dist/{serena → smart-edit}/project.js

@@ -2,14 +2,14 @@ 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 { createSmartEditLogger } 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: 'smart-edit.project', emitToConsole: true, level: 'info' });
+import { DEFAULT_TOOL_TIMEOUT, ProjectConfig } from './config/smart_edit_config.js';
+import { SMART_EDIT_MANAGED_DIR_IN_HOME, SMART_EDIT_MANAGED_DIR_NAME } from './constants.js';
+import { SmartLanguageServer } from '../smart-lsp/ls.js';
+import { getLanguageFilenameMatcher } from '../smart-lsp/ls_config.js';
+const { logger: log } = createSmartEditLogger({ name: 'smart-edit.project', emitToConsole: true, level: 'info' });
 class IgnoreMatcher {
     engine;
     constructor(patterns) {
@@ -60,7 +60,7 @@ export class Project {
         this.projectRoot = path.resolve(init.projectRoot);
         this.projectConfig = init.projectConfig;
         this.isNewlyCreated = init.isNewlyCreated ?? false;
-        this.ensureSerenaDataGitignore();
+        this.ensureSmartEditDataGitignore();
         const patterns = new Set();
         for (const pattern of this.projectConfig.ignoredPaths) {
             if (pattern) {
@@ -97,11 +97,11 @@ export class Project {
     get language() {
         return this.projectConfig.language;
     }
-    pathToSerenaDataFolder() {
-        return path.join(this.projectRoot, SERENA_MANAGED_DIR_NAME);
+    pathToSmartEditDataFolder() {
+        return path.join(this.projectRoot, SMART_EDIT_MANAGED_DIR_NAME);
     }
-    path_to_serena_data_folder() {
-        return this.pathToSerenaDataFolder();
+    path_to_smart_edit_data_folder() {
+        return this.pathToSmartEditDataFolder();
     }
     pathToProjectYml() {
         return path.join(this.projectRoot, ProjectConfig.relPathToProjectYml());
@@ -265,28 +265,28 @@ export class Project {
     }
     createLanguageServer(options) {
         const lsTimeout = options.lsTimeout === undefined ? DEFAULT_TOOL_TIMEOUT - 5 : options.lsTimeout;
-        return SolidLanguageServer.create({
+        return SmartLanguageServer.create({
             codeLanguage: this.projectConfig.language,
             traceLspCommunication: options.traceLspCommunication,
             startIndependentLspProcess: true,
             ignoredPaths: this.projectConfig.ignoredPaths
         }, { level: options.logLevel }, this.projectRoot, {
             timeout: lsTimeout,
-            solidlspSettings: {
+            smartLspSettings: {
                 lsSpecificSettings: options.lsSpecificSettings ?? {},
-                solidlspDir: SERENA_MANAGED_DIR_IN_HOME,
-                projectDataRelativePath: SERENA_MANAGED_DIR_NAME
+                smartLspDir: SMART_EDIT_MANAGED_DIR_IN_HOME,
+                projectDataRelativePath: SMART_EDIT_MANAGED_DIR_NAME
             }
         });
     }
-    ensureSerenaDataGitignore() {
-        const gitignorePath = path.join(this.pathToSerenaDataFolder(), '.gitignore');
+    ensureSmartEditDataGitignore() {
+        const gitignorePath = path.join(this.pathToSmartEditDataFolder(), '.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`, {
+        fs.writeFileSync(gitignorePath, `/${SmartLanguageServer.CACHE_FOLDER_NAME}\n`, {
             encoding: 'utf-8'
         });
     }

package/dist/{serena → smart-edit}/prompt_factory.d.ts

@@ -1,14 +1,14 @@
 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> {
+export interface SmartEditPromptFactoryOptions extends Partial<PromptFactoryBaseOptions> {
     userPromptDir?: string;
     internalPromptDir?: string;
 }
 export type CreateSystemPromptOptions = CreateSystemPromptParams;
 export type CreateOnboardingPromptOptions = CreateOnboardingPromptParams;
-export declare class SerenaPromptFactory extends PromptFactory {
+export declare class SmartEditPromptFactory extends PromptFactory {
     private readonly searchDirectories;
-    constructor(options?: SerenaPromptFactoryOptions);
+    constructor(options?: SmartEditPromptFactoryOptions);
     getPromptDirectories(): string[];
     createSystemPrompt(options: CreateSystemPromptOptions): string;
     listPromptTemplateNames(): string[];

package/dist/{serena → smart-edit}/prompt_factory.js

@@ -1,7 +1,7 @@
 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 {
+export class SmartEditPromptFactory extends PromptFactory {
     searchDirectories;
     constructor(options = {}) {
         const userPromptDir = options.userPromptDir ?? PROMPT_TEMPLATES_DIR_IN_USER_HOME;

package/dist/{serena → smart-edit}/resources/config/contexts/codex.yml

@@ -7,10 +7,10 @@ prompt: |
   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, 
+  If smart-edit'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 
+  you should use smart-edit'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,

package/dist/{serena → smart-edit}/resources/config/contexts/context.template.yml

@@ -1,4 +1,4 @@
-# See Serena's documentation for more details on concept of contexts.
+# See Smart-Edit'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: []

package/dist/{serena → smart-edit}/resources/config/contexts/ide-assistant.yml

@@ -7,10 +7,10 @@ prompt: |
   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, 
+  If smart-edit'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. 
+  you should use smart-edit'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,

package/dist/{serena → smart-edit}/resources/config/modes/mode.template.yml

@@ -1,4 +1,4 @@
-# See Serena's documentation for more details on concept of modes.
+# See Smart-Edit's documentation for more details on concept of modes.
 description: Description of the mode, not used in the code.
 prompt: Prompt that will form part of the message sent to the model when activating this mode.
 excluded_tools: []

package/dist/{serena → smart-edit}/resources/config/prompt_templates/simple_tool_outputs.yml

@@ -1,4 +1,4 @@
-# Some of Serena's tools are just outputting a fixed text block without doing anything else.
+# Some of Smart-Edit's tools are just outputting a fixed text block without doing anything else.
 # Such tools are meant to encourage the agent to think in a certain way, to stay on track
 # and so on. The (templates for) outputs of these tools are contained here.
 prompts: