sanook-cli 0.5.1 → 0.5.2

package/dist/brain-context.js

@@ -0,0 +1,223 @@
+import { stat } from 'node:fs/promises';
+import { inlineValue, takeValue } from './cli-option-values.js';
+import { buildBrainContextParts, renderBrainContext, } from './memory.js';
+import { checkSearchIndexFreshness } from './brain-doctor.js';
+import { search } from './search/engine.js';
+import { SEARCH_SOURCES } from './search/index-core.js';
+import { INDEX_PATH } from './search/store.js';
+const SEARCH_MODES = ['auto', 'fts', 'semantic', 'hybrid'];
+const DEFAULT_CONTEXT_WARNING_CHARS = 6500;
+const DEFAULT_TASK_SOURCES = ['vault', 'session', 'skill'];
+function isSearchMode(value) {
+    return SEARCH_MODES.includes(value);
+}
+function isSearchSource(value) {
+    return SEARCH_SOURCES.includes(value);
+}
+function parsePositiveInteger(raw) {
+    if (!raw || !/^[1-9]\d*$/.test(raw))
+        return undefined;
+    const n = Number(raw);
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+function inlineSourceValue(value) {
+    return inlineValue('--source', value) ?? inlineValue('--sources', value);
+}
+export function parseBrainContextArgs(args) {
+    const taskParts = [];
+    let task;
+    let mode = 'auto';
+    let limit = 5;
+    let sources;
+    let showContent = true;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            taskParts.push(...args.slice(i + 1));
+            break;
+        }
+        else if (a === '--task' || a.startsWith('--task=')) {
+            const next = a === '--task' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--task', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw)
+                return { ok: false, message: '--task ต้องระบุข้อความ task' };
+            task = raw.trim();
+            if (!task)
+                return { ok: false, message: '--task ต้องระบุข้อความ task' };
+        }
+        else if (a === '--mode' || a.startsWith('--mode=')) {
+            const next = a === '--mode' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--mode', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw)
+                return { ok: false, message: `--mode ต้องระบุค่าเป็น ${SEARCH_MODES.join('|')}` };
+            if (!isSearchMode(raw))
+                return { ok: false, message: `--mode ต้องเป็น ${SEARCH_MODES.join('|')}` };
+            mode = raw;
+        }
+        else if (a === '--limit' || a.startsWith('--limit=')) {
+            const next = a === '--limit' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--limit', a);
+            if (next)
+                i = next.nextIndex;
+            const n = parsePositiveInteger(raw);
+            if (n === undefined)
+                return { ok: false, message: '--limit ต้องเป็น integer บวก เช่น 5' };
+            limit = n;
+        }
+        else if (a === '--source' || a === '--sources' || a.startsWith('--source=') || a.startsWith('--sources=')) {
+            const next = a === '--source' || a === '--sources' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineSourceValue(a);
+            if (next)
+                i = next.nextIndex;
+            const requested = (raw ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+            if (!requested.length)
+                return { ok: false, message: `--source ต้องระบุค่าเป็น ${SEARCH_SOURCES.join(',')}` };
+            const bad = requested.filter((s) => !isSearchSource(s));
+            if (bad.length)
+                return { ok: false, message: `--source ต้องเป็น ${SEARCH_SOURCES.join(',')}` };
+            sources = [...new Set(requested)];
+        }
+        else if (a === '--no-content' || a === '--summary') {
+            showContent = false;
+        }
+        else if (a === '--content') {
+            showContent = true;
+        }
+        else {
+            taskParts.push(a);
+        }
+    }
+    const positionalTask = taskParts.join(' ').trim();
+    const finalTask = (task ?? positionalTask).trim();
+    return { ok: true, value: { task: finalTask || undefined, mode, limit, sources, showContent } };
+}
+export async function inspectBrainContext(options = {}) {
+    const brainPath = options.brainPath;
+    const warnings = [];
+    if (!brainPath) {
+        return {
+            ok: false,
+            context: '',
+            contextChars: 0,
+            sources: [],
+            warnings: ['No second-brain path is configured. Run `sanook brain init [path]` first.'],
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                context: '',
+                contextChars: 0,
+                sources: [],
+                warnings: ['Configured second-brain path is not a directory.'],
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            context: '',
+            contextChars: 0,
+            sources: [],
+            warnings: ['Configured second-brain path does not exist.'],
+        };
+    }
+    const parts = await buildBrainContextParts(brainPath);
+    const context = renderBrainContext(brainPath, parts);
+    const sourceReports = parts.map((part) => ({
+        id: part.id,
+        label: part.label,
+        relPath: part.relPath,
+        path: part.path,
+        status: part.status,
+        chars: part.chars,
+        maxChars: part.maxChars,
+    }));
+    for (const part of sourceReports) {
+        if (part.status === 'missing')
+            warnings.push(`Missing context source: ${part.relPath}`);
+    }
+    if (!context)
+        warnings.push('Brain context is empty; expected at least one hot context source to contain content.');
+    const maxContextChars = options.maxContextChars ?? DEFAULT_CONTEXT_WARNING_CHARS;
+    if (context.length > maxContextChars) {
+        warnings.push(`Brain context is ${context.length} chars, above the ${maxContextChars} char warning threshold.`);
+    }
+    const indexCheck = await checkSearchIndexFreshness(brainPath, options.indexPath ?? INDEX_PATH, options.indexFreshnessToleranceMs);
+    if (indexCheck.status !== 'pass')
+        warnings.push(indexCheck.message);
+    const taskQuery = options.task?.trim();
+    let taskReport;
+    if (taskQuery) {
+        const taskSources = options.sources?.length ? options.sources : [...DEFAULT_TASK_SOURCES];
+        const res = await (options.searchImpl ?? search)(taskQuery, {
+            mode: options.mode ?? 'auto',
+            limit: options.limit ?? 5,
+            sources: taskSources,
+        });
+        taskReport = {
+            query: taskQuery,
+            mode: res.mode,
+            degraded: res.degraded,
+            total: res.total,
+            hits: res.hits,
+            sources: taskSources,
+        };
+    }
+    return {
+        ok: true,
+        brainPath,
+        context,
+        contextChars: context.length,
+        sources: sourceReports,
+        warnings,
+        task: taskReport,
+    };
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(7);
+}
+export function formatBrainContextReport(report, showContent = true) {
+    const lines = ['Sanook brain context'];
+    lines.push(`vault: ${report.brainPath ?? '(not configured)'}`);
+    lines.push(`context: ${report.contextChars} chars`);
+    if (report.sources.length) {
+        lines.push('sources:');
+        for (const source of report.sources) {
+            lines.push(`  [${statusLabel(source.status)}] ${source.relPath} (${source.chars} chars, cap ${source.maxChars})`);
+        }
+    }
+    if (report.warnings.length) {
+        lines.push('warnings:');
+        for (const warning of report.warnings)
+            lines.push(`  - ${warning}`);
+    }
+    if (showContent) {
+        lines.push('--- context ---');
+        lines.push(report.context || '(empty)');
+    }
+    if (report.task) {
+        lines.push(`--- task retrieval: "${report.task.query}" ---`);
+        lines.push(`mode=${report.task.mode}${report.task.degraded ? ` degraded=${report.task.degraded}` : ''} ` +
+            `sources=${report.task.sources.join(',')} hits=${report.task.hits.length}/${report.task.total}`);
+        if (!report.task.hits.length) {
+            lines.push('(no task hits; run `sanook index` if the vault changed recently)');
+        }
+        else {
+            for (const hit of report.task.hits) {
+                const title = hit.title.trim();
+                const body = title ? `${title} — ${hit.snippet}` : hit.snippet;
+                const where = hit.path ? ` (${hit.path})` : '';
+                lines.push(`[${hit.source}] ${body}${where}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/brain-doctor.js

@@ -0,0 +1,318 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, posix, win32 } from 'node:path';
+import { appHomePath } from './brand.js';
+import { FOLDERS } from './brain.js';
+import { INDEX_PATH } from './search/store.js';
+export const BRAIN_HOT_FILES = [
+    'SANOOK.md',
+    'Shared/AI-Context-Index.md',
+    'Vault Structure Map.md',
+    'Shared/Operating-State/current-state.md',
+];
+const DEFAULT_INDEX_FRESHNESS_TOLERANCE_MS = 1000;
+const SKIP_DIRS = new Set(['.git', '.obsidian', 'node_modules']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeSlashes(path) {
+    return path.trim().replace(/\\/g, '/');
+}
+function normalizeFolderReference(path) {
+    const normalized = posix
+        .normalize(normalizeSlashes(path))
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '');
+    return normalized === '.' ? '' : normalized;
+}
+function isVaultRelativeFolderReference(path) {
+    const trimmed = path.trim();
+    const slashed = normalizeSlashes(trimmed);
+    const hasWindowsDriveSpecifier = /^[A-Za-z]:/.test(trimmed);
+    return (!posix.isAbsolute(slashed) &&
+        !win32.isAbsolute(trimmed) &&
+        !hasWindowsDriveSpecifier &&
+        !slashed.split('/').includes('..'));
+}
+function normalizeExpectedFolders(expectedFolders) {
+    const folders = new Set();
+    const invalid = new Set();
+    for (const dir of expectedFolders) {
+        const slashed = normalizeSlashes(dir);
+        if (!slashed)
+            continue;
+        const folder = normalizeFolderReference(dir);
+        if (!isVaultRelativeFolderReference(dir)) {
+            invalid.add(slashed.replace(/\/+$/, ''));
+            continue;
+        }
+        if (!folder)
+            continue;
+        folders.add(folder);
+    }
+    return { folders: [...folders], invalid: [...invalid] };
+}
+function extractFolderReferences(map) {
+    const references = new Set();
+    for (const match of map.matchAll(/`([^`]+)`/g)) {
+        if (!isVaultRelativeFolderReference(match[1]))
+            continue;
+        const normalized = normalizeFolderReference(match[1]);
+        if (normalized)
+            references.add(normalized);
+    }
+    return references;
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function latestMarkdownMtimeMs(root) {
+    let latest = 0;
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name))
+                    await walk(join(dir, entry.name));
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            try {
+                latest = Math.max(latest, (await stat(join(dir, entry.name))).mtimeMs);
+            }
+            catch {
+                // File disappeared between readdir and stat; ignore the race.
+            }
+        }
+    }
+    await walk(root);
+    return latest;
+}
+export async function checkBrainHotFiles(brainPath) {
+    const missing = [];
+    for (const rel of BRAIN_HOT_FILES) {
+        if (!(await fileExists(join(brainPath, rel))))
+            missing.push(rel);
+    }
+    if (missing.length) {
+        return {
+            id: 'brain.hot-files',
+            status: 'fail',
+            message: `Missing ${missing.length} required second-brain file${missing.length === 1 ? '' : 's'}.`,
+            path: brainPath,
+            details: missing,
+        };
+    }
+    return {
+        id: 'brain.hot-files',
+        status: 'pass',
+        message: 'Required second-brain hot files are present.',
+        path: brainPath,
+    };
+}
+export async function checkBrainFolders(brainPath, expectedFolders = FOLDERS.map((f) => f.dir)) {
+    const expected = normalizeExpectedFolders(expectedFolders);
+    if (expected.invalid.length) {
+        return {
+            id: 'brain.folders',
+            status: 'fail',
+            message: `Invalid expected second-brain folder reference${expected.invalid.length === 1 ? '' : 's'}.`,
+            path: brainPath,
+            details: expected.invalid,
+        };
+    }
+    const missing = [];
+    for (const dir of expected.folders) {
+        if (!(await directoryExists(join(brainPath, dir))))
+            missing.push(dir);
+    }
+    if (missing.length) {
+        return {
+            id: 'brain.folders',
+            status: 'fail',
+            message: `Missing ${missing.length} expected second-brain folder${missing.length === 1 ? '' : 's'}.`,
+            path: brainPath,
+            details: missing,
+        };
+    }
+    return {
+        id: 'brain.folders',
+        status: 'pass',
+        message: 'Expected second-brain folders are present.',
+        path: brainPath,
+    };
+}
+export async function checkVaultStructureMap(brainPath, expectedFolders = FOLDERS.map((f) => f.dir)) {
+    const mapPath = join(brainPath, 'Vault Structure Map.md');
+    let map;
+    try {
+        map = await readFile(mapPath, 'utf8');
+    }
+    catch {
+        return {
+            id: 'brain.structure-map',
+            status: 'fail',
+            message: 'Vault Structure Map.md is missing or unreadable.',
+            path: mapPath,
+        };
+    }
+    const expected = normalizeExpectedFolders(expectedFolders);
+    if (expected.invalid.length) {
+        return {
+            id: 'brain.structure-map',
+            status: 'fail',
+            message: `Invalid expected second-brain folder reference${expected.invalid.length === 1 ? '' : 's'}.`,
+            path: mapPath,
+            details: expected.invalid,
+        };
+    }
+    const folderReferences = extractFolderReferences(map);
+    const missing = expected.folders.filter((dir) => !folderReferences.has(dir));
+    if (missing.length) {
+        return {
+            id: 'brain.structure-map',
+            status: 'fail',
+            message: `Vault Structure Map.md is missing ${missing.length} folder reference${missing.length === 1 ? '' : 's'}.`,
+            path: mapPath,
+            details: missing,
+        };
+    }
+    return {
+        id: 'brain.structure-map',
+        status: 'pass',
+        message: 'Vault Structure Map.md covers the expected folder manifest.',
+        path: mapPath,
+    };
+}
+export async function checkSearchIndexFreshness(brainPath, indexPath = INDEX_PATH, toleranceMs = DEFAULT_INDEX_FRESHNESS_TOLERANCE_MS) {
+    const latestVaultMtimeMs = await latestMarkdownMtimeMs(brainPath);
+    if (latestVaultMtimeMs === 0) {
+        return {
+            id: 'brain.search-index',
+            status: 'warn',
+            message: 'No markdown files were found in the configured second-brain vault.',
+            path: brainPath,
+        };
+    }
+    let indexMtimeMs = 0;
+    try {
+        indexMtimeMs = (await stat(indexPath)).mtimeMs;
+    }
+    catch {
+        return {
+            id: 'brain.search-index',
+            status: 'warn',
+            message: 'Search index is missing; run `sanook index` to build it.',
+            path: indexPath,
+        };
+    }
+    if (indexMtimeMs + toleranceMs < latestVaultMtimeMs) {
+        return {
+            id: 'brain.search-index',
+            status: 'warn',
+            message: 'Search index is older than the second-brain markdown files.',
+            path: indexPath,
+            details: [`index_mtime_ms=${Math.round(indexMtimeMs)}`, `vault_latest_mtime_ms=${Math.round(latestVaultMtimeMs)}`],
+        };
+    }
+    return {
+        id: 'brain.search-index',
+        status: 'pass',
+        message: 'Search index is present and fresh enough for the vault.',
+        path: indexPath,
+    };
+}
+export async function checkBrainMcpWiring(brainPath, mcpConfigPath = appHomePath('mcp.json')) {
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(mcpConfigPath, 'utf8'));
+    }
+    catch {
+        return {
+            id: 'brain.mcp',
+            status: 'warn',
+            message: 'MCP config is missing or unreadable; `sanook brain init` can wire the vault.',
+            path: mcpConfigPath,
+        };
+    }
+    const servers = isRecord(raw) && isRecord(raw.mcpServers) ? raw.mcpServers : undefined;
+    const server = servers && isRecord(servers['second-brain']) ? servers['second-brain'] : undefined;
+    const args = server && Array.isArray(server.args) ? server.args : [];
+    if (!args.includes(brainPath)) {
+        return {
+            id: 'brain.mcp',
+            status: 'warn',
+            message: 'MCP server `second-brain` is not wired to the configured vault path.',
+            path: mcpConfigPath,
+        };
+    }
+    return {
+        id: 'brain.mcp',
+        status: 'pass',
+        message: 'MCP server `second-brain` points at the configured vault path.',
+        path: mcpConfigPath,
+    };
+}
+export async function checkBrain(options = {}) {
+    const checks = [];
+    const brainPath = options.brainPath;
+    if (!brainPath) {
+        checks.push({
+            id: 'brain.configured',
+            status: 'fail',
+            message: 'No second-brain path is configured.',
+        });
+        return { ok: false, checks };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            checks.push({
+                id: 'brain.path',
+                status: 'fail',
+                message: 'Configured second-brain path is not a directory.',
+                path: brainPath,
+            });
+            return { ok: false, checks };
+        }
+    }
+    catch {
+        checks.push({
+            id: 'brain.path',
+            status: 'fail',
+            message: 'Configured second-brain path does not exist.',
+            path: brainPath,
+        });
+        return { ok: false, checks };
+    }
+    checks.push({
+        id: 'brain.path',
+        status: 'pass',
+        message: 'Configured second-brain path exists.',
+        path: brainPath,
+    });
+    checks.push(await checkBrainFolders(brainPath, options.expectedFolders));
+    checks.push(await checkBrainHotFiles(brainPath));
+    checks.push(await checkVaultStructureMap(brainPath, options.expectedFolders));
+    checks.push(await checkSearchIndexFreshness(brainPath, options.indexPath, options.indexFreshnessToleranceMs ?? DEFAULT_INDEX_FRESHNESS_TOLERANCE_MS));
+    checks.push(await checkBrainMcpWiring(brainPath, options.mcpConfigPath));
+    return { ok: !checks.some((check) => check.status === 'fail'), checks };
+}