sanook-cli 0.5.2 → 0.5.5

package/dist/model-picker.js

@@ -0,0 +1,58 @@
+import { canonicalSpec, hasUsableEnvKey, PROVIDERS, parseSpec } from './providers/registry.js';
+function statusFor(provider) {
+    const cfg = PROVIDERS[provider];
+    if (cfg.kind === 'delegate')
+        return 'delegate';
+    if (!cfg.requiresKey)
+        return 'local';
+    return hasUsableEnvKey(provider) ? 'ready' : 'needs-key';
+}
+function statusLabel(status) {
+    if (status === 'needs-key')
+        return 'needs key';
+    return status;
+}
+export function modelPickerOptions(current) {
+    const currentSpec = canonicalSpec(current);
+    return Object.entries(PROVIDERS).flatMap(([provider, cfg]) => {
+        const grouped = new Map();
+        for (const [alias, model] of Object.entries(cfg.models)) {
+            const aliases = grouped.get(model) ?? [];
+            aliases.push(alias);
+            grouped.set(model, aliases);
+        }
+        const status = statusFor(provider);
+        return [...grouped.entries()].map(([model, aliases]) => {
+            const nonDefaultAliases = aliases.filter((alias) => alias !== 'default');
+            const displayAliases = nonDefaultAliases.length ? nonDefaultAliases.join('/') : 'default';
+            const spec = `${provider}:${model}`;
+            return {
+                aliases: displayAliases,
+                current: spec === currentSpec,
+                label: `${provider}:${displayAliases}`,
+                meta: `${cfg.label} · ${statusLabel(status)}`,
+                model,
+                provider,
+                spec,
+                status,
+            };
+        });
+    });
+}
+export function initialModelPickerIndex(options) {
+    const current = options.findIndex((option) => option.current);
+    return current === -1 ? 0 : current;
+}
+export function modelProviderEntries() {
+    return Object.entries(PROVIDERS).map(([id, cfg]) => ({
+        id,
+        label: cfg.label,
+        status: statusFor(id),
+        modelCount: new Set(Object.values(cfg.models)).size,
+    }));
+}
+export function filterModelPickerOptions(options, providerId) {
+    if (!providerId)
+        return options;
+    return options.filter((option) => option.provider === providerId);
+}

package/dist/orchestrate.js

@@ -1,20 +1,22 @@
 import { inspect } from 'node:util';
+import { redactKey, redactUnknown } from './providers/keys.js';
 export function formatSubagentError(e) {
     if (e instanceof Error)
-        return e.message || e.name;
+        return redactKey(e.message || e.name);
     if (typeof e === 'string')
-        return e;
+        return redactKey(e);
     if (e == null)
         return String(e);
+    const safe = redactUnknown(e);
     try {
-        const json = JSON.stringify(e);
+        const json = JSON.stringify(safe);
         if (json)
             return json;
     }
     catch {
-        return inspect(e, { breakLength: Infinity, depth: 2 });
+        return inspect(safe, { breakLength: Infinity, depth: 2 });
     }
-    return String(e);
+    return redactKey(String(e));
 }
 const DEFAULT_CONCURRENCY = 5;
 const DEFAULT_GLOBAL_SUBAGENT_CONCURRENCY = 16;

package/dist/plan-handoff.js

@@ -0,0 +1,17 @@
+import { BRAND } from './brand.js';
+/** Shell-safe double-quoted string for handoff hints (task may contain quotes/newlines). */
+export function shellQuoteDouble(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n')}"`;
+}
+/** Hint printed after plan mode completes — stderr so stdout stays pipe-friendly. */
+export function formatPlanExecuteHandoff(originalTask) {
+    const task = originalTask.trim();
+    const quoted = task ? shellQuoteDouble(task) : '<task>';
+    return [
+        '---',
+        'Plan complete. Execute with:',
+        `  ${BRAND.cliName} --yes ${quoted}`,
+        `  ${BRAND.cliName} plan ${quoted} | ${BRAND.cliName} --yes ${shellQuoteDouble('Execute this plan:')}`,
+        `  (plan text on stdout → pipe into ${BRAND.cliName} --yes "Execute this plan:" with stdin)`,
+    ].join('\n');
+}

package/dist/polyglot.js

@@ -0,0 +1,162 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { BRAND } from './brand.js';
+import { findBinary } from './lsp/servers.js';
+import { safeProcessEnv } from './process-runner.js';
+const execFileAsync = promisify(execFile);
+const MAX_VERSION_TEXT = 160;
+const RUNTIME_SPECS = [
+    {
+        id: 'python',
+        label: 'Python',
+        candidates: ['python3', 'python'],
+        versionArgs: ['--version'],
+        role: 'data/doc/ML glue, JSON/CSV transforms, OCR/transcription helpers, one-off research scripts via run_python',
+        install: 'Install Python 3.11+ (python.org, Homebrew, pyenv, or uv).',
+    },
+    {
+        id: 'uv',
+        label: 'uv',
+        candidates: ['uv'],
+        versionArgs: ['--version'],
+        role: 'fast Python project/env management when Sanook grows optional Python packs',
+        install: 'Install uv: https://docs.astral.sh/uv/',
+    },
+    {
+        id: 'rustc',
+        label: 'Rust compiler',
+        candidates: ['rustc'],
+        versionArgs: ['--version'],
+        role: 'compile small high-speed/safe helpers and future native accelerators via run_rust',
+        install: 'Install Rust via rustup: https://rustup.rs/',
+    },
+    {
+        id: 'cargo',
+        label: 'Cargo',
+        candidates: ['cargo'],
+        versionArgs: ['--version'],
+        role: 'build/test packaged Rust helpers when a native crate becomes worth shipping',
+        install: 'Install Rust via rustup: https://rustup.rs/',
+    },
+    {
+        id: 'pyright',
+        label: 'Pyright LSP',
+        candidates: ['pyright-langserver'],
+        versionArgs: ['--version'],
+        role: 'Python diagnostics through Sanook diagnostics tool',
+        install: 'npm i -g pyright',
+    },
+    {
+        id: 'rust-analyzer',
+        label: 'rust-analyzer LSP',
+        candidates: ['rust-analyzer'],
+        versionArgs: ['--version'],
+        role: 'Rust diagnostics through Sanook diagnostics tool',
+        install: 'rustup component add rust-analyzer',
+    },
+];
+async function defaultVersion(command, args, cwd) {
+    const { stdout, stderr } = await execFileAsync(command, args, { cwd, env: safeProcessEnv(), timeout: 5_000, maxBuffer: 256 * 1024 });
+    return stdout.trim() ? stdout : stderr;
+}
+function normalizeVersionText(version) {
+    const firstLine = version.trim().split(/\r?\n/)[0]?.trim() || '(version unavailable)';
+    if (firstLine.length <= MAX_VERSION_TEXT)
+        return firstLine;
+    return `${firstLine.slice(0, MAX_VERSION_TEXT - '... [truncated]'.length)}... [truncated]`;
+}
+async function detectSpec(spec, cwd, findBinaryImpl, versionImpl) {
+    for (const candidate of spec.candidates) {
+        const command = await findBinaryImpl(candidate, cwd);
+        if (!command)
+            continue;
+        let version;
+        try {
+            version = normalizeVersionText(await versionImpl(command, [...spec.versionArgs], cwd));
+        }
+        catch {
+            version = '(installed; version probe failed)';
+        }
+        return {
+            id: spec.id,
+            label: spec.label,
+            status: 'ready',
+            command,
+            version,
+            role: spec.role,
+            install: spec.install,
+        };
+    }
+    return {
+        id: spec.id,
+        label: spec.label,
+        status: 'missing',
+        role: spec.role,
+        install: spec.install,
+    };
+}
+export async function inspectPolyglotRuntimes(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const findBinaryImpl = options.findBinaryImpl ?? findBinary;
+    const versionImpl = options.versionImpl ?? defaultVersion;
+    const optional = await Promise.all(RUNTIME_SPECS.map((spec) => detectSpec(spec, cwd, findBinaryImpl, versionImpl)));
+    return {
+        cwd,
+        runtimes: [
+            {
+                id: 'typescript',
+                label: 'TypeScript / Node.js',
+                status: 'core',
+                command: process.execPath,
+                version: `node ${process.versions.node}`,
+                role: 'core Sanook runtime: agent loop, TUI, gateway, MCP, second-brain, packaging',
+            },
+            ...optional,
+        ],
+        strategy: [
+            'TypeScript stays the control plane and npm-distributed default.',
+            'Python is the optional analysis/data plane: scripts, data wrangling, document/ML/OCR workflows, and research helpers.',
+            'Rust is the optional performance/safety plane: single-binary helpers, high-throughput parsing/search, and future native accelerators.',
+            'Optional runtimes must degrade gracefully; missing Python/Rust should never break basic Sanook install or chat.',
+        ],
+        notes: [
+            '`run_python` and `run_rust` are approval-gated tools because arbitrary code can mutate files.',
+            'The diagnostics tool already understands Python and Rust when Pyright/rust-analyzer are installed.',
+            'Use `sanook mcp list --tools` for external runtime capabilities exposed through MCP servers.',
+        ],
+    };
+}
+function fmtStatus(status) {
+    if (status === 'core')
+        return 'CORE ';
+    if (status === 'ready')
+        return 'READY';
+    return 'MISS ';
+}
+export function renderPolyglotReport(report) {
+    const missingRuntimes = report.runtimes.filter((runtime) => runtime.status === 'missing');
+    const lines = [
+        `${BRAND.productName} runtimes`,
+        `cwd: ${report.cwd}`,
+        '',
+        'Runtime surface:',
+        ...report.runtimes.map((runtime) => {
+            const version = runtime.version ? ` — ${runtime.version}` : '';
+            const command = runtime.command ? ` (${runtime.command})` : '';
+            return `  [${fmtStatus(runtime.status)}] ${runtime.label}${version}${command}`;
+        }),
+        '',
+        'Role map:',
+        ...report.runtimes.map((runtime) => `  - ${runtime.label}: ${runtime.role}`),
+        '',
+        'Strategy:',
+        ...report.strategy.map((item) => `  - ${item}`),
+        '',
+        'Missing install hints:',
+        ...(missingRuntimes.length > 0 ? missingRuntimes.map((runtime) => `  - ${runtime.label}: ${runtime.install}`) : ['  - None']),
+        '',
+        'Notes:',
+        ...report.notes.map((note) => `  - ${note}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/process-runner.js

@@ -0,0 +1,96 @@
+import { spawn } from 'node:child_process';
+import { clamp } from './tools/util.js';
+const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'TMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
+const DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
+export function safeProcessEnv(env = process.env) {
+    const out = {};
+    for (const key of SAFE_ENV_KEYS) {
+        const value = env[key];
+        if (value != null)
+            out[key] = value;
+    }
+    return out;
+}
+function appendChunk(chunks, chunk, state, maxBuffer) {
+    if (state.bytes >= maxBuffer) {
+        state.truncated = true;
+        return;
+    }
+    const remaining = maxBuffer - state.bytes;
+    const kept = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+    chunks.push(kept);
+    state.bytes += kept.length;
+    if (kept.length < chunk.length)
+        state.truncated = true;
+}
+export function runProcess(file, args, options = {}) {
+    const timeoutMs = Math.max(1, Math.min(options.timeoutMs ?? 120_000, 300_000));
+    const maxBuffer = Math.max(1, options.maxBuffer ?? DEFAULT_MAX_BUFFER);
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stdoutState = { bytes: 0, truncated: false };
+    const stderrState = { bytes: 0, truncated: false };
+    return new Promise((resolve) => {
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(file, args, {
+            cwd: options.cwd,
+            env: safeProcessEnv(),
+            shell: false,
+            windowsHide: true,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+            }, 1_000).unref();
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => appendChunk(stdoutChunks, chunk, stdoutState, maxBuffer));
+        child.stderr.on('data', (chunk) => appendChunk(stderrChunks, chunk, stderrState, maxBuffer));
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            settled = true;
+            resolve({
+                ok: false,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                code: null,
+                signal: null,
+                timedOut,
+                truncated: stdoutState.truncated || stderrState.truncated,
+                error: err.message,
+            });
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            settled = true;
+            resolve({
+                ok: code === 0 && !timedOut,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                code,
+                signal,
+                timedOut,
+                truncated: stdoutState.truncated || stderrState.truncated,
+            });
+        });
+        if (options.input != null)
+            child.stdin.end(options.input);
+        else
+            child.stdin.end();
+    });
+}
+export function formatProcessResult(result) {
+    const body = (result.stdout + (result.stderr ? `\n[stderr]\n${result.stderr}` : '')).trim();
+    const truncated = result.truncated ? '\n... [process output truncated]' : '';
+    if (result.ok)
+        return clamp(`${body}${truncated}`.trim()) || '(no output)';
+    const status = result.timedOut
+        ? 'timeout'
+        : result.error
+            ? result.error
+            : `exit ${result.code ?? 'unknown'}${result.signal ? ` (${result.signal})` : ''}`;
+    return clamp(`ERROR: process failed — ${status}${body ? `\n${body}` : ''}${truncated}`);
+}

package/dist/project-init.js

@@ -0,0 +1,91 @@
+import { mkdir, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { BRAND, appProjectPath } from './brand.js';
+import { loadConfig } from './config.js';
+import { projectRoot, projectTrustStatus, trustProject } from './trust.js';
+export const STARTER_COMMANDS = {
+    review: {
+        description: 'Review recent changes before commit',
+        body: `Review the recent changes in this repo. Focus on bugs, regressions, and missing tests.
+
+$ARGUMENTS`,
+    },
+    plan: {
+        description: 'Plan a task without modifying files yet',
+        body: `Plan how to accomplish the following without modifying any files yet. Break down steps, risks, and a test approach.
+
+$ARGUMENTS`,
+    },
+};
+async function exists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function commandTemplate(name, spec) {
+    return ['---', `description: ${spec.description}`, '---', '', spec.body.trim(), ''].join('\n');
+}
+export async function scaffoldProjectCommands(root) {
+    const commandsDir = appProjectPath(root, 'commands');
+    await mkdir(commandsDir, { recursive: true });
+    const created = [];
+    const skipped = [];
+    for (const [name, spec] of Object.entries(STARTER_COMMANDS)) {
+        const rel = join(BRAND.configDirName, 'commands', `${name}.md`);
+        const path = join(commandsDir, `${name}.md`);
+        if (await exists(path)) {
+            skipped.push(rel);
+            continue;
+        }
+        await writeFile(path, commandTemplate(name, spec));
+        created.push(rel);
+    }
+    return { created, skipped };
+}
+export async function buildInitHints(root, trusted) {
+    const hints = [];
+    const config = await loadConfig({}, root);
+    if (!config.brainPath?.trim()) {
+        hints.push(`${BRAND.cliName} brain init — สร้าง second-brain vault แล้วเก็บ path ใน config.brainPath`);
+    }
+    else if (!(await exists(config.brainPath))) {
+        hints.push(`config.brainPath ชี้ไป path ที่ไม่มี: ${config.brainPath} — รัน ${BRAND.cliName} brain init หรือแก้ config`);
+    }
+    hints.push(`${BRAND.cliName} mcp preset dev — ดู MCP starter pack สำหรับ repo/issues/docs/debug`);
+    if (!trusted) {
+        hints.push(`${BRAND.cliName} trust add — เปิดใช้ project .sanook/commands ใน REPL (ต้อง trust ก่อน)`);
+    }
+    return hints;
+}
+export function formatInitResult(result) {
+    const lines = [`initialized ${result.root}`];
+    if (result.created.length)
+        lines.push(`created: ${result.created.join(', ')}`);
+    if (result.skipped.length)
+        lines.push(`skipped (already exists): ${result.skipped.join(', ')}`);
+    if (result.trusted)
+        lines.push('trusted: yes');
+    if (result.hints.length) {
+        lines.push('', 'next:');
+        for (const hint of result.hints)
+            lines.push(`  ${hint}`);
+    }
+    return lines.join('\n');
+}
+/** sanook init — scaffold project .sanook/commands + optional trust + onboarding hints */
+export async function initProject(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const root = await projectRoot(cwd);
+    const { created, skipped } = await scaffoldProjectCommands(root);
+    let trusted = (await projectTrustStatus(root)).trusted;
+    if (options.trust && !trusted) {
+        await trustProject(root);
+        trusted = true;
+    }
+    const hints = await buildInitHints(root, trusted);
+    return { root, created, skipped, trusted, hints };
+}

package/dist/project-registry.js

@@ -0,0 +1,143 @@
+import { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+const PROJECTS_DIR = 'Projects';
+const REPO_PATH_LINE = /^repo_path:\s*(.+)\s*$/im;
+const VERIFY_LINE = /^verify:\s*(.+)\s*$/im;
+const DEFAULT_BRANCH_LINE = /^default_branch:\s*(.+)\s*$/im;
+const FRONTMATTER_REPO = /^repo_path:\s*(.+)\s*$/m;
+/** Hot project files injected when cwd matches repo_path (order matters). */
+export const PROJECT_HOT_FILES = [
+    { key: 'current-state', rel: 'current-state.md', maxChars: 1200, heading: 'project-current-state' },
+    { key: 'context', rel: 'context.md', maxChars: 1200, heading: 'project-context' },
+    { key: 'overview', rel: 'overview.md', maxChars: 900, heading: 'project-overview' },
+];
+function normalizeRel(path) {
+    return path.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function titleFromSlug(slug) {
+    return slug
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function parseRepoMetadata(content) {
+    const repoMatch = content.match(REPO_PATH_LINE) ?? content.match(FRONTMATTER_REPO);
+    const verifyMatch = content.match(VERIFY_LINE);
+    const branchMatch = content.match(DEFAULT_BRANCH_LINE);
+    return {
+        repoPath: repoMatch?.[1]?.trim(),
+        verify: verifyMatch?.[1]?.trim(),
+        defaultBranch: branchMatch?.[1]?.trim(),
+    };
+}
+function titleFromMarkdown(content, fallback) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match?.[1]?.trim() || fallback;
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function canonicalDir(path) {
+    try {
+        const abs = resolve(path);
+        const st = await stat(abs);
+        if (!st.isDirectory())
+            return undefined;
+        return await realpath(abs);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadProjectFromDir(brainPath, slug) {
+    const relDir = `${PROJECTS_DIR}/${slug}`;
+    const dir = join(brainPath, relDir);
+    try {
+        if (!(await stat(dir)).isDirectory())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const repoMd = await readText(join(dir, 'repo.md'));
+    const overviewMd = await readText(join(dir, 'overview.md'));
+    const indexMd = await readText(join(dir, '_Index.md'));
+    const metaSource = repoMd || overviewMd || indexMd;
+    if (!metaSource.trim() && !overviewMd.trim() && !indexMd.trim())
+        return null;
+    const meta = parseRepoMetadata(metaSource);
+    const title = titleFromMarkdown(overviewMd || indexMd, titleFromSlug(slug));
+    return { slug, relDir, title, ...meta };
+}
+/** List project workspaces under Projects/<slug>/ with at least one marker file. */
+export async function listVaultProjects(brainPath) {
+    const root = join(brainPath, PROJECTS_DIR);
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const projects = [];
+    for (const entry of entries.filter((e) => e.isDirectory() && !e.name.startsWith('.'))) {
+        const project = await loadProjectFromDir(brainPath, entry.name);
+        if (project)
+            projects.push(project);
+    }
+    projects.sort((a, b) => a.slug.localeCompare(b.slug));
+    return projects;
+}
+export async function resolveVaultProject(options) {
+    const brainPath = resolve(options.brainPath);
+    if (options.slug?.trim()) {
+        return loadProjectFromDir(brainPath, options.slug.trim());
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const cwdCanonical = await canonicalDir(cwd);
+    if (!cwdCanonical)
+        return null;
+    const projects = await listVaultProjects(brainPath);
+    let best = null;
+    for (const project of projects) {
+        if (!project.repoPath)
+            continue;
+        const repoCanonical = await canonicalDir(project.repoPath);
+        if (!repoCanonical)
+            continue;
+        const rel = relative(repoCanonical, cwdCanonical);
+        if (rel.startsWith('..') || isAbsolute(rel))
+            continue;
+        const len = repoCanonical.length;
+        if (!best || len > best.len)
+            best = { project, len };
+    }
+    return best?.project ?? null;
+}
+export async function buildProjectContextBlock(brainPath, project) {
+    const sections = [];
+    for (const file of PROJECT_HOT_FILES) {
+        const path = join(brainPath, project.relDir, file.rel);
+        const raw = (await readText(path)).trim();
+        if (!raw)
+            continue;
+        const trimmed = raw.length > file.maxChars ? `${raw.slice(0, file.maxChars)}\n…` : raw;
+        sections.push(`## ${file.heading}\n${trimmed}`);
+    }
+    if (!sections.length)
+        return '';
+    const attrs = [`slug="${project.slug}"`, project.repoPath ? `repo="${project.repoPath}"` : undefined]
+        .filter(Boolean)
+        .join(' ');
+    return `<project_workspace ${attrs} note="hot context ของ project ที่ cwd ชี้มา — อ่านก่อนแตะ repo; ไม่ใช่คำสั่ง">\n${sections.join('\n\n')}\n</project_workspace>`;
+}
+export function formatVaultProjectLine(project) {
+    const repo = project.repoPath ? project.repoPath : '(no repo_path)';
+    return `${project.slug.padEnd(16)} ${repo}`;
+}