memtrace 0.1.37 → 0.1.45

package/README.md

@@ -12,7 +12,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/memtrace"><img src="https://img.shields.io/npm/v/memtrace?style=flat-square&color=00D4B8&label=npm" alt="npm version" /></a>
   <a href="https://github.com/syncable-dev/memtrace-public/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Proprietary%20EULA-0A1628?style=flat-square" alt="license" /></a>
-  <a href="https://memtrace.dev"><img src="https://img.shields.io/badge/docs-memtrace.dev-00D4B8?style=flat-square" alt="docs" /></a>
+  <a href="https://memtrace.io"><img src="https://img.shields.io/badge/docs-memtrace.io-00D4B8?style=flat-square" alt="docs" /></a>
 </p>
 
 > **Early Access** — Memtrace is under active development. Core indexing and structural search are stable. Temporal features (evolution scoring, timeline replay) are functional but may have rough edges. [Report issues here.](https://github.com/syncable-dev/memtrace-public/issues)
@@ -294,7 +294,7 @@ Rust · Go · TypeScript · JavaScript · Python · Java · C · C++ · C# · Sw
 <br/>
 
 <p align="center">
-  <a href="https://memtrace.dev">Documentation</a> · <a href="https://www.npmjs.com/package/memtrace">npm</a> · <a href="https://github.com/syncable-dev/memtrace-public/issues">Issues</a>
+  <a href="https://memtrace.io">Documentation</a> · <a href="https://www.npmjs.com/package/memtrace">npm</a> · <a href="https://github.com/syncable-dev/memtrace-public/issues">Issues</a>
 </p>
 
 <p align="center">

package/bin/memtrace.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 "use strict";
 
-const { spawnSync } = require("child_process");
+const os   = require("os");
+const path = require("path");
+const fs   = require("fs");
+const { spawnSync, spawn } = require("child_process");
 const { getBinaryPath } = require("../install.js");
 
 // ── Handle `memtrace uninstall` before delegating to the Rust binary ────────
@@ -11,10 +14,6 @@ const { getBinaryPath } = require("../install.js");
 const args = process.argv.slice(2);
 
 if (args[0] === "uninstall" || args[0] === "cleanup") {
-  const path = require("path");
-  const os = require("os");
-
-  // Try the bundled script first, then the persisted copy in ~/.memtrace/
   const candidates = [
     path.join(__dirname, "..", "uninstall.js"),
     path.join(os.homedir(), ".memtrace", "uninstall.js"),
@@ -41,7 +40,7 @@ if (args[0] === "uninstall" || args[0] === "cleanup") {
   process.exit(0);
 }
 
-// ── Delegate everything else to the Rust binary ─────────────────────────────
+// ── Resolve native binary ─────────────────────────────────────────────────────
 
 let binaryPath;
 try {
@@ -51,14 +50,103 @@ try {
   process.exit(1);
 }
 
-const result = spawnSync(binaryPath, args, {
-  stdio: "inherit",
-  env: process.env,
-});
+// ── Update checker ────────────────────────────────────────────────────────────
+// Checks registry.npmjs.org at most once every 24 h (cached in ~/.memtrace/).
+// Completely non-blocking: errors are silently swallowed.
 
-if (result.error) {
-  console.error(`Failed to run memtrace: ${result.error.message}`);
-  process.exit(1);
+const CACHE_FILE    = path.join(os.homedir(), ".memtrace", "update-check.json");
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 h in ms
+
+function readUpdateCache() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeUpdateCache(data) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch {
+    // non-fatal
+  }
+}
+
+function checkForUpdate(currentVersion) {
+  return new Promise((resolve) => {
+    // Return cached result if it's fresh enough
+    const cache = readUpdateCache();
+    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL) {
+      resolve(cache.latestVersion !== currentVersion ? cache.latestVersion : null);
+      return;
+    }
+
+    const https = require("https");
+    const req = https.get(
+      "https://registry.npmjs.org/memtrace/latest",
+      { headers: { Accept: "application/json" }, timeout: 3000 },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            const latest = JSON.parse(body).version;
+            writeUpdateCache({ checkedAt: Date.now(), latestVersion: latest });
+            resolve(latest !== currentVersion ? latest : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error",   () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+  });
 }
 
-process.exit(result.status ?? 0);
+// ── MCP mode: async spawn so the event loop stays alive for the update check ─
+
+if (args[0] === "mcp") {
+  const { version: currentVersion } = require("../package.json");
+
+  // Fire the update check in the background — result prints to stderr if newer
+  checkForUpdate(currentVersion).then((latest) => {
+    if (latest) {
+      process.stderr.write(
+        `\n[memtrace] Update available: ${currentVersion} → ${latest}\n` +
+        `           Run: npm install -g memtrace\n\n`
+      );
+    }
+  });
+
+  // Use async spawn (not spawnSync) so Node's event loop keeps running
+  const child = spawn(binaryPath, args, {
+    stdio: "inherit",
+    env:   process.env,
+  });
+
+  child.on("error", (e) => {
+    process.stderr.write(`memtrace: failed to start: ${e.message}\n`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    process.exit(signal ? 1 : (code ?? 0));
+  });
+
+} else {
+  // ── All other commands: synchronous pass-through ────────────────────────────
+
+  const result = spawnSync(binaryPath, args, {
+    stdio: "inherit",
+    env:   process.env,
+  });
+
+  if (result.error) {
+    console.error(`Failed to run memtrace: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 0);
+}

package/install.js

@@ -4,13 +4,9 @@
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
-const { execSync } = require("child_process");
+const { spawnSync } = require("child_process");
 
-// ── Constants ─────────────────────────────────────────────────────────────────
-
-const PLUGIN_NAME = "memtrace-skills";
-const MARKETPLACE_NAME = "memtrace";
-const MARKETPLACE_REPO = "syncable-dev/memtrace-public";
+// ── Platform binary resolution (preserved from legacy) ───────────────────────
 
 const PLATFORM_MAP = {
   "darwin-arm64": "@memtrace/darwin-arm64",
@@ -20,8 +16,6 @@ const PLATFORM_MAP = {
   "win32-x64":    "@memtrace/win32-x64",
 };
 
-// ── Binary helpers ────────────────────────────────────────────────────────────
-
 function getPlatformKey() {
   return `${os.platform()}-${os.arch()}`;
 }
@@ -29,17 +23,14 @@ function getPlatformKey() {
 function getBinaryPath() {
   const key = getPlatformKey();
   const pkg = PLATFORM_MAP[key];
-
   if (!pkg) {
     throw new Error(
       `Memtrace does not support platform: ${key}\n` +
       `Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`
     );
   }
-
   const ext = os.platform() === "win32" ? ".exe" : "";
   const binaryName = `memtrace${ext}`;
-
   try {
     return require.resolve(`${pkg}/bin/${binaryName}`);
   } catch {
@@ -50,149 +41,10 @@ function getBinaryPath() {
   }
 }
 
-// ── Skill installation ───────────────────────────────────────────────────────
-
-function installSkills() {
-  const skillsSrc = path.join(__dirname, "skills");
-  if (!fs.existsSync(skillsSrc)) {
-    console.warn("memtrace: skills directory not found, skipping skill installation");
-    return;
-  }
-
-  const claudeSkillsDir = path.join(os.homedir(), ".claude", "skills");
-
-  // Collect all .md skill files from commands/ and workflows/
-  const skillDirs = ["commands", "workflows"];
-  let installed = 0;
-
-  for (const dir of skillDirs) {
-    const srcDir = path.join(skillsSrc, dir);
-    if (!fs.existsSync(srcDir)) continue;
-
-    const files = fs.readdirSync(srcDir).filter(f => f.endsWith(".md"));
-    for (const file of files) {
-      const skillName = file.replace(/\.md$/, "");
-      const destDir = path.join(claudeSkillsDir, skillName);
-      const srcFile = path.join(srcDir, file);
-
-      try {
-        fs.mkdirSync(destDir, { recursive: true });
-        fs.copyFileSync(srcFile, path.join(destDir, "SKILL.md"));
-        installed++;
-      } catch (e) {
-        console.warn(`memtrace: failed to install skill ${skillName}: ${e.message}`);
-      }
-    }
-  }
-
-  if (installed > 0) {
-    console.log(`memtrace: installed ${installed} skills to ${claudeSkillsDir}`);
-  }
-}
-
-// ── Settings.json helpers ────────────────────────────────────────────────────
-
-function readSettings() {
-  const settingsFile = path.join(os.homedir(), ".claude", "settings.json");
-  if (fs.existsSync(settingsFile)) {
-    try {
-      return JSON.parse(fs.readFileSync(settingsFile, "utf-8"));
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-
-function writeSettings(settings) {
-  const settingsFile = path.join(os.homedir(), ".claude", "settings.json");
-  fs.mkdirSync(path.dirname(settingsFile), { recursive: true });
-  fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
-}
-
-// ── MCP server registration ─────────────────────────────────────────────────
-
-function registerMcpServer(binaryPath) {
-  const settings = readSettings();
-
-  if (!settings.mcpServers || typeof settings.mcpServers !== "object") {
-    settings.mcpServers = {};
-  }
-
-  settings.mcpServers.memtrace = {
-    command: binaryPath,
-    args: ["mcp"],
-    env: {
-      MEMGRAPH_URL: "bolt://localhost:7687",
-    },
-  };
-
-  writeSettings(settings);
-  console.log("memtrace: registered MCP server in ~/.claude/settings.json");
-}
-
-// ── Plugin + marketplace registration ────────────────────────────────────────
-
-function enablePlugin() {
-  const settings = readSettings();
-
-  // Enable plugin
-  if (!settings.enabledPlugins || typeof settings.enabledPlugins !== "object") {
-    settings.enabledPlugins = {};
-  }
-  const pluginKey = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-  settings.enabledPlugins[pluginKey] = true;
-
-  // Register marketplace
-  if (!settings.extraKnownMarketplaces || typeof settings.extraKnownMarketplaces !== "object") {
-    settings.extraKnownMarketplaces = {};
-  }
-  settings.extraKnownMarketplaces[MARKETPLACE_NAME] = {
-    source: {
-      source: "github",
-      repo: MARKETPLACE_REPO,
-    },
-  };
-
-  writeSettings(settings);
-  console.log(`memtrace: enabled plugin ${pluginKey}`);
-  console.log(`memtrace: registered marketplace ${MARKETPLACE_NAME}`);
-}
-
-// ── Try Claude CLI install first ─────────────────────────────────────────────
-
-function commandExists(cmd) {
-  try {
-    execSync(`which ${cmd}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function tryClaudeCliInstall() {
-  if (!commandExists("claude")) return false;
-
-  try {
-    execSync(`claude plugin marketplace add ${MARKETPLACE_REPO}`, {
-      stdio: "ignore",
-      timeout: 15000,
-    });
-    execSync(`claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME} --scope user`, {
-      stdio: "ignore",
-      timeout: 15000,
-    });
-    console.log("memtrace: installed skills via Claude CLI");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ── Main postinstall ─────────────────────────────────────────────────────────
 
 if (require.main === module) {
-  // 1. Verify binary
+  // 1. Verify binary exists + is executable
   let binaryPath = null;
   try {
     binaryPath = getBinaryPath();
@@ -207,40 +59,30 @@ if (require.main === module) {
     console.warn(`memtrace: ${e.message}`);
   }
 
-  // 2. Install skills to ~/.claude/skills/
-  try {
-    installSkills();
-  } catch (e) {
-    console.warn(`memtrace: skill installation failed: ${e.message}`);
-  }
-
-  // 3. Try Claude CLI first, fall back to manual settings
-  try {
-    if (!tryClaudeCliInstall()) {
-      enablePlugin();
-    }
-  } catch (e) {
-    console.warn(`memtrace: plugin registration failed: ${e.message}`);
-  }
-
-  // 4. Register MCP server
-  if (binaryPath) {
-    try {
-      registerMcpServer(binaryPath);
-    } catch (e) {
-      console.warn(`memtrace: MCP server registration failed: ${e.message}`);
+  // 2. Delegate to compiled installer (global, all agents, non-interactive)
+  const bundled = path.join(__dirname, "installer", "dist", "index.js");
+  if (fs.existsSync(bundled)) {
+    const result = spawnSync(process.execPath, [bundled, "install", "--yes"], {
+      stdio: "inherit",
+      env: { ...process.env, MEMTRACE_POSTINSTALL: "1" },
+    });
+    if (result.status !== 0) {
+      console.warn(`memtrace: installer exited with code ${result.status}; continuing.`);
     }
+  } else {
+    console.warn("memtrace: bundled installer not found at installer/dist/index.js");
+    console.warn("memtrace: run 'memtrace install' manually after the package is built.");
   }
 
-  // 5. Persist uninstall script to ~/.memtrace/ so it survives `npm uninstall -g`
-  //    (npm v7+ does NOT fire preuninstall hooks for global packages — npm/cli#3042)
+  // 3. Persist uninstall script to ~/.memtrace/ (survives `npm uninstall -g`)
   try {
     const memtraceDir = path.join(os.homedir(), ".memtrace");
     fs.mkdirSync(memtraceDir, { recursive: true });
-    const src = path.join(__dirname, "uninstall.js");
-    const dest = path.join(memtraceDir, "uninstall.js");
-    fs.copyFileSync(src, dest);
-    console.log(`memtrace: persisted uninstall script to ${dest}`);
+    fs.copyFileSync(
+      path.join(__dirname, "uninstall.js"),
+      path.join(memtraceDir, "uninstall.js"),
+    );
+    console.log(`memtrace: persisted uninstall script to ${path.join(memtraceDir, "uninstall.js")}`);
   } catch (e) {
     console.warn(`memtrace: failed to persist uninstall script: ${e.message}`);
   }

package/installer/dist/commands/doctor.d.ts

@@ -0,0 +1,16 @@
+export interface AgentReport {
+    agent: string;
+    skillsFound: number;
+    skillsDir: string;
+    mcpRegistered: boolean;
+    mcpConfigPath: string;
+}
+export interface DoctorReport {
+    binaryOk: boolean;
+    binaryPath?: string;
+    binaryVersion?: string;
+    agents: AgentReport[];
+}
+export declare function runDoctorChecks(): Promise<DoctorReport>;
+export declare function formatReport(r: DoctorReport): string;
+export declare function runDoctor(): Promise<number>;

package/installer/dist/commands/doctor.js

@@ -0,0 +1,86 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { commandExists, execCommand } from '../utils.js';
+import { safeReadJson } from '../fs-safe.js';
+async function checkBinary() {
+    if (!(await commandExists('memtrace')))
+        return { binaryOk: false };
+    try {
+        const which = process.platform === 'win32' ? 'where memtrace' : 'which memtrace';
+        const binaryPath = (await execCommand(which, { timeoutMs: 3_000 })).split('\n')[0].trim();
+        let binaryVersion;
+        try {
+            binaryVersion = await execCommand('memtrace --version', { timeoutMs: 3_000 });
+        }
+        catch { /* optional */ }
+        return { binaryOk: true, binaryPath, binaryVersion };
+    }
+    catch {
+        return { binaryOk: false };
+    }
+}
+function countMemtraceSkills(dir) {
+    if (!fs.existsSync(dir))
+        return 0;
+    return fs.readdirSync(dir)
+        .filter(e => e.startsWith('memtrace-'))
+        .filter(e => fs.existsSync(path.join(dir, e, 'SKILL.md')))
+        .length;
+}
+function mcpHasMemtrace(file) {
+    const { value } = safeReadJson(file);
+    if (!value)
+        return false;
+    return Boolean(value.mcpServers && value.mcpServers['memtrace']);
+}
+function checkAgent(agent) {
+    if (agent === 'claude') {
+        const skillsDir = path.join(os.homedir(), '.claude', 'skills');
+        const mcpConfigPath = path.join(os.homedir(), '.claude', 'settings.json');
+        return {
+            agent,
+            skillsFound: countMemtraceSkills(skillsDir),
+            skillsDir,
+            mcpRegistered: mcpHasMemtrace(mcpConfigPath),
+            mcpConfigPath,
+        };
+    }
+    const skillsDir = path.join(os.homedir(), '.cursor', 'skills');
+    const mcpConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    return {
+        agent,
+        skillsFound: countMemtraceSkills(skillsDir),
+        skillsDir,
+        mcpRegistered: mcpHasMemtrace(mcpConfigPath),
+        mcpConfigPath,
+    };
+}
+export async function runDoctorChecks() {
+    const binary = await checkBinary();
+    return {
+        ...binary,
+        agents: [checkAgent('claude'), checkAgent('cursor')],
+    };
+}
+export function formatReport(r) {
+    const lines = [];
+    const check = (ok) => (ok ? '✓' : '✗');
+    lines.push('memtrace doctor');
+    lines.push('───────────────');
+    lines.push(`${check(r.binaryOk)} memtrace binary${r.binaryPath ? '   ' + r.binaryPath : ''}`);
+    if (r.binaryVersion)
+        lines.push(`  version: ${r.binaryVersion}`);
+    for (const a of r.agents) {
+        lines.push(`${check(a.skillsFound > 0)} ${a.agent} skills installed   ${a.skillsFound} in ${a.skillsDir}`);
+        lines.push(`${check(a.mcpRegistered)} ${a.agent} MCP registered      ${a.mcpConfigPath}`);
+    }
+    return lines.join('\n');
+}
+export async function runDoctor() {
+    const report = await runDoctorChecks();
+    console.log(formatReport(report));
+    const healthy = report.binaryOk
+        && report.agents.every(a => a.skillsFound > 0 && a.mcpRegistered);
+    return healthy ? 0 : 1;
+}

package/installer/dist/commands/install.d.ts

@@ -0,0 +1,9 @@
+export interface InstallOptions {
+    scope: 'global' | 'local';
+    only?: string[];
+    skipMcp?: boolean;
+    yes?: boolean;
+}
+export declare function resolveMemtraceBinary(): Promise<string | null>;
+export declare function runInstall(options: InstallOptions): Promise<void>;
+export declare function runUninstall(options: InstallOptions): Promise<void>;

package/installer/dist/commands/install.js

@@ -0,0 +1,104 @@
+import path from 'path';
+import fs from 'fs';
+import { loadSkills } from '../skills.js';
+import { ALL_TRANSFORMERS, findTransformer } from '../transformers/index.js';
+import { commandExists, execCommand } from '../utils.js';
+import { canPrompt, promptForChoices } from './picker.js';
+export async function resolveMemtraceBinary() {
+    if (await commandExists('memtrace'))
+        return 'memtrace';
+    try {
+        const npmBin = await execCommand('npm bin -g', { timeoutMs: 5_000 });
+        const ext = process.platform === 'win32' ? '.exe' : '';
+        const abs = path.join(npmBin.trim(), `memtrace${ext}`);
+        if (fs.existsSync(abs))
+            return abs;
+    }
+    catch { /* fall through */ }
+    return null;
+}
+function selectTransformers(options) {
+    if (!options.only || options.only.length === 0)
+        return ALL_TRANSFORMERS;
+    const picks = [];
+    for (const name of options.only) {
+        const t = findTransformer(name);
+        if (!t) {
+            throw new Error(`Unknown agent: ${name}. Known: ${ALL_TRANSFORMERS.map(x => x.name).join(', ')}`);
+        }
+        picks.push(t);
+    }
+    return picks;
+}
+export async function runInstall(options) {
+    console.log('\n  Memtrace Skills Installer\n');
+    // Interactive prompt only when TTY is available and user didn't pre-specify
+    if (!options.yes && (!options.only || options.only.length === 0) && canPrompt()) {
+        const choice = await promptForChoices({ agents: [], scope: options.scope });
+        options.only = choice.agents;
+        options.scope = choice.scope;
+    }
+    const skillsDir = path.resolve(import.meta.dirname, '..', '..', 'skills');
+    const skills = loadSkills(skillsDir);
+    if (skills.length === 0) {
+        console.error('  Error: No skills found. Ensure skills/ directory exists.\n');
+        process.exit(1);
+    }
+    const memtraceBin = await resolveMemtraceBinary();
+    if (memtraceBin === null) {
+        console.warn('  ⚠ memtrace binary not found on PATH.');
+        console.warn('    MCP registration will be skipped for every agent.\n');
+    }
+    const transformers = selectTransformers(options);
+    const ctx = {
+        scope: options.scope,
+        cwd: process.cwd(),
+        memtraceBinary: memtraceBin ?? '',
+        skipMcp: options.skipMcp || memtraceBin === null,
+    };
+    for (const t of transformers) {
+        console.log(`  [${t.name}] installing...`);
+        try {
+            const r = await t.install(skills, ctx);
+            console.log(`  [${t.name}] ✓ ${r.skillsWritten} skills → ${r.skillsDir}`);
+            if (r.mcpRegistered)
+                console.log(`  [${t.name}] ✓ MCP registered`);
+            else if (ctx.skipMcp)
+                console.log(`  [${t.name}] (MCP skipped)`);
+            else
+                console.log(`  [${t.name}] ⚠ MCP registration failed`);
+            for (const w of r.warnings)
+                console.warn(`  [${t.name}] warn: ${w}`);
+        }
+        catch (e) {
+            console.error(`  [${t.name}] ✗ install failed: ${e.message}`);
+        }
+    }
+    // Auto health check — never affects install exit code
+    try {
+        const { runDoctorChecks, formatReport } = await import('./doctor.js');
+        const report = await runDoctorChecks();
+        console.log('\n' + formatReport(report));
+    }
+    catch { /* doctor failures never break install */ }
+    console.log('\n  Done.\n');
+}
+export async function runUninstall(options) {
+    console.log('\n  Removing Memtrace skills...\n');
+    const transformers = selectTransformers(options);
+    const ctx = {
+        scope: options.scope,
+        cwd: process.cwd(),
+        memtraceBinary: '',
+    };
+    for (const t of transformers) {
+        try {
+            await t.uninstall(ctx);
+            console.log(`  [${t.name}] removed`);
+        }
+        catch (e) {
+            console.warn(`  [${t.name}] uninstall failed: ${e.message}`);
+        }
+    }
+    console.log('\n  Done.\n');
+}

package/installer/dist/commands/picker.d.ts

@@ -0,0 +1,6 @@
+export interface PickerResult {
+    agents: string[];
+    scope: 'global' | 'local';
+}
+export declare function canPrompt(): boolean;
+export declare function promptForChoices(defaults: PickerResult): Promise<PickerResult>;

package/installer/dist/commands/picker.js

@@ -0,0 +1,22 @@
+import readline from 'readline';
+import { ALL_TRANSFORMERS } from '../transformers/index.js';
+export function canPrompt() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export async function promptForChoices(defaults) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    console.log('\n  Agents available:');
+    for (const t of ALL_TRANSFORMERS)
+        console.log(`    - ${t.name}`);
+    const agentsInput = await ask(`\n  Install for which agents? (comma-separated, default: all) `);
+    const agents = agentsInput.trim()
+        ? agentsInput.split(',').map(s => s.trim()).filter(Boolean)
+        : ALL_TRANSFORMERS.map(t => t.name);
+    const defaultScope = defaults.scope;
+    const scopeInput = await ask(`  Scope? [global/local] (default: ${defaultScope}) `);
+    const typed = scopeInput.trim().toLowerCase();
+    const scope = typed === 'local' ? 'local' : typed === 'global' ? 'global' : defaultScope;
+    rl.close();
+    return { agents, scope };
+}