@andespindola/brainlink 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/cli/commands/config-commands.js

@@ -0,0 +1,167 @@
+import { doctorVault } from '../../application/analyze-vault.js';
+import { indexVault } from '../../application/index-vault.js';
+import { migrateVaultContent, shouldMigrateDefaultVault } from '../../application/migrate-vault.js';
+import { defaultBrainlinkConfig, detectVaultConfigSource, loadBrainlinkConfig, loadLegacyLocalRawConfig, loadRawConfig, resolveConfigPath, writeRawConfig } from '../../infrastructure/config.js';
+import { assertVaultAllowed } from '../../infrastructure/file-system-vault.js';
+import { print } from '../runtime.js';
+const resolveScope = (globalOption) => globalOption ? 'global' : 'local';
+const normalizeVaultPath = (vault) => assertVaultAllowed(vault, []);
+const uniqueValues = (values) => Array.from(new Set(values));
+const resolveScopeFromSource = (source) => source === 'global' || source === 'default' ? 'global' : 'local';
+export const registerConfigCommands = (program) => {
+    const configCommand = program.command('config').description('read or update Brainlink configuration');
+    configCommand
+        .command('get [key]')
+        .option('--json', 'print machine-readable JSON')
+        .description('read effective Brainlink config values')
+        .action(async (key, options) => {
+        const config = await loadBrainlinkConfig();
+        if (!key) {
+            print(options.json, config, () => JSON.stringify(config, null, 2));
+            return;
+        }
+        if (!(key in config)) {
+            throw new Error(`Unknown config key: ${key}`);
+        }
+        const value = config[key];
+        print(options.json, { key, value }, () => `${key}=${typeof value === 'string' ? value : JSON.stringify(value)}`);
+    });
+    configCommand
+        .command('set-vault <vault>')
+        .option('--global', 'write to global config in $BRAINLINK_HOME/brainlink.config.json')
+        .option('--no-allowlist', 'do not append the vault to allowedVaults in the target config file')
+        .option('--migrate-from <vault>', 'copy existing Markdown memory from another vault into the configured vault')
+        .option('--no-migrate', 'skip migration step')
+        .option('--no-index', 'skip reindex after migration')
+        .option('--json', 'print machine-readable JSON')
+        .description('set the default vault path in Brainlink config')
+        .action(async (vault, options) => {
+        const scope = resolveScope(options.global);
+        const before = await loadBrainlinkConfig();
+        const targetVault = normalizeVaultPath(vault);
+        const rawConfig = await loadRawConfig(scope);
+        const configPath = resolveConfigPath(scope);
+        const shouldAllowlist = options.allowlist !== false;
+        const nextAllowedVaults = shouldAllowlist
+            ? uniqueValues([...(rawConfig.allowedVaults ?? []), targetVault])
+            : rawConfig.allowedVaults;
+        const nextRawConfig = {
+            ...rawConfig,
+            vault: targetVault,
+            ...(nextAllowedVaults ? { allowedVaults: nextAllowedVaults } : {})
+        };
+        await writeRawConfig(scope, nextRawConfig);
+        const shouldMigrate = options.migrate !== false;
+        const explicitSource = options.migrateFrom ? normalizeVaultPath(options.migrateFrom) : undefined;
+        const shouldAutoMigrate = shouldMigrate &&
+            explicitSource === undefined &&
+            (await shouldMigrateDefaultVault(before.vault, targetVault));
+        const migrationSource = shouldMigrate ? explicitSource ?? (shouldAutoMigrate ? before.vault : undefined) : undefined;
+        const migration = migrationSource ? await migrateVaultContent(migrationSource, targetVault) : undefined;
+        const shouldIndex = options.index !== false && migration !== undefined && migration.copied + migration.conflicted > 0;
+        const index = shouldIndex ? await indexVault(targetVault) : undefined;
+        const after = await loadBrainlinkConfig();
+        print(options.json, {
+            scope,
+            configPath,
+            beforeVault: before.vault,
+            vault: targetVault,
+            migration: migration ?? null,
+            index: index ?? null,
+            config: after
+        }, () => {
+            const migrationMessage = migration
+                ? ` Migrated ${migration.copied} files, preserved ${migration.conflicted} conflicts and kept ${migration.unchanged} unchanged files.`
+                : '';
+            const indexMessage = index
+                ? ` Indexed ${index.documentCount} documents, ${index.chunkCount} chunks and ${index.linkCount} links.`
+                : '';
+            return `Configured ${scope} vault at ${targetVault} in ${configPath}.${migrationMessage}${indexMessage}`;
+        });
+    });
+    configCommand
+        .command('where')
+        .option('--json', 'print machine-readable JSON')
+        .description('show effective vault path and config file locations')
+        .action(async (options) => {
+        const config = await loadBrainlinkConfig();
+        print(options.json, {
+            vault: config.vault,
+            localConfigPath: resolveConfigPath('local'),
+            globalConfigPath: resolveConfigPath('global'),
+            defaultVault: defaultBrainlinkConfig.vault
+        }, () => [
+            `vault=${config.vault}`,
+            `localConfigPath=${resolveConfigPath('local')}`,
+            `globalConfigPath=${resolveConfigPath('global')}`,
+            `defaultVault=${defaultBrainlinkConfig.vault}`
+        ].join('\n'));
+    });
+    configCommand
+        .command('doctor')
+        .option('--fix', 'apply safe config fixes (without this flag, doctor is dry-run)')
+        .option('--json', 'print machine-readable JSON')
+        .description('inspect effective config sources and run vault readiness checks')
+        .action(async (options) => {
+        const config = await loadBrainlinkConfig();
+        const source = await detectVaultConfigSource();
+        const globalConfigPath = resolveConfigPath('global');
+        const localConfigPath = resolveConfigPath('local');
+        const allowedVaultCheck = assertVaultAllowed(config.vault, config.allowedVaults);
+        const vaultDoctor = await doctorVault(config.vault);
+        const targetScope = resolveScopeFromSource(source);
+        const rawConfig = source === 'local-legacy'
+            ? await loadLegacyLocalRawConfig()
+            : await loadRawConfig(targetScope);
+        const normalizedVault = normalizeVaultPath(typeof rawConfig.vault === 'string' ? rawConfig.vault : config.vault);
+        const normalizedAllowedVaults = uniqueValues([
+            ...(Array.isArray(rawConfig.allowedVaults) ? rawConfig.allowedVaults.filter((item) => typeof item === 'string') : []),
+            normalizedVault
+        ].map((value) => normalizeVaultPath(value)));
+        const nextRawConfig = {
+            ...rawConfig,
+            vault: normalizedVault,
+            allowedVaults: normalizedAllowedVaults
+        };
+        const plannedFixes = [
+            `normalize vault path in ${targetScope} config`,
+            `ensure allowedVaults includes ${normalizedVault}`,
+            ...(source === 'local-legacy' ? ['migrate .brainlink.json settings into brainlink.config.json'] : []),
+            ...(source === 'default' ? ['create global brainlink.config.json with explicit vault'] : [])
+        ];
+        let fixApplied = false;
+        let fixedConfigPath = null;
+        if (options.fix) {
+            fixedConfigPath = await writeRawConfig(targetScope, nextRawConfig);
+            fixApplied = true;
+        }
+        const response = {
+            vault: config.vault,
+            vaultSource: source,
+            allowedVaultCheck,
+            localConfigPath,
+            globalConfigPath,
+            doctor: vaultDoctor,
+            fix: {
+                dryRun: options.fix !== true,
+                applied: fixApplied,
+                scope: targetScope,
+                path: fixedConfigPath,
+                plannedFixes
+            }
+        };
+        print(options.json, response, () => [
+            `vault=${response.vault}`,
+            `vaultSource=${response.vaultSource}`,
+            `localConfigPath=${response.localConfigPath}`,
+            `globalConfigPath=${response.globalConfigPath}`,
+            `configFixDryRun=${response.fix.dryRun}`,
+            ...(response.fix.applied && response.fix.path ? [`configFixAppliedAt=${response.fix.path}`] : []),
+            ...(response.fix.plannedFixes.length > 0 ? ['Planned config fixes:', ...response.fix.plannedFixes.map((step) => `- ${step}`)] : []),
+            ...response.doctor.checks.map((check) => `${check.ok ? 'OK' : 'FAIL'} ${check.name}: ${check.message}`),
+            ...(response.doctor.recommendations && response.doctor.recommendations.length > 0
+                ? ['Recommended next steps:', ...response.doctor.recommendations.map((recommendation) => `- ${recommendation}`)]
+                : [])
+        ].join('\n'));
+    });
+};

package/dist/cli/commands/read-commands.js

@@ -1,4 +1,4 @@
-import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from '../../application/analyze-vault.js';
+import { getBrokenLinksReport, getExtendedStats, getOrphansReport, getStats, validateVault } from '../../application/analyze-vault.js';
 import { buildContextPackage } from '../../application/build-context.js';
 import { getGraph } from '../../application/get-graph.js';
 import { listAgents } from '../../application/list-agents.js';
@@ -12,14 +12,14 @@ export const registerReadCommands = (program) => {
         .argument('<query>', 'search query')
         .option('-v, --vault <vault>', 'vault directory')
         .option('-a, --agent <agent>', 'filter by agent memory namespace')
-        .option('-l, --limit <limit>', 'maximum results', '10')
+        .option('-l, --limit <limit>', 'maximum results')
         .option('-m, --mode <mode>', 'search mode: fts, semantic or hybrid')
         .option('--json', 'print machine-readable JSON')
         .description('search indexed knowledge')
         .action(async (query, options) => {
         const resolved = await resolveOptions(options);
-        const limit = parsePositiveInteger(options.limit ?? String(resolved.config.defaultSearchLimit), resolved.config.defaultSearchLimit);
-        const mode = sanitizeSearchMode(options.mode, resolved.config.defaultSearchMode);
+        const limit = parsePositiveInteger(options.limit ?? String(resolved.defaults.defaultSearchLimit), resolved.defaults.defaultSearchLimit);
+        const mode = sanitizeSearchMode(options.mode, resolved.defaults.defaultSearchMode);
         const results = await searchKnowledge(resolved.vault, query, limit, resolved.agent, mode);
         print(options.json, { query, agent: resolved.agent, limit, mode, results }, () => results
             .map((result, index) => [`${index + 1}. ${result.title} (${result.path}) score=${result.score.toFixed(3)} mode=${result.searchMode}`, result.content].join('\n'))
@@ -58,15 +58,15 @@ export const registerReadCommands = (program) => {
         .argument('<query>', 'context query')
         .option('-v, --vault <vault>', 'vault directory')
         .option('-a, --agent <agent>', 'filter by agent memory namespace')
-        .option('-l, --limit <limit>', 'maximum search results before context selection', '12')
-        .option('-t, --tokens <tokens>', 'maximum estimated context tokens', '2000')
+        .option('-l, --limit <limit>', 'maximum search results before context selection')
+        .option('-t, --tokens <tokens>', 'maximum estimated context tokens')
         .option('-m, --mode <mode>', 'search mode: fts, semantic or hybrid')
         .option('--json', 'print machine-readable JSON')
         .description('build a compact context package for an agent')
         .action(async (query, options) => {
         const resolved = await resolveOptions(options);
-        const mode = sanitizeSearchMode(options.mode, resolved.config.defaultSearchMode);
-        const contextPackage = await buildContextPackage(resolved.vault, query, parsePositiveInteger(options.limit ?? '12', 12), parsePositiveInteger(options.tokens ?? String(resolved.config.defaultContextTokens), resolved.config.defaultContextTokens), resolved.agent, mode);
+        const mode = sanitizeSearchMode(options.mode, resolved.defaults.defaultSearchMode);
+        const contextPackage = await buildContextPackage(resolved.vault, query, parsePositiveInteger(options.limit ?? String(resolved.defaults.defaultSearchLimit), resolved.defaults.defaultSearchLimit), parsePositiveInteger(options.tokens ?? String(resolved.defaults.defaultContextTokens), resolved.defaults.defaultContextTokens), resolved.agent, mode);
         print(options.json, contextPackage, () => contextPackage.content);
     });
     program
@@ -94,10 +94,27 @@ export const registerReadCommands = (program) => {
         .command('stats')
         .option('-v, --vault <vault>', 'vault directory')
         .option('-a, --agent <agent>', 'filter by agent memory namespace')
+        .option('--extended', 'include storage, quality and latency observability probes')
         .option('--json', 'print machine-readable JSON')
         .description('print indexed vault statistics')
         .action(async (options) => {
         const resolved = await resolveOptions(options);
+        if (options.extended) {
+            const stats = await getExtendedStats(resolved.vault, resolved.agent);
+            print(options.json, stats, () => [
+                `Documents: ${stats.stats.documentCount}`,
+                `Links: ${stats.stats.linkCount}`,
+                `Resolved links: ${stats.stats.resolvedLinkCount}`,
+                `Broken links: ${stats.stats.brokenLinkCount}`,
+                `Orphans: ${stats.stats.orphanCount}`,
+                `Tags: ${stats.stats.tagCount}`,
+                `Total files: ${stats.storage.totalFileCount}`,
+                `Markdown files: ${stats.storage.markdownFileCount}`,
+                `Vault bytes: ${stats.storage.totalBytes}`,
+                `Latency index/search/context (ms): ${stats.observability.latenciesMs.index}/${stats.observability.latenciesMs.search}/${stats.observability.latenciesMs.context}`
+            ].join('\n'));
+            return;
+        }
         const stats = await getStats(resolved.vault, resolved.agent);
         print(options.json, stats, () => [
             `Documents: ${stats.documentCount}`,