engram-mcp-server 1.2.2 → 1.2.4

package/README.md

@@ -216,15 +216,17 @@ Engram is published to the npm registry. **You do not need to download or compil
 
 As long as you have Node.js installed, your IDE will download and run the latest version of Engram automatically using `npx`.
 
-### Option 1: The Magic Installer (Zero Config)
+### Option 1: The Magic Installer (Interactive)
 
-Run this single command in your terminal. It will automatically detect your IDEs (Cursor, VS Code, Visual Studio, Cline, Windsurf, Antigravity) and inject the correct configuration for you:
+Run this single command in your terminal. It will automatically detect your IDE (Cursor, VS Code, Visual Studio, Cline, Windsurf, Antigravity) and ask for confirmation before injecting the configuration:
 
 ```bash
 npx -y engram-mcp-server --install
 ```
 
-*(You can also run `npx -y engram-mcp-server --list` to see what IDEs it detects before installing)*
+If it cannot detect your IDE automatically, it will present a numbered menu where you can choose your IDE from a list, or even **provide a custom path** to any `mcp.json` file on your system.
+
+*(You can also run `npx -y engram-mcp-server --list` to preview which IDEs are detected on your machine!)*
 
 Restart your IDE, and Engram is ready!
 

package/dist/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const SERVER_NAME = "engram-mcp-server";
-export declare const SERVER_VERSION = "1.2.2";
+export declare const SERVER_VERSION = "1.2.4";
 export declare const TOOL_PREFIX = "engram";
 export declare const DB_DIR_NAME = ".engram";
 export declare const DB_FILE_NAME = "memory.db";

package/dist/constants.js

@@ -2,7 +2,7 @@
 // Engram MCP Server — Constants
 // ============================================================================
 export const SERVER_NAME = "engram-mcp-server";
-export const SERVER_VERSION = "1.2.2";
+export const SERVER_VERSION = "1.2.4";
 export const TOOL_PREFIX = "engram";
 // Database
 export const DB_DIR_NAME = ".engram";

package/dist/installer.d.ts

@@ -1,2 +1,2 @@
-export declare function runInstaller(args: string[]): void;
+export declare function runInstaller(args: string[]): Promise<void>;
 //# sourceMappingURL=installer.d.ts.map

package/dist/installer.js

@@ -1,55 +1,66 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
+import readline from "readline";
 const HOME = os.homedir();
 const APPDATA = process.env.APPDATA || path.join(HOME, ".config");
-// ─── IDE Config Locations ────────────────────────────────────────────
 const IDE_CONFIGS = {
     antigravity: {
         name: "Antigravity IDE",
-        paths: [
-            path.join(HOME, ".gemini", "antigravity", "mcp_config.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [path.join(HOME, ".gemini", "antigravity", "mcp_config.json")],
+        },
     },
     cursor: {
         name: "Cursor",
-        paths: [
-            path.join(HOME, ".cursor", "mcp.json"),
-            path.join(APPDATA, "Cursor", "mcp.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(HOME, ".cursor", "mcp.json"),
+                path.join(APPDATA, "Cursor", "mcp.json"),
+            ],
+            localDirs: [".cursor"],
+        },
     },
     vscode: {
         name: "VS Code (Copilot)",
-        paths: [
-            path.join(APPDATA, "Code", "User", "mcp.json"),
-            path.join(HOME, ".vscode", "mcp.json"),
-        ],
         format: "servers",
+        scopes: {
+            global: [
+                path.join(APPDATA, "Code", "User", "mcp.json"),
+                path.join(HOME, ".vscode", "mcp.json"),
+            ],
+            localDirs: [".vscode"],
+        },
     },
     cline: {
         name: "Cline / Roo Code",
-        paths: [
-            path.join(APPDATA, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-            path.join(HOME, ".cline", "mcp_settings.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(APPDATA, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+                path.join(HOME, ".cline", "mcp_settings.json"),
+            ],
+        },
     },
     windsurf: {
         name: "Windsurf",
-        paths: [
-            path.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-            path.join(APPDATA, "Windsurf", "mcp.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+                path.join(APPDATA, "Windsurf", "mcp.json"),
+            ],
+        },
     },
     visualstudio: {
-        name: "Visual Studio 2022",
-        paths: [
-            path.join(HOME, ".mcp.json"), // Global config for Visual Studio
-        ],
+        name: "Visual Studio 2022/2026",
         format: "servers",
+        scopes: {
+            global: [path.join(HOME, ".mcp.json")],
+            localDirs: [".vs", ""], // "" means root of solution (e.g. SolutionDir/.mcp.json)
+        },
     },
 };
 // ─── Engram Entry ────────────────────────────────────────────────────
@@ -82,59 +93,226 @@ function addToConfig(configPath, format) {
     const key = format; // "mcpServers" or "servers"
     if (!config[key])
         config[key] = {};
+    const newEntry = makeEngramEntry(format);
     if (config[key].engram) {
-        // Already exists — update to use npx
-        config[key].engram = makeEngramEntry(format);
+        // Already exists — check if it's identical
+        if (JSON.stringify(config[key].engram) === JSON.stringify(newEntry)) {
+            return "exists";
+        }
+        // Exists but different (e.g. old local path) — update to use npx
+        config[key].engram = newEntry;
         writeJson(configPath, config);
         return "updated";
     }
-    config[key].engram = makeEngramEntry(format);
+    config[key].engram = newEntry;
     writeJson(configPath, config);
     return "added";
 }
+// ─── Environment Detection ──────────────────────────────────────────
+function detectCurrentIde() {
+    const env = process.env;
+    // Explicit hints usually present in extension hosts or integrated terminals
+    if (env.ANTIGRAVITY_EDITOR_APP_ROOT)
+        return "antigravity";
+    if (env.WINDSURF_PROFILE)
+        return "windsurf";
+    // VS Code forks share TERM_PROGRAM="vscode", but we can distinguish them by checking VSCODE_CWD or path
+    if (env.TERM_PROGRAM === "vscode" || env.VSCODE_IPC_HOOK || env.VSCODE_CWD) {
+        const cwdLower = (env.VSCODE_CWD || "").toLowerCase();
+        if (cwdLower.includes("antigravity"))
+            return "antigravity";
+        if (cwdLower.includes("cursor"))
+            return "cursor";
+        if (cwdLower.includes("windsurf"))
+            return "windsurf";
+        // Final fallback: check PATH but ONLY for the specific IDE execution paths, not generically
+        const pathLower = (env.PATH || "").toLowerCase();
+        if (pathLower.includes("antigravity"))
+            return "antigravity";
+        if (pathLower.includes("cursor\\cli"))
+            return "cursor"; // more specific to avoid false positives
+        if (pathLower.includes("windsurf"))
+            return "windsurf";
+        return "vscode";
+    }
+    return null;
+}
 // ─── Main ────────────────────────────────────────────────────────────
-export function runInstaller(args) {
+async function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+export async function runInstaller(args) {
     if (args.includes("--list")) {
         console.log("\nEngram can be auto-installed into these IDEs:\n");
         for (const [id, ide] of Object.entries(IDE_CONFIGS)) {
-            const found = ide.paths.find((p) => fs.existsSync(p) || fs.existsSync(path.dirname(p)));
-            console.log(`  ${id.padEnd(15)} ${ide.name} ${found ? "✅ detected" : "❌ not found"}`);
+            let found = false;
+            if (ide.scopes.global) {
+                found = !!ide.scopes.global.find(p => fs.existsSync(p) || fs.existsSync(path.dirname(p)));
+            }
+            console.log(`  ${id.padEnd(15)} ${ide.name}${ide.scopes.localDirs ? " (Global / Local)" : " (Global)"} ${found ? "✅ global path detected" : "❌ global not found"}`);
         }
         process.exit(0);
     }
-    // Specific IDE requested?
+    // Specific IDE requested via CLI flag?
     const ideFlagIdx = args.indexOf("--ide");
-    const targetIde = ideFlagIdx >= 0 ? args[ideFlagIdx + 1] : null;
-    const idesToProcess = targetIde
-        ? (IDE_CONFIGS[targetIde] ? { [targetIde]: IDE_CONFIGS[targetIde] } : null)
-        : IDE_CONFIGS;
-    if (!idesToProcess) {
-        console.error(`Unknown IDE: "${targetIde}". Options: ${Object.keys(IDE_CONFIGS).join(", ")}`);
-        process.exit(1);
+    if (ideFlagIdx >= 0 && args[ideFlagIdx + 1]) {
+        const targetIde = args[ideFlagIdx + 1];
+        if (!IDE_CONFIGS[targetIde]) {
+            console.error(`Unknown IDE: "${targetIde}". Options: ${Object.keys(IDE_CONFIGS).join(", ")}`);
+            process.exit(1);
+        }
+        await performInstallationInteractive({ [targetIde]: IDE_CONFIGS[targetIde] });
+        return;
     }
     console.log("\n🧠 Engram MCP Installer\n");
-    let installed = 0;
+    // Auto-detect environment if it's run without specific args
+    const currentIde = detectCurrentIde();
+    if (currentIde && IDE_CONFIGS[currentIde]) {
+        console.log(`🔍 Detected environment: ${IDE_CONFIGS[currentIde].name}`);
+        const ans = await askQuestion("   Install Engram for this IDE? [Y/n]: ");
+        if (ans.trim().toLowerCase() !== 'n') {
+            await performInstallationInteractive({ [currentIde]: IDE_CONFIGS[currentIde] });
+            return;
+        }
+        console.log(""); // Skip to menu
+    }
+    // Interactive Menu
+    console.log("Where would you like to configure the Engram MCP server?\n");
+    const ideKeys = Object.keys(IDE_CONFIGS);
+    ideKeys.forEach((key, index) => {
+        console.log(`  ${index + 1}. ${IDE_CONFIGS[key].name}`);
+    });
+    const allOpt = ideKeys.length + 1;
+    const customOpt = ideKeys.length + 2;
+    console.log(`  ${allOpt}. Install to ALL detected IDEs`);
+    console.log(`  ${customOpt}. Custom IDE config path...`);
+    console.log(`  0. Cancel`);
+    const answer = await askQuestion(`\nSelect an option [0-${customOpt}]: `);
+    const choice = parseInt(answer.trim(), 10);
+    if (isNaN(choice) || choice === 0) {
+        console.log("Installation cancelled.");
+        process.exit(0);
+    }
+    let idesToProcess = {};
+    if (choice === allOpt) {
+        idesToProcess = IDE_CONFIGS; // All
+    }
+    else if (choice === customOpt) {
+        const customPath = await askQuestion("Enter the absolute path to your MCP config JSON file: ");
+        if (!customPath.trim()) {
+            console.log("No path provided. Exiting.");
+            process.exit(1);
+        }
+        idesToProcess = {
+            custom: {
+                name: "Custom Path",
+                paths: [customPath.trim()],
+                format: "mcpServers" // Safe default for unknown IDEs
+            }
+        };
+    }
+    else if (choice >= 1 && choice <= ideKeys.length) {
+        const selectedKey = ideKeys[choice - 1];
+        idesToProcess = { [selectedKey]: IDE_CONFIGS[selectedKey] };
+    }
+    else {
+        console.log("\nInvalid selection. Exiting.");
+        process.exit(1);
+    }
+    await performInstallationInteractive(idesToProcess);
+}
+// Interactive wizard to resolve specific config paths for the selected IDEs
+async function performInstallationInteractive(idesToProcess) {
+    let resolvedConfigs = [];
     for (const [id, ide] of Object.entries(idesToProcess)) {
-        const configPath = ide.paths.find((p) => fs.existsSync(p)) || ide.paths[0];
+        if (id === "custom") {
+            resolvedConfigs.push({ name: ide.name, path: ide.paths[0], format: ide.format });
+            continue;
+        }
+        const supportsLocal = ide.scopes?.localDirs && ide.scopes.localDirs.length > 0;
+        const supportsGlobal = ide.scopes?.global && ide.scopes.global.length > 0;
+        let targetScope = "global";
+        if (supportsLocal && supportsGlobal) {
+            console.log(`\n${ide.name} supports multiple installation scopes.`);
+            console.log(`  1. Global (Applies to all projects)`);
+            console.log(`  2. Local  (Applies to a specific Solution/Workspace)`);
+            const scopeAns = await askQuestion("Select scope [1-2] (default 1): ");
+            if (scopeAns.trim() === "2") {
+                targetScope = "local";
+            }
+        }
+        else if (supportsLocal && !supportsGlobal) {
+            targetScope = "local";
+        }
+        if (targetScope === "global") {
+            const configPath = ide.scopes.global.find((p) => fs.existsSync(p)) || ide.scopes.global[0];
+            resolvedConfigs.push({ name: `${ide.name} (Global)`, path: configPath, format: ide.format });
+        }
+        else if (targetScope === "local") {
+            const solutionDir = await askQuestion(`Enter the absolute path to your ${ide.name} Solution/Workspace directory:\n> `);
+            if (!solutionDir.trim()) {
+                console.log(`Skipping ${ide.name} local installation (no path provided).`);
+                continue;
+            }
+            // For Visual studio, it's .vs/mcp.json or .mcp.json at root. We'll use the first defined localDir.
+            const localDirPrefix = ide.scopes.localDirs[0];
+            let configFileName = "mcp.json";
+            // Visual Studio special case: if localDir is "" (root), the file is usually .mcp.json
+            if (id === "visualstudio" && localDirPrefix === "") {
+                configFileName = ".mcp.json";
+            }
+            else if (id === "visualstudio" && localDirPrefix === ".vs") {
+                configFileName = "mcp.json";
+            }
+            // If they use `.mcp.json` vs `mcp.json` varies slightly, but standard is mcp.json inside `.vscode` or `.vs`
+            const configPath = path.join(solutionDir.trim(), localDirPrefix, configFileName);
+            resolvedConfigs.push({ name: `${ide.name} (Local: ${path.basename(solutionDir)})`, path: configPath, format: ide.format });
+        }
+    }
+    await performInstallation(resolvedConfigs);
+}
+async function performInstallation(configs) {
+    let installed = 0;
+    for (const config of configs) {
         try {
-            const result = addToConfig(configPath, ide.format);
-            console.log(`\n   ✅ ${ide.name}`);
-            console.log(`      Config: ${configPath}`);
-            console.log(`      Status: ${result === "added" ? "Engram added" : "Engram config updated to use npx"}`);
-            installed++;
+            const result = addToConfig(config.path, config.format);
+            console.log(`\n   ✅ ${config.name}`);
+            console.log(`      Config: ${config.path}`);
+            let statusText = "";
+            if (result === "added")
+                statusText = "Engram added";
+            else if (result === "updated")
+                statusText = "Engram config updated to use npx";
+            else if (result === "exists")
+                statusText = "Engram is already installed and up to date";
+            console.log(`      Status: ${statusText}`);
+            if (result !== "exists") {
+                installed++;
+            }
         }
         catch (e) {
-            console.log(`\n   ⚠️  ${ide.name}`);
-            console.log(`      Could not write to: ${configPath}`);
+            console.log(`\n   ⚠️  ${config.name}`);
+            console.log(`      Could not write to: ${config.path}`);
             console.log(`      Reason: ${e.message}`);
+            console.log(`\n      For manual instructions, visit: https://github.com/keggan-std/Engram`);
         }
     }
-    if (installed === 0) {
-        console.log("\n   No supported IDEs were found on this machine.");
-        console.log("   Run 'npx -y engram-mcp-server --list' to see what was detected.\n");
+    if (configs.length === 0) {
+        console.log("\n   No target configurations resolved.");
+    }
+    else if (installed === 0) {
+        // Technically they could all just be "already exists"
+        console.log("\n✅ Done! No new changes were needed.");
     }
     else {
-        console.log(`\n✅ Done! Engram configured in ${installed} IDE(s).`);
+        console.log(`\n✅ Done! Engram configured in ${installed} IDE scope(s).`);
         console.log("   Restart your IDE(s) to load Engram.\n");
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engram-mcp-server",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Engram — Persistent Memory Cortex for AI coding agents. Gives agents session continuity, change tracking, decision logging, and project intelligence across sessions.",
   "type": "module",
   "main": "dist/index.js",

package/src/constants.ts

@@ -3,7 +3,7 @@
 // ============================================================================
 
 export const SERVER_NAME = "engram-mcp-server";
-export const SERVER_VERSION = "1.2.2";
+export const SERVER_VERSION = "1.2.4";
 export const TOOL_PREFIX = "engram";
 
 // Database

package/src/installer.ts

@@ -1,58 +1,77 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
+import readline from "readline";
 
 const HOME = os.homedir();
 const APPDATA = process.env.APPDATA || path.join(HOME, ".config");
 
-// ─── IDE Config Locations ────────────────────────────────────────────
+interface IdeDefinition {
+    name: string;
+    format: "mcpServers" | "servers";
+    scopes: {
+        global?: string[];
+        localDirs?: string[]; // e.g. [".vs", ".vscode"] - appended to a user-provided solution path
+    };
+}
 
-const IDE_CONFIGS: Record<string, any> = {
+const IDE_CONFIGS: Record<string, IdeDefinition> = {
     antigravity: {
         name: "Antigravity IDE",
-        paths: [
-            path.join(HOME, ".gemini", "antigravity", "mcp_config.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [path.join(HOME, ".gemini", "antigravity", "mcp_config.json")],
+        },
     },
     cursor: {
         name: "Cursor",
-        paths: [
-            path.join(HOME, ".cursor", "mcp.json"),
-            path.join(APPDATA, "Cursor", "mcp.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(HOME, ".cursor", "mcp.json"),
+                path.join(APPDATA, "Cursor", "mcp.json"),
+            ],
+            localDirs: [".cursor"],
+        },
     },
     vscode: {
         name: "VS Code (Copilot)",
-        paths: [
-            path.join(APPDATA, "Code", "User", "mcp.json"),
-            path.join(HOME, ".vscode", "mcp.json"),
-        ],
         format: "servers",
+        scopes: {
+            global: [
+                path.join(APPDATA, "Code", "User", "mcp.json"),
+                path.join(HOME, ".vscode", "mcp.json"),
+            ],
+            localDirs: [".vscode"],
+        },
     },
     cline: {
         name: "Cline / Roo Code",
-        paths: [
-            path.join(APPDATA, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-            path.join(HOME, ".cline", "mcp_settings.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(APPDATA, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+                path.join(HOME, ".cline", "mcp_settings.json"),
+            ],
+        },
     },
     windsurf: {
         name: "Windsurf",
-        paths: [
-            path.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-            path.join(APPDATA, "Windsurf", "mcp.json"),
-        ],
         format: "mcpServers",
+        scopes: {
+            global: [
+                path.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+                path.join(APPDATA, "Windsurf", "mcp.json"),
+            ],
+        },
     },
     visualstudio: {
-        name: "Visual Studio 2022",
-        paths: [
-            path.join(HOME, ".mcp.json"), // Global config for Visual Studio
-        ],
+        name: "Visual Studio 2022/2026",
         format: "servers",
+        scopes: {
+            global: [path.join(HOME, ".mcp.json")],
+            localDirs: [".vs", ""], // "" means root of solution (e.g. SolutionDir/.mcp.json)
+        },
     },
 };
 
@@ -88,73 +107,255 @@ function writeJson(filePath: string, data: any) {
 }
 
 function addToConfig(configPath: string, format: string) {
-    let config = readJson(configPath) || {};
+    let config: Record<string, any> = readJson(configPath) || {};
     const key = format; // "mcpServers" or "servers"
 
     if (!config[key]) config[key] = {};
 
+    const newEntry = makeEngramEntry(format);
+
     if (config[key].engram) {
-        // Already exists — update to use npx
-        config[key].engram = makeEngramEntry(format);
+        // Already exists — check if it's identical
+        if (JSON.stringify(config[key].engram) === JSON.stringify(newEntry)) {
+            return "exists";
+        }
+
+        // Exists but different (e.g. old local path) — update to use npx
+        config[key].engram = newEntry;
         writeJson(configPath, config);
         return "updated";
     }
 
-    config[key].engram = makeEngramEntry(format);
+    config[key].engram = newEntry;
     writeJson(configPath, config);
     return "added";
 }
 
+// ─── Environment Detection ──────────────────────────────────────────
+
+function detectCurrentIde(): string | null {
+    const env = process.env;
+
+    // Explicit hints usually present in extension hosts or integrated terminals
+    if (env.ANTIGRAVITY_EDITOR_APP_ROOT) return "antigravity";
+    if (env.WINDSURF_PROFILE) return "windsurf";
+
+    // VS Code forks share TERM_PROGRAM="vscode", but we can distinguish them by checking VSCODE_CWD or path
+    if (env.TERM_PROGRAM === "vscode" || env.VSCODE_IPC_HOOK || env.VSCODE_CWD) {
+        const cwdLower = (env.VSCODE_CWD || "").toLowerCase();
+        if (cwdLower.includes("antigravity")) return "antigravity";
+        if (cwdLower.includes("cursor")) return "cursor";
+        if (cwdLower.includes("windsurf")) return "windsurf";
+
+        // Final fallback: check PATH but ONLY for the specific IDE execution paths, not generically
+        const pathLower = (env.PATH || "").toLowerCase();
+        if (pathLower.includes("antigravity")) return "antigravity";
+        if (pathLower.includes("cursor\\cli")) return "cursor"; // more specific to avoid false positives
+        if (pathLower.includes("windsurf")) return "windsurf";
+
+        return "vscode";
+    }
+
+    return null;
+}
+
 // ─── Main ────────────────────────────────────────────────────────────
 
-export function runInstaller(args: string[]) {
+async function askQuestion(query: string): Promise<string> {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+
+export async function runInstaller(args: string[]) {
     if (args.includes("--list")) {
         console.log("\nEngram can be auto-installed into these IDEs:\n");
         for (const [id, ide] of Object.entries(IDE_CONFIGS)) {
-            const found = ide.paths.find((p: string) => fs.existsSync(p) || fs.existsSync(path.dirname(p)));
-            console.log(`  ${id.padEnd(15)} ${ide.name} ${found ? "✅ detected" : "❌ not found"}`);
+            let found = false;
+            if (ide.scopes.global) {
+                found = !!ide.scopes.global.find(p => fs.existsSync(p) || fs.existsSync(path.dirname(p)));
+            }
+            console.log(`  ${id.padEnd(15)} ${ide.name}${ide.scopes.localDirs ? " (Global / Local)" : " (Global)"} ${found ? "✅ global path detected" : "❌ global not found"}`);
         }
         process.exit(0);
     }
 
-    // Specific IDE requested?
+    // Specific IDE requested via CLI flag?
     const ideFlagIdx = args.indexOf("--ide");
-    const targetIde = ideFlagIdx >= 0 ? args[ideFlagIdx + 1] : null;
+    if (ideFlagIdx >= 0 && args[ideFlagIdx + 1]) {
+        const targetIde = args[ideFlagIdx + 1];
+        if (!IDE_CONFIGS[targetIde]) {
+            console.error(`Unknown IDE: "${targetIde}". Options: ${Object.keys(IDE_CONFIGS).join(", ")}`);
+            process.exit(1);
+        }
+        await performInstallationInteractive({ [targetIde]: IDE_CONFIGS[targetIde] });
+        return;
+    }
+
+    console.log("\n🧠 Engram MCP Installer\n");
+
+    // Auto-detect environment if it's run without specific args
+    const currentIde = detectCurrentIde();
+
+    if (currentIde && IDE_CONFIGS[currentIde]) {
+        console.log(`🔍 Detected environment: ${IDE_CONFIGS[currentIde].name}`);
+        const ans = await askQuestion("   Install Engram for this IDE? [Y/n]: ");
+
+        if (ans.trim().toLowerCase() !== 'n') {
+            await performInstallationInteractive({ [currentIde]: IDE_CONFIGS[currentIde] });
+            return;
+        }
+        console.log(""); // Skip to menu
+    }
+
+    // Interactive Menu
+    console.log("Where would you like to configure the Engram MCP server?\n");
+
+    const ideKeys = Object.keys(IDE_CONFIGS);
+    ideKeys.forEach((key, index) => {
+        console.log(`  ${index + 1}. ${IDE_CONFIGS[key].name}`);
+    });
+
+    const allOpt = ideKeys.length + 1;
+    const customOpt = ideKeys.length + 2;
 
-    const idesToProcess = targetIde
-        ? (IDE_CONFIGS[targetIde] ? { [targetIde]: IDE_CONFIGS[targetIde] } : null)
-        : IDE_CONFIGS;
+    console.log(`  ${allOpt}. Install to ALL detected IDEs`);
+    console.log(`  ${customOpt}. Custom IDE config path...`);
+    console.log(`  0. Cancel`);
 
-    if (!idesToProcess) {
-        console.error(`Unknown IDE: "${targetIde}". Options: ${Object.keys(IDE_CONFIGS).join(", ")}`);
+    const answer = await askQuestion(`\nSelect an option [0-${customOpt}]: `);
+    const choice = parseInt(answer.trim(), 10);
+
+    if (isNaN(choice) || choice === 0) {
+        console.log("Installation cancelled.");
+        process.exit(0);
+    }
+
+    let idesToProcess: Record<string, any> = {};
+
+    if (choice === allOpt) {
+        idesToProcess = IDE_CONFIGS; // All
+    } else if (choice === customOpt) {
+        const customPath = await askQuestion("Enter the absolute path to your MCP config JSON file: ");
+        if (!customPath.trim()) {
+            console.log("No path provided. Exiting.");
+            process.exit(1);
+        }
+        idesToProcess = {
+            custom: {
+                name: "Custom Path",
+                paths: [customPath.trim()],
+                format: "mcpServers" // Safe default for unknown IDEs
+            }
+        };
+    } else if (choice >= 1 && choice <= ideKeys.length) {
+        const selectedKey = ideKeys[choice - 1];
+        idesToProcess = { [selectedKey]: IDE_CONFIGS[selectedKey] };
+    } else {
+        console.log("\nInvalid selection. Exiting.");
         process.exit(1);
     }
 
-    console.log("\n🧠 Engram MCP Installer\n");
+    await performInstallationInteractive(idesToProcess);
+}
 
-    let installed = 0;
+// Interactive wizard to resolve specific config paths for the selected IDEs
+async function performInstallationInteractive(idesToProcess: Record<string, IdeDefinition | any>) {
+    let resolvedConfigs: { name: string; path: string; format: string }[] = [];
 
     for (const [id, ide] of Object.entries(idesToProcess)) {
-        const configPath = ide.paths.find((p: string) => fs.existsSync(p)) || ide.paths[0];
+        if (id === "custom") {
+            resolvedConfigs.push({ name: ide.name, path: ide.paths[0], format: ide.format });
+            continue;
+        }
+
+        const supportsLocal = ide.scopes?.localDirs && ide.scopes.localDirs.length > 0;
+        const supportsGlobal = ide.scopes?.global && ide.scopes.global.length > 0;
+
+        let targetScope = "global";
+
+        if (supportsLocal && supportsGlobal) {
+            console.log(`\n${ide.name} supports multiple installation scopes.`);
+            console.log(`  1. Global (Applies to all projects)`);
+            console.log(`  2. Local  (Applies to a specific Solution/Workspace)`);
+            const scopeAns = await askQuestion("Select scope [1-2] (default 1): ");
+            if (scopeAns.trim() === "2") {
+                targetScope = "local";
+            }
+        } else if (supportsLocal && !supportsGlobal) {
+            targetScope = "local";
+        }
+
+        if (targetScope === "global") {
+            const configPath = ide.scopes.global!.find((p: string) => fs.existsSync(p)) || ide.scopes.global![0];
+            resolvedConfigs.push({ name: `${ide.name} (Global)`, path: configPath, format: ide.format });
+        } else if (targetScope === "local") {
+            const solutionDir = await askQuestion(`Enter the absolute path to your ${ide.name} Solution/Workspace directory:\n> `);
+            if (!solutionDir.trim()) {
+                console.log(`Skipping ${ide.name} local installation (no path provided).`);
+                continue;
+            }
+
+            // For Visual studio, it's .vs/mcp.json or .mcp.json at root. We'll use the first defined localDir.
+            const localDirPrefix = ide.scopes.localDirs![0];
+
+            let configFileName = "mcp.json";
+            // Visual Studio special case: if localDir is "" (root), the file is usually .mcp.json
+            if (id === "visualstudio" && localDirPrefix === "") {
+                configFileName = ".mcp.json";
+            } else if (id === "visualstudio" && localDirPrefix === ".vs") {
+                configFileName = "mcp.json";
+            }
+            // If they use `.mcp.json` vs `mcp.json` varies slightly, but standard is mcp.json inside `.vscode` or `.vs`
+
+            const configPath = path.join(solutionDir.trim(), localDirPrefix, configFileName);
+            resolvedConfigs.push({ name: `${ide.name} (Local: ${path.basename(solutionDir)})`, path: configPath, format: ide.format });
+        }
+    }
 
+    await performInstallation(resolvedConfigs);
+}
+
+async function performInstallation(configs: { name: string; path: string; format: string }[]) {
+    let installed = 0;
+
+    for (const config of configs) {
         try {
-            const result = addToConfig(configPath, ide.format);
-            console.log(`\n   ✅ ${ide.name}`);
-            console.log(`      Config: ${configPath}`);
-            console.log(`      Status: ${result === "added" ? "Engram added" : "Engram config updated to use npx"}`);
-            installed++;
+            const result = addToConfig(config.path, config.format);
+            console.log(`\n   ✅ ${config.name}`);
+            console.log(`      Config: ${config.path}`);
+
+            let statusText = "";
+            if (result === "added") statusText = "Engram added";
+            else if (result === "updated") statusText = "Engram config updated to use npx";
+            else if (result === "exists") statusText = "Engram is already installed and up to date";
+
+            console.log(`      Status: ${statusText}`);
+
+            if (result !== "exists") {
+                installed++;
+            }
         } catch (e: any) {
-            console.log(`\n   ⚠️  ${ide.name}`);
-            console.log(`      Could not write to: ${configPath}`);
+            console.log(`\n   ⚠️  ${config.name}`);
+            console.log(`      Could not write to: ${config.path}`);
             console.log(`      Reason: ${e.message}`);
+            console.log(`\n      For manual instructions, visit: https://github.com/keggan-std/Engram`);
         }
     }
 
-    if (installed === 0) {
-        console.log("\n   No supported IDEs were found on this machine.");
-        console.log("   Run 'npx -y engram-mcp-server --list' to see what was detected.\n");
+    if (configs.length === 0) {
+        console.log("\n   No target configurations resolved.");
+    } else if (installed === 0) {
+        // Technically they could all just be "already exists"
+        console.log("\n✅ Done! No new changes were needed.");
     } else {
-        console.log(`\n✅ Done! Engram configured in ${installed} IDE(s).`);
+        console.log(`\n✅ Done! Engram configured in ${installed} IDE scope(s).`);
         console.log("   Restart your IDE(s) to load Engram.\n");
     }
 }