vault-go 0.4.0 → 0.6.0

package/README.md

@@ -70,6 +70,8 @@ renovação automática da sessão.
 - `vault_go_stats`: contagens isoladas da conta.
 - `vault_go_jobs`: fila PostgreSQL da conta, sem payload sensível.
 - `vault_go_job_retry` e `vault_go_job_cancel`: controle idempotente do processamento.
+- `vault_go_export` e `vault_go_import`: transporte JSON tenant-scoped, atômico e idempotente.
+- `vault_go_embedding_status` e `vault_go_embedding_backfill`: busca híbrida e fila vetorial, sem expor chaves.
 - `vault_go_forget`: exclusão explícita de uma memória.
 
 O recurso `vault-go://status` fornece o resumo sanitizado em JSON.

package/dist/cloud.d.ts

@@ -15,6 +15,10 @@ export interface VaultMemoryApi {
     jobs(input: Record<string, unknown>): Promise<unknown>;
     retryJob(id: string): Promise<unknown>;
     cancelJob(id: string): Promise<unknown>;
+    exportMemories(input: Record<string, unknown>): Promise<unknown>;
+    importMemories(input: Record<string, unknown>): Promise<unknown>;
+    embeddingStatus(): Promise<unknown>;
+    embeddingBackfill(): Promise<unknown>;
 }
 export declare class VaultCloudClient implements VaultMemoryApi {
     private readonly home;
@@ -36,6 +40,10 @@ export declare class VaultCloudClient implements VaultMemoryApi {
     jobs(input: Record<string, unknown>): Promise<unknown>;
     retryJob(id: string): Promise<unknown>;
     cancelJob(id: string): Promise<unknown>;
+    exportMemories(input: Record<string, unknown>): Promise<unknown>;
+    importMemories(input: Record<string, unknown>): Promise<unknown>;
+    embeddingStatus(): Promise<unknown>;
+    embeddingBackfill(): Promise<unknown>;
     private endpoint;
     private accessToken;
     private request;

package/dist/cloud.js

@@ -61,6 +61,23 @@ export class VaultCloudClient {
     async cancelJob(id) {
         return this.request(`/memory/jobs/${encodeURIComponent(id)}/cancel`, { method: 'POST' });
     }
+    async exportMemories(input) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(input)) {
+            if (value !== undefined)
+                query.set(key, String(value));
+        }
+        return this.request(`/memory/export?${query.toString()}`);
+    }
+    async importMemories(input) {
+        return this.request('/memory/import', { method: 'POST', body: input });
+    }
+    async embeddingStatus() {
+        return this.request('/memory/embeddings/status');
+    }
+    async embeddingBackfill() {
+        return this.request('/memory/embeddings/backfill', { method: 'POST' });
+    }
     endpoint(path) {
         const base = validateApiUrl(loadConfig(this.home).apiUrl);
         const prefix = base.pathname.replace(/\/$/u, '');

package/dist/server.js

@@ -180,6 +180,47 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         inputSchema: { id: uuid },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     }, async ({ id }) => run(() => cloud.cancelJob(id)));
+    server.registerTool('vault_go_export', {
+        title: 'Exportar memórias',
+        description: 'Exporta um lote tenant-scoped em formato JSON versionado.',
+        inputSchema: {
+            projectId: uuid.optional(),
+            limit: z.number().int().min(1).max(1_000).default(500),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.exportMemories(input)));
+    server.registerTool('vault_go_import', {
+        title: 'Importar memórias',
+        description: 'Importa um lote atômico e idempotente em um projeto existente.',
+        inputSchema: {
+            projectId: uuid,
+            records: z.array(z.object({
+                sourceId: z.string().trim().min(1).max(500),
+                sessionId: uuid.optional(),
+                kind: z.string().trim().min(1).max(100).default('observation'),
+                memoryType: z.string().trim().min(1).max(100).default('discovery'),
+                title: z.string().trim().max(500).optional(),
+                content: z.string().trim().min(1).max(200_000),
+                facts: z.array(z.string().trim().min(1).max(2_000)).max(200).default([]),
+                concepts: z.array(z.string().trim().min(1).max(500)).max(200).default([]),
+                filesRead: z.array(z.string().trim().min(1).max(2_000)).max(500).default([]),
+                filesModified: z.array(z.string().trim().min(1).max(2_000)).max(500).default([]),
+            })).min(1).max(1_000),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.importMemories(input)));
+    server.registerTool('vault_go_embedding_status', {
+        title: 'Status da busca semântica',
+        description: 'Mostra provedor, modelo e fila de vetores sem revelar a chave.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async () => run(() => cloud.embeddingStatus()));
+    server.registerTool('vault_go_embedding_backfill', {
+        title: 'Atualizar vetores',
+        description: 'Agenda de forma idempotente o backfill semântico da conta autenticada.',
+        inputSchema: {},
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async () => run(() => cloud.embeddingBackfill()));
     server.registerResource('vault-go-status', 'vault-go://status', {
         title: 'Status do Vault Go',
         description: 'Resumo sanitizado da conexão cloud.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Servidor MCP Bun para pesquisar e registrar memória na plataforma Vault.",
   "type": "module",
   "bin": {