sanook-cli 0.5.1 → 0.5.5

package/dist/session.js

@@ -1,30 +1,60 @@
-import { chmod, readFile, writeFile, mkdir, readdir, realpath } from 'node:fs/promises';
+import { chmod, readFile, writeFile, mkdir, readdir, realpath, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { appHomePath, persistenceEnabled } from './brand.js';
-import { redactKey } from './providers/keys.js';
+import { redactKey, redactUnknown } from './providers/keys.js';
 // session store — จำ conversation + ความคืบหน้า เพื่อ "ทำงานต่อได้" ไม่ลืมว่าทำถึงไหน
 const SESSION_DIR = appHomePath('sessions');
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isModelMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.role === 'system')
+        return typeof value.content === 'string';
+    if (value.role === 'tool')
+        return Array.isArray(value.content);
+    if (value.role === 'user' || value.role === 'assistant') {
+        return typeof value.content === 'string' || Array.isArray(value.content);
+    }
+    return false;
+}
+function isSession(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        (value.title === undefined || typeof value.title === 'string') &&
+        typeof value.created === 'string' &&
+        typeof value.updated === 'string' &&
+        typeof value.model === 'string' &&
+        typeof value.cwd === 'string' &&
+        Array.isArray(value.messages) &&
+        value.messages.every(isModelMessage));
+}
 export function newSessionId() {
     // CLI runtime — ใช้ Date/random ได้ (ไม่ใช่ workflow context)
     const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
     return `${ts}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function redactUnknown(value) {
-    if (typeof value === 'string')
-        return redactKey(value);
-    if (Array.isArray(value))
-        return value.map(redactUnknown);
-    if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactUnknown(v)]));
+export function sessionStorePath() {
+    return SESSION_DIR;
+}
+function sessionFilePath(id) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(id) || id.includes('..')) {
+        throw new Error(`session id ไม่ถูกต้อง: ${id}`);
     }
-    return value;
+    return join(SESSION_DIR, `${id}.json`);
 }
 function sanitizeSession(s) {
     return {
         ...s,
+        title: typeof s.title === 'string' ? redactKey(s.title) : s.title,
         messages: redactUnknown(s.messages),
     };
 }
+export function sanitizeSessionForExport(s) {
+    return sanitizeSession(s);
+}
 async function canonicalPath(path) {
     try {
         return await realpath(path);
@@ -37,24 +67,25 @@ export async function saveSession(s) {
     if (!persistenceEnabled())
         return;
     await mkdir(SESSION_DIR, { recursive: true });
-    const path = join(SESSION_DIR, `${s.id}.json`);
+    const path = sessionFilePath(s.id);
     await writeFile(path, `${JSON.stringify(sanitizeSession(s), null, 2)}\n`, { mode: 0o600 });
     await chmod(path, 0o600).catch(() => { });
 }
 export async function loadSession(id) {
     try {
-        return JSON.parse(await readFile(join(SESSION_DIR, `${id}.json`), 'utf8'));
+        const parsed = JSON.parse(await readFile(sessionFilePath(id), 'utf8'));
+        return isSession(parsed) && parsed.id === id ? parsed : null;
     }
     catch {
         return null;
     }
 }
-/** session ล่าสุด (สำหรับ --continue). ค่า default จำกัดเฉพาะ cwd ปัจจุบัน กัน context ข้าม project */
-export async function latestSession(cwd = process.cwd()) {
+export async function listSessions(options = {}) {
     try {
+        const cwd = options.cwd === undefined ? process.cwd() : options.cwd;
         const ids = (await readdir(SESSION_DIR)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5));
         if (!ids.length)
-            return null;
+            return [];
         let sessions = (await Promise.all(ids.map(loadSession))).filter((s) => s !== null);
         if (cwd) {
             const current = await canonicalPath(cwd);
@@ -62,9 +93,54 @@ export async function latestSession(cwd = process.cwd()) {
             sessions = pairs.filter((p) => p.cwd === current).map((p) => p.session);
         }
         sessions.sort((a, b) => b.updated.localeCompare(a.updated));
-        return sessions[0] ?? null;
+        const limit = options.limit;
+        return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? sessions.slice(0, limit) : sessions;
     }
     catch {
+        return [];
+    }
+}
+export async function removeSession(id) {
+    try {
+        await rm(sessionFilePath(id), { force: false });
+        return true;
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 'ENOENT')
+            return false;
+        throw e;
+    }
+}
+export async function renameSession(id, title) {
+    const session = await loadSession(id);
+    if (!session)
         return null;
+    const next = { ...session, title: title.trim(), updated: new Date().toISOString() };
+    await saveSession(next);
+    return next;
+}
+export async function pruneSessions(options = {}) {
+    const sessions = await listSessions({ cwd: options.cwd });
+    const removeIds = new Set();
+    if (Number.isInteger(options.keep) && options.keep >= 0) {
+        for (const s of sessions.slice(options.keep))
+            removeIds.add(s.id);
     }
+    if (options.before) {
+        const beforeMs = options.before.getTime();
+        for (const s of sessions) {
+            const updatedMs = Date.parse(s.updated);
+            if (Number.isFinite(updatedMs) && updatedMs < beforeMs)
+                removeIds.add(s.id);
+        }
+    }
+    const removed = sessions.filter((s) => removeIds.has(s.id));
+    for (const s of removed)
+        await removeSession(s.id);
+    return removed;
+}
+/** session ล่าสุด (สำหรับ --continue). ค่า default จำกัดเฉพาะ cwd ปัจจุบัน กัน context ข้าม project */
+export async function latestSession(cwd = process.cwd()) {
+    return (await listSessions({ cwd, limit: 1 }))[0] ?? null;
 }

package/dist/skill-install.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile, rename } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, basename, resolve, sep, dirname } from 'node:path';
 import { execFile } from 'node:child_process';
@@ -6,13 +6,14 @@ import { promisify } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
-import { parseFrontmatter, isValidSkillName } from './skills.js';
+import { parseFrontmatter, isValidSkillName, bundledSkillsDir, listBundledSkills } from './skills.js';
 import { appHomePath, BRAND } from './brand.js';
 const execFileAsync = promisify(execFile);
 const USER_SKILLS = appHomePath('skills');
 const MAX_FILES = 300;
 const MAX_BYTES = 20 * 1024 * 1024; // 20MB ต่อ skill
 const MAX_MD = 2 * 1024 * 1024; // 2MB ต่อ SKILL.md จาก URL
+const SUPPORT_DIRS = new Set(['references', 'scripts', 'assets', 'templates']);
 const exists = async (p) => {
     try {
         await stat(p);
@@ -22,7 +23,7 @@ const exists = async (p) => {
         return false;
     }
 };
-async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
+async function copyTreeSafe(srcDir, destDir, budget, depth = 2, atRoot = true) {
     if (depth < 0)
         return;
     let entries;
@@ -35,12 +36,14 @@ async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
     for (const e of entries) {
         if (e.name.startsWith('.'))
             continue; // skip .git/dotfiles
+        if (atRoot && e.name !== 'SKILL.md' && !SUPPORT_DIRS.has(e.name))
+            continue;
         const s = join(srcDir, e.name);
         const st = await lstat(s);
         if (st.isSymbolicLink())
             continue; // ห้าม copy symlink (กัน planted symlink หลุด ~/.sanook)
         if (st.isDirectory()) {
-            await copyTreeSafe(s, join(destDir, e.name), budget, depth - 1);
+            await copyTreeSafe(s, join(destDir, e.name), budget, depth - 1, false);
         }
         else if (st.isFile()) {
             if (--budget.files < 0)
@@ -53,7 +56,22 @@ async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
         }
     }
 }
-/** copy skill dir (SKILL.md + references/scripts ที่เป็น regular file) → ~/.sanook/skills/<name> */
+async function replaceSkillDir(name, populate) {
+    const dest = join(USER_SKILLS, name);
+    const tmp = join(USER_SKILLS, `.${name}.${randomUUID()}.tmp`);
+    await mkdir(USER_SKILLS, { recursive: true });
+    try {
+        await populate(tmp);
+        await rm(dest, { recursive: true, force: true });
+        await rename(tmp, dest);
+        return dest;
+    }
+    catch (e) {
+        await rm(tmp, { recursive: true, force: true }).catch(() => { });
+        throw e;
+    }
+}
+/** copy skill dir (SKILL.md + allowed support dirs as regular files) → ~/.sanook/skills/<name> */
 async function installFromDir(srcDir) {
     const md = join(srcDir, 'SKILL.md');
     const stMd = await lstat(md);
@@ -63,10 +81,7 @@ async function installFromDir(srcDir) {
     const name = meta.name || basename(srcDir);
     if (!isValidSkillName(name))
         throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
-    const dest = join(USER_SKILLS, name);
-    await rm(dest, { recursive: true, force: true });
-    await mkdir(dest, { recursive: true });
-    await copyTreeSafe(srcDir, dest, { files: MAX_FILES, bytes: MAX_BYTES });
+    const dest = await replaceSkillDir(name, (tmp) => copyTreeSafe(srcDir, tmp, { files: MAX_FILES, bytes: MAX_BYTES }));
     return { name, path: dest };
 }
 /** เขียน SKILL.md เดียว (จาก URL) → ~/.sanook/skills/<name> */
@@ -75,10 +90,10 @@ async function installFromContent(content, fallbackName) {
     const name = meta.name || fallbackName;
     if (!isValidSkillName(name))
         throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
-    const dest = join(USER_SKILLS, name);
-    await rm(dest, { recursive: true, force: true });
-    await mkdir(dest, { recursive: true });
-    await writeFile(join(dest, 'SKILL.md'), content);
+    const dest = await replaceSkillDir(name, async (tmp) => {
+        await mkdir(tmp, { recursive: true });
+        await writeFile(join(tmp, 'SKILL.md'), content);
+    });
     return { name, path: dest };
 }
 /** หา SKILL.md ใน dir (ตรงๆ, ทุก subdir, หรือ skills/ subdir) → ติดตั้งทั้งหมด */
@@ -95,6 +110,8 @@ async function installFromLocal(path, onLog) {
             continue;
         }
         for (const e of entries) {
+            if (e.name.startsWith('.'))
+                continue;
             if (e.isDirectory() && (await exists(join(root, e.name, 'SKILL.md')))) {
                 try {
                     out.push(await installFromDir(join(root, e.name)));
@@ -155,6 +172,29 @@ async function fetchSkillMd(url) {
         throw new Error('SKILL.md ใหญ่เกิน 2MB');
     return text;
 }
+function bundledCatalogHint(name) {
+    const sample = ['git-commit-pr', 'write-tests', 'debug-root-cause'];
+    return `ไม่เจอ bundled skill "${name}" — ลอง ${sample.join(', ')} หรือ ${BRAND.cliName} skill list`;
+}
+/**
+ * ติดตั้ง skill จาก bundled catalog (ชื่อ slug) · local path · URL · GitHub
+ * ⚠️ skill = instruction ที่ agent จะ trust (ไม่ใช่ data) — ติดตั้งจาก source ที่เชื่อถือเท่านั้น
+ */
+export async function installNamedSkill(nameOrSource, onLog) {
+    if (await exists(nameOrSource))
+        return installFromLocal(nameOrSource, onLog);
+    if (isValidSkillName(nameOrSource)) {
+        const bundled = join(bundledSkillsDir(), nameOrSource);
+        if (await exists(join(bundled, 'SKILL.md')))
+            return [await installFromDir(bundled)];
+        const catalog = await listBundledSkills();
+        const match = catalog.find((skill) => skill.name === nameOrSource);
+        if (match)
+            return [await installFromDir(dirname(dirname(match.path)))];
+        throw new Error(bundledCatalogHint(nameOrSource));
+    }
+    return installSkill(nameOrSource, onLog);
+}
 /**
  * ติดตั้ง skill จาก source — local path · URL ของ SKILL.md (https) · GitHub ("user/repo" หรือ "user/repo/sub/path")
  * ⚠️ skill = instruction ที่ agent จะ trust (ไม่ใช่ data) — ติดตั้งจาก source ที่เชื่อถือเท่านั้น

package/dist/skills.js

@@ -9,6 +9,9 @@ import { projectConfigPathIfTrusted } from './trust.js';
 // 3 ชั้น: bundled (ship กับ CLI) → global (~/.sanook) → project (.sanook) — ชั้นหลัง override ชื่อซ้ำ
 const BUNDLED_SKILLS = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
 const GLOBAL_SKILLS = appHomePath('skills');
+export function bundledSkillsDir() {
+    return BUNDLED_SKILLS;
+}
 /** minimal frontmatter parser (key: value ใน --- block) — ไม่พึ่ง YAML dep */
 export function parseFrontmatter(content) {
     const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
@@ -33,6 +36,36 @@ export function parseFrontmatter(content) {
 export function isValidSkillName(name) {
     return /^[a-z0-9][a-z0-9-]{0,63}$/.test(name);
 }
+/** list bundled skills only (sanook skill install <name> catalog) */
+export async function listBundledSkills() {
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(BUNDLED_SKILLS, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory() || !isValidSkillName(e.name))
+            continue;
+        const p = join(BUNDLED_SKILLS, e.name, 'SKILL.md');
+        try {
+            const { meta } = parseFrontmatter(await readFile(p, 'utf8'));
+            const name = meta.name && isValidSkillName(meta.name) ? meta.name : e.name;
+            out.push({
+                name,
+                description: meta.description ?? '',
+                whenToUse: meta.when_to_use,
+                path: p,
+            });
+        }
+        catch {
+            /* skip invalid entries */
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
 /** scan project + global skills → list (name+description เท่านั้น สำหรับ inject). project ทับ global ชื่อซ้ำ */
 export async function loadSkills(cwd = process.cwd()) {
     const out = new Map();

package/dist/slash-completion.js

@@ -0,0 +1,155 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, resolve } from 'node:path';
+const PATH_TOKEN_RE = /((?:\.{1,2}\/|~\/?|\/|@|[^"'`\s]+\/)[^"'`\s]*)$/;
+const MAX_PATH_COMPLETIONS = 40;
+const DETAIL_SECTIONS = [
+    { text: 'thinking ', display: 'thinking', meta: 'details section' },
+    { text: 'tools ', display: 'tools', meta: 'details section' },
+];
+const DETAIL_MODES = [
+    { text: 'hidden', display: 'hidden', meta: 'details mode' },
+    { text: 'collapsed', display: 'collapsed', meta: 'details mode' },
+    { text: 'expanded', display: 'expanded', meta: 'details mode' },
+];
+const TRAIL_MODES = [
+    { text: 'compact', display: 'compact', meta: 'trail mode' },
+    { text: 'expanded', display: 'expanded', meta: 'trail mode' },
+];
+const COPY_TARGETS = [{ text: 'last', display: 'last', meta: 'copy target' }];
+const BUILTIN_SLASH_COMPLETIONS = [
+    { text: '/help', display: '/help', meta: 'command list + pager' },
+    { text: '/hotkeys', display: '/hotkeys', meta: 'keyboard shortcuts' },
+    { text: '/details', display: '/details', meta: 'thinking/tool trail visibility' },
+    { text: '/model', display: '/model', meta: 'pick provider then model' },
+    { text: '/setup', display: '/setup', meta: 'setup wizard sections' },
+    { text: '/dashboard', display: '/dashboard', meta: 'open web dashboard' },
+    { text: '/mcp', display: '/mcp', meta: 'browse MCP servers' },
+    { text: '/skills', display: '/skills', meta: 'browse loaded skills' },
+    { text: '/sessions', display: '/sessions', meta: 'resume saved sessions' },
+    { text: '/tasks', display: '/tasks', meta: 'background task_spawn jobs' },
+    { text: '/status', display: '/status', meta: 'session/model status' },
+    { text: '/platforms', display: '/platforms', meta: 'providers + gateways' },
+    { text: '/trail', display: '/trail', meta: 'toggle tool trail detail' },
+    { text: '/tools', display: '/tools', meta: 'agent tools' },
+    { text: '/diff', display: '/diff', meta: 'git diff stat' },
+    { text: '/copy', display: '/copy', meta: 'copy latest assistant response' },
+    { text: '/retry', display: '/retry', meta: 'rerun last prompt' },
+    { text: '/stop', display: '/stop', meta: 'stop current turn' },
+    { text: '/undo', display: '/undo', meta: 'stash recent file edits' },
+    { text: '/rewind', display: '/rewind', meta: 'restore previous turn' },
+    { text: '/cost', display: '/cost', meta: 'last usage/cost' },
+    { text: '/usage', display: '/usage', meta: 'last usage/cost' },
+    { text: '/insights', display: '/insights', meta: 'local usage insights' },
+    { text: '/personality', display: '/personality', meta: 'set response style' },
+    { text: '/compact', display: '/compact', meta: 'compress context' },
+    { text: '/compress', display: '/compress', meta: 'compress context' },
+    { text: '/new', display: '/new', meta: 'new conversation' },
+    { text: '/reset', display: '/reset', meta: 'new conversation' },
+    { text: '/clear', display: '/clear', meta: 'clear conversation' },
+    { text: '/quit', display: '/quit', meta: 'exit REPL' },
+];
+export function slashCompletionItems(input) {
+    if (!/^\/[a-z0-9-?]*$/i.test(input))
+        return [];
+    const query = input.slice(1).toLowerCase();
+    return BUILTIN_SLASH_COMPLETIONS.filter((item) => item.text.slice(1).startsWith(query));
+}
+export function completionForInput(input, cwd = process.cwd()) {
+    const slash = slashCompletionItems(input);
+    if (slash.length)
+        return { items: slash, replaceFrom: 0 };
+    const slashArgs = slashArgumentCompletion(input);
+    if (slashArgs.items.length)
+        return slashArgs;
+    const path = pathCompletion(input, cwd);
+    if (path.items.length)
+        return path;
+    return { items: [], replaceFrom: 0 };
+}
+function slashArgumentCompletion(input) {
+    const commandMatch = /^\/([a-z0-9-?]+)\s+/i.exec(input);
+    if (!commandMatch)
+        return { items: [], replaceFrom: 0 };
+    const command = commandMatch[1].toLowerCase();
+    const rawArgs = input.slice(commandMatch[0].length);
+    const hasTrailingSpace = /\s$/.test(input);
+    const args = rawArgs.trim() ? rawArgs.trim().split(/\s+/) : [];
+    const activeIndex = hasTrailingSpace ? args.length : Math.max(0, args.length - 1);
+    const prefix = hasTrailingSpace ? '' : (args.at(-1) ?? '');
+    const replaceFrom = input.length - prefix.length;
+    if (command === 'trail' && activeIndex === 0) {
+        return { items: filterArgumentItems(TRAIL_MODES, prefix), replaceFrom };
+    }
+    if (command === 'copy' && activeIndex === 0) {
+        return { items: filterArgumentItems(COPY_TARGETS, prefix), replaceFrom };
+    }
+    if (command === 'details') {
+        if (activeIndex === 0)
+            return { items: filterArgumentItems(DETAIL_SECTIONS, prefix), replaceFrom };
+        const section = args[0]?.toLowerCase();
+        if (activeIndex === 1 && (section === 'thinking' || section === 'tools')) {
+            return { items: filterArgumentItems(DETAIL_MODES, prefix), replaceFrom };
+        }
+    }
+    return { items: [], replaceFrom: 0 };
+}
+function filterArgumentItems(items, prefix) {
+    const query = prefix.toLowerCase();
+    return items.filter((item) => item.text.toLowerCase().startsWith(query));
+}
+function pathCompletion(input, cwd) {
+    const match = PATH_TOKEN_RE.exec(input);
+    if (!match)
+        return { items: [], replaceFrom: 0 };
+    const token = match[1];
+    const replaceFrom = input.length - token.length;
+    const mention = token.startsWith('@');
+    const rawToken = mention ? token.slice(1) : token;
+    const raw = rawToken === '~' ? '~/' : rawToken;
+    const hasTrailingSlash = raw.endsWith('/');
+    const rawDir = hasTrailingSlash ? raw : dirname(raw);
+    const prefix = hasTrailingSlash ? '' : basename(raw);
+    const dirPart = rawDir === '.' ? '' : rawDir;
+    const absoluteDir = resolveInputPath(dirPart || '.', cwd);
+    if (!existsSync(absoluteDir))
+        return { items: [], replaceFrom };
+    let entries;
+    try {
+        entries = readdirSync(absoluteDir, { withFileTypes: true });
+    }
+    catch {
+        return { items: [], replaceFrom };
+    }
+    const head = `${mention ? '@' : ''}${dirPart ? `${dirPart.replace(/\/?$/, '/')}` : ''}`;
+    const items = entries
+        .filter((entry) => !entry.name.startsWith('.') && entry.name.startsWith(prefix))
+        .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+        .slice(0, MAX_PATH_COMPLETIONS)
+        .map((entry) => {
+        const suffix = entry.isDirectory() ? '/' : '';
+        const text = `${head}${entry.name}${suffix}`;
+        return { display: text, meta: entry.isDirectory() ? 'dir' : 'file', text };
+    });
+    return { items, replaceFrom };
+}
+function resolveInputPath(input, cwd) {
+    if (input === '~')
+        return homedir();
+    if (input.startsWith('~/'))
+        return resolve(homedir(), input.slice(2));
+    if (isAbsolute(input))
+        return input;
+    return resolve(cwd, input);
+}
+export function clampCompletionIndex(index, count) {
+    if (count <= 0)
+        return 0;
+    return ((index % count) + count) % count;
+}
+export function completionReplaceValue(input, item, replaceFrom = 0) {
+    if (!item)
+        return null;
+    const next = `${input.slice(0, replaceFrom)}${item.text}`;
+    return next === input ? null : next;
+}