sanook-cli 0.5.2 → 0.5.5

package/dist/project-scaffold.js

@@ -0,0 +1,124 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const TEMPLATE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', 'second-brain', 'Templates', 'project-workspace');
+const WORKSPACE_FILES = ['_Index.md', 'overview.md', 'current-state.md', 'context.md', 'repo.md'];
+export function slugifyProject(value) {
+    const slug = value
+        .normalize('NFKD')
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80)
+        .replace(/-+$/g, '');
+    return slug || 'project';
+}
+function renderTemplate(raw, vars) {
+    let out = raw;
+    for (const [key, value] of Object.entries(vars)) {
+        out = out.replaceAll(`{{${key}}}`, value);
+    }
+    return out;
+}
+async function readTemplate(name) {
+    return readFile(join(TEMPLATE_ROOT, name), 'utf8');
+}
+async function fileExists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function maybeAppendProjectsIndex(brainPath, slug, title) {
+    const indexPath = join(brainPath, 'Projects', '_Index.md');
+    let content;
+    try {
+        content = await readFile(indexPath, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const link = `[[Projects/${slug}/_Index]]`;
+    if (content.includes(link))
+        return false;
+    const line = `- ${link} — ${title}`;
+    const marker = 'up:: [[Home]]';
+    const next = content.includes(marker) ? content.replace(marker, `${line}\n\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
+    await writeFile(indexPath, next, 'utf8');
+    return true;
+}
+export async function scaffoldProjectWorkspace(options) {
+    const brainPath = resolve(options.brainPath);
+    const title = options.title.trim() || 'Project';
+    const slug = options.slug?.trim() || slugifyProject(title);
+    const relDir = `Projects/${slug}`;
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const repoPath = options.repoPath?.trim() ?? '';
+    const verify = options.verify?.trim() ?? 'npm test && npm run typecheck';
+    const defaultBranch = options.defaultBranch?.trim() ?? 'main';
+    const created = [];
+    const skipped = [];
+    const warnings = [];
+    const vars = {
+        DATE: today,
+        TITLE: title,
+        SLUG: slug,
+        REPO_PATH: repoPath,
+        VERIFY: verify,
+        DEFAULT_BRANCH: defaultBranch,
+    };
+    for (const name of WORKSPACE_FILES) {
+        const rel = `${relDir}/${name}`;
+        const path = join(brainPath, rel);
+        if ((await fileExists(path)) && !options.force) {
+            skipped.push(rel);
+            continue;
+        }
+        await mkdir(dirname(path), { recursive: true });
+        const raw = await readTemplate(name);
+        await writeFile(path, renderTemplate(raw, vars), 'utf8');
+        created.push(rel);
+    }
+    if (!created.length && skipped.length) {
+        return {
+            ok: false,
+            brainPath,
+            slug,
+            title,
+            relDir,
+            created,
+            skipped,
+            indexed: false,
+            warnings: ['Project workspace already exists. Re-run with --force to overwrite scaffold files.'],
+        };
+    }
+    const indexed = await maybeAppendProjectsIndex(brainPath, slug, title);
+    if (!indexed)
+        warnings.push('Projects/_Index.md was not updated (missing or link already present).');
+    return { ok: true, brainPath, slug, title, relDir, created, skipped, indexed, warnings };
+}
+export function formatScaffoldProjectReport(report) {
+    const lines = ['Sanook brain new project (workspace scaffold)'];
+    lines.push(`vault: ${report.brainPath}`);
+    lines.push(`slug: ${report.slug}`);
+    lines.push(`title: ${report.title}`);
+    lines.push(`dir: ${report.relDir}/`);
+    if (report.created.length) {
+        lines.push(`created (${report.created.length}):`);
+        for (const rel of report.created)
+            lines.push(`  ${rel}`);
+    }
+    if (report.skipped.length) {
+        lines.push(`skipped (${report.skipped.length}):`);
+        for (const rel of report.skipped)
+            lines.push(`  ${rel}`);
+    }
+    if (report.indexed)
+        lines.push('index: Projects/_Index.md updated');
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}

package/dist/prompt-size.js

@@ -0,0 +1,155 @@
+import { BRAND } from './brand.js';
+import { loadConfig } from './config.js';
+import { gitContext } from './git.js';
+import { SYSTEM } from './loop.js';
+import { loadAutoMemory, loadBrainContext, loadMemory } from './memory.js';
+import { personalityPrompt } from './personality.js';
+import { loadRepoMap } from './repomap.js';
+import { loadSkills, renderAvailableSkills } from './skills.js';
+import { tools as builtInTools } from './tools/index.js';
+const CHARS_PER_TOKEN = 4;
+export function approximateTokens(chars) {
+    return chars <= 0 ? 0 : Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function utf8Bytes(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+export function measurePromptSection(id, label, text) {
+    return {
+        id,
+        label,
+        chars: text.length,
+        bytes: utf8Bytes(text),
+        approxTokens: approximateTokens(text.length),
+        empty: text.length === 0,
+    };
+}
+function joinPromptBlocks(blocks) {
+    return blocks.filter(Boolean).join('\n\n');
+}
+function toJsonSafe(value, options = {}, depth = 0, seen = new WeakSet()) {
+    const maxDepth = options.maxDepth ?? 6;
+    const maxStringLength = options.maxStringLength ?? 2_000;
+    if (value == null)
+        return value;
+    if (typeof value === 'string')
+        return value.length > maxStringLength ? `${value.slice(0, maxStringLength)}...[truncated]` : value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'undefined')
+        return undefined;
+    if (depth >= maxDepth)
+        return '[MaxDepth]';
+    if (Array.isArray(value))
+        return value.map((item) => toJsonSafe(item, options, depth + 1, seen));
+    if (typeof value !== 'object')
+        return String(value);
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    const out = {};
+    for (const [key, child] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+        if (key === 'execute' || key === 'experimental_toToolResultContent')
+            continue;
+        const safe = toJsonSafe(child, options, depth + 1, seen);
+        if (safe !== undefined)
+            out[key] = safe;
+    }
+    seen.delete(value);
+    return out;
+}
+export function serializeToolSchemas(tools) {
+    const payload = Object.entries(tools)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, tool]) => {
+        const t = tool;
+        return {
+            name,
+            description: typeof t.description === 'string' ? t.description : '',
+            inputSchema: toJsonSafe(t.inputSchema ?? t.parameters),
+        };
+    });
+    return JSON.stringify(payload, null, 2);
+}
+export async function buildPromptSizeBreakdown(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const planMode = options.planMode ?? false;
+    const [config, memory, autoMemory, skills, git, brain, repoMap,] = await Promise.all([
+        (options.loadConfigImpl ?? loadConfig)({}, cwd),
+        (options.loadMemoryImpl ?? loadMemory)(cwd),
+        (options.loadAutoMemoryImpl ?? loadAutoMemory)(),
+        (options.loadSkillsImpl ?? loadSkills)(cwd),
+        (options.gitContextImpl ?? gitContext)(cwd),
+        (options.loadBrainContextImpl ?? loadBrainContext)(),
+        (options.loadRepoMapImpl ?? loadRepoMap)(cwd),
+    ]);
+    const planSuffix = planMode
+        ? '\n\nPLAN MODE: สำรวจและวางแผนเท่านั้น — ห้ามแก้ไฟล์หรือรันคำสั่งที่เปลี่ยน state. จบด้วยแผนเป็นขั้นตอนให้ user อนุมัติก่อนลงมือ.'
+        : '';
+    const brainNudge = brain
+        ? '\n- second-brain vault โหลดอยู่ (ดู <brain_vault>) — อ่าน current-state + โน้ตที่เกี่ยวก่อนงานไม่ trivial · เจอ preference/decision สำคัญ → remember (เข้า vault) · งานเสร็จควร route/บันทึกตาม Vault Structure Map ของ vault'
+        : '';
+    const baseSystem = SYSTEM + planSuffix + brainNudge;
+    const personality = personalityPrompt(config.personality);
+    const skillsBlock = renderAvailableSkills(skills);
+    const staticSystem = joinPromptBlocks([baseSystem, personality, autoMemory, skillsBlock, brain, memory, repoMap]);
+    const systemPromptText = joinPromptBlocks([staticSystem, git]);
+    const toolSchemaText = serializeToolSchemas(options.tools ?? builtInTools);
+    const sections = [
+        measurePromptSection('base-system', 'Base system', baseSystem),
+        measurePromptSection('personality', 'Personality overlay', personality),
+        measurePromptSection('auto-memory', 'Auto memory', autoMemory),
+        measurePromptSection('skills-index', 'Skills index', skillsBlock),
+        measurePromptSection('brain-context', 'Second-brain context', brain),
+        measurePromptSection('project-memory', 'Project memory', memory),
+        measurePromptSection('repo-map', 'Repo map', repoMap),
+        measurePromptSection('git-context', 'Git context', git),
+    ];
+    const systemPrompt = measurePromptSection('system-prompt', 'System prompt total', systemPromptText);
+    const toolSchemas = measurePromptSection('tool-schemas', 'Built-in tool schemas', toolSchemaText);
+    const totalText = `${systemPromptText}\n\n${toolSchemaText}`;
+    return {
+        cwd,
+        model: config.model,
+        planMode,
+        skillsCount: skills.length,
+        builtInToolsCount: Object.keys(options.tools ?? builtInTools).length,
+        sections,
+        systemPrompt,
+        toolSchemas,
+        total: measurePromptSection('total-fixed-payload', 'Total fixed payload', totalText),
+        notes: [
+            'Counts are approximate; model tokenizers vary.',
+            'MCP tools are intentionally not spawned here. Use `sanook mcp list --tools` for live MCP catalog details.',
+            'The runtime sends git context as a separate system message so the static prompt cache stays useful.',
+        ],
+    };
+}
+function formatNumber(n) {
+    return new Intl.NumberFormat('en-US').format(n);
+}
+function formatSection(section) {
+    const empty = section.empty ? ' (empty)' : '';
+    return `${section.label.padEnd(22)} ${formatNumber(section.chars).padStart(8)} chars  ~${formatNumber(section.approxTokens).padStart(6)} tokens  ${formatNumber(section.bytes).padStart(8)} bytes${empty}`;
+}
+export function renderPromptSizeBreakdown(report) {
+    const lines = [
+        `${BRAND.productName} prompt-size`,
+        `cwd: ${report.cwd}`,
+        `model: ${report.model}${report.planMode ? '  plan-mode: on' : ''}`,
+        `skills: ${report.skillsCount}  built-in tools: ${report.builtInToolsCount}`,
+        '',
+        formatSection(report.systemPrompt),
+        formatSection(report.toolSchemas),
+        formatSection(report.total),
+        '',
+        'Breakdown:',
+        ...report.sections.map((section) => `  ${formatSection(section)}`),
+        '',
+        'Notes:',
+        ...report.notes.map((note) => `  - ${note}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/providers/codex-login.js

@@ -0,0 +1,138 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { codexHome } from './codex.js';
+/** OpenAI Codex OAuth client id (same public client as Codex CLI / Hermes). */
+export const CODEX_OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const CODEX_OAUTH_ISSUER = 'https://auth.openai.com';
+const CODEX_OAUTH_TOKEN_URL = `${CODEX_OAUTH_ISSUER}/oauth/token`;
+export const CODEX_DEVICE_VERIFY_URL = `${CODEX_OAUTH_ISSUER}/codex/device`;
+function parseRetryAfterSeconds(headers) {
+    const raw = headers?.get('retry-after')?.trim();
+    if (!raw)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.floor(seconds);
+    return undefined;
+}
+async function postJson(url, body, fetchImpl) {
+    return fetchImpl(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
+/** Step 1 — request device code (Hermes / Codex CLI compatible). */
+export async function requestCodexDeviceCode(fetchImpl = fetch) {
+    const maxAttempts = 4;
+    let resp;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        resp = await postJson(`${CODEX_OAUTH_ISSUER}/api/accounts/deviceauth/usercode`, { client_id: CODEX_OAUTH_CLIENT_ID }, fetchImpl);
+        if (resp.status !== 429)
+            break;
+        if (attempt < maxAttempts) {
+            const retryAfter = parseRetryAfterSeconds(resp.headers) ?? 2 ** attempt;
+            await new Promise((r) => setTimeout(r, Math.max(1000, Math.min(retryAfter * 1000, 60_000))));
+        }
+    }
+    if (!resp || resp.status === 429) {
+        throw new Error('OpenAI จำกัดการ login ชั่วคราว (429) — รอ 1 นาทีแล้วลองใหม่');
+    }
+    if (!resp.ok) {
+        throw new Error(`ขอ device code ไม่สำเร็จ (HTTP ${resp.status})`);
+    }
+    const data = (await resp.json());
+    const userCode = data.user_code?.trim();
+    const deviceAuthId = data.device_auth_id?.trim();
+    if (!userCode || !deviceAuthId)
+        throw new Error('OpenAI ตอบ device code ไม่ครบ');
+    const pollIntervalMs = Math.max(3000, Number(data.interval ?? 5) * 1000);
+    return { userCode, deviceAuthId, pollIntervalMs };
+}
+/** Step 2 — poll until the user completes browser login. */
+export async function pollCodexDeviceCode(session, opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const deadline = Date.now() + (opts.maxWaitMs ?? 15 * 60_000);
+    while (Date.now() < deadline) {
+        if (opts.signal?.aborted)
+            throw new Error('ยกเลิก login แล้ว');
+        await sleep(session.pollIntervalMs);
+        if (opts.signal?.aborted)
+            throw new Error('ยกเลิก login แล้ว');
+        const pollResp = await postJson(`${CODEX_OAUTH_ISSUER}/api/accounts/deviceauth/token`, { device_auth_id: session.deviceAuthId, user_code: session.userCode }, fetchImpl);
+        if (pollResp.status === 200) {
+            const payload = (await pollResp.json());
+            const authorization_code = payload.authorization_code?.trim();
+            const code_verifier = payload.code_verifier?.trim();
+            if (!authorization_code || !code_verifier)
+                throw new Error('OpenAI ตอบ authorization code ไม่ครบ');
+            return { authorization_code, code_verifier };
+        }
+        if (pollResp.status === 403 || pollResp.status === 404)
+            continue;
+        throw new Error(`รอ login ไม่สำเร็จ (HTTP ${pollResp.status})`);
+    }
+    throw new Error('หมดเวลารอ login (15 นาที) — ลองใหม่');
+}
+/** Step 3 — exchange authorization code for tokens. */
+export async function exchangeCodexDeviceCode(exchange, fetchImpl = fetch) {
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: exchange.authorization_code,
+        redirect_uri: `${CODEX_OAUTH_ISSUER}/deviceauth/callback`,
+        client_id: CODEX_OAUTH_CLIENT_ID,
+        code_verifier: exchange.code_verifier,
+    });
+    const resp = await fetchImpl(CODEX_OAUTH_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    if (resp.status === 429)
+        throw new Error('OpenAI จำกัดการ login ชั่วคราว (429) — รอแล้วลองใหม่');
+    if (!resp.ok)
+        throw new Error(`แลก token ไม่สำเร็จ (HTTP ${resp.status})`);
+    const tokens = (await resp.json());
+    const access_token = tokens.access_token?.trim();
+    const refresh_token = tokens.refresh_token?.trim();
+    if (!access_token || !refresh_token)
+        throw new Error('OpenAI ไม่ส่ง access/refresh token');
+    return {
+        access_token,
+        refresh_token,
+        id_token: tokens.id_token?.trim() || undefined,
+    };
+}
+/** Persist ChatGPT-plan credentials where the official Codex CLI expects them. */
+export async function saveCodexAuthFile(tokens, home = codexHome()) {
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    const authPath = join(home, 'auth.json');
+    const payload = {
+        auth_mode: 'chatgpt',
+        tokens: {
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            ...(tokens.id_token ? { id_token: tokens.id_token } : {}),
+        },
+        last_refresh: new Date().toISOString(),
+    };
+    await writeFile(authPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+    return authPath;
+}
+/** Full Hermes-style device-code login → ~/.codex/auth.json (Codex CLI can reuse). */
+export async function runCodexDeviceCodeLogin(opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const onStatus = opts.onStatus ?? (() => { });
+    onStatus('requesting');
+    const session = await requestCodexDeviceCode(fetchImpl);
+    onStatus(`code:${session.userCode}`);
+    onStatus('waiting');
+    const exchange = await pollCodexDeviceCode(session, opts);
+    onStatus('exchanging');
+    const tokens = await exchangeCodexDeviceCode(exchange, fetchImpl);
+    onStatus('saving');
+    const authPath = await saveCodexAuthFile(tokens);
+    onStatus('done');
+    return authPath;
+}

package/dist/providers/codex.js

@@ -5,8 +5,18 @@ import { join } from 'node:path';
 export function codexHome() {
     return process.env.CODEX_HOME?.trim() || join(homedir(), '.codex');
 }
+async function readCodexLoggedIn() {
+    try {
+        const auth = JSON.parse(await readFile(join(codexHome(), 'auth.json'), 'utf8'));
+        return auth?.auth_mode === 'chatgpt' || Boolean(auth?.tokens?.access_token);
+    }
+    catch {
+        return false;
+    }
+}
 /** เช็กว่า codex CLI ติดตั้ง + login ChatGPT แล้ว */
 export async function detectCodex() {
+    const loggedIn = await readCodexLoggedIn();
     const hasBinary = await new Promise((resolve) => {
         const p = spawn('codex', ['--version'], { shell: process.platform === 'win32' });
         // timeout: binary ค้าง (shim รอ stdin / Gatekeeper stall ตอนรันครั้งแรกบน macOS) → ไม่ให้ wizard ตัน
@@ -24,16 +34,18 @@ export async function detectCodex() {
         });
     });
     if (!hasBinary) {
-        return { installed: false, loggedIn: false, reason: 'ไม่พบ codex CLI — ติดตั้ง: npm i -g @openai/codex' };
-    }
-    try {
-        const auth = JSON.parse(await readFile(join(codexHome(), 'auth.json'), 'utf8'));
-        const loggedIn = auth?.auth_mode === 'chatgpt' || Boolean(auth?.tokens?.access_token);
-        return { installed: true, loggedIn, reason: loggedIn ? undefined : 'ยังไม่ได้ login — รัน: codex login' };
+        return {
+            installed: false,
+            loggedIn,
+            reason: loggedIn
+                ? 'login แล้ว แต่ยังไม่มี codex CLI — ติดตั้ง: npm i -g @openai/codex'
+                : 'ไม่พบ codex CLI — ติดตั้ง: npm i -g @openai/codex',
+        };
     }
-    catch {
-        return { installed: true, loggedIn: false, reason: 'ยังไม่ได้ login — รัน: codex login' };
+    if (loggedIn) {
+        return { installed: true, loggedIn: true, reason: undefined };
     }
+    return { installed: true, loggedIn: false, reason: 'ยังไม่ได้ login — รัน: codex login' };
 }
 /**
  * รัน `codex exec` แบบ non-interactive — ส่ง prompt ทาง stdin, parse JSONL events

package/dist/providers/keys.js

@@ -36,3 +36,24 @@ export function assertDirectApiKey(policy, key) {
 export function redactKey(s) {
     return s.replace(/\b(AKIA[0-9A-Z]{16}|sk-[A-Za-z0-9_-]{6,}|AIza[A-Za-z0-9_-]{10,}|xai-[A-Za-z0-9]{10,}|gsk_[A-Za-z0-9]{10,}|[A-Za-z0-9_-]{24,})\b/g, (m) => (m.length > 8 ? `${m.slice(0, 4)}…${m.slice(-2)}` : '…'));
 }
+export function redactUnknown(value) {
+    const visiting = new WeakSet();
+    const visit = (current) => {
+        if (typeof current === 'string')
+            return redactKey(current);
+        if (!current || typeof current !== 'object')
+            return current;
+        if (visiting.has(current))
+            return '[Circular]';
+        visiting.add(current);
+        try {
+            if (Array.isArray(current))
+                return current.map(visit);
+            return Object.fromEntries(Object.entries(current).map(([k, v]) => [redactKey(k), visit(v)]));
+        }
+        finally {
+            visiting.delete(current);
+        }
+    };
+    return visit(value);
+}

package/dist/providers/models.js

@@ -22,7 +22,7 @@ export async function listRemoteModels(cfg, key, timeoutMs = 6000) {
                 .map((m) => (m.name ?? '').replace(/^models\//, ''))
                 .filter(Boolean);
         }
-        const base = process.env[`${cfg.id.toUpperCase()}_BASE_URL`] ?? cfg.baseURL;
+        const base = process.env[`${cfg.id.toUpperCase()}_BASE_URL`]?.trim() || cfg.baseURL?.trim();
         if (!base)
             return []; // ไม่มี baseURL = ดึงไม่ได้
         const headers = cfg.id === 'anthropic'

package/dist/search/cli.js

@@ -19,7 +19,9 @@ function inlineSourceValue(value) {
 export function parseSearchArgs(args) {
     const queryParts = [];
     let mode = 'auto';
+    let modeSet = false;
     let limit = 8;
+    let limitSet = false;
     let sources;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -36,7 +38,10 @@ export function parseSearchArgs(args) {
                 return { ok: false, message: `--mode ต้องระบุค่าเป็น ${SEARCH_MODES.join('|')}` };
             if (!isSearchMode(v))
                 return { ok: false, message: `--mode ต้องเป็น ${SEARCH_MODES.join('|')}` };
+            if (modeSet)
+                return { ok: false, message: 'ใช้ --mode เพียงครั้งเดียว' };
             mode = v;
+            modeSet = true;
         }
         else if (a === '--limit' || a.startsWith('--limit=')) {
             const next = a === '--limit' ? takeValue(args, i) : undefined;
@@ -48,7 +53,10 @@ export function parseSearchArgs(args) {
             const n = parsePositiveInteger(raw);
             if (n === undefined)
                 return { ok: false, message: '--limit ต้องเป็น integer บวก เช่น 8' };
+            if (limitSet)
+                return { ok: false, message: 'ใช้ --limit เพียงครั้งเดียว' };
             limit = n;
+            limitSet = true;
         }
         else if (a === '--source' || a === '--sources' || a.startsWith('--source=') || a.startsWith('--sources=')) {
             const next = a === '--source' || a === '--sources' ? takeValue(args, i) : undefined;
@@ -62,7 +70,7 @@ export function parseSearchArgs(args) {
             }
             if (bad.length)
                 return { ok: false, message: `--source ต้องเป็น ${SEARCH_SOURCES.join(',')} (คั่นหลายค่าได้ด้วย comma)` };
-            sources = [...new Set(requested)];
+            sources = [...new Set([...(sources ?? []), ...requested])];
         }
         else {
             queryParts.push(a);

package/dist/search/embedding-config.js

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { appHomePath } from '../brand.js';
+const EMBEDDING_MODEL_ENV = 'SANOOK_EMBEDDING_MODEL';
+export function cleanEmbeddingModelSpec(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const clean = v.trim();
+    return clean ? clean : undefined;
+}
+/** read an optional embeddingModel spec from ~/.sanook/config.json. */
+export async function configEmbeddingModel() {
+    try {
+        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
+        return cleanEmbeddingModelSpec(cfg.embeddingModel);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function embeddingModelSpec(override) {
+    return cleanEmbeddingModelSpec(override) ?? cleanEmbeddingModelSpec(process.env[EMBEDDING_MODEL_ENV]) ?? (await configEmbeddingModel());
+}

package/dist/search/engine.js

@@ -14,11 +14,10 @@
 // lazily, and on ANY embedding error degrades to BM25 with a `degraded` flag —
 // search must never throw at the floor.
 // ============================================================================
-import { readFile } from 'node:fs/promises';
-import { appHomePath } from '../brand.js';
 import { bm25Search, termList } from './index-core.js';
 import { rrfFuse } from './fuse.js';
 import { cosineTopK, embedQuery, getEmbedder, loadVectors, vectorsMtimeMs, } from './embed-store.js';
+import { embeddingModelSpec } from './embedding-config.js';
 import { indexMtimeMs, loadIndex } from './store.js';
 const CAND = 60; // candidate pool depth per leg before fusion/limit
 const SNIPPET_WIDTH = 64;
@@ -138,16 +137,6 @@ async function cachedVectors() {
     }
     return vectorCache.vectors;
 }
-/** read an optional embeddingModel spec from ~/.sanook/config.json. */
-async function configEmbeddingModel() {
-    try {
-        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
-        return cfg.embeddingModel;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** drop in-process caches (tests + after a reindex in the same process). */
 export function resetSearchCaches() {
     indexCache = null;
@@ -165,7 +154,7 @@ export async function search(query, opts = {}) {
     const mode = opts.mode ?? 'auto';
     if (mode === 'fts')
         return rankSearch(index, query, opts);
-    const spec = opts.embeddingModel ?? process.env.SANOOK_EMBEDDING_MODEL ?? (await configEmbeddingModel());
+    const spec = await embeddingModelSpec(opts.embeddingModel);
     const embedder = getEmbedder(spec);
     if (!embedder) {
         const res = rankSearch(index, query, opts);

package/dist/search/indexer.js

@@ -24,6 +24,7 @@ import { loadSkills } from '../skills.js';
 import { activeFacts, effImportance, loadStore } from '../memory-store.js';
 import { chunkMarkdown } from './chunk.js';
 import { addDoc, removeDoc, removeSource } from './index-core.js';
+import { embeddingModelSpec } from './embedding-config.js';
 import { loadIndex, saveIndex } from './store.js';
 import { buildVectorIndex, embedTexts, getEmbedder, invalidateVectors, saveVectors } from './embed-store.js';
 /** strip a .md path to a human title fallback when a chunk has no heading. */
@@ -38,6 +39,14 @@ export async function indexVaultFiles(index, manifest, fs) {
     const next = {};
     const diff = { added: 0, updated: 0, removed: 0, skipped: 0 };
     const paths = await fs.listMarkdown();
+    // Guard against a momentarily-unreadable vault (unmounted drive / perms blip / wrong cwd): walk()
+    // swallows readdir errors and returns [], which would otherwise evict the ENTIRE persisted index
+    // via the deletion sweep below. If a non-empty manifest just lost >50% of its files, treat it as a
+    // transient read failure and keep the existing index+manifest untouched (recovers on the next pass).
+    const manifestSize = Object.keys(manifest).length;
+    if (manifestSize > 0 && paths.length < Math.ceil(manifestSize * 0.5)) {
+        return { manifest, diff: { added: 0, updated: 0, removed: 0, skipped: manifestSize } };
+    }
     const seenExisting = new Set();
     for (const rel of paths) {
         const fp = await fs.fingerprint(rel);
@@ -192,15 +201,6 @@ export function nodeVaultFS(root) {
     };
 }
 const SESSIONS_DIR = appHomePath('sessions');
-async function configEmbeddingModel() {
-    try {
-        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
-        return cfg.embeddingModel;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** load first-user-message of the most recent sessions (bounded) for the session corpus. */
 export async function loadRecentSessions(limit = 60) {
     const out = [];
@@ -263,7 +263,7 @@ export async function reindex(now = Date.now()) {
     })));
     await saveIndex(index, nextManifest);
     let vectors = 0;
-    const embedder = getEmbedder(process.env.SANOOK_EMBEDDING_MODEL ?? (await configEmbeddingModel()));
+    const embedder = getEmbedder(await embeddingModelSpec());
     if (!embedder) {
         await invalidateVectors().catch(() => { });
     }