@usewhisper/mcp-server 2.2.0 → 2.3.0

package/dist/server.js

@@ -524,9 +524,71 @@ var WhisperContext = class _WhisperContext {
       this.projectRefToId.set(p.slug, p.id);
       this.projectRefToId.set(p.name, p.id);
     }
+    if (this.defaultProject) {
+      const hasDefaultProject = this.projectCache.some(
+        (project) => project.id === this.defaultProject || project.slug === this.defaultProject || project.name === this.defaultProject
+      );
+      if (!hasDefaultProject) {
+        const resolvedDefault = await this.fetchResolvedProject(this.defaultProject);
+        if (resolvedDefault) {
+          this.projectCache = [...this.projectCache, resolvedDefault];
+          this.projectRefToId.set(resolvedDefault.id, resolvedDefault.id);
+          this.projectRefToId.set(resolvedDefault.slug, resolvedDefault.id);
+          this.projectRefToId.set(resolvedDefault.name, resolvedDefault.id);
+        }
+      }
+    }
     this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
     return this.projectCache;
   }
+  async fetchResolvedProject(projectRef) {
+    if (!projectRef) return null;
+    try {
+      const response = await this.request(`/v1/projects/resolve?project=${encodeURIComponent(projectRef)}`, { method: "GET" });
+      return response?.resolved || null;
+    } catch (error) {
+      if (error instanceof WhisperError && error.code === "PROJECT_NOT_FOUND") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async resolveProject(projectRef) {
+    const resolvedRef = this.getRequiredProject(projectRef);
+    const cachedProjects = await this.refreshProjectCache(false);
+    const cachedProject = cachedProjects.find(
+      (project) => project.id === resolvedRef || project.slug === resolvedRef || project.name === resolvedRef
+    );
+    if (cachedProject) {
+      return cachedProject;
+    }
+    const resolvedProject = await this.fetchResolvedProject(resolvedRef);
+    if (resolvedProject) {
+      this.projectRefToId.set(resolvedProject.id, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.slug, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.name, resolvedProject.id);
+      this.projectCache = [
+        ...this.projectCache.filter((project) => project.id !== resolvedProject.id),
+        resolvedProject
+      ];
+      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+      return resolvedProject;
+    }
+    if (isLikelyProjectId(resolvedRef)) {
+      return {
+        id: resolvedRef,
+        orgId: "",
+        name: resolvedRef,
+        slug: resolvedRef,
+        createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+    }
+    throw new WhisperError({
+      code: "PROJECT_NOT_FOUND",
+      message: `Project '${resolvedRef}' not found`
+    });
+  }
   async resolveProjectId(projectRef) {
     if (this.projectRefToId.has(projectRef)) {
       return this.projectRefToId.get(projectRef);
@@ -547,6 +609,18 @@ var WhisperContext = class _WhisperContext {
     if (isLikelyProjectId(projectRef)) {
       return projectRef;
     }
+    const resolvedProject = await this.fetchResolvedProject(projectRef);
+    if (resolvedProject) {
+      this.projectRefToId.set(resolvedProject.id, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.slug, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.name, resolvedProject.id);
+      this.projectCache = [
+        ...this.projectCache.filter((project) => project.id !== resolvedProject.id),
+        resolvedProject
+      ];
+      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+      return resolvedProject.id;
+    }
     throw new WhisperError({
       code: "PROJECT_NOT_FOUND",
       message: `Project '${projectRef}' not found`
@@ -602,6 +676,26 @@ var WhisperContext = class _WhisperContext {
       message: `Project '${projectRef}' not found`
     });
   }
+  shouldRetryWithResolvedProjectId(error) {
+    return error instanceof WhisperError && error.status === 404 && !this.isEndpointNotFoundError(error);
+  }
+  async withProjectPathFallback(projectRef, execute) {
+    try {
+      return await execute(projectRef);
+    } catch (error) {
+      if (!this.shouldRetryWithResolvedProjectId(error)) {
+        throw error;
+      }
+    }
+    const resolvedProjectId = await this.resolveProjectId(projectRef);
+    if (resolvedProjectId === projectRef) {
+      throw new WhisperError({
+        code: "PROJECT_NOT_FOUND",
+        message: `Project '${projectRef}' not found`
+      });
+    }
+    return execute(resolvedProjectId);
+  }
   classifyError(status, message) {
     if (status === 401 || /api key|unauthorized|forbidden/i.test(message)) {
       return { code: "INVALID_API_KEY", retryable: false };
@@ -717,29 +811,42 @@ var WhisperContext = class _WhisperContext {
     return projects;
   }
   async getProject(id) {
-    const projectId = await this.resolveProjectId(id);
-    return this.request(`/v1/projects/${projectId}`);
+    return this.withProjectPathFallback(
+      this.getRequiredProject(id),
+      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}`)
+    );
+  }
+  async listSources(project) {
+    const projectRef = this.getRequiredProject(project);
+    return this.withProjectRefFallback(
+      projectRef,
+      (resolvedProject) => this.request(`/v1/sources?project=${encodeURIComponent(resolvedProject)}`, { method: "GET" })
+    );
   }
   async deleteProject(id) {
     const projectId = await this.resolveProjectId(id);
     return this.request(`/v1/projects/${projectId}`, { method: "DELETE" });
   }
   async addSource(projectId, params) {
-    const resolvedProjectId = await this.resolveProjectId(projectId);
-    return this.request(`/v1/projects/${resolvedProjectId}/sources`, {
-      method: "POST",
-      body: JSON.stringify(params)
-    });
+    return this.withProjectPathFallback(
+      this.getRequiredProject(projectId),
+      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}/sources`, {
+        method: "POST",
+        body: JSON.stringify(params)
+      })
+    );
   }
   async syncSource(sourceId) {
     return this.request(`/v1/sources/${sourceId}/sync`, { method: "POST" });
   }
   async addSourceByType(projectId, params) {
-    const resolvedProjectId = await this.resolveProjectId(projectId);
-    return this.request(`/v1/projects/${resolvedProjectId}/add_source`, {
-      method: "POST",
-      body: JSON.stringify(params)
-    });
+    return this.withProjectPathFallback(
+      this.getRequiredProject(projectId),
+      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}/add_source`, {
+        method: "POST",
+        body: JSON.stringify(params)
+      })
+    );
   }
   async getSourceStatus(sourceId) {
     return this.request(`/v1/sources/${sourceId}/status`, { method: "GET" });
@@ -801,14 +908,16 @@ var WhisperContext = class _WhisperContext {
     };
   }
   async ingest(projectId, documents) {
-    const resolvedProjectId = await this.resolveProjectId(projectId);
-    return this.request(`/v1/projects/${resolvedProjectId}/ingest`, {
-      method: "POST",
-      body: JSON.stringify({ documents })
-    });
+    return this.withProjectPathFallback(
+      this.getRequiredProject(projectId),
+      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}/ingest`, {
+        method: "POST",
+        body: JSON.stringify({ documents })
+      })
+    );
   }
   async addContext(params) {
-    const projectId = await this.resolveProjectId(this.getRequiredProject(params.project));
+    const projectId = (await this.resolveProject(this.getRequiredProject(params.project))).id;
     return this.ingest(projectId, [
       {
         title: params.title || "Context",
@@ -1218,28 +1327,37 @@ var WhisperContext = class _WhisperContext {
     });
   }
   async createSharedContext(params) {
-    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
-    return this.request("/v1/context/share", {
-      method: "POST",
-      body: JSON.stringify({ ...params, project })
-    });
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(
+      projectRef,
+      (project) => this.request("/v1/context/share", {
+        method: "POST",
+        body: JSON.stringify({ ...params, project })
+      })
+    );
   }
   async loadSharedContext(shareId) {
     return this.request(`/v1/context/shared/${shareId}`);
   }
   async resumeFromSharedContext(params) {
-    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
-    return this.request("/v1/context/resume", {
-      method: "POST",
-      body: JSON.stringify({ ...params, project })
-    });
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(
+      projectRef,
+      (project) => this.request("/v1/context/resume", {
+        method: "POST",
+        body: JSON.stringify({ ...params, project })
+      })
+    );
   }
   async consolidateMemories(params) {
-    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
-    return this.request("/v1/memory/consolidate", {
-      method: "POST",
-      body: JSON.stringify({ ...params, project })
-    });
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(
+      projectRef,
+      (project) => this.request("/v1/memory/consolidate", {
+        method: "POST",
+        body: JSON.stringify({ ...params, project })
+      })
+    );
   }
   async updateImportanceDecay(params) {
     const project = await this.resolveProjectId(this.getRequiredProject(params.project));
@@ -1622,7 +1740,17 @@ function computeChecksum(value) {
 }
 var cachedProjectRef = DEFAULT_PROJECT || void 0;
 async function resolveProjectRef(explicit) {
-  if (explicit?.trim()) return explicit.trim();
+  if (explicit?.trim()) {
+    const requestedRef = explicit.trim();
+    try {
+      const resolved = await whisper.resolveProject(requestedRef);
+      cachedProjectRef = resolved.slug || resolved.name || resolved.id;
+      return cachedProjectRef;
+    } catch {
+      cachedProjectRef = requestedRef;
+      return requestedRef;
+    }
+  }
   if (cachedProjectRef) return cachedProjectRef;
   try {
     const { projects } = await whisper.listProjects();
@@ -2568,7 +2696,19 @@ server.tool(
   async () => {
     try {
       const { projects } = await whisper.listProjects();
-      const text = projects.length === 0 ? "No projects found." : projects.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
+      const visibleProjects = [...projects];
+      if (cachedProjectRef) {
+        const hasCachedProject = visibleProjects.some(
+          (project) => project.id === cachedProjectRef || project.slug === cachedProjectRef || project.name === cachedProjectRef
+        );
+        if (!hasCachedProject) {
+          try {
+            visibleProjects.push(await whisper.resolveProject(cachedProjectRef));
+          } catch {
+          }
+        }
+      }
+      const text = visibleProjects.length === 0 ? "No projects found." : visibleProjects.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
       return { content: [{ type: "text", text }] };
     } catch (error) {
       return { content: [{ type: "text", text: `Error: ${error.message}` }] };
@@ -2581,8 +2721,8 @@ server.tool(
   { project: z.string().optional().describe("Project name or slug") },
   async ({ project }) => {
     try {
-      const projectData = await whisper.getProject(project || DEFAULT_PROJECT);
-      const srcs = projectData.sources || [];
+      const sourceData = await whisper.listSources(project || DEFAULT_PROJECT);
+      const srcs = sourceData.sources || [];
       const text = srcs.length === 0 ? "No sources connected." : srcs.map((s) => `- ${s.name} (${s.connectorType}) \u2014 ${s.status}`).join("\n");
       return { content: [{ type: "text", text }] };
     } catch (error) {
@@ -3134,7 +3274,25 @@ server.tool(
           top_k: 25,
           include_relations: false
         });
-        const memoryIds = (search.results || []).map((r) => String(r?.memory?.id || "")).filter(Boolean);
+        const normalizedQuery = String(target.query || "").trim().toLowerCase();
+        const exactMatches = (search.results || []).filter((r) => {
+          const memory = r?.memory || r;
+          const content = String(memory?.content || "").trim().toLowerCase();
+          const memoryId = String(memory?.id || "").trim().toLowerCase();
+          const metadata = memory?.metadata || {};
+          const normalizedContent = String(metadata?.normalized_content || "").trim().toLowerCase();
+          const canonicalContent = String(metadata?.canonical_content || "").trim().toLowerCase();
+          return memoryId === normalizedQuery || content === normalizedQuery || normalizedContent === normalizedQuery || canonicalContent === normalizedQuery;
+        });
+        const memoryIds = exactMatches.map((r) => String(r?.memory?.id || "")).filter(Boolean);
+        if (memoryIds.length === 0) {
+          const payload2 = {
+            status: "completed",
+            affected_ids: affectedIds,
+            warning: "Query did not resolve to an exact memory match. No memories were changed."
+          };
+          return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+        }
         for (const id of memoryIds) {
           await applyToMemory(id);
         }
@@ -3208,6 +3366,7 @@ server.tool(
       const bundleWithoutChecksum = {
         bundle_version: "1.0",
         workspace_id: workspaceId,
+        ...resolvedProject ? { project: resolvedProject } : {},
         exported_at: now,
         contents
       };
@@ -3227,6 +3386,7 @@ server.tool(
     bundle: z.object({
       bundle_version: z.string(),
       workspace_id: z.string(),
+      project: z.string().optional(),
       exported_at: z.string(),
       contents: z.object({
         memories: z.array(z.any()).default([]),
@@ -3250,8 +3410,10 @@ server.tool(
         if (dedupe_strategy === "id") return existing.some((e) => e.id === incoming.id);
         const norm = incoming.content.toLowerCase().trim();
         return existing.some((e) => e.content.toLowerCase().trim() === norm);
+      }, normalizeString2 = function(value) {
+        return String(value || "").trim().toLowerCase();
       };
-      var dedupe = dedupe2;
+      var dedupe = dedupe2, normalizeString = normalizeString2;
       const workspaceId = getWorkspaceId(workspace_id || bundle.workspace_id);
       const state = loadState();
       const workspace = getWorkspaceState(state, workspaceId);
@@ -3277,6 +3439,30 @@ server.tool(
         session_summaries: 0,
         documents: 0
       };
+      const resolvedProject = await resolveProjectRef(bundle.project);
+      async function shouldSkipImportedMemory(memory) {
+        if (dedupe_strategy === "none" || !resolvedProject) return false;
+        const exactId = normalizeString2(memory?.id);
+        const exactContent = normalizeString2(memory?.content);
+        if (!exactId && !exactContent) return false;
+        const existing = await whisper.searchMemoriesSOTA({
+          project: resolvedProject,
+          query: exactId || exactContent,
+          top_k: 10,
+          include_relations: false
+        });
+        return (existing.results || []).some((result) => {
+          const candidate = result?.memory || result;
+          const candidateId = normalizeString2(candidate?.id);
+          const candidateContent = normalizeString2(candidate?.content);
+          const candidateMetadata = candidate?.metadata || {};
+          const importedOriginalId = normalizeString2(candidateMetadata?.bundle_original_id);
+          if (dedupe_strategy === "id") {
+            return Boolean(exactId) && (candidateId === exactId || importedOriginalId === exactId);
+          }
+          return Boolean(exactContent) && candidateContent === exactContent;
+        });
+      }
       if (mode === "replace") {
         workspace.entities = [];
         workspace.decisions = [];
@@ -3286,6 +3472,40 @@ server.tool(
         workspace.documents = [];
         workspace.events = [];
       }
+      if (!checksumVerified) {
+        const payload2 = {
+          imported_counts: importedCounts,
+          skipped_counts: skippedCounts,
+          conflicts,
+          checksum_verified: checksumVerified
+        };
+        return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+      }
+      for (const memory of bundle.contents.memories || []) {
+        if (!resolvedProject) {
+          skippedCounts.memories += 1;
+          continue;
+        }
+        if (await shouldSkipImportedMemory(memory)) {
+          skippedCounts.memories += 1;
+          continue;
+        }
+        await whisper.addMemory({
+          project: resolvedProject,
+          content: String(memory?.content || ""),
+          memory_type: String(memory?.type || memory?.memoryType || "factual"),
+          user_id: memory?.user_id || memory?.userId,
+          session_id: memory?.session_id || memory?.sessionId,
+          importance: typeof memory?.importance === "number" ? memory.importance : void 0,
+          metadata: {
+            ...memory?.metadata && typeof memory.metadata === "object" ? memory.metadata : {},
+            bundle_original_id: memory?.id || void 0,
+            imported_from_bundle: true,
+            bundle_exported_at: bundle.exported_at
+          }
+        });
+        importedCounts.memories += 1;
+      }
       const keys = ["entities", "decisions", "failures", "annotations", "session_summaries", "documents"];
       for (const key of keys) {
         const sourceItems = bundle.contents[key];
@@ -3312,7 +3532,7 @@ server.tool(
       const payload = {
         imported_counts: importedCounts,
         skipped_counts: skippedCounts,
-        conflicts,
+        conflicts: resolvedProject ? conflicts : [...conflicts, "project_unresolved"],
         checksum_verified: checksumVerified
       };
       return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usewhisper/mcp-server",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "whisperContractVersion": "2026.03.09",
   "scripts": {
     "build": "tsup ../src/mcp/server.ts --format esm --out-dir dist",