@datacore-one/mcp 1.1.0 → 1.1.1

package/dist/index.js

@@ -237,7 +237,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.1.0",
+  version: "1.1.1",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -933,7 +933,15 @@ async function handleInject(args2, paths) {
   const result = selectEngrams(ctx, personalEngrams, packs);
   const totalCount = result.directives.length + result.consider.length;
   if (totalCount === 0) {
-    return { text: "", count: 0, tokens_used: 0 };
+    return {
+      text: "",
+      count: 0,
+      tokens_used: 0,
+      _hints: buildHints({
+        next: "No engrams matched this task. Use datacore.recall to search all sources, or datacore.learn to record new knowledge.",
+        related: ["datacore.recall", "datacore.learn"]
+      })
+    };
   }
   const lines = [];
   if (result.directives.length > 0) {
@@ -1383,6 +1391,10 @@ async function handleInstall(args2, packsDir) {
     const downloaded = await downloadPack(srcDir);
     if (downloaded.error) return { success: false, error: downloaded.error };
     srcDir = downloaded.path;
+  } else if (!srcDir.includes("/") && !srcDir.includes("\\")) {
+    const resolved = resolvePackId(srcDir, packsDir);
+    if (resolved.error) return { success: false, error: resolved.error };
+    srcDir = resolved.path;
   }
   const skillPath = path9.join(srcDir, "SKILL.md");
   if (!fs11.existsSync(skillPath)) {
@@ -1449,6 +1461,29 @@ function findPackRoot(dir) {
   }
   return null;
 }
+function resolvePackId(packId, packsDir) {
+  const registryPack = packs_default.packs.find((p) => p.id === packId);
+  if (!registryPack) {
+    return { error: `Pack "${packId}" not found in registry. Use datacore.packs.discover to browse available packs.` };
+  }
+  if (registryPack.download_url) {
+    return { error: `Pack "${packId}" must be installed via URL: ${registryPack.download_url}` };
+  }
+  const bundledDir = path9.join(
+    path9.dirname(new URL(import.meta.url).pathname),
+    "..",
+    "packs",
+    packId
+  );
+  if (fs11.existsSync(path9.join(bundledDir, "SKILL.md"))) {
+    return { path: bundledDir };
+  }
+  const localDir = path9.join(packsDir, packId);
+  if (fs11.existsSync(path9.join(localDir, "SKILL.md"))) {
+    return { path: localDir };
+  }
+  return { error: `Pack "${packId}" is registered but not available locally. It may need to be downloaded manually.` };
+}
 
 // src/tools/export.ts
 import * as fs12 from "fs";
@@ -1496,6 +1531,12 @@ async function handleExport(args2, paths) {
       }
     };
   }
+  if (fs12.existsSync(packDir)) {
+    return {
+      success: false,
+      error: `Pack directory already exists at ${packDir}. Remove it first or use a different name.`
+    };
+  }
   fs12.mkdirSync(packDir, { recursive: true });
   const skillContent = `---
 name: "${args2.name}"
@@ -1524,6 +1565,7 @@ Exported ${selected.length} engrams.
     visibility: e.visibility,
     statement: e.statement,
     rationale: e.rationale,
+    contraindications: e.contraindications,
     tags: e.tags,
     domain: e.domain,
     status: "active",
@@ -1797,9 +1839,10 @@ async function handleForget(args2, engramsPath) {
   }
   if (args2.search) {
     const searchLower = args2.search.toLowerCase();
-    const matches = engrams.filter((e) => e.status !== "retired").filter(
+    const allMatches = engrams.filter((e) => e.status !== "retired").filter(
       (e) => e.statement.toLowerCase().includes(searchLower) || e.id.toLowerCase().includes(searchLower) || e.tags.some((t) => t.toLowerCase().includes(searchLower))
-    ).slice(0, 10);
+    );
+    const matches = allMatches.slice(0, 100);
     if (matches.length === 0) {
       return { success: false, error: `No active engrams matching "${args2.search}"` };
     }
@@ -1810,26 +1853,44 @@ async function handleForget(args2, engramsPath) {
       saveEngrams(engramsPath, engrams);
       return { success: true, retired: { id: engram.id, statement: engram.statement } };
     }
+    const truncated = allMatches.length > 100;
     return {
       success: false,
       matches: matches.map((e) => ({ id: e.id, statement: e.statement })),
-      error: `Multiple matches found. Specify an exact ID to retire.`
+      total_matches: allMatches.length,
+      error: `${allMatches.length} matches found${truncated ? " (showing first 100)" : ""}. Specify an exact ID to retire.`
     };
   }
   return { success: false, error: "Provide either id or search parameter" };
 }
 
 // src/tools/feedback.ts
-async function handleFeedback(args2, engramsPath) {
+import * as path13 from "path";
+function findEngram(engramId, engramsPath, packsPath) {
+  const personal = loadEngrams(engramsPath);
+  const found = personal.find((e) => e.id === engramId);
+  if (found) return { engram: found, source: "personal", personalEngrams: personal };
+  const packs = loadAllPacks(packsPath);
+  for (const pack of packs) {
+    const packEngram = pack.engrams.find((e) => e.id === engramId);
+    if (packEngram) {
+      const packId = pack.manifest["x-datacore"]?.id;
+      const packEngramsPath = packId ? path13.join(packsPath, packId, "engrams.yaml") : void 0;
+      return { engram: packEngram, source: "pack", packEngrams: pack.engrams, packEngramsPath };
+    }
+  }
+  return null;
+}
+async function handleFeedback(args2, engramsPath, packsPath) {
+  const pPath = packsPath ?? path13.join(path13.dirname(engramsPath), "packs");
   if (args2.signals && args2.signals.length > 0) {
-    return handleBatchFeedback(args2.signals, engramsPath);
+    return handleBatchFeedback(args2.signals, engramsPath, pPath);
   }
-  return handleSingleFeedback(args2.engram_id, args2.signal, args2.comment, engramsPath);
+  return handleSingleFeedback(args2.engram_id, args2.signal, args2.comment, engramsPath, pPath);
 }
-async function handleSingleFeedback(engram_id, signal, comment, engramsPath) {
-  const engrams = loadEngrams(engramsPath);
-  const engram = engrams.find((e) => e.id === engram_id);
-  if (!engram) {
+async function handleSingleFeedback(engram_id, signal, comment, engramsPath, packsPath) {
+  const found = findEngram(engram_id, engramsPath, packsPath);
+  if (!found) {
     return {
       mode: "single",
       success: false,
@@ -1843,29 +1904,55 @@ async function handleSingleFeedback(engram_id, signal, comment, engramsPath) {
     };
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  if (!engram.feedback_signals) {
-    engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+  if (!found.engram.feedback_signals) {
+    found.engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+  }
+  found.engram.feedback_signals[signal] += 1;
+  found.engram.activation.last_accessed = today;
+  if (found.source === "personal" && found.personalEngrams) {
+    atomicWriteYaml(engramsPath, { engrams: found.personalEngrams });
+  } else if (found.source === "pack" && found.packEngrams && found.packEngramsPath) {
+    atomicWriteYaml(found.packEngramsPath, { engrams: found.packEngrams });
   }
-  engram.feedback_signals[signal] += 1;
-  engram.activation.last_accessed = today;
-  atomicWriteYaml(engramsPath, { engrams });
   return {
     mode: "single",
     success: true,
     engram_id,
     signal,
-    feedback_signals: { ...engram.feedback_signals }
+    source: found.source,
+    feedback_signals: { ...found.engram.feedback_signals }
   };
 }
-async function handleBatchFeedback(signals, engramsPath) {
-  const engrams = loadEngrams(engramsPath);
+async function handleBatchFeedback(signals, engramsPath, packsPath) {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const results = [];
   const summary = { positive: 0, negative: 0, neutral: 0 };
-  let changed = false;
+  const personal = loadEngrams(engramsPath);
+  const packs = loadAllPacks(packsPath);
+  let personalDirty = false;
+  const dirtyPackFiles = /* @__PURE__ */ new Map();
   for (const { engram_id, signal } of signals) {
-    const engram = engrams.find((e) => e.id === engram_id);
-    if (!engram) {
+    let engram = personal.find((e) => e.id === engram_id);
+    let source;
+    if (engram) {
+      source = "personal";
+    } else {
+      for (const pack of packs) {
+        engram = pack.engrams.find((e) => e.id === engram_id);
+        if (engram) {
+          source = "pack";
+          const packId = pack.manifest["x-datacore"]?.id;
+          if (packId) {
+            dirtyPackFiles.set(
+              path13.join(packsPath, packId, "engrams.yaml"),
+              pack.engrams
+            );
+          }
+          break;
+        }
+      }
+    }
+    if (!engram || !source) {
       results.push({ engram_id, signal, success: false, error: `Engram ${engram_id} not found` });
       continue;
     }
@@ -1875,11 +1962,14 @@ async function handleBatchFeedback(signals, engramsPath) {
     engram.feedback_signals[signal] += 1;
     engram.activation.last_accessed = today;
     summary[signal]++;
-    changed = true;
-    results.push({ engram_id, signal, success: true });
+    if (source === "personal") personalDirty = true;
+    results.push({ engram_id, signal, success: true, source });
   }
-  if (changed) {
-    atomicWriteYaml(engramsPath, { engrams });
+  if (personalDirty) {
+    atomicWriteYaml(engramsPath, { engrams: personal });
+  }
+  for (const [filePath, engrams] of dirtyPackFiles) {
+    atomicWriteYaml(filePath, { engrams });
   }
   return {
     mode: "batch",
@@ -1894,7 +1984,7 @@ async function handleBatchFeedback(signals, engramsPath) {
 
 // src/tools/session-start.ts
 import * as fs15 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 async function handleSessionStart(args2, storage2, bridge) {
   let engrams = null;
   if (args2.task) {
@@ -1907,7 +1997,7 @@ async function handleSessionStart(args2, storage2, bridge) {
     }
   }
   const { date: today } = localDate();
-  const journalFile = path13.join(storage2.journalPath, `${today}.md`);
+  const journalFile = path14.join(storage2.journalPath, `${today}.md`);
   const journal_today = fs15.existsSync(journalFile) ? fs15.readFileSync(journalFile, "utf8") : null;
   const allEngrams = loadEngrams(storage2.engramsPath);
   const pending_candidates = allEngrams.filter((e) => e.status === "candidate").length;
@@ -2114,7 +2204,7 @@ import {
   ListResourceTemplatesRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import * as fs16 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
 function registerResources(server, storage2) {
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -2195,7 +2285,7 @@ function registerResources(server, storage2) {
     const journalMatch = uri.match(/^datacore:\/\/journal\/(.+)$/);
     if (journalMatch) {
       const dateStr = journalMatch[1] === "today" ? localDate().date : journalMatch[1];
-      const filePath = path14.join(storage2.journalPath, `${dateStr}.md`);
+      const filePath = path15.join(storage2.journalPath, `${dateStr}.md`);
       if (!fs16.existsSync(filePath)) {
         return { contents: [{ uri, mimeType: "text/markdown", text: `No journal entry for ${dateStr}` }] };
       }
@@ -2431,7 +2521,7 @@ function registerPrompts(server) {
 // src/datacortex.ts
 import { execFile } from "child_process";
 import * as fs17 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 var DatacortexBridge = class {
   pythonPath;
   scriptPath;
@@ -2441,8 +2531,8 @@ var DatacortexBridge = class {
   }
   findBridgeScript(datacorePath) {
     const candidates = [
-      path15.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
-      path15.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
+      path16.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path16.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
     ];
     for (const candidate of candidates) {
       if (fs17.existsSync(candidate)) return candidate;
@@ -2579,7 +2669,7 @@ async function routeTool(name, args2) {
         result = await handleForget(validated, storage.engramsPath);
         break;
       case "datacore.feedback":
-        result = await handleFeedback(validated, storage.engramsPath);
+        result = await handleFeedback(validated, storage.engramsPath, storage.packsPath);
         break;
       case "datacore.session.start":
         result = await handleSessionStart(validated, storage, datacortexBridge);