vault-go 0.29.2 → 0.31.0

package/dist/skill-tools.js

@@ -0,0 +1,356 @@
+// Biblioteca privada de skills do Vault pelo MCP: listar, ler, salvar, organizar
+// e instalar localmente. Excluir fica de fora de propósito (só nas interfaces).
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { findWorkspaceProject } from './hooks.js';
+import { run } from './mcp-result.js';
+import { clip, skillContextSection } from './skill-context.js';
+import { frontmatter, installedSkills, installSkillArchive, readSourceDir } from './skill-local.js';
+import { downloadSkillArchive } from './skill-download.js';
+import { listAllSkillSummaries } from './skill-library.js';
+export { skillContextSection };
+export const SKILL_TEXT_MAX = 64 * 1024;
+const SOURCE = 'biblioteca privada de skills do usuário (Vault)';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const unsupported = () => { throw new Error('Este Vault ainda não oferece a biblioteca de skills. Atualize o vault-go ou o servidor.'); };
+/** Método do cliente preso ao próprio objeto: o VaultCloudClient é uma classe e depende do this. */
+function api(cloud, key) {
+    const fn = cloud[key];
+    if (typeof fn !== 'function')
+        return unsupported();
+    return fn.bind(cloud);
+}
+const record = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : {});
+export function page(text, offset = 0, max = SKILL_TEXT_MAX) {
+    const start = Math.max(0, Math.min(offset, text.length));
+    const end = Math.min(text.length, start + max);
+    return { text: text.slice(start, end), offset: start, nextOffset: end < text.length ? end : null, truncated: end < text.length };
+}
+export async function loadFolders(cloud) {
+    const folders = record(await api(cloud, 'skillFolders')()).folders;
+    if (!Array.isArray(folders))
+        throw new Error('Resposta de pastas inválida.');
+    return folders;
+}
+/** Caminho "a/b" → id da pasta ('' ou '/' = raiz → null). */
+export function folderByPath(folders, path) {
+    const normalized = path.trim().replace(/^\/+|\/+$/g, '');
+    if (!normalized)
+        return null;
+    return folders.find(f => f.path.toLowerCase() === normalized.toLowerCase());
+}
+async function listAll(cloud, query) {
+    return await listAllSkillSummaries(cloud, query);
+}
+/** Aceita o id da skill, `pasta/sub/nome` ou só `nome` (quando for único). */
+export async function resolveSkill(cloud, ref) {
+    const value = ref.trim();
+    if (UUID.test(value))
+        return { id: value };
+    const parts = value.replace(/^\/+|\/+$/g, '').split('/');
+    const name = parts.pop().toLowerCase();
+    if (parts.length) {
+        const folder = folderByPath(await loadFolders(cloud), parts.join('/'));
+        if (!folder)
+            throw new Error(`Pasta não encontrada: ${parts.join('/')}`);
+        const found = (await listAll(cloud, { folderId: folder.id })).find(s => s.name.toLowerCase() === name);
+        if (!found)
+            throw new Error(`Skill não encontrada: ${value}`);
+        return found;
+    }
+    const matches = (await listAll(cloud, {})).filter(s => s.name.toLowerCase() === name);
+    if (matches.length === 1)
+        return matches[0];
+    if (!matches.length)
+        throw new Error(`Skill não encontrada: ${value}`);
+    throw new Error(`Mais de uma skill com esse nome; informe o caminho: ${matches.map(s => `${s.folderPath ? `${s.folderPath}/` : ''}${s.name}`).join(', ')}`);
+}
+export async function currentProject(cloud, cwd) {
+    try {
+        const project = await findWorkspaceProject(cloud, cwd);
+        return project && typeof project.id === 'string' ? { id: project.id, name: typeof project.name === 'string' ? project.name : '' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const SKILL_TARGETS = ['claude', 'grok', 'agents'];
+export function targetRoot(target, userHome = homedir()) {
+    return target === 'agents' ? join(userHome, '.agents', 'skills') : join(userHome, `.${target}`, 'skills');
+}
+/** Garante a pasta pelo caminho, criando os segmentos que faltarem; '' é a raiz (null). */
+async function ensureFolder(cloud, path) {
+    const segments = path.trim().replace(/^\/+|\/+$/g, '').split('/').filter(Boolean);
+    if (!segments.length)
+        return null;
+    const folders = await loadFolders(cloud);
+    let parentId = null;
+    let prefix = '';
+    for (const name of segments) {
+        prefix = prefix ? `${prefix}/${name}` : name;
+        const existing = folderByPath(folders, prefix);
+        if (existing) {
+            parentId = existing.id;
+            continue;
+        }
+        const created = record(record(await api(cloud, 'createSkillFolder')({ name, parentId })).folder);
+        if (typeof created.id !== 'string')
+            throw new Error('Resposta de pasta inválida.');
+        folders.push(created);
+        parentId = created.id;
+    }
+    return parentId;
+}
+const union = (a, b) => [...new Set([...a, ...b])];
+const compact = (s) => ({ id: s.id, name: s.name, description: clip(s.description), folder: s.folderPath, scope: s.scope ?? null, version: s.latestVersion?.id ?? null, projectIds: s.projectIds });
+function tree(folders) {
+    return folders.map(f => `${'  '.repeat(f.depth - 1)}${f.name} (${f.skillCount})`).join('\n');
+}
+export function registerSkillTools(server, home, cloud, options = {}) {
+    void home;
+    const cwd = options.cwd ?? (() => process.cwd());
+    const max = options.maxChars ?? SKILL_TEXT_MAX;
+    const read = { readOnlyHint: true, idempotentHint: true, openWorldHint: true };
+    const skillRef = z.string().trim().min(1).max(600).describe('Id da skill, "pasta/sub/nome" ou só o nome quando for único');
+    const version = z.string().trim().regex(/^[A-Za-z0-9_-]{1,128}$/).optional();
+    const offset = z.number().int().min(0).default(0);
+    server.registerTool('vault_go_skills', {
+        title: 'Listar skills privadas',
+        description: 'Lista a biblioteca privada de skills do usuário. Sem projectId, usa o projeto do diretório atual (skills do projeto primeiro, depois as globais). Use q para busca por texto e folder ("dev/review") para filtrar por pasta.',
+        inputSchema: {
+            q: z.string().trim().min(1).max(200).optional(), folder: z.string().trim().max(600).optional(), recursive: z.boolean().optional(),
+            projectId: z.string().trim().min(1).max(128).optional(), ignoreProject: z.boolean().optional(), limit: z.number().int().min(1).max(50).default(25),
+            cursor: z.string().max(200).optional(),
+        },
+        annotations: read,
+    }, async (input) => run(async () => {
+        const query = {};
+        if (input.q)
+            query.q = input.q;
+        if (input.folder !== undefined) {
+            const folder = folderByPath(await loadFolders(cloud), input.folder);
+            if (folder === undefined)
+                throw new Error(`Pasta não encontrada: ${input.folder}`);
+            query.folderId = folder ? folder.id : 'root';
+            if (input.recursive)
+                query.recursive = 'true';
+        }
+        const project = input.projectId ? { id: input.projectId, name: '' } : input.ignoreProject ? null : await currentProject(cloud, cwd());
+        if (project)
+            query.projectId = project.id;
+        query.limit = input.limit;
+        if (input.cursor)
+            query.cursor = input.cursor;
+        const result = record(await api(cloud, 'skills')(query));
+        const skills = (Array.isArray(result.skills) ? result.skills : []).map(compact);
+        return {
+            project, skills, nextCursor: result.nextCursor ?? null,
+            ...(!project && !input.ignoreProject && !input.projectId ? { note: 'Nenhum projeto do Vault corresponde ao diretório atual; listando toda a biblioteca.' } : {}),
+        };
+    }));
+    server.registerTool('vault_go_skill_folders', {
+        title: 'Pastas de skills',
+        description: 'Mostra a árvore de pastas da biblioteca privada de skills, com a quantidade de skills em cada pasta.',
+        inputSchema: {}, annotations: read,
+    }, async () => run(async () => {
+        const folders = await loadFolders(cloud);
+        return { tree: tree(folders), folders };
+    }));
+    server.registerTool('vault_go_skill_read', {
+        title: 'Ler skill',
+        description: 'Carrega uma skill da biblioteca privada: o SKILL.md completo e a lista de arquivos. Siga o SKILL.md; abra arquivos auxiliares com vault_go_skill_file só quando ele mandar.',
+        inputSchema: { skill: skillRef, version, offset }, annotations: read,
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const skill = record(record(await api(cloud, 'skill')(id, input.version)).skill);
+        const md = page(typeof skill.skillMd === 'string' ? skill.skillMd : '', input.offset, max);
+        const files = (Array.isArray(skill.files) ? skill.files : []).map(f => ({ path: f.path, size: f.size, kind: f.classification }));
+        return {
+            source: SOURCE, id: skill.id, name: skill.name, description: skill.description, folder: skill.folderPath ?? null,
+            version: record(skill.version).id ?? null, projectIds: skill.projectIds ?? [],
+            instructions: 'Siga as instruções do SKILL.md. Abra um arquivo auxiliar com vault_go_skill_file somente quando o SKILL.md o referenciar e ele for necessário. Não execute scripts sem necessidade clara.',
+            skillMd: md.text, offset: md.offset, nextOffset: md.nextOffset, truncated: md.truncated, files,
+        };
+    }));
+    server.registerTool('vault_go_skill_file', {
+        title: 'Ler arquivo de skill',
+        description: 'Lê um arquivo auxiliar de uma skill (ex.: references/guia.md, scripts/run.py). Texto volta em UTF-8; binário em base64. Conteúdo grande é paginado com offset.',
+        inputSchema: { skill: skillRef, path: z.string().trim().min(1).max(1024), version, offset }, annotations: read,
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const file = record(await api(cloud, 'skillFile')(id, input.path, input.version));
+        const content = page(typeof file.content === 'string' ? file.content : '', input.offset, max);
+        return { source: SOURCE, path: file.path, encoding: file.encoding, size: file.size, executable: file.executable ?? false, version: file.version ?? null, content: content.text, offset: content.offset, nextOffset: content.nextOffset, truncated: content.truncated };
+    }));
+    const fileInput = z.object({
+        path: z.string().trim().min(1).max(1024), content: z.string(), encoding: z.enum(['utf8', 'base64']).optional(), executable: z.boolean().optional(),
+    });
+    const normalize = (files) => files.map(f => ({ path: f.path, content: f.content, encoding: f.encoding ?? 'utf8', ...(f.executable !== undefined ? { executable: f.executable } : {}) }));
+    const write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+    server.registerTool('vault_go_skill_save', {
+        title: 'Salvar skill',
+        description: 'Salva uma skill na biblioteca privada: cria se não existir nessa pasta, senão publica uma nova versão (as anteriores ficam guardadas). Envie files (SKILL.md com frontmatter name/description e arquivos auxiliares) ou sourceDir (pasta local). folder aceita caminho ("dev/review") e cria o que faltar. linkCurrentProject liga ao projeto do diretório atual.',
+        inputSchema: {
+            name: z.string().trim().min(1).max(64).optional(), description: z.string().trim().min(1).max(4096).optional(),
+            folder: z.string().trim().max(600).optional(), projectIds: z.array(z.string().trim().min(1).max(128)).max(50).optional(),
+            linkCurrentProject: z.boolean().optional(), files: z.array(fileInput).max(512).optional(), sourceDir: z.string().trim().min(1).max(2000).optional(),
+            patch: z.boolean().optional(), remove: z.array(z.string().trim().min(1).max(1024)).max(512).optional(),
+            baseVersion: z.string().trim().regex(/^[A-Za-z0-9_-]{1,128}$/).optional(), releaseNotes: z.string().max(10_000).optional(),
+        },
+        annotations: write,
+    }, async (input) => run(async () => {
+        if (!input.files && !input.sourceDir)
+            throw new Error('Informe files ou sourceDir.');
+        const files = input.sourceDir ? readSourceDir(input.sourceDir) : normalize(input.files ?? []);
+        const md = files.find(f => f.path === 'SKILL.md');
+        const front = md && md.encoding === 'utf8' ? frontmatter(md.content) : null;
+        if (!input.patch && !front)
+            throw new Error('SKILL.md na raiz precisa de frontmatter com name e description.');
+        if (input.patch && !input.baseVersion)
+            throw new Error('patch exige baseVersion.');
+        const name = input.name ?? front?.name;
+        if (!name)
+            throw new Error('Informe name (ou um SKILL.md com frontmatter).');
+        const folderId = input.folder !== undefined ? await ensureFolder(cloud, input.folder) : null;
+        const existing = (await listAll(cloud, { folderId: folderId ?? 'root' })).find(s => s.name.toLowerCase() === name.toLowerCase());
+        const project = input.linkCurrentProject ? await currentProject(cloud, cwd()) : null;
+        if (input.linkCurrentProject && !project)
+            throw new Error('Nenhum projeto do Vault corresponde ao diretório atual.');
+        const links = union(input.projectIds ?? [], project ? [project.id] : []);
+        const releaseNotes = input.releaseNotes ?? '';
+        const naming = { ...(input.name ? { name: input.name } : {}), ...(input.description ? { description: input.description } : {}) };
+        if (!existing) {
+            if (input.patch)
+                throw new Error(`Skill não encontrada para patch: ${name}`);
+            const created = record(await api(cloud, 'createSkill')({ files, folderId, releaseNotes, ...naming, ...(links.length ? { projectIds: links } : {}) }));
+            return { action: 'created', skill: compact(record(created.skill)) };
+        }
+        const body = input.patch
+            ? { baseVersion: input.baseVersion, upsert: files, remove: input.remove ?? [], releaseNotes, ...(input.description ? { description: input.description } : {}) }
+            : { files, ...(input.baseVersion ? { baseVersion: input.baseVersion } : {}), releaseNotes, ...naming };
+        let updated = record(record(await api(cloud, 'createSkillVersion')(existing.id, body)).skill);
+        if (links.length)
+            updated = record(record(await api(cloud, 'setSkillProjects')(existing.id, union(existing.projectIds ?? [], links))).skill);
+        return { action: 'updated', skill: compact(updated) };
+    }));
+    server.registerTool('vault_go_skill_organize', {
+        title: 'Organizar skills',
+        description: 'Organiza a biblioteca privada: create_folder, move_folder, rename_folder, move_skill, rename_skill, link_projects e unlink_projects. Caminhos de pasta usam "/" e "" é a raiz. Sem projectIds, link/unlink usam o projeto do diretório atual. Não exclui nada.',
+        inputSchema: {
+            action: z.enum(['create_folder', 'move_folder', 'rename_folder', 'move_skill', 'rename_skill', 'link_projects', 'unlink_projects']),
+            skill: skillRef.optional(), folder: z.string().trim().max(600).optional(), targetFolder: z.string().trim().max(600).optional(),
+            newName: z.string().trim().min(1).max(64).optional(), description: z.string().trim().min(1).max(4096).optional(),
+            projectIds: z.array(z.string().trim().min(1).max(128)).max(50).optional(),
+        },
+        annotations: write,
+    }, async (input) => run(async () => {
+        const required = (value, field) => { if (value === undefined || value === null)
+            throw new Error(`${input.action} exige ${field}.`); return value; };
+        const existingFolder = async (path) => {
+            const folder = folderByPath(await loadFolders(cloud), path);
+            if (!folder)
+                throw new Error(`Pasta não encontrada: ${path}`);
+            return folder;
+        };
+        switch (input.action) {
+            case 'create_folder':
+                return { folderId: await ensureFolder(cloud, required(input.folder, 'folder')) };
+            case 'rename_folder': {
+                const folder = await existingFolder(required(input.folder, 'folder'));
+                return api(cloud, 'updateSkillFolder')(folder.id, { name: required(input.newName, 'newName') });
+            }
+            case 'move_folder': {
+                const folder = await existingFolder(required(input.folder, 'folder'));
+                return api(cloud, 'updateSkillFolder')(folder.id, { parentId: await ensureFolder(cloud, required(input.targetFolder, 'targetFolder')) });
+            }
+            case 'move_skill': {
+                const target = required(input.targetFolder, 'targetFolder');
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                return api(cloud, 'updateSkill')(id, { folderId: await ensureFolder(cloud, target) });
+            }
+            case 'rename_skill': {
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                return api(cloud, 'updateSkill')(id, { name: required(input.newName, 'newName'), ...(input.description ? { description: input.description } : {}) });
+            }
+            case 'link_projects':
+            case 'unlink_projects': {
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                let ids = input.projectIds;
+                if (!ids?.length) {
+                    const project = await currentProject(cloud, cwd());
+                    if (!project)
+                        throw new Error('Informe projectIds: nenhum projeto do Vault corresponde ao diretório atual.');
+                    ids = [project.id];
+                }
+                const current = record(record(await api(cloud, 'skill')(id)).skill).projectIds ?? [];
+                const next = input.action === 'link_projects' ? union(current, ids) : current.filter(p => !ids.includes(p));
+                return api(cloud, 'setSkillProjects')(id, next);
+            }
+        }
+    }));
+    const userHome = options.userHome ?? homedir();
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const targets = z.array(z.enum(SKILL_TARGETS)).min(1).max(3).default(['claude']);
+    async function download(id, versionId) {
+        return downloadSkillArchive(cloud, id, versionId, fetcher);
+    }
+    async function installInto(id, name, roots, versionId) {
+        const archive = await download(id, versionId);
+        return roots.map(root => ({ root, versionId: archive.versionId, ...installSkillArchive({ bytes: archive.bytes, expectedSha256: archive.sha256, dirName: name, root, skillId: id, versionId: archive.versionId }) }));
+    }
+    server.registerTool('vault_go_skill_install', {
+        title: 'Instalar skill localmente',
+        description: 'Baixa uma skill da biblioteca privada, confere a integridade e instala em ~/.claude/skills (ou .grok/.agents). Nunca sobrescreve uma skill que o Vault não instalou.',
+        inputSchema: { skill: skillRef, version, targets },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const detail = record(record(await api(cloud, 'skill')(id, input.version)).skill);
+        const name = String(detail.name);
+        const done = await installInto(id, name, input.targets.map(t => targetRoot(t, userHome)), input.version);
+        return { installed: done.map((d, i) => ({ target: input.targets[i], path: d.path, versionId: d.versionId })) };
+    }));
+    server.registerTool('vault_go_skill_sync', {
+        title: 'Sincronizar skills instaladas',
+        description: 'Atualiza as skills instaladas pelo Vault que têm versão nova. Com currentProject ou projectId, também instala as skills vinculadas ao projeto que ainda não estão instaladas.',
+        inputSchema: { currentProject: z.boolean().optional(), projectId: z.string().trim().min(1).max(128).optional(), targets },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(async () => {
+        const roots = input.targets.map(t => targetRoot(t, userHome));
+        const installed = installedSkills(roots);
+        const updated = [], missing = [], added = [];
+        for (const item of installed) {
+            let detail;
+            try {
+                detail = record(record(await api(cloud, 'skill')(item.skillId)).skill);
+            }
+            catch {
+                missing.push({ skill: item.dir, path: join(item.root, item.dir) });
+                continue;
+            }
+            const latest = record(detail.latestVersion).id;
+            if (typeof latest !== 'string' || latest === item.versionId)
+                continue;
+            const [done] = await installInto(item.skillId, item.dir, [item.root], latest);
+            updated.push({ skill: detail.name, from: item.versionId, to: latest, path: done.path });
+        }
+        const projectId = input.projectId ?? (input.currentProject ? (await currentProject(cloud, cwd()))?.id : undefined);
+        if (input.currentProject && !projectId)
+            throw new Error('Nenhum projeto do Vault corresponde ao diretório atual.');
+        if (projectId) {
+            const have = new Set(installedSkills(roots).map(i => `${i.skillId}\0${i.root}`));
+            const linked = (await listAll(cloud, { projectId })).filter(s => s.scope === 'project');
+            for (const skill of linked) {
+                const missingRoots = roots.filter(root => !have.has(`${skill.id}\0${root}`));
+                if (!missingRoots.length)
+                    continue;
+                const done = await installInto(skill.id, skill.name, missingRoots);
+                added.push(...done.map(d => ({ skill: skill.name, path: d.path, versionId: d.versionId })));
+                for (const root of missingRoots)
+                    have.add(`${skill.id}\0${root}`);
+            }
+        }
+        return { updated, installed: added, missing };
+    }));
+}

package/dist/skills-cli.d.ts

@@ -0,0 +1,31 @@
+import type { VaultMemoryApi } from './cloud.js';
+type Target = 'agents' | 'claude' | 'grok';
+type ListedSkill = {
+    id: string;
+    name: string;
+    folderPath: string | null;
+};
+type InstalledSkillResult = {
+    name: string;
+    target: Target;
+    path: string;
+    versionId: string;
+};
+type SkippedSkillResult = {
+    name: string;
+    target: Target;
+    path: string;
+    reason: 'unmanaged' | 'foreign';
+};
+export type SkillsCommandResult = {
+    skills: ListedSkill[];
+    installed: InstalledSkillResult[];
+    skipped: SkippedSkillResult[];
+};
+type Dependencies = {
+    cloud: VaultMemoryApi;
+    userHome?: string;
+    fetcher?: typeof fetch;
+};
+export declare function executeSkillsCommand(args: string[], dependencies: Dependencies): Promise<SkillsCommandResult>;
+export {};

package/dist/skills-cli.js

@@ -0,0 +1,90 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { inspectSkillDestination, installSkillArchive } from './skill-local.js';
+import { downloadSkillArchive } from './skill-download.js';
+import { listAllSkillSummaries } from './skill-library.js';
+async function listSkills(cloud) {
+    return (await listAllSkillSummaries(cloud)).map(skill => ({ id: skill.id, name: skill.name, folderPath: skill.folderPath ?? null }));
+}
+function parse(args) {
+    const action = args[0] ?? 'list';
+    if (action !== 'list' && action !== 'install')
+        throw new Error('Use vault-go skills list ou vault-go skills install --skill <nome>|--all.');
+    let all = false;
+    let target = 'agents';
+    const refs = [];
+    for (let index = 1; index < args.length; index++) {
+        const flag = args[index];
+        if (flag === '--all') {
+            all = true;
+            continue;
+        }
+        if (flag === '--skill' || flag === '--target') {
+            const value = args[++index];
+            if (!value || value.startsWith('--'))
+                throw new Error(`${flag} exige um valor.`);
+            if (flag === '--skill')
+                refs.push(value);
+            else if (value === 'agents' || value === 'claude' || value === 'grok')
+                target = value;
+            else
+                throw new Error('--target deve ser agents, claude ou grok.');
+            continue;
+        }
+        throw new Error(`Opção desconhecida: ${flag}`);
+    }
+    if (action === 'list' && (all || refs.length || target !== 'agents'))
+        throw new Error('vault-go skills list não aceita opções de instalação.');
+    if (action === 'install' && (all === (refs.length > 0)))
+        throw new Error('Use --all ou pelo menos um --skill.');
+    return { action, all, refs, target };
+}
+function select(skills, all, refs) {
+    const selected = all ? skills : refs.map(ref => {
+        const matches = skills.filter(skill => [skill.id, skill.name, `${skill.folderPath ? `${skill.folderPath}/` : ''}${skill.name}`].some(value => value.toLowerCase() === ref.toLowerCase()));
+        if (!matches.length)
+            throw new Error(`Skill não encontrada: ${ref}`);
+        if (matches.length > 1)
+            throw new Error(`Skill ambígua: ${ref}. Informe pasta/nome.`);
+        return matches[0];
+    });
+    const unique = [...new Map(selected.map(skill => [skill.id, skill])).values()];
+    const names = new Set();
+    for (const skill of unique) {
+        const name = skill.name.toLowerCase();
+        if (names.has(name))
+            throw new Error(`Mais de uma skill usa a pasta ${skill.name}; selecione uma por vez.`);
+        names.add(name);
+    }
+    return unique;
+}
+export async function executeSkillsCommand(args, dependencies) {
+    const command = parse(args);
+    const skills = await listSkills(dependencies.cloud);
+    if (command.action === 'list')
+        return { skills, installed: [], skipped: [] };
+    if (!dependencies.cloud.skillDownloadGrant)
+        throw new Error('Este Vault não oferece download de skills.');
+    const selected = select(skills, command.all, command.refs);
+    const root = command.target === 'agents'
+        ? join(dependencies.userHome ?? homedir(), '.agents', 'skills')
+        : join(dependencies.userHome ?? homedir(), `.${command.target}`, 'skills');
+    const fetcher = dependencies.fetcher ?? globalThis.fetch;
+    const installed = [];
+    const skipped = [];
+    const planned = selected.flatMap(skill => {
+        const destination = inspectSkillDestination(root, skill.name, skill.id);
+        if (destination.status !== 'conflict')
+            return [skill];
+        if (!command.all)
+            throw new Error(`${destination.path} já existe; skill ${skill.name} não foi instalada.`);
+        skipped.push({ name: skill.name, target: command.target, path: destination.path, reason: destination.reason });
+        return [];
+    });
+    for (const skill of planned) {
+        const downloaded = await downloadSkillArchive(dependencies.cloud, skill.id, undefined, fetcher);
+        const result = installSkillArchive({ bytes: downloaded.bytes, expectedSha256: downloaded.sha256, dirName: skill.name, root, skillId: skill.id, versionId: downloaded.versionId });
+        installed.push({ name: skill.name, target: command.target, path: result.path, versionId: downloaded.versionId });
+    }
+    return { skills: [], installed, skipped };
+}

package/dist/transcript-config.d.ts

@@ -1,4 +1,4 @@
-export type TranscriptAdapter = 'claude' | 'codex';
+export type TranscriptAdapter = 'claude' | 'codex' | 'cursor';
 export interface TranscriptTarget {
     id: string;
     adapter: TranscriptAdapter;

package/dist/transcript-config.js

@@ -44,10 +44,11 @@ function load(home) {
     const value = readPrivateJson(home, 'transcript-watchers.json', 100_000);
     if (value?.version !== 1 || value.owner !== captureOwner(home) || !Array.isArray(value.targets))
         return { version: 1, owner: captureOwner(home), targets: [] };
-    return { version: 1, owner: value.owner, targets: value.targets.filter(t => t && typeof t.id === 'string' && ['claude', 'codex'].includes(t.adapter) && typeof t.root === 'string' && isAbsolute(t.root) && typeof t.workspace === 'string' && isAbsolute(t.workspace) && typeof t.since === 'number').slice(0, 20) };
+    return { version: 1, owner: value.owner, targets: value.targets.filter(t => t && typeof t.id === 'string' && ['claude', 'codex', 'cursor'].includes(t.adapter) && typeof t.root === 'string' && isAbsolute(t.root) && typeof t.workspace === 'string' && isAbsolute(t.workspace) && typeof t.since === 'number').slice(0, 20) };
 }
 export function defaultTranscriptRoot(adapter, userHome = homedir()) {
-    return join(userHome, adapter === 'claude' ? '.claude/projects' : '.codex/sessions');
+    const folder = adapter === 'claude' ? '.claude/projects' : adapter === 'cursor' ? '.cursor/projects' : '.codex/sessions';
+    return join(userHome, folder);
 }
 export function transcriptStatus(home) {
     const config = load(home);
@@ -64,7 +65,7 @@ export function transcriptCaptureEnabled(home, adapter, cwd) {
     return load(home).targets.some(t => t.enabled && t.adapter === adapter && t.workspace === workspace);
 }
 export function configureTranscriptWatcher(home, input) {
-    if (!['claude', 'codex'].includes(input.adapter) || !isAbsolute(input.workspace))
+    if (!['claude', 'codex', 'cursor'].includes(input.adapter) || !isAbsolute(input.workspace))
         throw new Error('Adaptador ou workspace inválido. Use um caminho absoluto.');
     if (input.enabled && input.consent !== true)
         throw new Error('Ativar exige consent=true para capturar transcripts deste workspace.');

package/dist/transcript-parser.js

@@ -63,7 +63,7 @@ export function parseTranscript(adapter, value, previous, offset) {
         if (cwd)
             state.cwd = cwd;
     }
-    if (adapter === 'claude') {
+    if (adapter === 'claude' || adapter === 'cursor') {
         scope(text(row.sessionId), text(row.cwd));
         if (row.private === true || row.isPrivate === true || row.is_private === true) {
             state.private = true;

package/dist/transcript-tools.js

@@ -8,7 +8,7 @@ export function registerTranscriptTools(server, home, cloud) {
     server.registerTool('vault_go_transcripts_status', { description: 'Watchers opt-in de Claude/Codex neste dispositivo e conta. Requer automaticCapture para enviar eventos; geração usa o motor já escolhido.', inputSchema: {}, annotations: { readOnlyHint: true, openWorldHint: false } }, () => run(async () => transcriptStatus(home)));
     server.registerTool('vault_go_transcripts_configure', {
         description: 'Ativa/desativa captura persistente de um workspace com consentimento explícito. Por padrão ignora histórico existente; fromStart importa histórico. Hooks nativos preservam contexto e cedem escrita ao watcher enquanto ativo. O worker local precisa estar em execução.',
-        inputSchema: { adapter: z.enum(['claude', 'codex']), workspace: path, root: path.optional(), enabled: z.boolean(), consent: z.boolean().default(false), fromStart: z.boolean().default(false) },
+        inputSchema: { adapter: z.enum(['claude', 'codex', 'cursor']), workspace: path, root: path.optional(), enabled: z.boolean(), consent: z.boolean().default(false), fromStart: z.boolean().default(false) },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
     }, input => run(async () => { const { root, ...rest } = input; return configureTranscriptWatcher(home, { ...rest, ...(root === undefined ? {} : { root }) }); }));
     server.registerTool('vault_go_transcripts_poll', { description: 'Processa um lote limitado dos watchers já consentidos. Retomada e idempotência persistem entre reinícios; não ativa captura nem muda o motor.', inputSchema: {}, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true } }, () => run(() => pollTranscripts(home, cloud)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.29.2",
+  "version": "0.31.0",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
@@ -26,6 +26,20 @@
     "dist/knowledge-agent.d.ts",
     "dist/knowledge-tools.js",
     "dist/knowledge-tools.d.ts",
+    "dist/skill-context.js",
+    "dist/skill-context.d.ts",
+    "dist/skill-local.js",
+    "dist/skill-local.d.ts",
+    "dist/legacy-brand.js",
+    "dist/legacy-brand.d.ts",
+    "dist/skill-tools.js",
+    "dist/skill-tools.d.ts",
+    "dist/skill-download.js",
+    "dist/skill-download.d.ts",
+    "dist/skill-library.js",
+    "dist/skill-library.d.ts",
+    "dist/skills-cli.js",
+    "dist/skills-cli.d.ts",
     "dist/activity.js",
     "dist/activity.d.ts",
     "dist/auth.js",
@@ -133,6 +147,10 @@
     "dist/awareness-tools.d.ts",
     "dist/skill-install.js",
     "dist/skill-install.d.ts",
+    "dist/memory-archive.js",
+    "dist/memory-archive.d.ts",
+    "dist/agent-cost.js",
+    "dist/agent-cost.d.ts",
     "grammars/"
   ],
   "scripts": {