sanook-cli 0.5.5 → 0.5.8

package/dist/self-improve-synth.js

@@ -0,0 +1,86 @@
+// Default skill synthesizer for self-improvement. Tries the model (cheap sibling) to write a
+// proper runbook; if no key resolves or the model output isn't usable, falls back to a deterministic
+// template built from the observed prompts — so a skill is ALWAYS created on the Nth repeat without
+// depending on fragile LLM JSON. Kept out of self-improve.ts so the detection core stays offline.
+import { generateText } from 'ai';
+import { resolveModel, fastSibling, PROVIDERS, parseSpec } from './providers/registry.js';
+import { redactKey } from './providers/keys.js';
+import { slugifySkillName } from './self-improve.js';
+const SYNTH_PROMPT = 'คุณกำลังสร้าง "skill" (runbook ทำซ้ำได้) จากคำสั่งที่ผู้ใช้สั่งซ้ำหลายครั้ง. ' +
+    'ตอบเป็น JSON อย่างเดียว (ไม่มีข้อความอื่น) รูปแบบ: ' +
+    '{"name":"slug-a-z0-9-","description":"1 บรรทัดบอกว่า skill ทำอะไร","when_to_use":"เมื่อไรควรหยิบมาใช้","steps":["ขั้นตอน 1","ขั้นตอน 2"]}. ' +
+    'name ต้องเป็น slug a-z 0-9 - สั้นๆ. steps เป็นขั้นตอนที่ทำให้ครั้งหน้าทำงานนี้ได้เร็วและไม่พลาด.\n\nคำสั่งที่สั่งซ้ำ:\n';
+function templateDraft(family) {
+    const top = family.terms.slice(0, 4).join('-');
+    const name = slugifySkillName(top || family.samples[0] || 'recurring-task');
+    const requests = family.samples.map((s) => `- ${s}`).join('\n');
+    const body = [
+        '## When to Use',
+        `งานเกี่ยวกับ: ${family.terms.slice(0, 8).join(', ')}`,
+        '',
+        '## Observed requests',
+        requests,
+        '',
+        '## Steps',
+        '_(สร้างอัตโนมัติจากงานที่ทำซ้ำ — เพิ่มขั้นตอน/คำสั่งที่ใช้จริงได้)_',
+        '',
+        '## Common Errors / Gotchas',
+        '_(เติมข้อควรระวังที่เจอระหว่างทำงานนี้)_',
+    ].join('\n');
+    return {
+        name,
+        description: `งานที่ทำซ้ำ: ${family.samples[0]?.slice(0, 80) ?? family.terms.slice(0, 5).join(' ')}`,
+        whenToUse: `เมื่อเจองานเกี่ยวกับ ${family.terms.slice(0, 5).join(', ')}`,
+        body,
+    };
+}
+function draftFromModelText(text, family) {
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(match[0]);
+    }
+    catch {
+        return null;
+    }
+    const name = typeof parsed.name === 'string' ? parsed.name : '';
+    const description = typeof parsed.description === 'string' ? parsed.description : '';
+    const whenToUse = typeof parsed.when_to_use === 'string' ? parsed.when_to_use : undefined;
+    const steps = Array.isArray(parsed.steps) ? parsed.steps.filter((s) => typeof s === 'string') : [];
+    if (!name.trim() || !steps.length)
+        return null;
+    const fallback = templateDraft(family);
+    const body = [
+        '## When to Use',
+        whenToUse || fallback.whenToUse || '',
+        '',
+        '## Steps',
+        steps.map((s, i) => `${i + 1}. ${s}`).join('\n'),
+        '',
+        '## Observed requests',
+        family.samples.map((s) => `- ${s}`).join('\n'),
+    ].join('\n');
+    return { name, description: description || fallback.description, whenToUse, body };
+}
+/** สร้าง synthesizer: ลอง model ก่อน (ค่าย sibling ถูก) → ถ้าไม่ได้ key/parse พัง ใช้ template */
+export function defaultSkillSynthesizer(mainModel) {
+    return async (family) => {
+        // delegate provider (codex) ไม่มี generateText ตรง → ใช้ template ทันที
+        if (PROVIDERS[parseSpec(mainModel).provider]?.kind === 'delegate')
+            return templateDraft(family);
+        const transcript = family.samples.map((s, i) => `${i + 1}. ${s}`).join('\n');
+        try {
+            const { text } = await generateText({
+                model: resolveModel(fastSibling(mainModel)),
+                prompt: SYNTH_PROMPT + redactKey(transcript),
+                maxOutputTokens: 700,
+            });
+            return draftFromModelText(text, family) ?? templateDraft(family);
+        }
+        catch {
+            return templateDraft(family); // ไม่มี key / network ล้ม → ยังสร้าง skill ได้
+        }
+    };
+}

package/dist/self-improve.js

@@ -0,0 +1,203 @@
+// ============================================================================
+// src/self-improve.ts — Hermes-style "Self-improvement": when the user keeps asking
+// for the SAME kind of task, Sanook notices, writes a reusable skill automatically,
+// and announces it in the terminal ("✨ Self-improvement: created skill …").
+//
+// How it works (cheap, deterministic detection · LLM only fires on the Nth repeat):
+//   1) every completed turn, the prompt is reduced to a TERM SIGNATURE and matched
+//      (token-Jaccard) against a small persistent ledger at ~/.sanook/self-improve/ledger.json.
+//   2) when a task family reaches the threshold (default 3) and no skill exists for it yet,
+//      we synthesize a SKILL.md (model if a key resolves, else a deterministic template) and
+//      save it via skills.saveSkill — then mark the family so we never duplicate it.
+//
+// Pure functions (signature, match, ledger transforms) are unit-tested with an injected
+// clock and no FS/LLM. The orchestrator takes an injected `synthesize` so tests stay offline.
+// ============================================================================
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { appHomePath, persistenceEnabled, selfImproveEnabled, selfImproveThreshold } from './brand.js';
+import { termList } from './search/index-core.js';
+export const LEDGER_PATH = appHomePath('self-improve', 'ledger.json');
+const MAX_SAMPLES = 6; // prompts kept per task family (for synthesis context)
+const MAX_FAMILIES = 200; // ledger cap (drop oldest)
+const MATCH_THRESHOLD = 0.5; // token-Jaccard ≥ this ⇒ "same kind of task"
+const MAX_SIG_TERMS = 12;
+export const TaskFamilySchema = z.object({
+    sig: z.string(),
+    terms: z.array(z.string()),
+    samples: z.array(z.string()),
+    count: z.number().int().nonnegative(),
+    skillCreated: z.boolean().default(false),
+    skillName: z.string().nullable().default(null),
+    firstSeen: z.number(),
+    lastSeen: z.number(),
+});
+export const LedgerSchema = z.object({
+    version: z.literal(1).default(1),
+    families: z.array(TaskFamilySchema).default([]),
+});
+export function emptyLedger() {
+    return { version: 1, families: [] };
+}
+/** prompt → ชุด term สำคัญ (ตัด slash-command / @mention / ของสั้น) — เป็น signature ของงาน */
+export function signatureTerms(prompt) {
+    const cleaned = prompt
+        .replace(/^\s*\/\w+\s*/, '') // ตัด /command นำหน้า
+        .replace(/@[^\s]+/g, ' ') // ตัด @file mention
+        .replace(/\[\[\s*paste[^\]]*\]\]/gi, ' '); // ตัด paste token
+    const seen = new Set();
+    const out = [];
+    for (const t of termList(cleaned)) {
+        if (seen.has(t))
+            continue;
+        seen.add(t);
+        out.push(t);
+        if (out.length >= MAX_SIG_TERMS)
+            break;
+    }
+    return out;
+}
+export function signatureKey(terms) {
+    return [...terms].sort().join(' ');
+}
+/** token-Jaccard ระหว่าง 2 ชุด term (0..1) */
+export function jaccard(a, b) {
+    if (!a.length || !b.length)
+        return 0;
+    const setA = new Set(a);
+    const setB = new Set(b);
+    let inter = 0;
+    for (const t of setA)
+        if (setB.has(t))
+            inter += 1;
+    return inter / (setA.size + setB.size - inter);
+}
+/**
+ * บันทึก task 1 ครั้งเข้า ledger — match กับ family เดิมด้วย Jaccard, ไม่งั้นเปิด family ใหม่.
+ * คืน shouldCreateSkill=true เมื่อ count ถึง threshold ครั้งแรก (ยังไม่เคยสร้าง skill).
+ */
+export function recordTask(ledger, prompt, now, createThresholdOverride) {
+    const createThreshold = createThresholdOverride ?? selfImproveThreshold();
+    const terms = signatureTerms(prompt);
+    const sample = prompt.trim().replace(/\s+/g, ' ').slice(0, 240);
+    // งานสั้น/generic เกินไป (term น้อย) → ไม่ติดตาม (กัน false positive เช่น "ok", "ลองอีกที")
+    if (terms.length < 3) {
+        return { ledger, family: phantomFamily(terms, sample, now), shouldCreateSkill: false };
+    }
+    const families = ledger.families.slice();
+    let bestIdx = -1;
+    let bestSim = 0;
+    for (let i = 0; i < families.length; i += 1) {
+        const s = jaccard(terms, families[i].terms);
+        if (s > bestSim) {
+            bestSim = s;
+            bestIdx = i;
+        }
+    }
+    if (bestIdx >= 0 && bestSim >= MATCH_THRESHOLD) {
+        const prev = families[bestIdx];
+        const samples = prev.samples.includes(sample) ? prev.samples : [...prev.samples, sample].slice(-MAX_SAMPLES);
+        // keep family.terms = the first-seen signature (stable) so Jaccard doesn't drift/shrink as the family grows
+        const next = { ...prev, samples, count: prev.count + 1, lastSeen: now };
+        families[bestIdx] = next;
+        const shouldCreateSkill = !next.skillCreated && next.count >= createThreshold;
+        return { ledger: { ...ledger, families: capFamilies(families) }, family: next, shouldCreateSkill };
+    }
+    const fresh = {
+        sig: signatureKey(terms),
+        terms,
+        samples: [sample],
+        count: 1,
+        skillCreated: false,
+        skillName: null,
+        firstSeen: now,
+        lastSeen: now,
+    };
+    families.push(fresh);
+    return { ledger: { ...ledger, families: capFamilies(families) }, family: fresh, shouldCreateSkill: false };
+}
+/** mark ว่า family นี้สร้าง skill แล้ว (กันสร้างซ้ำ) */
+export function markSkillCreated(ledger, sig, skillName) {
+    return {
+        ...ledger,
+        families: ledger.families.map((f) => (f.sig === sig ? { ...f, skillCreated: true, skillName } : f)),
+    };
+}
+function capFamilies(families) {
+    if (families.length <= MAX_FAMILIES)
+        return families;
+    return [...families].sort((x, y) => y.lastSeen - x.lastSeen).slice(0, MAX_FAMILIES);
+}
+function phantomFamily(terms, sample, now) {
+    return { sig: signatureKey(terms), terms, samples: [sample], count: 0, skillCreated: false, skillName: null, firstSeen: now, lastSeen: now };
+}
+// ---- FS (gated by persistence) ---------------------------------------------
+export async function loadLedger() {
+    try {
+        const parsed = LedgerSchema.safeParse(JSON.parse(await readFile(LEDGER_PATH, 'utf8')));
+        return parsed.success ? parsed.data : emptyLedger();
+    }
+    catch {
+        return emptyLedger();
+    }
+}
+export async function saveLedger(ledger) {
+    if (!persistenceEnabled())
+        return;
+    await mkdir(dirname(LEDGER_PATH), { recursive: true });
+    await writeFile(LEDGER_PATH, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+}
+/**
+ * เรียกหลังจบ turn (best-effort, fire-and-forget). บันทึก task เข้า ledger; ถ้าถึง threshold
+ * และยังไม่เคยมี skill → synthesize + save + mark + คืน announcement สำหรับโชว์ใน terminal.
+ */
+export async function maybeAutoSkill(prompt, deps) {
+    if (!selfImproveEnabled())
+        return { created: false };
+    const now = deps.now ?? Date.now();
+    const ledger = await loadLedger();
+    const rec = recordTask(ledger, prompt, now);
+    await saveLedger(rec.ledger);
+    if (!rec.shouldCreateSkill)
+        return { created: false };
+    const draft = await deps.synthesize(rec.family).catch(() => null);
+    if (!draft || !draft.name.trim())
+        return { created: false };
+    const name = uniqueSkillName(draft.name, deps.existingSkillNames);
+    let path;
+    try {
+        path = await deps.saveSkill(name, draft.description, draft.body, draft.whenToUse);
+    }
+    catch {
+        return { created: false };
+    }
+    await saveLedger(markSkillCreated(rec.ledger, rec.family.sig, name)).catch(() => { });
+    return {
+        created: true,
+        skillName: name,
+        count: rec.family.count,
+        path,
+        announcement: `✨ Self-improvement: สร้าง skill \`${name}\` อัตโนมัติ จากงานที่ทำซ้ำ ${rec.family.count} ครั้ง — ครั้งหน้าหยิบใช้ได้เลย (\`sanook skill list\`)`,
+    };
+}
+/** slug ชื่อ skill ให้ไม่ชนของเดิม (เติม -2, -3, …) */
+export function uniqueSkillName(raw, existing) {
+    const base = slugifySkillName(raw);
+    if (!existing || !existing.has(base))
+        return base;
+    for (let i = 2; i < 100; i += 1) {
+        const candidate = `${base}-${i}`;
+        if (!existing.has(candidate))
+            return candidate;
+    }
+    return `${base}-${Date.now().toString(36).slice(-4)}`;
+}
+export function slugifySkillName(raw) {
+    const slug = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+    return slug || `auto-skill-${Date.now().toString(36).slice(-4)}`;
+}

package/dist/session-brain.js

@@ -0,0 +1,112 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { BRAND, persistenceEnabled } from './brand.js';
+import { createBrainNote } from './brain-new.js';
+import { getBrainPath } from './memory.js';
+import { PROVIDERS, parseSpec } from './providers/registry.js';
+import { makeSummarizer } from './summarize.js';
+import { distilledFactsFromMessages } from './session-distill.js';
+import { autoMaintainEnabled } from './auto-maintain.js';
+import { saveSession } from './session.js';
+function transcriptFromTurns(turns) {
+    return turns
+        .filter((t) => t.role === 'user' || t.role === 'assistant')
+        .map((t) => `${t.role === 'user' ? 'User' : 'Assistant'}: ${t.text.trim()}`)
+        .filter((line) => line.length > 8)
+        .join('\n\n');
+}
+function sessionTitleFromHistory(history) {
+    const firstUser = history.find((t) => t.role === 'user')?.text.trim();
+    if (!firstUser)
+        return 'repl session';
+    const cleaned = firstUser.replace(/^\/\w+\s*/, '').trim();
+    return cleaned.split(/\s+/).slice(0, 8).join(' ').slice(0, 72) || 'repl session';
+}
+function injectSessionSummary(template, summary, facts) {
+    const summaryBlock = [summary.trim(), facts.length ? `\n### Key facts\n${facts.map((f) => `- ${f}`).join('\n')}` : '']
+        .filter(Boolean)
+        .join('\n');
+    if (/^## Summary\s*$/m.test(template)) {
+        // replacer function so `$`-sequences in the AI summary/facts aren't interpreted as replace patterns
+        return template.replace(/^## Summary\s*$/m, () => `## Summary\n\n${summaryBlock}`);
+    }
+    return `${template.trimEnd()}\n\n## Summary\n\n${summaryBlock}\n`;
+}
+async function summarizeSession(model, transcript, messages) {
+    const provider = parseSpec(model).provider;
+    if (PROVIDERS[provider]?.kind !== 'delegate' && transcript.trim().length > 40) {
+        try {
+            const text = await makeSummarizer(model)(transcript);
+            if (text.trim())
+                return text.trim();
+        }
+        catch {
+            // fall through to heuristic distill
+        }
+    }
+    const facts = distilledFactsFromMessages(messages);
+    if (facts.length)
+        return facts.map((f) => `- ${f}`).join('\n');
+    const lines = transcript.split('\n\n').slice(-6);
+    return lines.length ? lines.join('\n\n') : 'Session ended with no durable transcript.';
+}
+/** Persist REPL session + write a Sessions/ note in the configured second-brain vault. */
+export async function finalizeReplSession(options) {
+    const hasConversation = options.messages.length > 0 || options.history.some((t) => t.role === 'user' || t.role === 'assistant');
+    if (!hasConversation || !persistenceEnabled()) {
+        return { sessionSaved: false };
+    }
+    const now = new Date().toISOString();
+    const session = {
+        id: options.sessionId,
+        title: sessionTitleFromHistory(options.history),
+        created: options.sessionCreated,
+        updated: now,
+        model: options.model,
+        cwd: options.cwd,
+        messages: options.messages,
+    };
+    await saveSession(session);
+    const brainPath = await getBrainPath();
+    if (!brainPath)
+        return { sessionSaved: true };
+    const transcript = transcriptFromTurns(options.history);
+    const summary = await summarizeSession(options.model, transcript, options.messages);
+    const title = sessionTitleFromHistory(options.history);
+    const slugSuffix = options.sessionId.slice(-6);
+    const today = now.slice(0, 10);
+    const output = `Sessions/${today}-${slugSuffix}-session.md`;
+    const report = await createBrainNote({
+        brainPath,
+        type: 'session',
+        title,
+        output,
+        force: true,
+        today,
+    });
+    if (!report.ok || !report.path)
+        return { sessionSaved: true };
+    const facts = distilledFactsFromMessages(options.messages);
+    const raw = await readFile(report.path, 'utf8');
+    const next = injectSessionSummary(raw, summary, facts.slice(0, 8));
+    await writeFile(report.path, next, 'utf8');
+    // also compound the distilled facts into durable auto-memory (not just the session note) so the
+    // self-retrieving brain surfaces them next session. Gated by autoMaintain (default on). Best-effort.
+    if (await autoMaintainEnabled()) {
+        const { appendMemory } = await import('./memory.js');
+        for (const fact of facts.slice(0, 8))
+            await appendMemory(fact).catch(() => { });
+    }
+    return {
+        sessionSaved: true,
+        brainNoteRel: report.relPath,
+        brainNotePath: report.path,
+    };
+}
+export function formatFinalizeMessage(result) {
+    if (!result.sessionSaved)
+        return undefined;
+    if (result.brainNoteRel) {
+        return `${BRAND.cliName}: session saved · second-brain → [[${result.brainNoteRel.replace(/\.md$/i, '')}]]`;
+    }
+    return `${BRAND.cliName}: session saved`;
+}

package/dist/slash-completion.js

@@ -41,6 +41,7 @@ const BUILTIN_SLASH_COMPLETIONS = [
     { 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: '/persona', display: '/persona', meta: 'set owner persona' },
     { text: '/personality', display: '/personality', meta: 'set response style' },
     { text: '/compact', display: '/compact', meta: 'compress context' },
     { text: '/compress', display: '/compress', meta: 'compress context' },