@nogataka/smart-edit 1.0.1 → 1.0.3

package/dist/smart-edit/agent.js

@@ -20,7 +20,7 @@ import { ActivateProjectTool, GetCurrentConfigTool, RemoveProjectTool, SwitchMod
 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';
+import { CheckOnboardingPerformedTool, OnboardingTool, CollectProjectSymbolsTool, ThinkAboutCollectedInformationTool, ThinkAboutTaskAdherenceTool, ThinkAboutWhetherYouAreDoneTool, SummarizeChangesTool, PrepareForNewConversationTool, InitialInstructionsTool } from './tools/workflow_tools.js';
 const { logger: log, memoryHandler: defaultMemoryHandler } = createSmartEditLogger({
     name: 'smart-edit.agent',
     emitToConsole: true,
@@ -62,6 +62,7 @@ const DEFAULT_TOOL_CLASSES = [
     InsertBeforeSymbolTool,
     CheckOnboardingPerformedTool,
     OnboardingTool,
+    CollectProjectSymbolsTool,
     ThinkAboutCollectedInformationTool,
     ThinkAboutTaskAdherenceTool,
     ThinkAboutWhetherYouAreDoneTool,

package/dist/smart-edit/cli.js

@@ -9,6 +9,7 @@ import { ProjectConfig, SmartEditConfig, SmartEditPaths } from './config/smart_e
 import { createSmartEditLogger, setConsoleLoggingEnabled } from './util/logging.js';
 import { SmartEditAgent } from './agent.js';
 import { SmartEditMCPFactorySingleProcess, createSmartEditHttpServer, createSmartEditStdioServer } from './mcp.js';
+import { DEFAULT_DASHBOARD_PORT, registerInstance, unregisterInstance, findAvailablePort } from './instance-registry.js';
 import { ToolRegistry } from './tools/tools_base.js';
 import { coerceLanguage } from '../smart-lsp/ls_config.js';
 import { ensureDefaultSubprocessOptions } from '../smart-lsp/util/subprocess_util.js';
@@ -96,8 +97,25 @@ function normalizeStartMcpServerOptions(raw) {
         }
         return undefined;
     };
+    // プロジェクトの決定ロジック:
+    // 1. --no-project が指定された場合: null（プロジェクトなしで起動）
+    // 2. --project が指定された場合: 指定されたパス
+    // 3. --project-file が指定された場合: 指定されたパス（後方互換）
+    // 4. どれも指定されていない場合: カレントディレクトリを使用
+    const resolveProject = () => {
+        if (raw.noProject === true) {
+            return null;
+        }
+        if (isNonEmptyString(raw.project)) {
+            return raw.project;
+        }
+        if (isNonEmptyString(raw.projectFile)) {
+            return raw.projectFile;
+        }
+        return process.cwd();
+    };
     return {
-        project: isNonEmptyString(raw.project) ? raw.project : null,
+        project: resolveProject(),
         projectFile: isNonEmptyString(raw.projectFile) ? raw.projectFile : null,
         context,
         modes: normalizedModes.slice(),
@@ -222,6 +240,8 @@ async function handleStartMcpServer(options, projectArg) {
             memoryLogHandler: agentOptions.memoryLogHandler ?? undefined
         })
     });
+    // Track registered instance for cleanup
+    let registeredInstance = null;
     try {
         const serverOptions = {
             host: options.host,
@@ -237,11 +257,26 @@ async function handleStartMcpServer(options, projectArg) {
         switch (options.transport) {
             case 'streamable-http': {
                 const server = await createSmartEditHttpServer(factory, serverOptions);
+                const serverPort = server.url.port ? Number.parseInt(server.url.port, 10) : options.port;
                 logger.info(`Streamable HTTP MCP server started: ${server.url.href}`);
                 logger.info('Press Ctrl+C to exit.');
+                // Register instance (skip in test environment)
+                if (!process.env.SMART_EDIT_SKIP_EDITOR) {
+                    registeredInstance = registerInstance({
+                        port: serverPort,
+                        project,
+                        pid: process.pid,
+                        transport: 'streamable-http'
+                    });
+                    logger.info(`Registered instance ${registeredInstance.id} in registry`);
+                }
                 await new Promise((resolve) => {
                     const shutdown = async () => {
                         logger.info('Stopping HTTP MCP server...');
+                        if (registeredInstance) {
+                            unregisterInstance(registeredInstance.id);
+                            logger.info(`Unregistered instance ${registeredInstance.id} from registry`);
+                        }
                         await server.close();
                         resolve();
                     };
@@ -257,6 +292,17 @@ async function handleStartMcpServer(options, projectArg) {
             case 'stdio': {
                 const server = await createSmartEditStdioServer(factory, serverOptions);
                 logger.info('STDIO MCP server started. Press Ctrl+C to exit.');
+                // For stdio transport, find an available port for the dashboard API (skip in test environment)
+                if (!process.env.SMART_EDIT_SKIP_EDITOR) {
+                    const dashboardPort = findAvailablePort();
+                    registeredInstance = registerInstance({
+                        port: dashboardPort,
+                        project,
+                        pid: process.pid,
+                        transport: 'stdio'
+                    });
+                    logger.info(`Registered instance ${registeredInstance.id} in registry (dashboard port: ${dashboardPort})`);
+                }
                 await new Promise((resolve) => {
                     let settled = false;
                     const finalize = async (reason) => {
@@ -265,6 +311,10 @@ async function handleStartMcpServer(options, projectArg) {
                         }
                         settled = true;
                         logger.info('Stopping STDIO MCP server...');
+                        if (registeredInstance) {
+                            unregisterInstance(registeredInstance.id);
+                            logger.info(`Unregistered instance ${registeredInstance.id} from registry`);
+                        }
                         if (reason === 'signal') {
                             await server.close();
                         }
@@ -295,6 +345,11 @@ async function handleStartMcpServer(options, projectArg) {
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logger.error(`Smart-Edit MCP サーバーの起動に失敗しました: ${message}`);
+        // Unregister instance on error
+        if (registeredInstance) {
+            unregisterInstance(registeredInstance.id);
+            logger.info(`Unregistered instance ${registeredInstance.id} from registry (error cleanup)`);
+        }
         throw error;
     }
     finally {
@@ -379,7 +434,8 @@ export function createSmartEditCli(options = {}) {
     }
     const startMcpServerCommand = new Command('start-mcp-server')
         .description('Smart-Edit MCP サーバーを起動します。')
-        .option('--project [project]', '起動時にアクティブ化するプロジェクト名またはパス。')
+        .option('--project [project]', '起動時にアクティブ化するプロジェクトパス。省略時はカレントディレクトリを使用。')
+        .option('--no-project', 'プロジェクトなしで起動。後から activate_project ツールで指定可能。')
         .option('--project-file [project]', '[非推奨] --project の旧名称。')
         .argument('[project]', '[非推奨] プロジェクトの位置引数。')
         .option('--context <context>', 'ビルトインコンテキスト名またはカスタム YAML へのパス。')
@@ -404,11 +460,32 @@ export function createSmartEditCli(options = {}) {
             await handleStartMcpServer(opts, normalizedProjectArg);
         }
         catch (error) {
+            // In test environment, rethrow the error so vitest can display it properly
+            // (this.error() calls process.exit which vitest intercepts, hiding the actual error)
+            if (process.env.SMART_EDIT_SKIP_EDITOR) {
+                throw error;
+            }
             const message = error instanceof Error ? error.message : String(error);
             this.error(`${message}\n`, { exitCode: 1 });
         }
     });
     program.addCommand(startMcpServerCommand);
+    const startDashboardCommand = new Command('start-dashboard')
+        .description('統合ダッシュボードを起動します（MCPサーバーなし）。複数のMCPインスタンスを一括管理できます。')
+        .option('--port <port>', 'ダッシュボードのポート番号。', (value) => parseInteger(value, '--port'), DEFAULT_DASHBOARD_PORT)
+        .action(async function () {
+        const opts = this.optsWithGlobals();
+        const port = typeof opts.port === 'number' ? opts.port : DEFAULT_DASHBOARD_PORT;
+        try {
+            const { runStandaloneDashboard } = await import('./standalone-dashboard.js');
+            await runStandaloneDashboard({ port });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`${message}\n`, { exitCode: 1 });
+        }
+    });
+    program.addCommand(startDashboardCommand);
     const modeCommand = new Command('mode')
         .description('Smart-Edit モードを管理します。');
     modeCommand

package/dist/smart-edit/dashboard.js

@@ -7,6 +7,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { createSmartEditLogger } from './util/logging.js';
 import { SMART_EDIT_DASHBOARD_DIR } from './constants.js';
+import { getInstances } from './instance-registry.js';
 const { logger } = createSmartEditLogger({ name: 'smart-edit.dashboard', emitToConsole: false, level: 'info' });
 const DEFAULT_DASHBOARD_PORT = 0x5eda;
 const DASHBOARD_HOST = '127.0.0.1';
@@ -292,6 +293,16 @@ export class SmartEditDashboardAPI {
         const method = req.method?.toUpperCase() ?? 'GET';
         const url = parseUrl(req.url ?? '/', true);
         const pathname = url.pathname ?? '/';
+        // Add CORS headers for cross-origin requests from multi-instance dashboard
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        // Handle CORS preflight
+        if (method === 'OPTIONS') {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
         try {
             if (pathname.startsWith('/dashboard')) {
                 if (method !== 'GET') {
@@ -356,6 +367,24 @@ export class SmartEditDashboardAPI {
                     this.shutdown();
                     this.sendJson(res, 200, { status: 'shutting down' });
                     return;
+                // Multi-instance dashboard APIs
+                case '/api/instances':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, { instances: getInstances() });
+                    return;
+                case '/api/instance-info':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, {
+                        port: this.listeningPort,
+                        project: this.agent.getActiveProject()?.projectName ?? null
+                    });
+                    return;
                 default:
                     this.respondNotFound(res);
             }

package/dist/smart-edit/instance-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Instance Registry for Multi-Instance Dashboard
+ *
+ * Manages registration of multiple Smart Edit MCP server instances.
+ * Each instance registers itself when starting and unregisters when stopping.
+ * The dashboard reads this registry to discover and connect to all running instances.
+ */
+export declare const DEFAULT_DASHBOARD_PORT = 24282;
+export interface InstanceInfo {
+    id: string;
+    port: number;
+    project: string | null;
+    pid: number;
+    startedAt: string;
+    transport: 'stdio' | 'sse' | 'streamable-http';
+}
+export declare function generateInstanceId(): string;
+/**
+ * Register a new MCP server instance in the registry.
+ * This function is designed to be non-fatal - if registration fails, the instance
+ * will still work, just won't be visible in the multi-instance dashboard.
+ */
+export declare function registerInstance(info: Omit<InstanceInfo, 'id' | 'startedAt'>): InstanceInfo;
+/**
+ * Unregister an MCP server instance from the registry.
+ */
+export declare function unregisterInstance(instanceId: string): void;
+/**
+ * Get all registered instances (with cleanup of dead processes).
+ */
+export declare function getInstances(): InstanceInfo[];
+/**
+ * Get a specific instance by ID.
+ */
+export declare function getInstance(instanceId: string): InstanceInfo | null;
+/**
+ * Find an available port for the dashboard, starting from the default port.
+ */
+export declare function findAvailablePort(startPort?: number): number;
+/**
+ * Update instance info (e.g., when project changes).
+ */
+export declare function updateInstance(instanceId: string, updates: Partial<Pick<InstanceInfo, 'project'>>): void;

package/dist/smart-edit/instance-registry.js

@@ -0,0 +1,269 @@
+/**
+ * Instance Registry for Multi-Instance Dashboard
+ *
+ * Manages registration of multiple Smart Edit MCP server instances.
+ * Each instance registers itself when starting and unregisters when stopping.
+ * The dashboard reads this registry to discover and connect to all running instances.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import crypto from 'node:crypto';
+import { SMART_EDIT_MANAGED_DIR_NAME } from './constants.js';
+import { createSmartEditLogger } from './util/logging.js';
+const { logger } = createSmartEditLogger({ name: 'smart-edit.instance-registry', emitToConsole: false, level: 'info' });
+export const DEFAULT_DASHBOARD_PORT = 0x5eda; // 24282
+// Compute paths dynamically to respect runtime HOME changes (important for testing)
+// Use process.env.HOME/USERPROFILE first as os.homedir() may cache the value
+function getSmartEditDir() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    return path.join(home, SMART_EDIT_MANAGED_DIR_NAME);
+}
+function getInstancesFilePath() {
+    return path.join(getSmartEditDir(), 'instances.json');
+}
+function getLockFilePath() {
+    return path.join(getSmartEditDir(), 'instances.lock');
+}
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_INTERVAL_MS = 50;
+function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function acquireLock() {
+    try {
+        const lockFile = getLockFilePath();
+        ensureDirectoryExists(lockFile);
+        const startTime = Date.now();
+        while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+            try {
+                fs.writeFileSync(lockFile, String(process.pid), { flag: 'wx' });
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'EEXIST') {
+                    // Lock file exists, check if the process is still alive
+                    try {
+                        const lockPid = Number.parseInt(fs.readFileSync(lockFile, 'utf-8').trim(), 10);
+                        if (!Number.isNaN(lockPid)) {
+                            try {
+                                // Check if process is alive (signal 0 doesn't kill, just checks)
+                                process.kill(lockPid, 0);
+                            }
+                            catch {
+                                // Process is dead, remove stale lock
+                                try {
+                                    fs.unlinkSync(lockFile);
+                                    continue;
+                                }
+                                catch {
+                                    // Ignore unlink errors
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Can't read lock file, try to remove it
+                        try {
+                            fs.unlinkSync(lockFile);
+                            continue;
+                        }
+                        catch {
+                            // Ignore unlink errors
+                        }
+                    }
+                    // Brief busy-wait before retry
+                    const waitUntil = Date.now() + Math.min(LOCK_RETRY_INTERVAL_MS, LOCK_TIMEOUT_MS - (Date.now() - startTime));
+                    while (Date.now() < waitUntil) {
+                        // Busy wait - acceptable since lock contention should be rare
+                    }
+                    continue;
+                }
+                // For other errors (EACCES, ENOENT, etc.), give up on locking
+                logger.warn(`Lock acquisition failed with error: ${err.code}`, err);
+                return false;
+            }
+        }
+        logger.warn('Failed to acquire lock for instance registry (timeout)');
+        return false;
+    }
+    catch (error) {
+        // Catch any unexpected errors (e.g., from ensureDirectoryExists)
+        logger.warn('Unexpected error during lock acquisition', error instanceof Error ? error : undefined);
+        return false;
+    }
+}
+function releaseLock() {
+    try {
+        fs.unlinkSync(getLockFilePath());
+    }
+    catch {
+        // Ignore errors when releasing lock
+    }
+}
+function readRegistry() {
+    const instancesFile = getInstancesFilePath();
+    ensureDirectoryExists(instancesFile);
+    try {
+        if (fs.existsSync(instancesFile)) {
+            const content = fs.readFileSync(instancesFile, 'utf-8');
+            const data = JSON.parse(content);
+            if (data && typeof data === 'object' && Array.isArray(data.instances)) {
+                return data;
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to read instance registry, starting fresh', error instanceof Error ? error : undefined);
+    }
+    return { instances: [] };
+}
+function writeRegistry(data) {
+    const instancesFile = getInstancesFilePath();
+    ensureDirectoryExists(instancesFile);
+    fs.writeFileSync(instancesFile, JSON.stringify(data, null, 2), 'utf-8');
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanupDeadInstances(data) {
+    const aliveInstances = data.instances.filter((instance) => isProcessAlive(instance.pid));
+    if (aliveInstances.length !== data.instances.length) {
+        logger.info(`Cleaned up ${data.instances.length - aliveInstances.length} dead instance(s) from registry`);
+    }
+    return { instances: aliveInstances };
+}
+export function generateInstanceId() {
+    return crypto.randomBytes(6).toString('hex');
+}
+/**
+ * Register a new MCP server instance in the registry.
+ * This function is designed to be non-fatal - if registration fails, the instance
+ * will still work, just won't be visible in the multi-instance dashboard.
+ */
+export function registerInstance(info) {
+    const id = generateInstanceId();
+    const instance = {
+        ...info,
+        id,
+        startedAt: new Date().toISOString()
+    };
+    try {
+        if (!acquireLock()) {
+            logger.warn('Failed to acquire lock for registering instance, continuing without registration');
+            return instance;
+        }
+        try {
+            let data = readRegistry();
+            data = cleanupDeadInstances(data);
+            // Check for duplicate port (shouldn't happen, but just in case)
+            const existingIndex = data.instances.findIndex((i) => i.port === info.port);
+            if (existingIndex !== -1) {
+                data.instances.splice(existingIndex, 1);
+            }
+            data.instances.push(instance);
+            writeRegistry(data);
+            logger.info(`Registered instance ${id} on port ${info.port} for project: ${info.project ?? '(none)'}`);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to register instance in registry', error instanceof Error ? error : undefined);
+    }
+    return instance;
+}
+/**
+ * Unregister an MCP server instance from the registry.
+ */
+export function unregisterInstance(instanceId) {
+    if (!acquireLock()) {
+        logger.error('Failed to acquire lock for unregistering instance');
+        return;
+    }
+    try {
+        const data = readRegistry();
+        const index = data.instances.findIndex((i) => i.id === instanceId);
+        if (index !== -1) {
+            const removed = data.instances.splice(index, 1)[0];
+            writeRegistry(data);
+            logger.info(`Unregistered instance ${instanceId} (port: ${removed.port})`);
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}
+/**
+ * Get all registered instances (with cleanup of dead processes).
+ */
+export function getInstances() {
+    if (!acquireLock()) {
+        // Even if we can't acquire lock, try to read
+        const data = readRegistry();
+        return data.instances.filter((instance) => isProcessAlive(instance.pid));
+    }
+    try {
+        let data = readRegistry();
+        data = cleanupDeadInstances(data);
+        writeRegistry(data);
+        return data.instances;
+    }
+    finally {
+        releaseLock();
+    }
+}
+/**
+ * Get a specific instance by ID.
+ */
+export function getInstance(instanceId) {
+    const instances = getInstances();
+    return instances.find((i) => i.id === instanceId) ?? null;
+}
+/**
+ * Find an available port for the dashboard, starting from the default port.
+ */
+export function findAvailablePort(startPort = DEFAULT_DASHBOARD_PORT) {
+    const instances = getInstances();
+    const usedPorts = new Set(instances.map((i) => i.port));
+    let port = startPort;
+    while (usedPorts.has(port) && port <= 65535) {
+        port++;
+    }
+    return port;
+}
+/**
+ * Update instance info (e.g., when project changes).
+ */
+export function updateInstance(instanceId, updates) {
+    if (!acquireLock()) {
+        logger.error('Failed to acquire lock for updating instance');
+        return;
+    }
+    try {
+        const data = readRegistry();
+        const instance = data.instances.find((i) => i.id === instanceId);
+        if (instance) {
+            if (updates.project !== undefined) {
+                instance.project = updates.project;
+            }
+            writeRegistry(data);
+            logger.info(`Updated instance ${instanceId}`);
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}

package/dist/smart-edit/resources/config/modes/careful-editor.yml

@@ -0,0 +1,47 @@
+description: Careful editing mode that respects existing code and prevents duplicate implementations
+prompt: |
+  You are operating in careful-editor mode. This mode emphasizes avoiding duplicate implementations
+  and respecting existing code patterns in the project.
+
+  ## Duplicate Prevention Rules
+
+  Before implementing anything, you MUST check for existing implementations:
+
+  1. **Read the "project-symbols" memory first**
+     - Check existing utility functions
+     - Check existing dependencies and their purposes
+     - Review common components and patterns
+
+  2. **Search for similar functionality**
+     - Before creating a new function, use `find_symbol` to search for similar names
+     - Before adding a new library, check package.json for existing dependencies
+     - Use `get_symbols_overview` to understand available utilities in relevant files
+
+  3. **Prefer existing code over new code**
+     - If an existing function can accomplish the task, use it instead of creating a new one
+     - If an existing library provides the functionality, use it instead of adding a new dependency
+     - If a similar pattern exists elsewhere in the codebase, follow that pattern
+
+  4. **Check onboarding status**
+     - If `check_onboarding_performed` returns `significantChanges: true`,
+       you should run onboarding again to refresh the project-symbols memory
+
+  ## When Creating New Code
+
+  If you determine that new code is truly necessary:
+
+  1. Place it in the appropriate existing file when possible
+  2. Follow existing naming conventions in the project
+  3. Document why existing utilities couldn't be used (if applicable)
+  4. Consider whether this new code should be added to the project-symbols memory
+
+  ## Examples of What to Avoid
+
+  - Creating `formatDate()` when the project already uses date-fns
+  - Adding lodash when the project already has similar utilities
+  - Creating a new `Button` component when one exists in `components/common/`
+  - Implementing custom validation when zod is already used
+
+  You have access to all editing tools, but use them thoughtfully.
+excluded_tools: []
+included_optional_tools: []