vault-go 0.20.0 → 0.22.0

package/dist/smart-code.js

@@ -1,26 +1,77 @@
-import { Lang, parse } from '@ast-grep/napi';
+import { Lang, parse, registerDynamicLanguage } from '@ast-grep/napi';
+import { createRequire } from 'node:module';
 import { readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
-import { basename, extname, isAbsolute, relative, resolve, sep } from 'node:path';
-export const SUPPORTED_LANGUAGES = [
-    { language: 'JavaScript', extensions: ['.js', '.jsx', '.mjs', '.cjs'] },
-    { language: 'TypeScript', extensions: ['.ts', '.mts', '.cts'] },
-    { language: 'Tsx', extensions: ['.tsx'] },
-    { language: 'Html', extensions: ['.html', '.htm'] },
-    { language: 'Css', extensions: ['.css'] },
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+const BUILTIN_LANGUAGES = [
+    { name: 'JavaScript', parser: Lang.JavaScript, extensions: ['.js', '.jsx', '.mjs', '.cjs'] },
+    { name: 'TypeScript', parser: Lang.TypeScript, extensions: ['.ts', '.mts', '.cts'] },
+    { name: 'Tsx', parser: Lang.Tsx, extensions: ['.tsx'] },
+    { name: 'Html', parser: Lang.Html, extensions: ['.html', '.htm'] },
+    { name: 'Css', parser: Lang.Css, extensions: ['.css'] },
 ];
-const LANGUAGE_BY_EXTENSION = new Map([
-    ['.js', { name: 'JavaScript', parser: Lang.JavaScript }],
-    ['.jsx', { name: 'JavaScript', parser: Lang.JavaScript }],
-    ['.mjs', { name: 'JavaScript', parser: Lang.JavaScript }],
-    ['.cjs', { name: 'JavaScript', parser: Lang.JavaScript }],
-    ['.ts', { name: 'TypeScript', parser: Lang.TypeScript }],
-    ['.mts', { name: 'TypeScript', parser: Lang.TypeScript }],
-    ['.cts', { name: 'TypeScript', parser: Lang.TypeScript }],
-    ['.tsx', { name: 'Tsx', parser: Lang.Tsx }],
-    ['.html', { name: 'Html', parser: Lang.Html }],
-    ['.htm', { name: 'Html', parser: Lang.Html }],
-    ['.css', { name: 'Css', parser: Lang.Css }],
-]);
+const DYNAMIC_LANGUAGES = [
+    { name: 'Python', parser: 'python', extensions: ['.py', '.pyw'], packageName: '@ast-grep/lang-python' },
+    { name: 'Go', parser: 'go', extensions: ['.go'], packageName: '@ast-grep/lang-go' },
+    { name: 'Rust', parser: 'rust', extensions: ['.rs'], packageName: '@ast-grep/lang-rust' },
+    { name: 'Ruby', parser: 'ruby', extensions: ['.rb'], packageName: '@ast-grep/lang-ruby' },
+    { name: 'Java', parser: 'java', extensions: ['.java'], packageName: '@ast-grep/lang-java' },
+    { name: 'C', parser: 'c', extensions: ['.c', '.h'], packageName: '@ast-grep/lang-c' },
+    { name: 'Cpp', parser: 'cpp', extensions: ['.cpp', '.cc', '.cxx', '.hpp', '.hh'], packageName: '@ast-grep/lang-cpp' },
+    { name: 'Kotlin', parser: 'kotlin', extensions: ['.kt', '.kts'], packageName: '@ast-grep/lang-kotlin' },
+    { name: 'Swift', parser: 'swift', extensions: ['.swift'], packageName: '@ast-grep/lang-swift' },
+    { name: 'Php', parser: 'php', extensions: ['.php'], packageName: '@ast-grep/lang-php' },
+    { name: 'Lua', parser: 'lua', extensions: ['.lua'], packageName: '@ast-grep/lang-lua' },
+    { name: 'Scala', parser: 'scala', extensions: ['.scala', '.sc'], packageName: '@ast-grep/lang-scala' },
+    { name: 'Bash', parser: 'bash', extensions: ['.sh', '.bash', '.zsh'], packageName: '@ast-grep/lang-bash' },
+    { name: 'Haskell', parser: 'haskell', extensions: ['.hs'], packageName: '@ast-grep/lang-haskell' },
+    { name: 'Toml', parser: 'toml', extensions: ['.toml'], packageName: '@ast-grep/lang-toml' },
+    { name: 'Yaml', parser: 'yaml', extensions: ['.yml', '.yaml'], packageName: '@ast-grep/lang-yaml' },
+    { name: 'Sql', parser: 'sql', extensions: ['.sql'], packageName: '@ast-grep/lang-sql' },
+    { name: 'Markdown', parser: 'markdown', extensions: ['.md', '.mdx'], packageName: '@ast-grep/lang-markdown' },
+    { name: 'Zig', parser: 'zig', extensions: ['.zig'], packageName: '@tree-sitter-grammars/tree-sitter-zig', binding: '@tree-sitter-grammars+tree-sitter-zig' },
+    { name: 'Scss', parser: 'scss', extensions: ['.scss'], packageName: 'tree-sitter-scss', binding: 'tree-sitter-scss' },
+];
+// Register the complete allowlisted set once. No path from a workspace/config is loaded as executable grammar code.
+const grammarRequire = createRequire(import.meta.url);
+const unavailable = new Set();
+const registrations = {};
+for (const language of DYNAMIC_LANGUAGES) {
+    try {
+        const grammar = language.binding ? {
+            libraryPath: join(dirname(grammarRequire.resolve(`${language.packageName}/package.json`)), 'prebuilds', `${process.platform}-${process.arch}`, `${language.binding}.node`),
+            extensions: language.extensions.map(ext => ext.slice(1)), languageSymbol: `tree_sitter_${language.parser}`, expandoChar: '_',
+        } : grammarRequire(language.packageName);
+        statSync(grammar.libraryPath);
+        registrations[language.parser] = { ...grammar, libraryPath: grammar.libraryPath };
+    }
+    catch {
+        unavailable.add(language.name);
+    }
+}
+try {
+    registerDynamicLanguage(registrations);
+}
+catch {
+    for (const language of DYNAMIC_LANGUAGES)
+        unavailable.add(language.name);
+}
+for (const language of DYNAMIC_LANGUAGES) {
+    if (!unavailable.has(language.name)) {
+        try {
+            parse(language.parser, '').root();
+        }
+        catch {
+            unavailable.add(language.name);
+        }
+    }
+}
+const LANGUAGE_BY_EXTENSION = new Map([...BUILTIN_LANGUAGES, ...DYNAMIC_LANGUAGES].flatMap(language => language.extensions.map(extension => [extension, language])));
+export const SUPPORTED_LANGUAGES = [...BUILTIN_LANGUAGES, ...DYNAMIC_LANGUAGES].filter(language => !unavailable.has(language.name)).map(language => ({ language: language.name, extensions: language.extensions }));
+export function smartLanguageStatus() {
+    return [
+        ...[...BUILTIN_LANGUAGES, ...DYNAMIC_LANGUAGES].map(language => ({ language: language.name, extensions: language.extensions, available: !unavailable.has(language.name), parser: 'tree-sitter/ast-grep', package: language.packageName ?? '@ast-grep/napi', ...(unavailable.has(language.name) ? { reason: 'No compatible installed prebuild; no regex fallback.' } : {}) })),
+    ];
+}
 export const SMART_CODE_LIMITS = Object.freeze({
     maxFileBytes: 1_048_576,
     maxOutlineSymbols: 1_000,
@@ -39,6 +90,8 @@ const DENIED_DIRECTORIES = new Set(['.git', 'node_modules', 'build', 'dist', 'co
 const TRUNCATION_SUFFIX = '\n… [truncated]';
 function languageFor(filePath) {
     const language = LANGUAGE_BY_EXTENSION.get(extname(filePath).toLowerCase());
+    if (language && unavailable.has(language.name))
+        throw new Error(`AST grammar unavailable for ${language.name} on ${process.platform}/${process.arch}. Install a compatible prebuild; no regex fallback is used.`);
     if (!language) {
         const extensions = [...LANGUAGE_BY_EXTENSION.keys()].join(', ');
         throw new Error(`Unsupported language for "${filePath}". Supported extensions: ${extensions}`);
@@ -106,8 +159,14 @@ function sourceLocation(node) {
         endColumn: range.end.column + 1,
     };
 }
-const IDENTIFIER_KINDS = new Set(['identifier', 'type_identifier', 'property_identifier', 'private_property_identifier']);
+const IDENTIFIER_KINDS = new Set(['identifier', 'type_identifier', 'property_identifier', 'private_property_identifier', 'field_identifier', 'simple_identifier', 'name', 'word', 'variable', 'constant']);
 function directIdentifier(node) {
+    const named = node.field('name');
+    if (named)
+        return named.text();
+    const declarator = node.field('declarator');
+    if (declarator)
+        return directIdentifier(declarator) ?? (IDENTIFIER_KINDS.has(String(declarator.kind())) ? declarator.text() : null);
     const identifier = node.namedChildren().find((child) => IDENTIFIER_KINDS.has(String(child.kind())));
     return identifier?.text() ?? null;
 }
@@ -124,12 +183,54 @@ function symbolDescriptor(node) {
         type_alias_declaration: 'type',
         enum_declaration: 'enum',
         internal_module: 'namespace',
+        function_definition: 'function', function_item: 'function', function_signature_item: 'function', function: 'function',
+        class_definition: 'class', class_specifier: 'class', object_definition: 'class', object_declaration: 'class',
+        method_declaration: 'method', method: 'method', singleton_method: 'method', constructor_declaration: 'method',
+        struct_item: 'struct', struct_specifier: 'struct', enum_item: 'enum', enum_specifier: 'enum',
+        trait_item: 'trait', trait_definition: 'trait', trait_declaration: 'trait', protocol_declaration: 'interface',
+        type_spec: 'type', type_item: 'type', type_synomym: 'type', type_synonym: 'type', newtype: 'type', data_type: 'type',
+        class: 'class', module: 'namespace', function_statement: 'function', mixin_statement: 'mixin',
     };
     const fixedKind = fixedKinds[syntaxKind];
     if (fixedKind) {
         const name = directIdentifier(node);
         return name ? { name, kind: fixedKind } : null;
     }
+    if (syntaxKind === 'impl_item') {
+        const type = node.field('type');
+        return type ? { name: type.text(), kind: 'impl' } : null;
+    }
+    if (syntaxKind === 'variable_declaration' && node.namedChildren().some(c => ['struct_declaration', 'enum_declaration', 'union_declaration'].includes(String(c.kind())))) {
+        const name = directIdentifier(node);
+        return name ? { name, kind: 'type' } : null;
+    }
+    if (syntaxKind === 'table' || syntaxKind === 'table_array_element') {
+        const key = node.namedChildren().find(c => ['bare_key', 'dotted_key', 'quoted_key'].includes(String(c.kind())));
+        return key ? { name: key.text(), kind: 'section' } : null;
+    }
+    if (syntaxKind === 'block_mapping_pair') {
+        const key = node.field('key');
+        return key ? { name: key.text(), kind: 'property' } : null;
+    }
+    if (['create_table', 'create_view', 'create_function'].includes(syntaxKind)) {
+        const name = node.namedChildren().find(c => String(c.kind()) === 'object_reference');
+        return name ? { name: name.text(), kind: syntaxKind === 'create_function' ? 'function' : 'class' } : null;
+    }
+    if (syntaxKind === 'section') {
+        const heading = node.namedChildren().find(c => ['atx_heading', 'setext_heading'].includes(String(c.kind())));
+        const name = heading?.field('heading_content') ?? heading?.namedChildren().find(c => ['inline', 'paragraph'].includes(String(c.kind())));
+        return name ? { name: name.text().trim(), kind: 'section' } : null;
+    }
+    if (syntaxKind === 'fenced_code_block') {
+        const info = node.namedChildren().find(c => String(c.kind()) === 'info_string');
+        return { name: info?.text() ?? 'code', kind: 'code' };
+    }
+    if (syntaxKind === 'minus_metadata')
+        return { name: 'frontmatter', kind: 'metadata' };
+    if (syntaxKind === 'link_reference_definition') {
+        const name = node.namedChildren().find(c => String(c.kind()) === 'link_label');
+        return name ? { name: name.text(), kind: 'reference' } : null;
+    }
     if (syntaxKind === 'variable_declarator' || syntaxKind === 'public_field_definition') {
         const children = node.namedChildren();
         const value = children.at(-1);
@@ -153,7 +254,7 @@ function symbolDescriptor(node) {
     }
     return null;
 }
-const DIRECT_BODY_KINDS = new Set(['statement_block', 'class_body', 'interface_body', 'enum_body', 'block']);
+const DIRECT_BODY_KINDS = new Set(['statement_block', 'class_body', 'interface_body', 'enum_body', 'block', 'body_statement', 'compound_statement', 'field_declaration_list', 'enumerator_list', 'function_body', 'template_body', 'declaration_list', 'match', 'column_definitions']);
 function functionValueBody(node) {
     if (!['variable_declarator', 'public_field_definition'].includes(String(node.kind())))
         return null;
@@ -166,10 +267,22 @@ function functionValueBody(node) {
     return candidate;
 }
 function signatureFor(node, descriptor) {
+    if (String(node.kind()) === 'section')
+        return node.namedChildren().find(c => ['atx_heading', 'setext_heading'].includes(String(c.kind())))?.text().trim() ?? descriptor.name;
+    if (String(node.kind()) === 'fenced_code_block')
+        return `\`\`\`${descriptor.name === 'code' ? '' : descriptor.name}`;
+    if (String(node.kind()) === 'minus_metadata')
+        return '---frontmatter---';
+    if (String(node.kind()) === 'table')
+        return `[${descriptor.name}]`;
+    if (String(node.kind()) === 'table_array_element')
+        return `[[${descriptor.name}]]`;
+    if (String(node.kind()) === 'block_mapping_pair')
+        return `${descriptor.name}:`;
     if (String(node.kind()) === 'element') {
         return node.namedChildren().find((child) => String(child.kind()) === 'start_tag')?.text() ?? descriptor.name;
     }
-    const body = node.namedChildren().find((child) => DIRECT_BODY_KINDS.has(String(child.kind()))) ?? functionValueBody(node);
+    const body = node.field('body') ?? node.namedChildren().find((child) => DIRECT_BODY_KINDS.has(String(child.kind()))) ?? functionValueBody(node);
     if (!body)
         return node.text().trim();
     const nodeText = node.text();
@@ -177,9 +290,6 @@ function signatureFor(node, descriptor) {
     const bodyOffset = nodeText.lastIndexOf(bodyText);
     if (bodyOffset < 0)
         return nodeText.trim();
-    const trailingText = nodeText.slice(bodyOffset + bodyText.length).trim();
-    if (trailingText !== '' && trailingText !== ';')
-        return nodeText.trim();
     return nodeText.slice(0, bodyOffset).trimEnd();
 }
 function extractSymbols(root) {
@@ -325,7 +435,8 @@ function discoverFiles(searchPath, workspace, filePattern) {
         return pattern.test(patternHasDirectory ? relativePath : basename(relativePath));
     };
     const addFile = (file, outputPath) => {
-        if (!LANGUAGE_BY_EXTENSION.has(extname(file).toLowerCase()) || !accepts(outputPath))
+        const language = LANGUAGE_BY_EXTENSION.get(extname(file).toLowerCase());
+        if (!language || unavailable.has(language.name) || !accepts(outputPath))
             return;
         const stats = statSync(file);
         if (stats.size > SMART_CODE_LIMITS.maxFileBytes) {

package/dist/telegram.d.ts

@@ -0,0 +1,39 @@
+import type { Buffer } from 'node:buffer';
+export interface TelegramConfiguration {
+    token: string;
+    chatId: string;
+    enabled: boolean;
+    triggerTypes: string[];
+    triggerConcepts: string[];
+}
+export interface TelegramStatus {
+    configured: boolean;
+    enabled: boolean;
+    chatId?: string;
+    triggerTypes: string[];
+    triggerConcepts: string[];
+}
+export interface TelegramObservation {
+    id: string;
+    type: string;
+    title?: string;
+    subtitle?: string;
+    project?: string;
+    concepts?: string[];
+    narrative?: string;
+    facts?: string[];
+}
+export interface TelegramRuntimeOptions {
+    key?: Buffer;
+    fetcher?: typeof fetch;
+}
+export declare function configureTelegram(home: string, input: TelegramConfiguration, key?: Buffer): TelegramStatus;
+export declare function telegramStatus(home: string, key?: Buffer): TelegramStatus;
+export declare function disableTelegram(home: string, key?: Buffer): TelegramStatus;
+export declare function sendTelegramTest(home: string, options?: TelegramRuntimeOptions): Promise<{
+    sent: true;
+}>;
+export declare function notifyTelegramObservation(home: string, observation: TelegramObservation, options?: TelegramRuntimeOptions): Promise<{
+    sent: boolean;
+    reason?: 'not-configured' | 'disabled' | 'no-trigger-match';
+}>;

package/dist/telegram.js

@@ -0,0 +1,138 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { captureOwner } from './transcript-config.js';
+import { redact } from './capture-privacy.js';
+import { privateStore } from './private-store.js';
+const STORE_NAME = 'telegram.json';
+const MAX_TRIGGERS = 32;
+const MAX_FIELD = 500;
+function validateTrigger(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(normalized))
+        throw new Error('Invalid Telegram trigger.');
+    return normalized;
+}
+function triggers(values) {
+    if (!Array.isArray(values) || values.length > MAX_TRIGGERS)
+        throw new Error('Too many Telegram triggers.');
+    return [...new Set(values.map(validateTrigger))];
+}
+function validate(input) {
+    if (!/^\d{5,15}:[A-Za-z0-9_-]{10,100}$/.test(input.token))
+        throw new Error('Invalid Telegram bot token.');
+    if (!/^-?\d{1,20}$/.test(input.chatId))
+        throw new Error('Invalid Telegram chat identifier.');
+    const triggerTypes = triggers(input.triggerTypes);
+    const triggerConcepts = triggers(input.triggerConcepts);
+    if (input.enabled && triggerTypes.length === 0 && triggerConcepts.length === 0) {
+        throw new Error('Enabled Telegram alerts require at least one trigger.');
+    }
+    return { ...input, chatId: input.chatId.trim(), triggerTypes, triggerConcepts };
+}
+function withStore(home, key, operation) {
+    const store = privateStore(home, key);
+    try {
+        return operation(store);
+    }
+    finally {
+        store.close();
+    }
+}
+function readConfiguration(home, key) {
+    if (!existsSync(join(home, STORE_NAME)))
+        return null;
+    return withStore(home, key, store => {
+        const value = store.read(STORE_NAME);
+        if (!value || !captureOwner(home) || value.owner !== captureOwner(home))
+            return null;
+        try {
+            return validate(value);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+function publicStatus(value) {
+    if (!value)
+        return { configured: false, enabled: false, triggerTypes: [], triggerConcepts: [] };
+    return {
+        configured: true,
+        enabled: value.enabled,
+        chatId: value.chatId,
+        triggerTypes: value.triggerTypes,
+        triggerConcepts: value.triggerConcepts,
+    };
+}
+export function configureTelegram(home, input, key) {
+    const owner = captureOwner(home);
+    if (!owner)
+        throw new Error('Conecte sua conta Vault antes de configurar alertas.');
+    const configuration = validate(input);
+    withStore(home, key, store => store.write(STORE_NAME, { ...configuration, owner }));
+    return publicStatus(configuration);
+}
+export function telegramStatus(home, key) {
+    return publicStatus(readConfiguration(home, key));
+}
+export function disableTelegram(home, key) {
+    const current = readConfiguration(home, key);
+    if (!current)
+        return publicStatus(null);
+    return configureTelegram(home, { ...current, enabled: false }, key);
+}
+function bounded(value, fallback) {
+    const normalized = String(redact(value ?? '')).replace(/\s+/g, ' ').trim();
+    return (normalized || fallback).slice(0, MAX_FIELD);
+}
+function observationText(observation) {
+    return [
+        'Vault observation',
+        `Type: ${bounded(observation.type, 'unknown')}`,
+        `Title: ${bounded(observation.title, 'Untitled')}`,
+        ...(observation.subtitle ? [`Subtitle: ${bounded(observation.subtitle, '')}`] : []),
+        ...(observation.project ? [`Project: ${bounded(observation.project, '')}`] : []),
+        `ID: ${bounded(observation.id, 'unknown')}`,
+    ].join('\n').slice(0, 3_500);
+}
+async function send(configuration, text, fetcher) {
+    let response;
+    try {
+        response = await fetcher(`https://api.telegram.org/bot${configuration.token}/sendMessage`, {
+            method: 'POST',
+            redirect: 'error',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ chat_id: configuration.chatId, text: text.slice(0, 3_500), disable_web_page_preview: true }),
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        throw new Error('Telegram request failed.');
+    }
+    if (!response.ok)
+        throw new Error(`Telegram request failed with status ${response.status}.`);
+}
+export async function sendTelegramTest(home, options = {}) {
+    const configuration = readConfiguration(home, options.key);
+    if (!configuration)
+        throw new Error('Telegram is not configured.');
+    if (!configuration.enabled)
+        throw new Error('Telegram alerts are disabled.');
+    await send(configuration, 'Vault Go Telegram test. Alerts are configured.', options.fetcher ?? fetch);
+    return { sent: true };
+}
+export async function notifyTelegramObservation(home, observation, options = {}) {
+    const configuration = readConfiguration(home, options.key);
+    if (!configuration)
+        return { sent: false, reason: 'not-configured' };
+    if (!configuration.enabled)
+        return { sent: false, reason: 'disabled' };
+    const type = observation.type.trim().toLowerCase();
+    const concepts = (observation.concepts ?? []).map(value => value.trim().toLowerCase());
+    const matches = configuration.triggerTypes.includes(type)
+        || concepts.some(concept => configuration.triggerConcepts.includes(concept));
+    if (!matches)
+        return { sent: false, reason: 'no-trigger-match' };
+    await send(configuration, observationText(observation), options.fetcher ?? fetch);
+    return { sent: true };
+}

package/dist/transcript-config.d.ts

@@ -0,0 +1,41 @@
+export type TranscriptAdapter = 'claude' | 'codex';
+export interface TranscriptTarget {
+    id: string;
+    adapter: TranscriptAdapter;
+    root: string;
+    workspace: string;
+    enabled: boolean;
+    fromStart: boolean;
+    since: number;
+}
+export declare function captureOwner(home: string): string;
+export declare function captureCredential(home: string): string;
+export declare function workspaceRoot(path: string): string;
+export declare function privateJson(home: string, name: string, value: unknown): void;
+export declare function readPrivateJson(home: string, name: string, maxBytes?: number): unknown;
+export declare function defaultTranscriptRoot(adapter: TranscriptAdapter, userHome?: string): string;
+export declare function transcriptStatus(home: string): {
+    lastError?: string;
+    lastScan?: number;
+    enabled: boolean;
+    targets: TranscriptTarget[];
+    requiresAutomaticCapture: boolean;
+    defaultFromStart: boolean;
+};
+export declare function transcriptTargets(home: string): TranscriptTarget[];
+export declare function transcriptCaptureEnabled(home: string, adapter: string, cwd: string): boolean;
+export declare function configureTranscriptWatcher(home: string, input: {
+    adapter: TranscriptAdapter;
+    workspace: string;
+    root?: string;
+    enabled: boolean;
+    consent?: boolean;
+    fromStart?: boolean;
+}): {
+    lastError?: string;
+    lastScan?: number;
+    enabled: boolean;
+    targets: TranscriptTarget[];
+    requiresAutomaticCapture: boolean;
+    defaultFromStart: boolean;
+};

package/dist/transcript-config.js

@@ -0,0 +1,97 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { loadConfig, loadTokens } from './config.js';
+export function captureOwner(home) {
+    const config = loadConfig(home), token = process.env['VAULT_GO_TOKEN'] || loadTokens(home)?.accessToken;
+    if (!token)
+        return '';
+    return createHash('sha256').update(JSON.stringify([config.apiUrl, process.env['VAULT_GO_TOKEN'] || config.email || token])).digest('hex');
+}
+export function captureCredential(home) {
+    return createHash('sha256').update(process.env['VAULT_GO_TOKEN'] || loadTokens(home)?.accessToken || '').digest('hex');
+}
+export function workspaceRoot(path) {
+    let current = resolve(path);
+    const initial = current;
+    while (dirname(current) !== current) {
+        if (existsSync(join(current, '.git')))
+            return current;
+        current = dirname(current);
+    }
+    return initial;
+}
+export function privateJson(home, name, value) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    const destination = join(home, name), temp = `${destination}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify(value) + '\n', { mode: 0o600 });
+    renameSync(temp, destination);
+    chmodSync(destination, 0o600);
+}
+export function readPrivateJson(home, name, maxBytes = 8_000_000) {
+    try {
+        const file = join(home, name);
+        if (statSync(file).size > maxBytes)
+            return null;
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+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) };
+}
+export function defaultTranscriptRoot(adapter, userHome = homedir()) {
+    return join(userHome, adapter === 'claude' ? '.claude/projects' : '.codex/sessions');
+}
+export function transcriptStatus(home) {
+    const config = load(home);
+    const state = readPrivateJson(home, 'transcript-checkpoints.json');
+    const current = state?.owner === config.owner ? state : null;
+    return { enabled: config.targets.some(t => t.enabled), targets: config.targets, requiresAutomaticCapture: true, defaultFromStart: false,
+        ...(typeof current?.lastScan === 'number' ? { lastScan: current.lastScan } : {}),
+        ...(current?.lastError === 'transcript_capture_failed' ? { lastError: current.lastError } : {}),
+    };
+}
+export function transcriptTargets(home) { return load(home).targets; }
+export function transcriptCaptureEnabled(home, adapter, cwd) {
+    const workspace = workspaceRoot(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))
+        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.');
+    const owner = captureOwner(home);
+    if (!owner)
+        throw new Error('Autentique a conta antes de configurar captura.');
+    const workspace = workspaceRoot(resolve(input.workspace)), config = load(home);
+    const existing = config.targets.find(t => t.adapter === input.adapter && t.workspace === workspace);
+    if (!input.enabled) {
+        if (existing)
+            existing.enabled = false;
+    }
+    else {
+        const root = input.root ?? defaultTranscriptRoot(input.adapter);
+        if (!isAbsolute(root) || !statSync(root).isDirectory())
+            throw new Error('A raiz de transcripts deve ser um diretório absoluto.');
+        if (!statSync(workspace).isDirectory())
+            throw new Error('Workspace inexistente.');
+        const target = { id: existing?.id ?? randomUUID(), adapter: input.adapter, root: realpathSync(root), workspace, enabled: true, fromStart: input.fromStart === true, since: existing?.enabled ? existing.since : Date.now() };
+        if (existing)
+            Object.assign(existing, target);
+        else {
+            if (config.targets.length >= 20)
+                throw new Error('Limite de 20 watchers.');
+            config.targets.push(target);
+        }
+    }
+    privateJson(home, 'transcript-watchers.json', { ...config, owner });
+    return transcriptStatus(home);
+}

package/dist/transcript-parser.d.ts

@@ -0,0 +1,24 @@
+import type { HookEvent } from './hooks.js';
+import type { TranscriptAdapter } from './transcript-config.js';
+type Row = Record<string, unknown>;
+export interface TranscriptState {
+    session: string;
+    cwd: string;
+    private: boolean;
+    pending: Record<string, {
+        name: string;
+        input: Row;
+        timestamp: string;
+    }>;
+    summarized?: boolean;
+}
+export interface TranscriptEvent {
+    event: HookEvent;
+    input: Row;
+}
+export declare const emptyTranscriptState: () => TranscriptState;
+export declare function parseTranscript(adapter: TranscriptAdapter, value: unknown, previous: TranscriptState, offset: number): {
+    state: TranscriptState;
+    events: TranscriptEvent[];
+};
+export {};