sanook-cli 0.4.0 → 0.5.1

package/dist/lsp/framing.js

@@ -0,0 +1,56 @@
+// ============================================================================
+// src/lsp/framing.ts — LSP message framing (the wire codec).
+//
+// The Language Server Protocol speaks JSON-RPC 2.0 over a stream framed with HTTP-
+// style headers: `Content-Length: <N>\r\n\r\n<N bytes of UTF-8 JSON>`, messages
+// back to back. This differs from MCP's newline-delimited framing (src/mcp.ts),
+// so it needs its own codec. Pure + dependency-free: encode() builds a frame,
+// LspDecoder.push() accumulates bytes and yields whatever complete messages have
+// arrived (headers and bodies may split across chunks). Fully unit-testable with
+// zero process, zero server.
+// ============================================================================
+/** encode a JSON-RPC message as an LSP frame (Content-Length header + body). */
+export function encode(msg) {
+    const body = Buffer.from(JSON.stringify(msg), 'utf8');
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii');
+    return Buffer.concat([header, body]);
+}
+/**
+ * Streaming decoder: feed it bytes, get back complete parsed messages. Tolerant of
+ * messages split across chunks and of extra headers (e.g. Content-Type). A body
+ * that fails to JSON-parse is skipped (defensive — a malformed frame must not wedge
+ * the stream), and the byte length is counted via Content-Length, not characters,
+ * so multibyte UTF-8 is handled correctly.
+ */
+export class LspDecoder {
+    buf = Buffer.alloc(0);
+    push(chunk) {
+        this.buf = Buffer.concat([this.buf, typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk]);
+        const out = [];
+        for (;;) {
+            const headerEnd = this.buf.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break; // headers not fully arrived yet
+            const header = this.buf.subarray(0, headerEnd).toString('ascii');
+            const m = /content-length:\s*(\d+)/i.exec(header);
+            if (!m) {
+                // no Content-Length in this header block — unrecoverable framing; drop it and resync
+                this.buf = this.buf.subarray(headerEnd + 4);
+                continue;
+            }
+            const len = Number(m[1]);
+            const bodyStart = headerEnd + 4;
+            if (this.buf.length < bodyStart + len)
+                break; // body not fully arrived yet
+            const body = this.buf.subarray(bodyStart, bodyStart + len).toString('utf8');
+            this.buf = this.buf.subarray(bodyStart + len);
+            try {
+                out.push(JSON.parse(body));
+            }
+            catch {
+                /* skip a malformed body rather than wedging the stream */
+            }
+        }
+        return out;
+    }
+}

package/dist/lsp/index.js

@@ -0,0 +1,138 @@
+// ============================================================================
+// src/lsp/index.ts — diagnose(file): spawn the right LSP server, get diagnostics.
+//
+// Ties the pieces together: resolveServer() picks an installed server, a real
+// Content-Length stdio transport drives an LspSession, and diagnostics come back
+// converted + human-1-based. Servers are POOLED per (binary, workspace) and
+// reused across calls — re-opening a file becomes a didChange, so the agent's
+// repeated "edit → check" loop pays the (slow) server init only once. Graceful at
+// every step: no server installed / spawn fails / silent server → a clear message,
+// never a crash.
+// ============================================================================
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { resolve as resolvePath } from 'node:path';
+import { getRepoRoot } from '../worktree.js';
+import { encode, LspDecoder } from './framing.js';
+import { LspSession, waitForDiagnostics } from './client.js';
+import { resolveServer } from './servers.js';
+const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
+function safeEnv() {
+    const out = {};
+    for (const k of SAFE_ENV_KEYS) {
+        const v = process.env[k];
+        if (v != null)
+            out[k] = v;
+    }
+    return out;
+}
+/** real stdio transport: spawn the server, frame with Content-Length both ways. */
+function spawnTransport(binPath, args, cwd) {
+    const proc = spawn(binPath, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: safeEnv() });
+    const decoder = new LspDecoder();
+    let handler = null;
+    proc.stdout?.on('data', (buf) => {
+        for (const m of decoder.push(buf))
+            handler?.(m);
+    });
+    proc.stdout?.on('error', () => { });
+    proc.stderr?.on('data', () => { }); // swallow server logs (stdout is the protocol)
+    proc.stdin?.on('error', () => { }); // guard EPIPE if the server dies
+    const transport = {
+        send: (msg) => {
+            if (proc.stdin?.writable)
+                proc.stdin.write(encode(msg));
+        },
+        onMessage: (cb) => {
+            handler = cb;
+        },
+        close: () => {
+            try {
+                proc.kill();
+            }
+            catch {
+                /* already dead */
+            }
+        },
+    };
+    return { transport, proc };
+}
+const pool = new Map(); // key = binPath\0rootUri
+let exitHooked = false;
+function hookExitOnce() {
+    if (exitHooked)
+        return;
+    exitHooked = true;
+    process.on('exit', closeAllServers);
+}
+/**
+ * Get language-server diagnostics for a file. Returns {ok:false,reason} when no
+ * server is configured/installed or the server can't start; otherwise the
+ * (possibly empty) diagnostics list. Never throws.
+ */
+export async function diagnose(filePath, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const abs = resolvePath(cwd, filePath);
+    const resolved = await resolveServer(abs, cwd);
+    if ('unavailable' in resolved)
+        return { ok: false, reason: resolved.unavailable };
+    const rootUri = pathToFileURL((await getRepoRoot(cwd)) ?? cwd).toString();
+    const key = `${resolved.binPath}\0${rootUri}`;
+    hookExitOnce();
+    let pooled = pool.get(key);
+    if (!pooled) {
+        try {
+            const { transport, proc } = spawnTransport(resolved.binPath, resolved.def.args, cwd);
+            const session = new LspSession(transport);
+            let died = false;
+            proc.on('exit', () => {
+                died = true;
+                pool.delete(key);
+            });
+            await session.initialize(rootUri);
+            if (died)
+                return { ok: false, reason: `${resolved.def.command} ออกก่อนเริ่มงาน (ติดตั้งครบไหม?)` };
+            pooled = { session, proc, opened: new Map() };
+            pool.set(key, pooled);
+        }
+        catch (e) {
+            pool.delete(key);
+            return { ok: false, reason: `เริ่ม ${resolved.def.command} ไม่สำเร็จ: ${e.message}` };
+        }
+    }
+    let text = opts.content;
+    if (text == null) {
+        try {
+            text = await readFile(abs, 'utf8');
+        }
+        catch (e) {
+            return { ok: false, reason: `อ่านไฟล์ไม่ได้: ${e.message}` };
+        }
+    }
+    const uri = pathToFileURL(abs).toString();
+    const waitOpts = { settleMs: opts.settleMs, timeoutMs: opts.timeoutMs };
+    // subscribe before sending open/change so we never miss an early publish
+    const wait = waitForDiagnostics(pooled.session, uri, waitOpts);
+    const prevVersion = pooled.opened.get(uri);
+    if (prevVersion == null) {
+        pooled.opened.set(uri, 1);
+        pooled.session.didOpen(uri, resolved.languageId, text);
+    }
+    else {
+        const version = prevVersion + 1;
+        pooled.opened.set(uri, version);
+        pooled.session.notify('textDocument/didChange', {
+            textDocument: { uri, version },
+            contentChanges: [{ text }], // full-document sync
+        });
+    }
+    const diagnostics = await wait;
+    return { ok: true, serverId: resolved.def.id, diagnostics };
+}
+/** shut down all pooled servers (called on process exit). */
+export function closeAllServers() {
+    for (const p of pool.values())
+        p.session.close();
+    pool.clear();
+}

package/dist/lsp/servers.js

@@ -0,0 +1,82 @@
+// ============================================================================
+// src/lsp/servers.ts — language → LSP server registry + availability detection.
+//
+// Zero-config floor: sanook does NOT bundle language servers (they're large and
+// language-specific, like ripgrep). Instead it maps a file's extension to the
+// conventional LSP server, detects whether that server is actually installed
+// (PATH or node_modules/.bin), and degrades to a clear "install X" message when
+// it isn't. Present server → real diagnostics; absent → graceful, never a crash.
+// ============================================================================
+import { access, constants } from 'node:fs/promises';
+import { join, extname, delimiter } from 'node:path';
+// conventional stdio language servers, by ecosystem. command is the binary NAME;
+// resolveServer() finds it in node_modules/.bin or PATH.
+export const SERVERS = [
+    {
+        id: 'typescript',
+        command: 'typescript-language-server',
+        args: ['--stdio'],
+        languages: { '.ts': 'typescript', '.tsx': 'typescriptreact', '.mts': 'typescript', '.cts': 'typescript', '.js': 'javascript', '.jsx': 'javascriptreact', '.mjs': 'javascript', '.cjs': 'javascript' },
+        install: 'npm i -g typescript-language-server typescript',
+    },
+    {
+        id: 'python',
+        command: 'pyright-langserver',
+        args: ['--stdio'],
+        languages: { '.py': 'python', '.pyi': 'python' },
+        install: 'npm i -g pyright',
+    },
+    { id: 'go', command: 'gopls', args: [], languages: { '.go': 'go' }, install: 'go install golang.org/x/tools/gopls@latest' },
+    { id: 'rust', command: 'rust-analyzer', args: [], languages: { '.rs': 'rust' }, install: 'rustup component add rust-analyzer' },
+    {
+        id: 'json',
+        command: 'vscode-json-language-server',
+        args: ['--stdio'],
+        languages: { '.json': 'json', '.jsonc': 'jsonc' },
+        install: 'npm i -g vscode-langservers-extracted',
+    },
+    { id: 'bash', command: 'bash-language-server', args: ['start'], languages: { '.sh': 'shellscript', '.bash': 'shellscript' }, install: 'npm i -g bash-language-server' },
+];
+/** the server def + languageId for a file, or null if no server is configured for that extension. */
+export function serverDefForFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    for (const def of SERVERS) {
+        const languageId = def.languages[ext];
+        if (languageId)
+            return { def, languageId };
+    }
+    return null;
+}
+/** resolve a binary name to an absolute path: node_modules/.bin first (project-local), then PATH. */
+export async function findBinary(command, cwd = process.cwd()) {
+    const candidates = [join(cwd, 'node_modules', '.bin', command)];
+    for (const dir of (process.env.PATH ?? '').split(delimiter).filter(Boolean)) {
+        candidates.push(join(dir, command));
+        if (process.platform === 'win32')
+            candidates.push(join(dir, `${command}.cmd`), join(dir, `${command}.exe`));
+    }
+    for (const c of candidates) {
+        try {
+            await access(c, constants.X_OK);
+            return c;
+        }
+        catch {
+            /* not here */
+        }
+    }
+    return null;
+}
+/**
+ * Resolve an installed server for a file. Returns the server + its absolute binary
+ * path, or null with a `reason` (no server configured for the ext, or not installed).
+ */
+export async function resolveServer(filePath, cwd = process.cwd()) {
+    const match = serverDefForFile(filePath);
+    if (!match)
+        return { unavailable: `ไม่มี language server ที่รองรับนามสกุล "${extname(filePath) || '(none)'}"` };
+    const binPath = await findBinary(match.def.command, cwd);
+    if (!binPath) {
+        return { unavailable: `ยังไม่ได้ติดตั้ง ${match.def.command} (สำหรับ ${match.def.id}) — ติดตั้ง: ${match.def.install}` };
+    }
+    return { def: match.def, languageId: match.languageId, binPath };
+}

package/dist/mcp-server.js

@@ -0,0 +1,244 @@
+// ============================================================================
+// src/mcp-server.ts — sanook's MCP SERVER (the strategic parity win).
+//
+// arra-oracle's entire value prop is "a queryable brain over MCP". sanook today
+// is MCP CLIENT-ONLY (src/mcp.ts connects OUT to other servers). This module adds
+// the server half over the SAME zero-dep JSON-RPC 2.0 newline framing and
+// PROTOCOL_VERSION, so any MCP host (Claude Desktop, Cursor, another agent) can
+// mount sanook's brain — BM25 over the second-brain vault + bi-temporal memory +
+// sessions + skills, with optional BYOK semantic search — Node-native,
+// Apache-2.0, no Bun, no SQLite, no native binary.
+//
+// STDOUT DISCIPLINE: stdout carries ONLY JSON-RPC frames. Every diagnostic goes
+// to stderr (a stray stdout write corrupts the protocol stream). Launched by
+// `sanook mcp serve`.
+// ============================================================================
+import { readFileSync } from 'node:fs';
+import { PROTOCOL_VERSION } from './mcp.js';
+import { BRAND } from './brand.js';
+import { search, resetSearchCaches } from './search/engine.js';
+import { reindex } from './search/indexer.js';
+import { loadIndex } from './search/store.js';
+import { loadVectors } from './search/embed-store.js';
+import { indexStats } from './search/index-core.js';
+import { recall } from './knowledge.js';
+import { appendMemory } from './memory.js';
+import { NOTE_TYPE } from './memory-store.js';
+const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const SERVER_NAME = `${BRAND.cliName}-brain`;
+const log = (msg) => void process.stderr.write(`[${SERVER_NAME}] ${msg}\n`);
+// ---- tool surface ----------------------------------------------------------
+const SOURCES = ['memory', 'vault', 'session', 'skill'];
+export const TOOLS = [
+    {
+        name: 'sanook_search',
+        description: "Hybrid BM25 + optional semantic search across the user's second-brain vault, " +
+            'bi-temporal memory, past sessions, and skills. Returns ranked, snippeted hits. ' +
+            "mode 'auto' uses semantic when a BYOK embeddings key is configured, else BM25.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'natural-language or keyword query' },
+                mode: { type: 'string', enum: ['auto', 'fts', 'semantic', 'hybrid'], description: "default 'auto'" },
+                limit: { type: 'number', description: 'max hits (default 8)' },
+                sources: { type: 'array', items: { type: 'string', enum: SOURCES }, description: 'restrict to these corpora' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'sanook_recall',
+        description: 'Quick keyword recall across memory + vault + skills + sessions (BM25, no network). ' +
+            'Use at the start of a task to reuse prior knowledge.',
+        inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string' } },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'sanook_remember',
+        description: 'Persist an atomic fact/preference/decision across sessions (Merge-Don\'t-Append: ' +
+            'dedups, supersedes contradictions, routes to the vault inbox).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'one concise atomic claim' },
+                noteType: { type: 'string', enum: [...NOTE_TYPE], description: 'optional classification' },
+            },
+            required: ['text'],
+        },
+    },
+    {
+        name: 'sanook_index',
+        description: 'Incrementally (re)index the vault + live memory/sessions/skills into the search index. ' +
+            'O(delta): only changed files are re-read. Run after editing the vault.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'sanook_stats',
+        description: 'Index health: document counts per source, term count, vault path, and vector/semantic status.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+// ---- tool implementations (return plain text for the MCP content block) -----
+function formatResult(res) {
+    const head = `${res.hits.length} hit(s) · mode=${res.mode}${res.degraded ? ` (degraded: ${res.degraded})` : ''}`;
+    if (!res.hits.length)
+        return `${head}\n(no matches)`;
+    const lines = res.hits.map((h) => {
+        const title = h.title.trim();
+        const body = title ? `${title} — ${h.snippet}` : h.snippet;
+        const where = h.path ? `  (${h.path})` : '';
+        return `[${h.source}] ${body}${where}`;
+    });
+    return `${head}\n${lines.join('\n')}`;
+}
+async function callTool(name, args) {
+    switch (name) {
+        case 'sanook_search': {
+            const query = String(args.query ?? '').trim();
+            if (!query)
+                return 'ERROR: query is required';
+            const res = await search(query, {
+                mode: args.mode ?? 'auto',
+                limit: typeof args.limit === 'number' ? args.limit : 8,
+                sources: Array.isArray(args.sources) ? args.sources : undefined,
+            });
+            return formatResult(res);
+        }
+        case 'sanook_recall': {
+            const query = String(args.query ?? '').trim();
+            if (!query)
+                return 'ERROR: query is required';
+            return recall(query);
+        }
+        case 'sanook_remember': {
+            const text = String(args.text ?? '').trim();
+            if (!text)
+                return 'ERROR: text is required';
+            const noteType = NOTE_TYPE.includes(String(args.noteType))
+                ? args.noteType
+                : undefined;
+            await appendMemory(text, noteType);
+            // keep the persisted search index fresh so the next sanook_search sees this fact
+            await reindex().catch((e) => log(`post-remember reindex failed: ${e.message}`));
+            resetSearchCaches();
+            return `OK: remembered — "${text}"`;
+        }
+        case 'sanook_index': {
+            const r = await reindex();
+            resetSearchCaches();
+            return (`indexed: +${r.added} ~${r.updated} -${r.removed} (skipped ${r.skipped}) · ` +
+                `memory=${r.memory} sessions=${r.sessions} skills=${r.skills} · vault=${r.vaultPath ?? '(none)'}`);
+        }
+        case 'sanook_stats': {
+            const { index } = await loadIndex();
+            const stats = indexStats(index);
+            const vectors = await loadVectors();
+            const bySrc = Object.entries(stats.bySource)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(' ');
+            const vec = vectors.dim ? `${vectors.tag} (${vectors.ids.length} vecs, dim ${vectors.dim})` : 'none (BM25 only)';
+            return `docs=${stats.docs} terms=${stats.terms} avgdl=${stats.avgdl.toFixed(1)}\nbySource: ${bySrc || '(empty)'}\nvectors: ${vec}`;
+        }
+        default:
+            throw new Error(`unknown tool: ${name}`);
+    }
+}
+export async function handle(msg) {
+    switch (msg.method) {
+        case 'initialize':
+            return {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: SERVER_NAME, version: VERSION },
+            };
+        case 'notifications/initialized':
+            return undefined; // notification → no response
+        case 'ping':
+            return {};
+        case 'tools/list':
+            return { tools: TOOLS };
+        case 'tools/call': {
+            const name = String(msg.params?.name ?? '');
+            const args = msg.params?.arguments ?? {};
+            try {
+                const text = await callTool(name, args);
+                return { content: [{ type: 'text', text }], isError: text.startsWith('ERROR:') };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `error: ${e.message}` }], isError: true };
+            }
+        }
+        default:
+            throw rpcError(-32601, `method not found: ${msg.method}`);
+    }
+}
+function rpcError(code, message) {
+    return { code, message };
+}
+const MAX_LINE = 16 * 1024 * 1024; // cap an un-terminated stdin line so a runaway host can't grow memory unbounded
+/** start the stdio MCP server loop. Resolves when stdin closes. */
+export function runMcpServer() {
+    return new Promise((resolve) => {
+        let buf = '';
+        const write = (obj) => {
+            try {
+                process.stdout.write(`${JSON.stringify(obj)}\n`);
+            }
+            catch (e) {
+                log(`stdout write failed: ${e.message}`); // never let a write fault escape the handler
+            }
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            buf += chunk;
+            if (buf.length > MAX_LINE && !buf.includes('\n')) {
+                log(`stdin line exceeded ${MAX_LINE} bytes with no newline — dropping`);
+                buf = '';
+                return;
+            }
+            let idx;
+            while ((idx = buf.indexOf('\n')) !== -1) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    log(`dropping non-JSON line (${line.length} bytes)`);
+                    continue;
+                }
+                const id = msg.id;
+                void handle(msg)
+                    .then((result) => {
+                    if (result === undefined || id == null)
+                        return; // notification → silent
+                    write({ jsonrpc: '2.0', id, result });
+                })
+                    .catch((err) => {
+                    if (id == null)
+                        return;
+                    const e = (err ?? {});
+                    const code = typeof e.code === 'number' ? e.code : -32603;
+                    const message = err instanceof Error ? err.message : typeof e.message === 'string' ? e.message : 'internal error';
+                    write({ jsonrpc: '2.0', id, error: { code, message } });
+                });
+            }
+        });
+        // resolve (and stop the server) on stream end/close OR error — an unhandled stdin
+        // 'error' would otherwise crash the process AND leave this promise pending forever.
+        const done = () => resolve();
+        process.stdin.on('end', done);
+        process.stdin.on('close', done);
+        process.stdin.on('error', (e) => {
+            log(`stdin error: ${e.message}`);
+            resolve();
+        });
+        log(`ready · ${TOOLS.length} tools · protocol ${PROTOCOL_VERSION}`);
+    });
+}