prism-mcp-server 20.2.6 → 20.2.7

package/dist/utils/nlQuery.js

@@ -7,11 +7,14 @@
  * This closes the gap where users have to learn tool syntax to query memories.
  * Instead, they ask plain English questions and get structured results.
  *
- * Pipeline:
+ * Parsing pipeline:
  *   1. Intent classification (decision, todo, file, general)
  *   2. Key phrase extraction
- *   3. Multi-strategy search (keyword + semantic)
- *   4. Answer synthesis (optional, uses local LLM)
+ *   3. Structured memory-query construction
+ *
+ * Execution, web fallback, and grounded prism_infer synthesis live in
+ * queryMemoryNaturalHandler.ts. Keeping network/model work out of this parser
+ * makes intent handling deterministic and independently testable.
  */
 import { debugLog } from "./logger.js";
 // ─── Intent Classification ───────────────────────────────────
@@ -151,34 +154,4 @@ export function parseNLQuery(query, project) {
         suggestedArgs: args,
     };
 }
-/**
- * Execute a natural language query end-to-end.
- *
- * Parses the query, executes the appropriate tool, and optionally
- * synthesizes an answer using the local LLM.
- */
-export async function executeNLQuery(query, project, synthesize = false) {
-    const parsed = parseNLQuery(query, project);
-    // Execute the search
-    let sources = [];
-    let answer = "";
-    try {
-        // Return the parsed query structure — the caller (handler) will
-        // execute the actual tool call using the suggestedTool and suggestedArgs.
-        answer =
-            `Intent: ${parsed.intent} (confidence: ${(parsed.confidence * 100).toFixed(0)}%)\n` +
-                `Keywords: ${parsed.extractedKeywords.join(", ")}\n` +
-                `Suggested tool: ${parsed.suggestedTool}\n` +
-                `Search query: "${parsed.searchQuery}"`;
-    }
-    catch (err) {
-        debugLog(`NL query execution failed: ${err}`);
-        answer = `Unable to parse query: ${err}`;
-    }
-    return {
-        ...parsed,
-        answer: answer || "No relevant memories found.",
-        sources,
-    };
-}
 debugLog("v12.2: Natural language query module loaded");

package/dist/utils/qualityGate.js

@@ -54,7 +54,11 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
         .replace(/^#{1,6}\s+.*$/gm, "")
         .replace(/^[\s*-]*\*{1,2}[^*]+\*{1,2}:?\s*$/gm, "");
     const proseSentences = proseOnly.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
-    if (proseSentences.length >= 6) {
+    // Plain source code often repeats structural lines across methods. In code
+    // mode those are not prose loops, and splitting on "." corrupts member
+    // access (`node = self.root` becomes `node = self`). Pass B below still
+    // catches egregious repetition at the higher threshold.
+    if (mode !== "code" && proseSentences.length >= 6) {
         const counts = new Map();
         for (const s of proseSentences) {
             const key = s.toLowerCase();
@@ -68,7 +72,17 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     // inside fake code blocks or other structural elements. Higher
     // threshold avoids false positives on legitimate code patterns
     // (e.g. `node = self.root` × 4 is fine, × 5 is suspicious).
-    const allSentences = stripped.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
+    // In code mode, periods are member-access operators, not sentence
+    // boundaries. Splitting `input.length` at "." made several different
+    // loops share the fragment `while (i < input` and falsely counted it as
+    // repeated output. Full-line matching still catches genuinely duplicated
+    // source while preserving valid repeated control-flow shapes.
+    const fullTextUnits = mode === "code"
+        ? stripped.split(/\n+/)
+        : stripped.split(/[.!?\n]+/);
+    const allSentences = fullTextUnits
+        .map(s => s.trim())
+        .filter(s => s.length > 10);
     if (allSentences.length >= 10) {
         const counts = new Map();
         for (const s of allSentences) {

package/dist/utils/synaluxSearch.js

@@ -69,7 +69,7 @@ async function portalPost(path, body, timeoutMs = 15_000) {
  * the shape of performWebSearch() in braveApi.ts.
  */
 export async function synaluxWebSearch(query, count = 10) {
-    debugLog(`[synaluxSearch] web search: q="${query}", limit=${count}`);
+    debugLog(`[synaluxSearch] web search: query_chars=${query.length}, limit=${count}`);
     const data = await portalPost("/api/v1/prism/search", {
         query,
         limit: Math.min(count, 20),
@@ -92,7 +92,7 @@ export async function synaluxWebSearch(query, count = 10) {
  * Used by code-mode handlers that pass raw data to the QuickJS sandbox.
  */
 export async function synaluxWebSearchRaw(query, count = 10) {
-    debugLog(`[synaluxSearch] web search raw: q="${query}", limit=${count}`);
+    debugLog(`[synaluxSearch] web search raw: query_chars=${query.length}, limit=${count}`);
     const data = await portalPost("/api/v1/prism/search", {
         query,
         limit: Math.min(count, 20),
@@ -118,7 +118,7 @@ export async function synaluxWebSearchRaw(query, count = 10) {
  * Returns formatted text matching performLocalSearch() shape.
  */
 export async function synaluxLocalSearch(query, count = 5) {
-    debugLog(`[synaluxSearch] local search: q="${query}", count=${count}`);
+    debugLog(`[synaluxSearch] local search: query_chars=${query.length}, count=${count}`);
     const data = await portalPost("/api/v1/prism/local-search", {
         query,
         count: Math.min(count, 20),
@@ -136,7 +136,7 @@ export async function synaluxLocalSearch(query, count = 5) {
  * Local/POI search raw — returns JSON string for code-mode sandbox.
  */
 export async function synaluxLocalSearchRaw(query, count = 5) {
-    debugLog(`[synaluxSearch] local search raw: q="${query}", count=${count}`);
+    debugLog(`[synaluxSearch] local search raw: query_chars=${query.length}, count=${count}`);
     const data = await portalPost("/api/v1/prism/local-search", {
         query,
         count: Math.min(count, 20),
@@ -162,7 +162,7 @@ export async function synaluxLocalSearchRaw(query, count = 5) {
  * AI-grounded answers via Synalux portal.
  */
 export async function synaluxBraveAnswers(query, model) {
-    debugLog(`[synaluxSearch] answers: q="${query}", model=${model || "default"}`);
+    debugLog(`[synaluxSearch] answers: query_chars=${query.length}, model=${model || "default"}`);
     const body = { query };
     if (model)
         body.model = model;
@@ -179,7 +179,7 @@ export async function synaluxBraveAnswers(query, model) {
  * Scrape a URL via Synalux portal. Returns the extracted content string.
  */
 export async function synaluxScrape(url, options) {
-    debugLog(`[synaluxSearch] scrape: url="${url}"`);
+    debugLog(`[synaluxSearch] scrape: url_chars=${url.length}`);
     const body = { url };
     if (options?.formats)
         body.formats = options.formats;
@@ -187,9 +187,13 @@ export async function synaluxScrape(url, options) {
         body.onlyMainContent = options.onlyMainContent;
     if (options?.waitFor !== undefined)
         body.waitFor = options.waitFor;
-    const data = await portalPost("/api/v1/prism/scrape", body);
+    const data = await portalPost("/api/v1/prism/scrape", body, options?.timeoutMs);
     if (data.status === "error") {
         throw new Error(`[synaluxSearch] scrape error: ${data.error || "unknown"}`);
     }
-    return data.content || "";
+    return data.content ||
+        data.data?.markdown ||
+        data.data?.html ||
+        data.data?.rawHtml ||
+        "";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.6",
+  "version": "20.2.7",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -154,10 +154,11 @@
     "jsdom": "^29.0.1",
     "openai": "^6.32.0",
     "p-limit": "^7.3.0",
-    "postcss": "8.5.12",
+    "postcss": "8.5.23",
     "quickjs-emscripten": "^0.32.0",
     "smol-toml": "^1.7.0",
     "stream-json": "^2.0.0",
+    "tldts": "^7.0.27",
     "turndown": "^7.2.2",
     "zod": "^4.3.6"
   }

package/dist/boundaries/__tests__/boundaries.test.js

@@ -1,46 +0,0 @@
-/**
- * boundaries.ts unit tests
- *
- * Verifies structural invariants of the safety declaration:
- * - BOUNDARIES_VERSION is present and non-empty
- * - BOUNDARIES_TEXT covers safety-critical concepts
- * - Architecture/routing docs moved to server instructions (not per-call)
- */
-import { describe, it, expect } from "vitest";
-import { BOUNDARIES_VERSION, BOUNDARIES_TEXT } from "../../boundaries/boundaries.js";
-describe("BOUNDARIES_VERSION", () => {
-    it("is a non-empty string", () => {
-        expect(typeof BOUNDARIES_VERSION).toBe("string");
-        expect(BOUNDARIES_VERSION.length).toBeGreaterThan(0);
-    });
-});
-describe("BOUNDARIES_TEXT structure", () => {
-    it("is a non-empty string under 500 chars (compressed from ~2000)", () => {
-        expect(typeof BOUNDARIES_TEXT).toBe("string");
-        expect(BOUNDARIES_TEXT.length).toBeGreaterThan(50);
-        expect(BOUNDARIES_TEXT.length).toBeLessThan(600);
-    });
-    it("has no leading or trailing whitespace (trim() was applied)", () => {
-        expect(BOUNDARIES_TEXT).toBe(BOUNDARIES_TEXT.trim());
-    });
-    it("references BCBA reserved categories", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/BCBA reserved/i);
-    });
-    it("references fail-closed refusal for reserved content", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/refused/i);
-    });
-    it("states AAC access is never restricted as a consequence", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/AAC access is never restricted/i);
-    });
-    it("references restraint as reserved", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/restraint/i);
-    });
-    it("references crisis/self-harm interception", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/crisis|self-harm/i);
-    });
-    it("does NOT contain architecture/routing docs (those moved to server instructions)", () => {
-        expect(BOUNDARIES_TEXT).not.toContain("session_save_ledger");
-        expect(BOUNDARIES_TEXT).not.toContain("inference routing");
-        expect(BOUNDARIES_TEXT).not.toMatch(/host note/i);
-    });
-});

package/dist/session/__tests__/sessionContext.test.js

@@ -1,134 +0,0 @@
-/**
- * sessionContext.ts unit tests
- *
- * Covers: markContextLoaded, requireContextLoaded, noteInferenceForSession,
- * getSessionState, TTL eviction, and fail-closed behaviour for unknown sessions.
- *
- * The module uses in-process Map state. Each test imports a fresh module instance
- * via vi.resetModules() + dynamic re-import so tests are isolated without needing
- * an exported reset function.
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { BOUNDARIES_VERSION } from "../../boundaries/boundaries.js";
-// Reset module registry before each test so the in-memory Map starts empty.
-let markContextLoaded;
-let requireContextLoaded;
-let noteInferenceForSession;
-let getSessionState;
-beforeEach(async () => {
-    vi.resetModules();
-    const mod = await import("../../session/sessionContext.js");
-    markContextLoaded = mod.markContextLoaded;
-    requireContextLoaded = mod.requireContextLoaded;
-    noteInferenceForSession = mod.noteInferenceForSession;
-    getSessionState = mod.getSessionState;
-});
-describe("requireContextLoaded — fail-closed defaults", () => {
-    it("blocks an unknown conversation (never seen)", () => {
-        const result = requireContextLoaded("never-seen-id");
-        expect(result).not.toBeNull();
-        expect(result.blocked).toBe(true);
-        if (result && result.blocked)
-            expect(result.error).toContain("context_not_loaded");
-    });
-    it("allows (returns null) when conversation_id is undefined — gate is opt-in", () => {
-        // Callers without a conversation_id (auto-push hosts, resource readers,
-        // legacy clients) are not gated — they use the session-agnostic interface.
-        const result = requireContextLoaded(undefined);
-        expect(result).toBeNull();
-    });
-    it("blocks (hard) when conversation_id is empty string — empty string is not opt-in bypass", () => {
-        // "" is not the same as undefined. An empty string means the caller explicitly
-        // provided a conversation_id but it's invalid. The gate should block, not bypass.
-        const result = requireContextLoaded("");
-        expect(result).not.toBeNull();
-        expect(result.blocked).toBe(true);
-        if (result && result.blocked)
-            expect(result.error).toContain("context_not_loaded");
-    });
-    it("blocks a session by unknown id even if noteInference was called for it", () => {
-        // noteInferenceForSession no longer creates stubs, so an unregistered id
-        // is still unknown to the gate.
-        noteInferenceForSession("conv-telemetry-only", { backend: "local", usedCloud: false });
-        const result = requireContextLoaded("conv-telemetry-only");
-        expect(result).not.toBeNull();
-        expect(result.blocked).toBe(true);
-    });
-});
-describe("markContextLoaded → requireContextLoaded lifecycle", () => {
-    it("returns null (pass) after markContextLoaded is called", () => {
-        markContextLoaded("conv-abc", "project-x", BOUNDARIES_VERSION);
-        expect(requireContextLoaded("conv-abc")).toBeNull();
-    });
-    it("records project and boundariesVersion on the session", () => {
-        markContextLoaded("conv-meta", "my-project", "42");
-        const state = getSessionState("conv-meta");
-        expect(state).not.toBeNull();
-        expect(state.project).toBe("my-project");
-        expect(state.boundariesVersion).toBe("42");
-        expect(state.contextLoaded).toBe(true);
-    });
-    it("is idempotent — calling twice does not break state", () => {
-        // Use the actual BOUNDARIES_VERSION so no drift warning fires.
-        markContextLoaded("conv-idem", "proj", BOUNDARIES_VERSION);
-        markContextLoaded("conv-idem", "proj-updated", BOUNDARIES_VERSION);
-        const state = getSessionState("conv-idem");
-        expect(state.project).toBe("proj-updated");
-        expect(state.boundariesVersion).toBe(BOUNDARIES_VERSION);
-        expect(requireContextLoaded("conv-idem")).toBeNull();
-    });
-    it("isolates sessions — loading one does not unblock another", () => {
-        markContextLoaded("conv-A", "proj", BOUNDARIES_VERSION);
-        expect(requireContextLoaded("conv-A")).toBeNull();
-        expect(requireContextLoaded("conv-B")).not.toBeNull();
-    });
-});
-describe("noteInferenceForSession", () => {
-    it("increments inferenceCalls on every call", () => {
-        markContextLoaded("conv-inf", "proj", BOUNDARIES_VERSION);
-        noteInferenceForSession("conv-inf", { backend: "local", usedCloud: false });
-        noteInferenceForSession("conv-inf", { backend: "local", usedCloud: false });
-        const state = getSessionState("conv-inf");
-        expect(state.inferenceCalls).toBe(2);
-    });
-    it("increments usedCloudCalls only for cloud calls", () => {
-        markContextLoaded("conv-cloud", "proj", BOUNDARIES_VERSION);
-        noteInferenceForSession("conv-cloud", { backend: "cloud", usedCloud: true });
-        noteInferenceForSession("conv-cloud", { backend: "local", usedCloud: false });
-        const state = getSessionState("conv-cloud");
-        expect(state.inferenceCalls).toBe(2);
-        expect(state.usedCloudCalls).toBe(1);
-    });
-    it("does NOT create a ghost stub for an unregistered session — only updates existing sessions", () => {
-        // noteInferenceForSession used to call getOrInit, creating stub entries
-        // with contextLoaded=false for every conversation_id that infers.
-        // Ghost stubs accumulate in the LRU and crowd out real sessions.
-        // The fix: no-op when the session doesn't exist yet.
-        noteInferenceForSession("conv-new-via-note", { backend: "local", usedCloud: false });
-        expect(getSessionState("conv-new-via-note")).toBeNull();
-    });
-});
-describe("getSessionState", () => {
-    it("returns null for an unknown session", () => {
-        expect(getSessionState("does-not-exist")).toBeNull();
-    });
-    it("returns the current state object for a known session", () => {
-        markContextLoaded("conv-get", "proj", BOUNDARIES_VERSION);
-        const state = getSessionState("conv-get");
-        expect(state).not.toBeNull();
-        expect(state.contextLoaded).toBe(true);
-    });
-});
-describe("lastSeen update", () => {
-    it("updates lastSeen on every requireContextLoaded call", async () => {
-        markContextLoaded("conv-ts", "proj", BOUNDARIES_VERSION);
-        const before = getSessionState("conv-ts").lastSeen;
-        // Advance time by mocking Date.now via vi.useFakeTimers
-        vi.useFakeTimers();
-        vi.advanceTimersByTime(5000);
-        requireContextLoaded("conv-ts");
-        const after = getSessionState("conv-ts").lastSeen;
-        vi.useRealTimers();
-        expect(after).toBeGreaterThanOrEqual(before);
-    });
-});