memtrace 0.3.23 → 0.3.24

package/README.md

@@ -238,7 +238,7 @@ Uses **Structural Significance Budgeting** to surface the minimum set of changes
 For manual setup:
 
 ```bash
-claude plugin marketplace add syncable-dev/memtrace
+claude plugin marketplace add https://github.com/syncable-dev/memtrace-public.git
 claude plugin install memtrace-skills@memtrace --scope user
 claude mcp add memtrace -- memtrace mcp -e MEMTRACE_ARCADEDB_BOLT_URL=bolt://localhost:7687
 ```

package/installer/dist/transformers/claude.d.ts

@@ -23,6 +23,15 @@ export declare function registerMcpInSettingsAt(settingsPath: string, memtraceBi
  * Never overwrites a malformed file.
  */
 export declare function enablePluginInSettingsAt(settingsPath: string): SettingsMutationResult;
+export interface SettingsCleanupResult {
+    changed: boolean;
+    backupPath?: string;
+}
+/**
+ * Remove every Claude settings entry Memtrace may have written across
+ * installer versions and Claude marketplace schema changes.
+ */
+export declare function removeClaudeSettingsEntriesAt(settingsPath: string): SettingsCleanupResult;
 /**
  * Full Claude Code plugin installation.
  *

package/installer/dist/transformers/claude.js

@@ -5,7 +5,23 @@ import { execCommand, commandExists } from '../utils.js';
 import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
 const PLUGIN_NAME = 'memtrace-skills';
 const MARKETPLACE_NAME = 'memtrace';
-const MARKETPLACE_REPO = 'syncable-dev/memtrace';
+const MARKETPLACE_REPO = 'syncable-dev/memtrace-public';
+const MARKETPLACE_GIT_URL = `https://github.com/${MARKETPLACE_REPO}.git`;
+const PLUGIN_KEY = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+const MARKETPLACE_SETTING_KEYS = [
+    MARKETPLACE_NAME,
+    'syncable-dev-memtrace',
+    'syncable-dev-memtrace-public',
+];
+const MARKETPLACE_SETTING_CONTAINERS = [
+    'extraKnownMarketplaces',
+    'marketplaces',
+    'pluginMarketplaces',
+    'knownMarketplaces',
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 /**
  * Try to register the memtrace MCP server via `claude mcp add-json`.
  * Returns true on success, false on timeout/error/missing CLI.
@@ -87,7 +103,7 @@ async function tryClaudeCliInstall() {
     if (!hasClaude)
         return false;
     try {
-        await execCommand(`claude plugin marketplace add ${MARKETPLACE_REPO}`);
+        await execCommand(`claude plugin marketplace add --scope user ${MARKETPLACE_GIT_URL}`);
     }
     catch {
         // Marketplace may already exist
@@ -101,8 +117,7 @@ async function tryClaudeCliInstall() {
             const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
             if (fs.existsSync(settingsPath)) {
                 const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                const key = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-                if (settings.enabledPlugins?.[key] === true) {
+                if (settings.enabledPlugins?.[PLUGIN_KEY] === true) {
                     return true;
                 }
             }
@@ -168,10 +183,10 @@ export function enablePluginInSettingsAt(settingsPath) {
     }
     const settings = (value ?? {});
     settings.enabledPlugins = settings.enabledPlugins ?? {};
-    settings.enabledPlugins[`${PLUGIN_NAME}@${MARKETPLACE_NAME}`] = true;
+    settings.enabledPlugins[PLUGIN_KEY] = true;
     settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
     settings.extraKnownMarketplaces[MARKETPLACE_NAME] = {
-        source: { source: 'github', repo: MARKETPLACE_REPO },
+        source: { source: 'git', url: MARKETPLACE_GIT_URL },
     };
     writeJsonAtomic(settingsPath, settings);
     return { registered: true };
@@ -183,6 +198,79 @@ function enablePluginInSettings() {
     const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
     enablePluginInSettingsAt(settingsFile);
 }
+/**
+ * Remove every Claude settings entry Memtrace may have written across
+ * installer versions and Claude marketplace schema changes.
+ */
+export function removeClaudeSettingsEntriesAt(settingsPath) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${settingsPath} is malformed; backed up to ${backupPath}. Skipped Claude settings cleanup.`);
+        return { changed: false, backupPath };
+    }
+    if (!value)
+        return { changed: false };
+    const settings = value;
+    let changed = false;
+    const enabledPlugins = settings.enabledPlugins;
+    if (isRecord(enabledPlugins)) {
+        for (const key of Object.keys(enabledPlugins)) {
+            if (key === PLUGIN_KEY || (key.startsWith(`${PLUGIN_NAME}@`) && key.includes('memtrace'))) {
+                delete enabledPlugins[key];
+                changed = true;
+            }
+        }
+        if (Object.keys(enabledPlugins).length === 0)
+            delete settings.enabledPlugins;
+    }
+    const mcpServers = settings.mcpServers;
+    if (isRecord(mcpServers) && Object.hasOwn(mcpServers, 'memtrace')) {
+        delete mcpServers.memtrace;
+        changed = true;
+        if (Object.keys(mcpServers).length === 0)
+            delete settings.mcpServers;
+    }
+    for (const containerName of MARKETPLACE_SETTING_CONTAINERS) {
+        const container = settings[containerName];
+        if (!isRecord(container))
+            continue;
+        for (const key of MARKETPLACE_SETTING_KEYS) {
+            if (Object.hasOwn(container, key)) {
+                delete container[key];
+                changed = true;
+            }
+        }
+        if (Object.keys(container).length === 0)
+            delete settings[containerName];
+    }
+    if (changed)
+        writeJsonAtomic(settingsPath, settings);
+    return { changed };
+}
+function removeClaudeMarketplaceCacheDirs() {
+    const marketplacesRoot = path.join(os.homedir(), '.claude', 'plugins', 'marketplaces');
+    for (const entry of MARKETPLACE_SETTING_KEYS) {
+        const dir = path.join(marketplacesRoot, entry);
+        if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+}
+function removeClaudeInstalledPluginMetadata() {
+    const installedPluginsFile = path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    const { value, corrupted } = safeReadJson(installedPluginsFile);
+    if (corrupted || !value || !isRecord(value.plugins))
+        return;
+    let changed = false;
+    for (const key of Object.keys(value.plugins)) {
+        if (key === PLUGIN_KEY || (key.startsWith(`${PLUGIN_NAME}@`) && key.includes('memtrace'))) {
+            delete value.plugins[key];
+            changed = true;
+        }
+    }
+    if (changed)
+        writeJsonAtomic(installedPluginsFile, value);
+}
 /**
  * Register the memtrace MCP server in Claude Code's settings.
  * This adds the MCP server config so Claude Code can connect to memtrace tools.
@@ -204,9 +292,13 @@ async function registerMcpServer(memtraceBinaryPath) {
  *  3. Register MCP server for memtrace tools
  */
 export async function installClaudePlugin(skills, memtraceBinaryPath) {
-    // Step 1: Try CLI install
+    // Step 1: make sure Claude sees the public HTTPS marketplace source before
+    // the CLI attempts to clone/update it.
+    enablePluginInSettings();
+    removeClaudeMarketplaceCacheDirs();
+    // Step 2: Try CLI install
     await tryClaudeCliInstall();
-    // Step 2: Find or create cache dir
+    // Step 3: Find or create cache dir
     let cacheDir = findCliInstalledCacheDir();
     if (cacheDir) {
         const orphanedFile = path.join(cacheDir, '.orphaned_at');
@@ -216,7 +308,7 @@ export async function installClaudePlugin(skills, memtraceBinaryPath) {
     else {
         cacheDir = getClaudePluginCacheDir();
     }
-    // Step 3: Clean up old versions
+    // Step 4: Clean up old versions
     const pluginRoot = getPluginCacheRoot();
     if (fs.existsSync(pluginRoot)) {
         const activeDirName = path.basename(cacheDir);
@@ -226,7 +318,7 @@ export async function installClaudePlugin(skills, memtraceBinaryPath) {
             }
         }
     }
-    // Step 4: Write skills
+    // Step 5: Write skills
     const skillsDir = path.join(cacheDir, 'skills');
     if (fs.existsSync(skillsDir)) {
         fs.rmSync(skillsDir, { recursive: true });
@@ -241,9 +333,9 @@ export async function installClaudePlugin(skills, memtraceBinaryPath) {
     }
     writePluginManifest(cacheDir);
     enablePluginInSettings();
-    // Step 5: Register MCP server
+    // Step 6: Register MCP server
     await registerMcpServer(memtraceBinaryPath);
-    // Step 6: Write user-level skills for SDK-based integrations
+    // Step 7: Write user-level skills for SDK-based integrations
     writeUserLevelSkills(skills);
     return { cacheDir, skillCount: skills.length };
 }
@@ -281,18 +373,12 @@ export async function uninstallClaudePlugin() {
     const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
     if (fs.existsSync(settingsFile)) {
         try {
-            const settings = JSON.parse(fs.readFileSync(settingsFile, 'utf-8'));
-            const pluginKey = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-            if (settings.enabledPlugins && typeof settings.enabledPlugins === 'object') {
-                delete settings.enabledPlugins[pluginKey];
-            }
-            if (settings.mcpServers && typeof settings.mcpServers === 'object') {
-                delete settings.mcpServers['memtrace'];
-            }
-            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+            removeClaudeSettingsEntriesAt(settingsFile);
         }
         catch { /* */ }
     }
+    removeClaudeMarketplaceCacheDirs();
+    removeClaudeInstalledPluginMetadata();
     // Clean up user-level skills
     const userSkillsDir = path.join(os.homedir(), '.claude', 'skills');
     if (fs.existsSync(userSkillsDir)) {

package/installer/skills/workflows/memtrace-first.md

@@ -16,6 +16,10 @@ Memtrace is the memory layer of the codebase. It has the full knowledge graph: e
 
 **97% better accuracy. 83% fewer wasted tokens. No exceptions.**
 
+## Value Tracking
+
+Do not print usage receipts in normal answers. Memtrace records tool usage, graph facts, file references, and estimated context avoided internally. Users can inspect that in the local UI's Value panel.
+
 ## Parameter Types — Read This Before Calling Any Tool
 
 All memtrace MCP tools are **strictly typed**. Pass JSON numbers (not strings) for integer parameters.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -36,9 +36,9 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.3.23",
-    "@memtrace/linux-x64": "0.3.23",
-    "@memtrace/win32-x64": "0.3.23"
+    "@memtrace/darwin-arm64": "0.3.24",
+    "@memtrace/linux-x64": "0.3.24",
+    "@memtrace/win32-x64": "0.3.24"
   },
   "engines": {
     "node": ">=18"

package/skills/workflows/memtrace-first.md

@@ -18,6 +18,10 @@ Memtrace is the memory layer of the codebase. It has the full knowledge graph: e
 
 **97% better accuracy. 83% fewer wasted tokens. No exceptions for what's in the graph.**
 
+## Value Tracking
+
+Do not print usage receipts in normal answers. Memtrace records tool usage, graph facts, file references, and estimated context avoided internally. Users can inspect that in the local UI's Value panel.
+
 ## What Memtrace actually indexes
 
 Memtrace's hybrid search = **BM25 over symbol metadata** (name, signature, file_path, kind) **+ semantic vector search over embedded code bodies** (first ~1500 chars of every Function / Method / Class / Struct / Interface body), fused via Reciprocal Rank Fusion.

package/uninstall.js

@@ -11,6 +11,18 @@ const { execSync, spawnSync } = require("child_process");
 const PLUGIN_NAME = "memtrace-skills";
 const MARKETPLACE_NAME = "memtrace";
 const MCP_SERVER_NAME = "memtrace";
+const PLUGIN_KEY = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+const MARKETPLACE_SETTING_KEYS = [
+  MARKETPLACE_NAME,
+  "syncable-dev-memtrace",
+  "syncable-dev-memtrace-public",
+];
+const MARKETPLACE_SETTING_CONTAINERS = [
+  "extraKnownMarketplaces",
+  "marketplaces",
+  "pluginMarketplaces",
+  "knownMarketplaces",
+];
 
 const SKILL_NAMES = [
   // Commands
@@ -71,13 +83,17 @@ function writeSettings(settings) {
   fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
 }
 
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ── Remove MCP server ───────────────────────────────────────────────────────
 
 function removeMcpServer() {
   const settings = readSettings();
   let changed = false;
 
-  if (settings.mcpServers && settings.mcpServers[MCP_SERVER_NAME]) {
+  if (isRecord(settings.mcpServers) && settings.mcpServers[MCP_SERVER_NAME]) {
     delete settings.mcpServers[MCP_SERVER_NAME];
     if (Object.keys(settings.mcpServers).length === 0) {
       delete settings.mcpServers;
@@ -94,29 +110,82 @@ function removeMcpServer() {
 function removePlugin() {
   const settings = readSettings();
   let changed = false;
-  const pluginKey = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 
-  if (settings.enabledPlugins && settings.enabledPlugins[pluginKey] !== undefined) {
-    delete settings.enabledPlugins[pluginKey];
+  if (isRecord(settings.enabledPlugins)) {
+    for (const key of Object.keys(settings.enabledPlugins)) {
+      if (key === PLUGIN_KEY || (key.startsWith(`${PLUGIN_NAME}@`) && key.includes("memtrace"))) {
+        delete settings.enabledPlugins[key];
+        changed = true;
+      }
+    }
     if (Object.keys(settings.enabledPlugins).length === 0) {
       delete settings.enabledPlugins;
     }
-    changed = true;
-    console.log(`memtrace: removed plugin ${pluginKey}`);
+    if (changed) console.log(`memtrace: removed plugin ${PLUGIN_KEY}`);
   }
 
-  if (settings.extraKnownMarketplaces && settings.extraKnownMarketplaces[MARKETPLACE_NAME]) {
-    delete settings.extraKnownMarketplaces[MARKETPLACE_NAME];
-    if (Object.keys(settings.extraKnownMarketplaces).length === 0) {
-      delete settings.extraKnownMarketplaces;
+  let removedMarketplace = false;
+  for (const containerName of MARKETPLACE_SETTING_CONTAINERS) {
+    const container = settings[containerName];
+    if (!isRecord(container)) continue;
+    for (const key of MARKETPLACE_SETTING_KEYS) {
+      if (Object.prototype.hasOwnProperty.call(container, key)) {
+        delete container[key];
+        changed = true;
+        removedMarketplace = true;
+      }
     }
-    changed = true;
+    if (Object.keys(container).length === 0) {
+      delete settings[containerName];
+    }
+  }
+
+  if (removedMarketplace) {
     console.log(`memtrace: removed marketplace ${MARKETPLACE_NAME}`);
   }
 
   if (changed) writeSettings(settings);
 }
 
+function removeMarketplaceCaches() {
+  const marketplacesRoot = path.join(os.homedir(), ".claude", "plugins", "marketplaces");
+  for (const entry of MARKETPLACE_SETTING_KEYS) {
+    const dir = path.join(marketplacesRoot, entry);
+    if (fs.existsSync(dir)) {
+      try {
+        fs.rmSync(dir, { recursive: true, force: true });
+        console.log(`memtrace: removed marketplace cache ${entry}`);
+      } catch (e) {
+        console.warn(`memtrace: failed to remove marketplace cache ${entry}: ${e.message}`);
+      }
+    }
+  }
+}
+
+function removeInstalledPluginMetadata() {
+  const installedPluginsFile = path.join(os.homedir(), ".claude", "plugins", "installed_plugins.json");
+  if (!fs.existsSync(installedPluginsFile)) return;
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(installedPluginsFile, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!isRecord(data.plugins)) return;
+
+  let changed = false;
+  for (const key of Object.keys(data.plugins)) {
+    if (key === PLUGIN_KEY || (key.startsWith(`${PLUGIN_NAME}@`) && key.includes("memtrace"))) {
+      delete data.plugins[key];
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(installedPluginsFile, JSON.stringify(data, null, 2) + "\n");
+    console.log("memtrace: removed plugin metadata");
+  }
+}
+
 // ── Try Claude CLI uninstall ────────────────────────────────────────────────
 
 function tryClaudeCliUninstall() {
@@ -140,11 +209,15 @@ function tryClaudeCliUninstall() {
 
 // ── Main uninstall logic ───────────────────────────────────────────────────
 
-function legacyCleanup() {
+function legacyCleanup(options = {}) {
   try { removeSkills(); } catch (e) { console.warn(`memtrace: skill removal failed: ${e.message}`); }
-  try { tryClaudeCliUninstall(); } catch { /* silent */ }
+  if (!options.skipClaudeCli) {
+    try { tryClaudeCliUninstall(); } catch { /* silent */ }
+  }
   try { removePlugin(); } catch (e) { console.warn(`memtrace: plugin removal failed: ${e.message}`); }
   try { removeMcpServer(); } catch (e) { console.warn(`memtrace: MCP server removal failed: ${e.message}`); }
+  try { removeMarketplaceCaches(); } catch (e) { console.warn(`memtrace: marketplace cache cleanup failed: ${e.message}`); }
+  try { removeInstalledPluginMetadata(); } catch (e) { console.warn(`memtrace: installed plugin metadata cleanup failed: ${e.message}`); }
 }
 
 function run() {
@@ -159,6 +232,9 @@ function run() {
     if (result.status !== 0) {
       console.warn(`memtrace: installer uninstall exited ${result.status}; falling back to legacy cleanup`);
       legacyCleanup();
+    } else {
+      // Older bundled uninstallers did not remove every marketplace shape.
+      legacyCleanup({ skipClaudeCli: true });
     }
   } else {
     // No bundled installer — use legacy JS-only cleanup (Claude-only)