vault-go 0.16.1 → 0.18.0

package/README.md

@@ -76,6 +76,9 @@ Clientes suportados:
 
 - Codex e ChatGPT Desktop local;
 - Claude Code e Claude Desktop;
+- Grok (config.toml nativo e hooks em `~/.grok/hooks`);
+- Agy / Antigravity CLI e IDE;
+- Gemini CLI;
 - Cursor e Windsurf;
 - VS Code com GitHub Copilot;
 - GitHub Copilot CLI;
@@ -170,7 +173,7 @@ limitados.
 
 O seletor de motor segue o mesmo modelo do claude-mem: Claude (CLI da assinatura), OpenRouter (chave), Gemini (chave) ou o Vault AI Resume da conta. Grave chaves com `vault-go engine key openrouter|gemini` ou no painel local; as ferramentas MCP não aceitam segredos.
 
-Na instalação, o Vault Go registra hooks no Claude Code e no Codex. Eles injetam contexto no início da sessão, capturam prompts e ferramentas, e o serviço local (`http://localhost:38850`) gera memórias com o motor escolhido — o mesmo ciclo do claude-mem, persistindo no Vault.
+Na instalação, o Vault Go registra hooks no Claude Code, no Codex, no Grok e no Agy. Eles injetam contexto no início da sessão, capturam prompts e ferramentas, e o serviço local (`http://localhost:38850`) gera memórias com o motor escolhido — o mesmo ciclo do claude-mem, persistindo no Vault.
 
 O recurso `vault-go://status` fornece o resumo sanitizado em JSON.
 

package/dist/cli.js

@@ -100,7 +100,7 @@ async function chooseClients(args, locale) {
         return parseNumberedClients(configured);
     const detected = detectMcpClients();
     for (const item of detected) {
-        process.stderr.write(`  ${MCP_CLIENTS.indexOf(item.client) + 1}. ${item.client.padEnd(12)} ${item.detected ? `● ${t.detected}` : `○ ${t.available}`}\n`);
+        process.stderr.write(`  ${MCP_CLIENTS.indexOf(item.client) + 1}. ${item.client.padEnd(14)} ${item.detected ? `● ${t.detected}` : `○ ${t.available}`}\n`);
     }
     const defaults = defaultClients();
     const answer = await promptText(`${t.choose} [${defaults.join(',')}]: `);
@@ -324,8 +324,8 @@ Uso:
       Escolhe o motor e o modelo de contexto. No Claude: haiku, sonnet ou opus.
 
   vault-go hook <adaptador> <evento>
-      Usado pelos hooks do Claude/Codex: injeta contexto, captura atividade
-      e enfileira geração com o motor escolhido.
+      Usado pelos hooks do Claude, Codex, Grok e Agy: injeta contexto,
+      captura atividade e enfileira geração com o motor escolhido.
 
   --lang pt|en|es
       Idioma do assistente (padrão: idioma do sistema).

package/dist/hook-install.d.ts

@@ -9,5 +9,6 @@ export declare const HOOK_EVENTS: {
 export declare function quoteShell(value: string): string;
 export declare function hookEntryPath(configHome?: string): string;
 export declare function hookCommand(adapter: string, event: string, configHome?: string): string;
-export declare function installClientHooks(client: "claude" | "codex", userHome?: string, configHome?: string): void;
+export type HookClient = "claude" | "codex" | "grok" | "agy";
+export declare function installClientHooks(client: HookClient, userHome?: string, configHome?: string): void;
 export declare function repairClientHooks(userHome?: string, configHome?: string): void;

package/dist/hook-install.js

@@ -73,7 +73,34 @@ function hookManifest(adapter, configHome = vaultHome()) {
         ])),
     };
 }
+function agyHandler(event, configHome = vaultHome()) {
+    return {
+        type: "command",
+        command: hookCommand("agy", event, configHome),
+        timeout: event === "context" ? 60 : 20,
+    };
+}
+function agyHookManifest(configHome = vaultHome()) {
+    return {
+        PreInvocation: [agyHandler("context", configHome)],
+        PreToolUse: [{ matcher: "*", hooks: [agyHandler("file-context", configHome)] }],
+        PostToolUse: [
+            { matcher: "*", hooks: [agyHandler("observation", configHome)] },
+        ],
+        Stop: [agyHandler("summarize", configHome)],
+    };
+}
 export function installClientHooks(client, userHome = homedir(), configHome = vaultHome()) {
+    if (client === "grok") {
+        atomicWriteJson(join(userHome, ".grok", "hooks", "vault-go.json"), hookManifest("grok", configHome));
+        return;
+    }
+    if (client === "agy") {
+        const path = join(userHome, ".gemini", "config", "hooks.json");
+        const config = readJsonObject(path);
+        atomicWriteJson(path, { ...config, "vault-go": agyHookManifest(configHome) });
+        return;
+    }
     const path = join(userHome, client === "claude" ? ".claude/settings.json" : ".codex/hooks.json");
     const config = readJsonObject(path);
     const hooks = {
@@ -110,4 +137,12 @@ export function installClientHooks(client, userHome = homedir(), configHome = va
 export function repairClientHooks(userHome = homedir(), configHome = vaultHome()) {
     installClientHooks("claude", userHome, configHome);
     installClientHooks("codex", userHome, configHome);
+    if (existsSync(join(userHome, ".grok"))) {
+        installClientHooks("grok", userHome, configHome);
+    }
+    if (existsSync(join(userHome, ".gemini", "config")) ||
+        existsSync(join(userHome, ".gemini", "antigravity")) ||
+        existsSync(join(userHome, ".gemini", "antigravity-cli"))) {
+        installClientHooks("agy", userHome, configHome);
+    }
 }

package/dist/hooks.d.ts

@@ -2,7 +2,8 @@ import { type VaultMemoryApi } from "./cloud.js";
 export declare const HOOK_EVENTS: readonly ["context", "session-init", "observation", "file-context", "summarize"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 type RecordValue = Record<string, unknown>;
-export declare function hookOutput(event: HookEvent, context?: string): RecordValue;
+export declare function normalizeHookInput(adapter: string, value: unknown): RecordValue;
+export declare function hookOutput(event: HookEvent, context?: string, adapter?: string): RecordValue;
 export declare function executeHook(adapter: string, event: HookEvent, value: unknown, cloud?: VaultMemoryApi, home?: string): Promise<RecordValue>;
 export declare function readHookInput(stream?: NodeJS.ReadableStream): Promise<unknown>;
 export declare function runHook(adapter: string, event: string): Promise<void>;

package/dist/hooks.js

@@ -45,7 +45,34 @@ function redact(value) {
     }
     return value;
 }
-export function hookOutput(event, context = "") {
+export function normalizeHookInput(adapter, value) {
+    const input = record(value);
+    const toolCall = record(input.toolCall);
+    const workspaces = Array.isArray(input.workspacePaths)
+        ? input.workspacePaths
+        : [];
+    const workspace = workspaces.find((item) => typeof item === "string" && Boolean(item.trim()));
+    return {
+        ...input,
+        session_id: string(input.session_id, input.sessionId, input.conversation_id, input.conversationId, input.thread_id),
+        cwd: string(input.cwd, input.workspace, input.workspaceRoot, workspace),
+        tool_name: string(input.tool_name, input.toolName, toolCall.name),
+        tool_input: record(input.tool_input ?? input.toolInput ?? toolCall.args),
+        last_assistant_message: string(input.last_assistant_message, input.lastAssistantMessage, input.response, input.summary),
+        prompt: string(input.prompt, input.user_prompt, input.userPrompt),
+    };
+}
+export function hookOutput(event, context = "", adapter = "claude") {
+    if (adapter === "agy") {
+        if (event === "context" || event === "session-init") {
+            return context
+                ? { injectSteps: [{ ephemeralMessage: context }] }
+                : {};
+        }
+        if (event === "file-context")
+            return { decision: "allow" };
+        return {};
+    }
     const result = { continue: true, suppressOutput: true };
     const name = event === "context"
         ? "SessionStart"
@@ -79,29 +106,29 @@ async function preferences(cloud) {
     };
 }
 export async function executeHook(adapter, event, value, cloud = new VaultCloudClient(), home = vaultHome()) {
-    const input = record(value);
-    const toolName = string(input.tool_name, input.toolName);
+    const input = normalizeHookInput(adapter, value);
+    const toolName = string(input.tool_name);
     if (input.private === true ||
         input.is_private === true ||
         /vault[_-]go|vault[_-]mem/.test(toolName)) {
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     }
     const prefs = await preferences(cloud);
     const reading = event === "context" || event === "file-context";
     if (!reading && prefs.automaticCapture !== true)
-        return hookOutput(event);
-    const tool = record(input.tool_input ?? input.toolInput);
-    const file = string(tool.file_path, tool.path, tool.notebook_path);
+        return hookOutput(event, "", adapter);
+    const tool = record(input.tool_input);
+    const file = string(tool.file_path, tool.path, tool.notebook_path, tool.AbsolutePath, tool.Path, tool.filePath);
     const modifies = /write|edit|patch|create|delete|move|rename/i.test(toolName);
     if (!reading && prefs.captureMode === "focused" && event !== "summarize")
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (event === "observation" && prefs.captureMode === "balanced" && !modifies)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (event === "file-context" && !file)
-        return hookOutput(event);
-    const sessionId = string(input.session_id, input.sessionId, input.thread_id, input.conversation_id);
+        return hookOutput(event, "", adapter);
+    const sessionId = string(input.session_id);
     if (!reading && !sessionId)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     const cwd = root(string(input.cwd, input.workspace) || process.cwd());
     const projects = await cloud.projects();
     if (!Array.isArray(projects))
@@ -110,7 +137,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         typeof item === "object" &&
         resolve(String(item.rootPath || "")) === cwd);
     if (!project && reading)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (!project) {
         project = record(await cloud.createProject({
             name: (basename(cwd) || "workspace").padEnd(3, "_").slice(0, 80),
@@ -131,7 +158,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
                 paths: [...new Set([file, resolve(cwd, file)])],
             })
             : await cloud.context(limits));
-        return hookOutput(event, string(result.context).slice(0, 24_000));
+        return hookOutput(event, string(result.context).slice(0, 24_000), adapter);
     }
     const session = record(await cloud.startSession({
         projectId: project.id,
@@ -140,8 +167,8 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     }));
     if (typeof session.id !== "string")
         throw new Error("Sessão inválida");
-    const prompt = string(input.prompt, input.user_prompt);
-    const response = string(input.last_assistant_message, input.response, input.summary);
+    const prompt = string(input.prompt);
+    const response = string(input.last_assistant_message);
     const rawContent = event === "session-init"
         ? prompt
         : event === "summarize"
@@ -195,7 +222,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     }
     if (event === "summarize")
         await cloud.endSession(session.id);
-    return hookOutput(event);
+    return hookOutput(event, "", adapter);
 }
 export async function readHookInput(stream = process.stdin) {
     const chunks = [];

package/dist/installer.d.ts

@@ -1,6 +1,6 @@
 export declare const MCP_SERVER_NAME = "vault-go";
 export declare const MCP_SERVER_COMMAND: readonly ["bunx", "--bun", "vault-go@latest", "serve"];
-export declare const MCP_CLIENTS: readonly ["codex", "claude", "claude-desktop", "cursor", "vscode", "copilot", "windsurf", "roo", "opencode"];
+export declare const MCP_CLIENTS: readonly ["codex", "claude", "claude-desktop", "cursor", "vscode", "copilot", "windsurf", "roo", "opencode", "grok", "agy", "gemini", "vault-desktop"];
 export type McpClient = (typeof MCP_CLIENTS)[number];
 export interface DetectedClient {
     client: McpClient;
@@ -17,6 +17,8 @@ type CommandResult = {
     error?: Error;
 };
 type CommandRunner = (command: string, args: readonly string[]) => CommandResult;
+export declare function vaultDesktopMcpPath(home: string): string;
+export declare function vaultDesktopDotMcpPath(home: string): string;
 export declare function installMcpClient(client: McpClient, options?: {
     home?: string;
     cwd?: string;

package/dist/installer.js

@@ -17,7 +17,16 @@ export const MCP_CLIENTS = [
     'windsurf',
     'roo',
     'opencode',
+    'grok',
+    'agy',
+    'gemini',
+    'vault-desktop',
 ];
+const CLIENT_ALIASES = {
+    antigravity: 'agy',
+    'gemini-cli': 'gemini',
+    desktop: 'vault-desktop',
+};
 const runCommand = (command, args) => spawnSync(command, [...args], { stdio: 'ignore' });
 function readJsonObject(path) {
     if (!existsSync(path))
@@ -35,12 +44,37 @@ function readJsonObject(path) {
     return parsed;
 }
 function atomicWriteJson(path, value) {
+    atomicWriteText(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+function atomicWriteText(path, text) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
-    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(temporary, text.endsWith('\n') ? text : `${text}\n`, { mode: 0o600 });
     renameSync(temporary, path);
     chmodSync(path, 0o600);
 }
+function formatTomlValue(value) {
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    return `[${value.map((item) => JSON.stringify(item)).join(', ')}]`;
+}
+function upsertTomlTable(path, table, assignments) {
+    const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const body = Object.entries(assignments)
+        .map(([key, value]) => `${key} = ${formatTomlValue(value)}`)
+        .join('\n');
+    const block = `[${table}]\n${body}\n`;
+    const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`(^|\\r?\\n)\\[${escaped}\\](?:\\r?\\n(?!\\[).*)*`);
+    const next = pattern.test(previous)
+        ? previous.replace(pattern, (match) => `${/^\r?\n/.exec(match)?.[0] ?? ''}${block}`)
+        : previous.trimEnd()
+            ? `${previous.trimEnd()}\n\n${block}`
+            : block;
+    atomicWriteText(path, next);
+}
 function standardServer() {
     return {
         command: MCP_SERVER_COMMAND[0],
@@ -70,6 +104,18 @@ function claudeDesktopPath(home) {
     }
     return join(home, '.config', 'Claude', 'claude_desktop_config.json');
 }
+export function vaultDesktopMcpPath(home) {
+    if (platform() === 'darwin') {
+        return join(home, 'Library', 'Application Support', 'Vault Desktop', 'mcp.json');
+    }
+    if (platform() === 'win32') {
+        return join(process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming'), 'Vault Desktop', 'mcp.json');
+    }
+    return join(home, '.config', 'Vault Desktop', 'mcp.json');
+}
+export function vaultDesktopDotMcpPath(home) {
+    return join(home, '.vault-desktop', 'mcp.json');
+}
 function installViaCli(client, command, getArgs, addArgs, runner) {
     const existing = runner(command, getArgs);
     if (existing.status === 0) {
@@ -125,6 +171,42 @@ export function installMcpClient(client, options = {}) {
         }
         return { client, status: 'installed', destination: 'VS Code user profile' };
     }
+    if (client === 'grok') {
+        const destination = join(home, '.grok', 'config.toml');
+        upsertTomlTable(destination, 'mcp_servers.vault-go', {
+            command: MCP_SERVER_COMMAND[0],
+            args: MCP_SERVER_COMMAND.slice(1),
+            enabled: true,
+        });
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('grok', home);
+        return { client, status: 'installed', destination };
+    }
+    if (client === 'agy') {
+        const cliPath = join(home, '.gemini', 'config', 'mcp_config.json');
+        mergeServer(cliPath);
+        mergeServer(join(home, '.gemini', 'antigravity', 'mcp_config.json'));
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('agy', home);
+        return { client, status: 'installed', destination: cliPath };
+    }
+    if (client === 'gemini') {
+        const path = join(home, '.gemini', 'settings.json');
+        mergeServer(path);
+        return { client, status: 'installed', destination: path };
+    }
+    if (client === 'vault-desktop') {
+        const destination = vaultDesktopMcpPath(home);
+        mergeServer(destination);
+        mergeServer(vaultDesktopDotMcpPath(home));
+        return { client, status: 'installed', destination };
+    }
     let path;
     if (client === 'claude-desktop')
         path = claudeDesktopPath(home);
@@ -169,6 +251,10 @@ export function detectMcpClients(home = homedir()) {
         ['windsurf', ['windsurf'], [join(home, '.codeium', 'windsurf')]],
         ['roo', [], []],
         ['opencode', ['opencode'], [join(home, '.config', 'opencode')]],
+        ['grok', ['grok'], [join(home, '.grok')]],
+        ['agy', ['agy'], [join(home, '.gemini', 'antigravity-cli'), join(home, '.gemini', 'config'), join(home, '.gemini', 'antigravity')]],
+        ['gemini', ['gemini'], [join(home, '.gemini', 'settings.json')]],
+        ['vault-desktop', [], [vaultDesktopMcpPath(home), vaultDesktopDotMcpPath(home), '/Applications/Vault Desktop.app']],
     ];
     return definitions.map(([client, commands, paths]) => {
         const command = commands.find((candidate) => Bun.which(candidate));
@@ -195,7 +281,10 @@ export function parseClientSelection(value) {
     const normalized = value.trim().toLowerCase();
     if (normalized === 'all' || normalized === 'todos')
         return [...MCP_CLIENTS];
-    const selected = [...new Set(normalized.split(',').map((item) => item.trim()).filter(Boolean))];
+    const selected = [...new Set(normalized.split(',').map((item) => {
+            const trimmed = item.trim();
+            return CLIENT_ALIASES[trimmed] ?? trimmed;
+        }).filter(Boolean))];
     const invalid = selected.filter((item) => !MCP_CLIENTS.includes(item));
     if (invalid.length > 0)
         throw new Error(`Clientes MCP desconhecidos: ${invalid.join(', ')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Servidor MCP universal com autenticação e instalação multi-cliente para a plataforma Vault.",
   "type": "module",
   "bin": {
@@ -103,7 +103,10 @@
     "codex",
     "claude",
     "copilot",
-    "cursor"
+    "cursor",
+    "grok",
+    "opencode",
+    "antigravity"
   ],
   "author": "Gutierrez Henrique",
   "license": "MIT",