@anuraghq/neuron-mcp-server 0.1.1 → 0.1.2

package/index.js

@@ -34817,6 +34817,177 @@ function compressToPacket(project, scoredMemories, query) {
   return packet;
 }
 
+// ../context-engine/dist/ai/llm-tasks.js
+async function summarizeMemoriesWithLlm(llm, rawSummary, projectName) {
+  if (!rawSummary.trim())
+    return "No project memories stored yet.";
+  return llm.chat([
+    {
+      role: "system",
+      content: "You summarize software project knowledge for AI coding assistants. Be concise, structured, and actionable. Use markdown headings and bullet points."
+    },
+    {
+      role: "user",
+      content: `Project: ${projectName ?? "Unknown"}
+
+Raw memory notes:
+${rawSummary}
+
+Write a compact project brief a developer can paste into an AI assistant.`
+    }
+  ], { maxTokens: 800, temperature: 0.2 });
+}
+async function enhanceContextNarrative(llm, query, memorySnippets) {
+  if (!memorySnippets.length)
+    return "";
+  return llm.chat([
+    {
+      role: "system",
+      content: "You synthesize project context for an AI coding session. Focus only on facts from the snippets. Max 150 words."
+    },
+    {
+      role: "user",
+      content: `Task/query: ${query}
+
+Relevant memories:
+${memorySnippets.join("\n---\n")}
+
+Write a focused context paragraph.`
+    }
+  ], { maxTokens: 300, temperature: 0.2 });
+}
+async function generateMemorySummary(llm, title, content) {
+  return llm.chat([
+    {
+      role: "system",
+      content: "Write a one-sentence summary (max 25 words) of this project memory."
+    },
+    {
+      role: "user",
+      content: `Title: ${title}
+Content: ${content.slice(0, 2e3)}`
+    }
+  ], { maxTokens: 60, temperature: 0.1 });
+}
+async function suggestMemoryTags(llm, title, content) {
+  const raw = await llm.chat([
+    {
+      role: "system",
+      content: "Return 3-5 lowercase tags for this memory as a JSON array of strings. No markdown."
+    },
+    {
+      role: "user",
+      content: `Title: ${title}
+Content: ${content.slice(0, 1500)}`
+    }
+  ], { maxTokens: 80, temperature: 0.1 });
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((t) => typeof t === "string").slice(0, 5);
+    }
+  } catch {
+  }
+  return [];
+}
+async function findDuplicateCandidates(llm, focus, candidates) {
+  const others = candidates.filter((c) => c.id !== focus.id).slice(0, 20);
+  if (!others.length)
+    return [];
+  const raw = await llm.chat([
+    {
+      role: "system",
+      content: 'Find likely duplicate project memories. Return JSON array: [{ "memoryId": "uuid", "similarity": 0.0-1.0, "reason": "brief" }]. Only include pairs with similarity >= 0.5. No markdown.'
+    },
+    {
+      role: "user",
+      content: `Focus memory:
+${focus.title}
+${focus.content.slice(0, 800)}
+
+Candidates:
+${others.map((c) => `[${c.id}] ${c.title}: ${c.content.slice(0, 200)}`).join("\n")}`
+    }
+  ], { maxTokens: 400, temperature: 0.1 });
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed))
+      return parsed.filter((d) => d.memoryId && d.similarity >= 0.5);
+  } catch {
+  }
+  return [];
+}
+async function extractMemoriesFromText(llm, conversation) {
+  const raw = await llm.chat([
+    {
+      role: "system",
+      content: 'Extract durable project facts from a dev conversation. Return JSON array: [{ "type": "fact|decision|pattern|bug|task", "title": "...", "content": "...", "tags": [] }]. Max 5 items. No markdown.'
+    },
+    {
+      role: "user",
+      content: conversation.slice(0, 8e3)
+    }
+  ], { maxTokens: 800, temperature: 0.2 });
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((d) => d.title && d.content).slice(0, 5);
+    }
+  } catch {
+  }
+  return [];
+}
+
+// ../context-engine/dist/ai/llm-rerank.js
+async function rerankMemoriesWithLlm(llm, query, memories, limit) {
+  if (!memories.length)
+    return [];
+  const listing = memories.slice(0, 30).map((m, i) => `[${i}] ${m.title}: ${(m.summary ?? m.content).slice(0, 120)}`).join("\n");
+  const raw = await llm.chat([
+    {
+      role: "system",
+      content: 'Rank memory indices by relevance to the query. Reply with JSON: {"ranked":[0,2,1,...]} using only indices from the list.'
+    },
+    { role: "user", content: `Query: ${query}
+
+Memories:
+${listing}` }
+  ], { maxTokens: 120, temperature: 0 });
+  try {
+    const parsed = JSON.parse(raw);
+    const ranked = parsed.ranked ?? [];
+    return ranked.filter((i) => i >= 0 && i < memories.length).slice(0, limit).map((i, rank) => ({
+      memory: memories[i],
+      score: 1 - rank * 0.05,
+      scoreBreakdown: {
+        semanticSimilarity: 0.8,
+        keywordMatch: 0.5,
+        graphProximity: 0,
+        recency: 0.5,
+        importance: memories[i].importance,
+        layerPriority: 0.5,
+        confidence: memories[i].confidence,
+        composite: 1 - rank * 0.05
+      }
+    }));
+  } catch {
+    return memories.slice(0, limit).map((m) => ({
+      memory: m,
+      score: 0.5,
+      scoreBreakdown: {
+        semanticSimilarity: 0,
+        keywordMatch: 0.5,
+        graphProximity: 0,
+        recency: 0.5,
+        importance: m.importance,
+        layerPriority: 0.5,
+        confidence: m.confidence,
+        composite: 0.5
+      }
+    }));
+  }
+}
+
 // ../context-engine/dist/engine.js
 var DEFAULT_TOKEN_BUDGET = 4e3;
 var ContextEngine = class {
@@ -34838,10 +35009,23 @@ var ContextEngine = class {
       }
     }
     if (this.deps.embeddingProvider) {
-      const text = `${memory.title}
+      try {
+        const text = `${memory.title}
 ${memory.content}`;
-      const vector = await this.deps.embeddingProvider.embed(text);
-      await this.deps.embeddings.create(memory.id, input.projectId, vector, this.deps.embeddingProvider.model);
+        const vector = await this.deps.embeddingProvider.embed(text);
+        await this.deps.embeddings.create(memory.id, input.projectId, vector, this.deps.embeddingProvider.model);
+      } catch (err) {
+        console.warn("Embedding skipped:", err instanceof Error ? err.message : err);
+      }
+    }
+    if (this.deps.llm && !memory.summary) {
+      try {
+        const summary = await generateMemorySummary(this.deps.llm, memory.title, memory.content);
+        const tags = input.tags?.length ? input.tags : await suggestMemoryTags(this.deps.llm, memory.title, memory.content);
+        return await this.deps.memories.update(memory.id, { summary, tags });
+      } catch (err) {
+        console.warn("AI memory enrichment skipped:", err instanceof Error ? err.message : err);
+      }
     }
     return memory;
   }
@@ -34865,11 +35049,21 @@ ${memory.content}`;
       status: MemoryStatus.Active,
       limit: 100
     });
-    const scored = rankMemories(memories, signals, semanticScores);
+    let results = rankMemories(memories, signals, semanticScores);
     const limit = options?.limit ?? 20;
+    if (this.deps.llm && query.trim()) {
+      try {
+        results = await rerankMemoriesWithLlm(this.deps.llm, query, results.map((r) => r.memory), limit);
+      } catch (err) {
+        console.warn("LLM rerank skipped:", err instanceof Error ? err.message : err);
+        results = results.slice(0, limit);
+      }
+    } else {
+      results = results.slice(0, limit);
+    }
     return {
-      results: scored.slice(0, limit),
-      totalCount: scored.length,
+      results,
+      totalCount: results.length,
       query
     };
   }
@@ -34920,14 +35114,38 @@ ${memory.content}`;
     for (const s of selected) {
       await this.deps.memories.incrementAccess(s.memory.id);
     }
-    return compressToPacket(project, selected, query);
+    const packet = compressToPacket(project, selected, query);
+    if (this.deps.llm && (query.query || query.taskDescription)) {
+      try {
+        const focus = query.query ?? query.taskDescription ?? "";
+        const snippets = selected.map((s) => `- ${s.memory.title}: ${s.memory.summary ?? s.memory.content.slice(0, 200)}`);
+        const narrative = await enhanceContextNarrative(this.deps.llm, focus, snippets);
+        packet.architecture = {
+          summary: narrative,
+          layers: packet.architecture?.layers ?? [],
+          patterns: packet.architecture?.patterns ?? [],
+          keyDecisions: packet.architecture?.keyDecisions ?? []
+        };
+        packet.tokenEstimate = estimateTokens(JSON.stringify(packet));
+      } catch (err) {
+        console.warn("AI context narrative skipped:", err instanceof Error ? err.message : err);
+      }
+    }
+    return packet;
   }
   /** Mark a memory as forgotten */
   async forget(memoryId, reason) {
     await this.deps.memories.forget({ memoryId, reason });
   }
-  /** Merge two memories into one */
-  async merge(sourceId, targetId) {
+  /** Merge two memories — checks duplicates unless force=true */
+  async merge(sourceId, targetId, options) {
+    if (!options?.force && this.deps.llm) {
+      const dupes = await this.findDuplicates((await this.deps.memories.findById(sourceId))?.projectId ?? "", sourceId);
+      const match = dupes.find((d) => d.memoryId === targetId);
+      if (!match || match.similarity < 0.6) {
+        throw new Error(`Memories may not be duplicates (similarity ${match?.similarity ?? 0}). Pass force=true to merge anyway.`);
+      }
+    }
     return this.deps.memories.merge({
       sourceMemoryId: sourceId,
       targetMemoryId: targetId
@@ -34964,10 +35182,100 @@ ${memory.content}`;
       lines.push("## Open Bugs");
       bugs.filter((b) => b.metadata.status === "open").forEach((b) => lines.push(`- [${b.metadata.severity}] ${b.title}`));
     }
-    return lines.join("\n");
+    const raw = lines.join("\n");
+    if (this.deps.llm) {
+      try {
+        const project = await this.deps.projects.findById(projectId);
+        return await summarizeMemoriesWithLlm(this.deps.llm, raw, project?.name);
+      } catch (err) {
+        console.warn("AI summarize skipped:", err instanceof Error ? err.message : err);
+      }
+    }
+    return raw || "No project memories stored yet.";
+  }
+  /** Find likely duplicate memories using Groq */
+  async findDuplicates(projectId, memoryId) {
+    const memories = await this.deps.memories.findByProject(projectId, {
+      status: MemoryStatus.Active,
+      limit: 80
+    });
+    if (!this.deps.llm || memories.length < 2)
+      return [];
+    const focus = memoryId ? memories.find((m) => m.id === memoryId) : memories[0];
+    if (!focus)
+      return [];
+    try {
+      return await findDuplicateCandidates(this.deps.llm, focus, memories);
+    } catch (err) {
+      console.warn("Duplicate detection skipped:", err instanceof Error ? err.message : err);
+      return [];
+    }
+  }
+  /** Extract structured memories from a Cursor/AI conversation transcript */
+  async extractMemoriesFromConversation(projectId, conversation) {
+    if (!this.deps.llm) {
+      throw new Error("GROQ_API_KEY required for memory extraction");
+    }
+    const drafts = await extractMemoriesFromText(this.deps.llm, conversation);
+    const saved = [];
+    for (const draft of drafts) {
+      const memory = await this.remember({
+        projectId,
+        type: draft.type,
+        title: draft.title,
+        content: draft.content,
+        tags: draft.tags,
+        layer: ContextLayer.Project,
+        source: { type: "conversation" }
+      });
+      saved.push(memory);
+    }
+    return saved;
   }
 };
 
+// ../context-engine/dist/ai/groq-client.js
+var GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions";
+var DEFAULT_MODEL = "llama-3.3-70b-versatile";
+function createGroqClient(apiKey) {
+  const key = apiKey ?? process.env.GROQ_API_KEY;
+  if (!key)
+    return void 0;
+  return {
+    model: DEFAULT_MODEL,
+    async chat(messages, options) {
+      const res = await fetch(GROQ_API_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: DEFAULT_MODEL,
+          messages,
+          max_tokens: options?.maxTokens ?? 1024,
+          temperature: options?.temperature ?? 0.3
+        })
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Groq API error (${res.status}): ${body}`);
+      }
+      const data = await res.json();
+      const content = data.choices?.[0]?.message?.content;
+      if (!content)
+        throw new Error("Groq API returned empty response");
+      return content;
+    }
+  };
+}
+
+// ../context-engine/dist/ai/create-ai-deps.js
+function createAiDeps() {
+  const llm = createGroqClient();
+  return { llm, embeddingProvider: void 0 };
+}
+
 // src/tools/schemas.ts
 var RememberSchema = external_exports.object({
   project_id: external_exports.string().uuid(),
@@ -43346,6 +43654,10 @@ function createMemoryRepository(client) {
         patch.title = data.title;
       if (data.content)
         patch.content = data.content;
+      if (data.summary !== void 0)
+        patch.summary = data.summary;
+      if (data.tags)
+        patch.tags = data.tags;
       if (data.status)
         patch.status = data.status;
       if (data.confidence !== void 0)
@@ -43487,8 +43799,20 @@ function createEmbeddingRepository(client) {
         console.warn("Embedding insert skipped:", error2.message);
       }
     },
-    async search(_projectId, _vector, _limit) {
-      return [];
+    async search(projectId, vector, limit) {
+      const { data, error: error2 } = await client.rpc("match_embeddings", {
+        query_embedding: JSON.stringify(vector),
+        p_project_id: projectId,
+        match_count: limit
+      });
+      if (error2) {
+        console.warn("Vector search skipped:", error2.message);
+        return [];
+      }
+      return (data ?? []).map((row) => ({
+        memoryId: row.memory_id,
+        similarity: row.similarity
+      }));
     }
   };
 }
@@ -43500,7 +43824,8 @@ function createContextEngineDeps(useServiceRole = false) {
     memories: createMemoryRepository(client),
     relationships: createRelationshipRepository(client),
     embeddings: createEmbeddingRepository(client),
-    projects: createProjectRepository(client)
+    projects: createProjectRepository(client),
+    ...createAiDeps()
   };
 }
 
@@ -43702,46 +44027,187 @@ function resolveEngineDeps() {
   return createInMemoryDeps();
 }
 
+// src/adapters/hosted-client.ts
+var DEFAULT_API_URL = "https://neuron-azure.vercel.app";
+async function hostedFetch(apiUrl, apiKey, tool, args) {
+  const res = await fetch(`${apiUrl.replace(/\/$/, "")}/api/mcp`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ tool, args })
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(body.error ?? `Neuron API error (${res.status})`);
+  }
+  return body;
+}
+async function resolveHostedProjectId(apiUrl, apiKey) {
+  const res = await fetch(`${apiUrl.replace(/\/$/, "")}/api/mcp`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.project_id) {
+    throw new Error(body.error ?? "Could not resolve project from NEURON_API_KEY");
+  }
+  return body.project_id;
+}
+function createHostedEngine(apiUrl, apiKey, projectId) {
+  const base = apiUrl.replace(/\/$/, "") || DEFAULT_API_URL;
+  const withProject = (args) => ({
+    ...args,
+    project_id: args.project_id ?? projectId
+  });
+  const engine = {
+    async remember(input) {
+      const tool = `remember_${input.type}`;
+      const result = await hostedFetch(base, apiKey, tool, {
+        project_id: input.projectId ?? projectId,
+        title: input.title,
+        content: input.content,
+        confidence: input.confidence,
+        importance: input.importance,
+        tags: input.tags,
+        metadata: input.metadata
+      });
+      return result.memory ?? result;
+    },
+    async searchMemory(pid, query, opts) {
+      const result = await hostedFetch(base, apiKey, "search_memory", withProject({
+        project_id: pid || projectId,
+        query,
+        types: opts?.types,
+        limit: opts?.limit
+      }));
+      return Array.isArray(result) ? result : [];
+    },
+    async getProjectContext(input) {
+      const result = await hostedFetch(base, apiKey, "get_project_context", withProject({
+        project_id: input.projectId || projectId,
+        query: input.query,
+        task_description: input.taskDescription,
+        open_files: input.openFiles,
+        branch_name: input.branchName,
+        token_budget: input.tokenBudget
+      }));
+      return result.packet ?? result;
+    },
+    async findRelated(memoryId, depth) {
+      const result = await hostedFetch(base, apiKey, "find_related", {
+        memory_id: memoryId,
+        depth
+      });
+      return result.memories ?? result;
+    },
+    async summarizeProject(pid) {
+      const result = await hostedFetch(base, apiKey, "summarize_project", {
+        project_id: pid || projectId
+      });
+      return result.summary ?? "";
+    },
+    async forget(memoryId, reason) {
+      await hostedFetch(base, apiKey, "forget_memory", { memory_id: memoryId, reason });
+    },
+    async merge(sourceId, targetId, options) {
+      const result = await hostedFetch(base, apiKey, "merge_memory", {
+        source_memory_id: sourceId,
+        target_memory_id: targetId,
+        force: options?.force
+      });
+      return result.memory ?? result;
+    },
+    async findDuplicates(pid, memoryId) {
+      const result = await hostedFetch(base, apiKey, "find_duplicates", withProject({
+        project_id: pid || projectId,
+        memory_id: memoryId
+      }));
+      return result.duplicates ?? [];
+    },
+    async extractMemoriesFromConversation(pid, conversation) {
+      const result = await hostedFetch(base, apiKey, "extract_memories", withProject({
+        project_id: pid || projectId,
+        conversation
+      }));
+      return result.extracted ?? [];
+    }
+  };
+  return engine;
+}
+function isHostedMode() {
+  return !!process.env.NEURON_API_KEY?.startsWith("nrn_");
+}
+function getHostedConfig() {
+  return {
+    apiKey: process.env.NEURON_API_KEY,
+    apiUrl: process.env.NEURON_API_URL ?? DEFAULT_API_URL
+  };
+}
+
 // src/cli/init.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var NPX_PACKAGE = "@anuraghq/neuron-mcp-server";
+var DEFAULT_API_URL2 = "https://neuron-azure.vercel.app";
 function parseArgs(argv) {
   const opts = { cursor: true };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--project") opts.project = true;
     if (arg === "--stdout") opts.stdout = true;
+    if (arg === "--api-key") opts.apiKey = argv[++i];
+    if (arg === "--api-url") opts.apiUrl = argv[++i];
     if (arg === "--supabase-url") opts.supabaseUrl = argv[++i];
     if (arg === "--service-key") opts.serviceRoleKey = argv[++i];
     if (arg === "--project-id") opts.projectId = argv[++i];
-    if (arg === "--groq-key") opts.groqApiKey = argv[++i];
   }
   return opts;
 }
-function buildNeuronConfig(opts) {
+function buildHostedConfig(opts) {
+  const apiKey = opts.apiKey ?? process.env.NEURON_API_KEY;
+  const apiUrl = opts.apiUrl ?? process.env.NEURON_API_URL ?? DEFAULT_API_URL2;
+  if (!apiKey?.startsWith("nrn_")) {
+    throw new Error(
+      "Missing NEURON_API_KEY. Get one from the Neuron dashboard \u2192 Settings, then:\n  NEURON_API_KEY=nrn_... npx @anuraghq/neuron-mcp-server init\nOr pass: --api-key nrn_... [--api-url https://neuron-azure.vercel.app]"
+    );
+  }
+  return {
+    command: "npx",
+    args: ["-y", NPX_PACKAGE],
+    env: {
+      NEURON_API_KEY: apiKey,
+      NEURON_API_URL: apiUrl
+    }
+  };
+}
+function buildDirectConfig(opts) {
   const supabaseUrl = opts.supabaseUrl ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
   const serviceRoleKey = opts.serviceRoleKey ?? process.env.SUPABASE_SERVICE_ROLE_KEY;
   const projectId = opts.projectId ?? process.env.NEURON_PROJECT_ID;
-  const groqApiKey = opts.groqApiKey ?? process.env.GROQ_API_KEY;
   if (!supabaseUrl || !serviceRoleKey || !projectId) {
     throw new Error(
-      "Missing credentials. Set env vars or pass flags:\n  --supabase-url  --service-key  --project-id\nOr: NEXT_PUBLIC_SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, NEURON_PROJECT_ID"
+      "Direct mode requires Supabase env vars. Prefer hosted mode with NEURON_API_KEY."
     );
   }
-  const env = {
-    NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
-    SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
-    NEURON_PROJECT_ID: projectId
-  };
-  if (groqApiKey) env.GROQ_API_KEY = groqApiKey;
   return {
     command: "npx",
     args: ["-y", NPX_PACKAGE],
-    env
+    env: {
+      NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
+      SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
+      NEURON_PROJECT_ID: projectId
+    }
   };
 }
+function buildNeuronConfig(opts) {
+  const apiKey = opts.apiKey ?? process.env.NEURON_API_KEY;
+  if (apiKey?.startsWith("nrn_")) return buildHostedConfig(opts);
+  const hasDirect = (opts.supabaseUrl ?? process.env.NEXT_PUBLIC_SUPABASE_URL) && (opts.serviceRoleKey ?? process.env.SUPABASE_SERVICE_ROLE_KEY) && (opts.projectId ?? process.env.NEURON_PROJECT_ID);
+  if (hasDirect) return buildDirectConfig(opts);
+  return buildHostedConfig(opts);
+}
 function mergeMcpJson(existing, neuronConfig) {
   const servers = existing.mcpServers ?? {};
   return { ...existing, mcpServers: { ...servers, neuron: neuronConfig } };
@@ -43778,8 +44244,17 @@ async function runInit(argv) {
 
 // src/index.ts
 async function startServer() {
-  const deps = resolveEngineDeps();
-  const engine = new ContextEngine(deps);
+  let engine;
+  if (isHostedMode()) {
+    const { apiKey, apiUrl } = getHostedConfig();
+    const projectId = await resolveHostedProjectId(apiUrl, apiKey);
+    engine = createHostedEngine(apiUrl, apiKey, projectId);
+    console.error(`Neuron MCP: hosted mode \u2192 ${apiUrl} (project ${projectId.slice(0, 8)}\u2026)`);
+  } else {
+    const deps = resolveEngineDeps();
+    engine = new ContextEngine(deps);
+    console.error("Neuron MCP: direct mode (Supabase env vars)");
+  }
   const server = new McpServer({
     name: "neuron",
     version: "0.1.0"