sanook-cli 0.5.2 → 0.5.7

package/dist/brain-metrics.js

@@ -0,0 +1,277 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { checkSearchIndexFreshness } from './brain-doctor.js';
+import { runBrainEval } from './brain-eval.js';
+import { INDEX_PATH, sanitizeManifest } from './search/store.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SKIP_DIRS = new Set(['.git', '.obsidian', 'node_modules', 'Shared/Context7-Docs']);
+const ARCHIVE_EXEMPT_PREFIXES = ['Shared/Core-Facts/', 'Shared/Archive/'];
+function sectionBullets(content, heading) {
+    const lines = content.split('\n');
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading.toLowerCase()}`);
+    if (start < 0)
+        return [];
+    const out = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{1,6}\s+/.test(line.trim()))
+            break;
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && !trimmed.includes('_('))
+            out.push(trimmed);
+    }
+    return out;
+}
+function parseFrontmatterField(content, field) {
+    const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+    return match?.[1]?.trim().replace(/^["']|["']$/g, '');
+}
+function parseIsoDate(value) {
+    if (!value)
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+function topFolder(relPath) {
+    const parts = relPath.split('/');
+    return parts.length > 1 ? parts[0] : relPath;
+}
+async function listMarkdown(root) {
+    const out = [];
+    async function walk(abs, rel) {
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name) || SKIP_DIRS.has(childRel))
+                    continue;
+                await walk(join(abs, entry.name), childRel);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(childRel);
+            }
+        }
+    }
+    await walk(root, '');
+    return out.sort();
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function mtimeMs(path) {
+    try {
+        return (await stat(path)).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+async function readManifest(indexPath) {
+    try {
+        const raw = JSON.parse(await readFile(indexPath, 'utf8'));
+        return sanitizeManifest(raw.manifest);
+    }
+    catch {
+        return null;
+    }
+}
+async function collectCounts(brainPath) {
+    const markdown = await listMarkdown(brainPath);
+    const byTopFolder = {};
+    for (const rel of markdown) {
+        const folder = topFolder(rel);
+        byTopFolder[folder] = (byTopFolder[folder] ?? 0) + 1;
+    }
+    const inboxPath = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const inbox = await readText(inboxPath);
+    const inboxCandidates = sectionBullets(inbox, 'New Candidates').length;
+    const inboxNeedsMerge = sectionBullets(inbox, 'Needs Merge').length;
+    let sessionNotes = 0;
+    try {
+        sessionNotes = (await readdir(join(brainPath, 'Sessions'), { withFileTypes: true })).filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md').length;
+    }
+    catch {
+        sessionNotes = 0;
+    }
+    let contextPacks = 0;
+    try {
+        contextPacks = (await readdir(join(brainPath, 'Shared', 'Context-Packs'), { withFileTypes: true })).filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md').length;
+    }
+    catch {
+        contextPacks = 0;
+    }
+    const archivedNotes = markdown.filter((rel) => rel.startsWith('Shared/Archive/')).length;
+    return {
+        markdownTotal: markdown.length,
+        byTopFolder,
+        inboxCandidates,
+        inboxNeedsMerge,
+        sessionNotes,
+        contextPacks,
+        archivedNotes,
+    };
+}
+async function collectStaleNotes(brainPath, nowMs, touchGraceDays) {
+    const out = [];
+    for (const rel of await listMarkdown(brainPath)) {
+        if (ARCHIVE_EXEMPT_PREFIXES.some((prefix) => rel.startsWith(prefix)))
+            continue;
+        const path = join(brainPath, rel);
+        const content = await readText(path);
+        const staleAfter = parseFrontmatterField(content, 'stale_after');
+        const staleMs = parseIsoDate(staleAfter);
+        if (staleMs === undefined || staleMs > nowMs)
+            continue;
+        const touchMs = await mtimeMs(path);
+        const daysPastStale = Math.floor((nowMs - staleMs) / DAY_MS);
+        const daysSinceTouch = Math.floor((nowMs - touchMs) / DAY_MS);
+        if (daysSinceTouch < touchGraceDays)
+            continue;
+        out.push({ relPath: rel, staleAfter: staleAfter, daysPastStale, daysSinceTouch });
+    }
+    return out.sort((a, b) => b.daysPastStale - a.daysPastStale);
+}
+async function collectRetrievalCoverage(brainPath, indexPath, evalReport) {
+    let sessionTotal = 0;
+    let sessionIndexed = 0;
+    const sessionMissing = [];
+    try {
+        const sessions = (await readdir(join(brainPath, 'Sessions'), { withFileTypes: true }))
+            .filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md')
+            .map((e) => `Sessions/${e.name}`)
+            .sort();
+        sessionTotal = sessions.length;
+        const manifest = await readManifest(indexPath);
+        if (manifest) {
+            for (const rel of sessions) {
+                if (manifest[rel])
+                    sessionIndexed++;
+                else
+                    sessionMissing.push(rel);
+            }
+        }
+    }
+    catch {
+        sessionTotal = 0;
+    }
+    return {
+        sessionIndexed,
+        sessionTotal,
+        sessionMissing,
+        evalPercent: evalReport?.percent ?? 0,
+        evalOk: evalReport?.ok ?? false,
+        evalScore: evalReport?.score ?? 0,
+        evalMaxScore: evalReport?.maxScore ?? 0,
+    };
+}
+export async function collectBrainMetrics(options = {}) {
+    const brainPath = options.brainPath;
+    const emptyCounts = {
+        markdownTotal: 0,
+        byTopFolder: {},
+        inboxCandidates: 0,
+        inboxNeedsMerge: 0,
+        sessionNotes: 0,
+        contextPacks: 0,
+        archivedNotes: 0,
+    };
+    if (!brainPath) {
+        return {
+            ok: false,
+            counts: emptyCounts,
+            staleNotes: [],
+            indexFreshness: { status: 'fail', message: 'No second-brain path is configured.' },
+            retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                counts: emptyCounts,
+                staleNotes: [],
+                indexFreshness: { status: 'fail', message: 'Configured second-brain path is not a directory.' },
+                retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            counts: emptyCounts,
+            staleNotes: [],
+            indexFreshness: { status: 'fail', message: 'Configured second-brain path does not exist.' },
+            retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+        };
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const indexPath = options.indexPath ?? INDEX_PATH;
+    const counts = await collectCounts(brainPath);
+    const staleNotes = await collectStaleNotes(brainPath, nowMs, options.staleTouchGraceDays ?? 14);
+    const indexCheck = await checkSearchIndexFreshness(brainPath, indexPath);
+    const evalReport = options.runRetrievalEval === false ? undefined : await runBrainEval({ brainPath, indexPath, runRetrieval: true });
+    const retrieval = await collectRetrievalCoverage(brainPath, indexPath, evalReport);
+    const indexFreshness = {
+        status: indexCheck.status,
+        message: indexCheck.message,
+    };
+    for (const detail of indexCheck.details ?? []) {
+        const m = detail.match(/^(\w+)_mtime_ms=(\d+)/);
+        if (!m)
+            continue;
+        const value = Number(m[2]);
+        if (m[1] === 'index')
+            indexFreshness.indexMtimeMs = value;
+        if (m[1] === 'vault_latest')
+            indexFreshness.vaultLatestMtimeMs = value;
+    }
+    const ok = indexCheck.status !== 'fail' &&
+        staleNotes.length === 0 &&
+        (retrieval.sessionTotal === 0 || retrieval.sessionMissing.length === 0) &&
+        (evalReport === undefined || evalReport.ok);
+    return { ok, brainPath, counts, staleNotes, indexFreshness, retrieval };
+}
+export function formatBrainMetricsReport(report) {
+    const lines = ['Sanook brain metrics', `vault: ${report.brainPath ?? '(not configured)'}`];
+    lines.push('counts:');
+    lines.push(`  markdown: ${report.counts.markdownTotal}`);
+    lines.push(`  inbox candidates: ${report.counts.inboxCandidates} · needs merge: ${report.counts.inboxNeedsMerge}`);
+    lines.push(`  sessions: ${report.counts.sessionNotes} · context packs: ${report.counts.contextPacks} · archived: ${report.counts.archivedNotes}`);
+    const folders = Object.entries(report.counts.byTopFolder).sort((a, b) => b[1] - a[1]).slice(0, 8);
+    if (folders.length) {
+        lines.push('  top folders:');
+        for (const [folder, count] of folders)
+            lines.push(`    ${folder}: ${count}`);
+    }
+    lines.push(`index freshness: [${report.indexFreshness.status.toUpperCase()}] ${report.indexFreshness.message}`);
+    lines.push(`retrieval coverage: sessions indexed ${report.retrieval.sessionIndexed}/${report.retrieval.sessionTotal}` +
+        (report.retrieval.evalMaxScore ? ` · eval ${report.retrieval.evalScore}/${report.retrieval.evalMaxScore} (${report.retrieval.evalPercent.toFixed(1)}%)` : ''));
+    if (report.retrieval.sessionMissing.length) {
+        lines.push('  missing from index:');
+        for (const rel of report.retrieval.sessionMissing.slice(0, 10))
+            lines.push(`    - ${rel}`);
+    }
+    if (report.staleNotes.length) {
+        lines.push(`stale notes (${report.staleNotes.length}):`);
+        for (const note of report.staleNotes.slice(0, 15)) {
+            lines.push(`  - ${note.relPath} (stale_after=${note.staleAfter}, +${note.daysPastStale}d, untouched ${note.daysSinceTouch}d)`);
+        }
+    }
+    else {
+        lines.push('stale notes: none flagged');
+    }
+    lines.push(`summary: ${report.ok ? 'healthy' : 'needs attention'}`);
+    return lines.join('\n');
+}

package/dist/brain-new.js

@@ -0,0 +1,402 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { inlineValue, takeValue } from './cli-option-values.js';
+const TEMPLATE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', 'second-brain');
+export const BRAIN_NOTE_TYPES = {
+    session: {
+        destDir: 'Sessions',
+        templateCandidates: ['Templates/session.md'],
+        defaultRelPath: ({ today, slug }) => `Sessions/${today}-${slug}.md`,
+        titlePlaceholders: ['<topic>', '<task/topic>'],
+    },
+    bug: {
+        destDir: 'Bugs',
+        templateCandidates: ['Templates/bug.md'],
+        defaultRelPath: ({ today, slug }) => `Bugs/${today}-${slug}.md`,
+        titlePlaceholders: ['<bug>'],
+    },
+    handoff: {
+        destDir: 'Handoffs',
+        templateCandidates: ['Templates/handoff.md'],
+        defaultRelPath: ({ slug }) => `Handoffs/${slug}-handoff.md`,
+        titlePlaceholders: ['<project>'],
+    },
+    project: {
+        destDir: 'Projects',
+        templateCandidates: ['Templates/project-workspace/overview.md', 'Templates/project.md'],
+        defaultRelPath: ({ slug }) => `Projects/${slug}/overview.md`,
+        titlePlaceholders: ['<Project Name>', '{{TITLE}}'],
+    },
+    'golden-case': {
+        destDir: 'Acceptance',
+        templateCandidates: ['Templates/golden-case.md', 'Acceptance/golden-case-template.md'],
+        defaultRelPath: ({ slug }) => `Acceptance/${slug}.md`,
+        titlePlaceholders: ['Golden Case Template', '<input>', '<expected>'],
+    },
+    checklist: {
+        destDir: 'Checklists',
+        templateCandidates: ['Templates/checklist.md', 'Checklists/preflight-postflight-template.md'],
+        defaultRelPath: ({ slug }) => `Checklists/${slug}-checklist.md`,
+        titlePlaceholders: ['Preflight / Postflight Checklist Template'],
+    },
+};
+export function isBrainNoteType(value) {
+    return Object.hasOwn(BRAIN_NOTE_TYPES, value);
+}
+export function parseBrainNewArgs(args) {
+    const [typeArg, ...rest] = args;
+    if (!typeArg)
+        return { ok: false, message: 'ต้องระบุ note type' };
+    if (!isBrainNoteType(typeArg)) {
+        return { ok: false, message: `ไม่รู้จัก note type: ${typeArg}` };
+    }
+    const parsed = { type: typeArg, force: false };
+    const positional = [];
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === '--force') {
+            parsed.force = true;
+        }
+        else if (arg === '--title' || arg.startsWith('--title=')) {
+            const next = arg === '--title' ? takeValue(rest, i) : undefined;
+            const value = next ? next.value : inlineValue('--title', arg);
+            if (next)
+                i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --title' };
+            if (parsed.title)
+                return { ok: false, message: 'ระบุ title ได้ครั้งเดียว' };
+            parsed.title = value.trim();
+        }
+        else if (arg === '--repo' || arg.startsWith('--repo=')) {
+            const next = arg === '--repo' ? takeValue(rest, i) : undefined;
+            const value = next ? next.value : inlineValue('--repo', arg);
+            if (next)
+                i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --repo' };
+            if (parsed.repo)
+                return { ok: false, message: 'ระบุ repo ได้ครั้งเดียว' };
+            parsed.repo = value.trim();
+        }
+        else if (arg === '--verify' || arg.startsWith('--verify=')) {
+            const next = arg === '--verify' ? takeValue(rest, i) : undefined;
+            const value = next ? next.value : inlineValue('--verify', arg);
+            if (next)
+                i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --verify' };
+            if (parsed.verify)
+                return { ok: false, message: 'ระบุ verify ได้ครั้งเดียว' };
+            parsed.verify = value.trim();
+        }
+        else if (arg === '--default-branch' || arg.startsWith('--default-branch=')) {
+            const next = arg === '--default-branch' ? takeValue(rest, i) : undefined;
+            const value = next ? next.value : inlineValue('--default-branch', arg);
+            if (next)
+                i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --default-branch' };
+            if (parsed.defaultBranch)
+                return { ok: false, message: 'ระบุ default-branch ได้ครั้งเดียว' };
+            parsed.defaultBranch = value.trim();
+        }
+        else if (arg === '--output') {
+            const next = takeValue(rest, i);
+            const value = next.value;
+            i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว' };
+            parsed.output = value.trim();
+        }
+        else if (arg.startsWith('--output=')) {
+            const value = arg.slice('--output='.length).trim();
+            if (!value)
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว' };
+            parsed.output = value;
+        }
+        else if (arg === '--') {
+            positional.push(...rest.slice(i + 1));
+            break;
+        }
+        else if (arg.startsWith('-')) {
+            return { ok: false, message: `ไม่รู้จัก option: ${arg}` };
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    const positionalTitle = positional.join(' ').trim();
+    if (parsed.title && positionalTitle)
+        return { ok: false, message: 'ระบุ title ได้ครั้งเดียว: ใช้ positional หรือ --title อย่างใดอย่างหนึ่ง' };
+    if (positionalTitle)
+        parsed.title = positionalTitle;
+    return { ok: true, value: parsed };
+}
+export function inferParentRelPath(relPath) {
+    const normalized = relPath.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    parts.pop();
+    if (!parts.length)
+        return 'Home';
+    return `${parts.join('/')}/_Index`;
+}
+export function destinationIndexRelPath(type, relPath) {
+    const config = BRAIN_NOTE_TYPES[type];
+    const normalized = relPath.replace(/\\/g, '/');
+    if (normalized.startsWith(`${config.destDir}/`) && normalized.includes('/')) {
+        const nested = normalized.slice(config.destDir.length + 1);
+        if (nested.includes('/')) {
+            const subDir = nested.split('/')[0];
+            return `${config.destDir}/${subDir}/_Index`;
+        }
+    }
+    return `${config.destDir}/_Index`;
+}
+export function validateNoteOutputPath(type, relPath) {
+    const config = BRAIN_NOTE_TYPES[type];
+    const normalized = relPath.replace(/\\/g, '/');
+    if (normalized.endsWith('/_Index.md') || normalized === '_Index.md') {
+        return { ok: false, message: 'Cannot create a note at an _Index.md path.' };
+    }
+    if (!normalized.startsWith(`${config.destDir}/`)) {
+        return { ok: false, message: `${type} notes must stay under ${config.destDir}/.` };
+    }
+    return { ok: true };
+}
+export function instantiateNoteTemplate(raw, options) {
+    let content = raw.replaceAll('YYYY-MM-DD', options.today).replaceAll('{{DATE}}', options.today);
+    const config = BRAIN_NOTE_TYPES[options.type];
+    for (const placeholder of config.titlePlaceholders) {
+        content = content.replaceAll(placeholder, options.title);
+    }
+    content = content.replace(/^# .+$/m, (heading) => {
+        if (heading.includes(options.title))
+            return heading;
+        if (options.type === 'session')
+            return `# ${options.today} — ${options.title}`;
+        if (options.type === 'bug')
+            return `# ${options.today} — ${options.title}`;
+        if (options.type === 'handoff')
+            return `# ${options.title} — Handoff`;
+        if (options.type === 'project')
+            return `# ${options.title}`;
+        if (options.type === 'golden-case')
+            return `# ${options.title}`;
+        if (options.type === 'checklist')
+            return `# ${options.title}`;
+        return heading;
+    });
+    const parentValue = `"[[${options.parent}]]"`;
+    if (/^parent:/m.test(content)) {
+        content = content.replace(/^parent:.*$/m, `parent: ${parentValue}`);
+    }
+    else if (/^---[\s\S]*?---/m.test(content)) {
+        content = content.replace(/^---\n/m, `---\nparent: ${parentValue}\n`);
+    }
+    const upLink = `up:: [[${options.parent}]]`;
+    if (content.includes('up:: [['))
+        content = content.replace(/^up:: \[\[[^\]]+\]\]\s*$/m, upLink);
+    else
+        content = `${content.trimEnd()}\n\n${upLink}\n`;
+    if (options.type === 'golden-case')
+        content = content.replace(/^note_type:\s*template/m, 'note_type: golden-case');
+    if (options.type === 'checklist')
+        content = content.replace(/^note_type:\s*template/m, 'note_type: checklist');
+    content = content.replace(/^tags: \[template,/m, 'tags: [');
+    return content;
+}
+export async function createBrainNote(options) {
+    const title = (options.title ?? defaultTitleForType(options.type)).trim() || defaultTitleForType(options.type);
+    const warnings = [];
+    if (!options.brainPath) {
+        return { ok: false, title, indexed: false, warnings: ['No second-brain path is configured.'] };
+    }
+    const brainPath = resolve(options.brainPath);
+    if (!(await pathExistsAsDir(brainPath))) {
+        return { ok: false, brainPath, title, indexed: false, warnings: ['Configured second-brain path does not exist or is not a directory.'] };
+    }
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    if (options.type === 'project' && !options.output) {
+        const { scaffoldProjectWorkspace } = await import('./project-scaffold.js');
+        const scaffold = await scaffoldProjectWorkspace({
+            brainPath,
+            title,
+            repoPath: options.repo,
+            verify: options.verify,
+            defaultBranch: options.defaultBranch,
+            today,
+            force: options.force,
+        });
+        return {
+            ok: scaffold.ok,
+            brainPath,
+            type: 'project',
+            title: scaffold.title,
+            template: 'Templates/project-workspace/*',
+            path: join(brainPath, scaffold.relDir),
+            relPath: `${scaffold.relDir}/overview.md`,
+            indexed: scaffold.indexed,
+            warnings: [
+                ...scaffold.warnings,
+                ...(scaffold.created.length ? [`created ${scaffold.created.length} file(s) under ${scaffold.relDir}/`] : []),
+            ],
+        };
+    }
+    const slug = slugify(title);
+    const config = BRAIN_NOTE_TYPES[options.type];
+    const relPath = normalizeRelPath(options.output ?? config.defaultRelPath({ today, slug }));
+    const valid = validateNoteOutputPath(options.type, relPath);
+    if (!valid.ok) {
+        return { ok: false, brainPath, type: options.type, title, indexed: false, warnings: [valid.message] };
+    }
+    const destIndexRel = destinationIndexRelPath(options.type, relPath);
+    const indexPath = join(brainPath, `${destIndexRel}.md`);
+    if (!(await fileExists(indexPath))) {
+        warnings.push(`Destination index missing: ${destIndexRel}.md`);
+    }
+    else {
+        await readFile(indexPath, 'utf8');
+    }
+    const outputPath = resolve(isAbsolute(relPath) ? relPath : join(brainPath, relPath));
+    const insideVault = !relative(brainPath, outputPath).startsWith('..') && !isAbsolute(relative(brainPath, outputPath));
+    if (!insideVault) {
+        return { ok: false, brainPath, type: options.type, title, indexed: false, warnings: ['--output must stay inside the configured second-brain vault.'] };
+    }
+    if ((await fileExists(outputPath)) && !options.force) {
+        return {
+            ok: false,
+            brainPath,
+            type: options.type,
+            title,
+            path: outputPath,
+            relPath,
+            indexed: false,
+            warnings: ['Note already exists. Re-run with --force or choose --output.'],
+        };
+    }
+    const template = await readNoteTemplate(brainPath, options.type);
+    if (!template.path) {
+        return { ok: false, brainPath, type: options.type, title, indexed: false, warnings: [template.message] };
+    }
+    const parent = destinationIndexRelPath(options.type, relPath);
+    const content = instantiateNoteTemplate(template.content, { today, title, parent, type: options.type });
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, content, 'utf8');
+    const indexed = await maybeAppendDestinationIndex(brainPath, destIndexRel, relPath, title, options.type);
+    return {
+        ok: true,
+        brainPath,
+        type: options.type,
+        title,
+        template: template.path,
+        path: outputPath,
+        relPath,
+        indexed,
+        warnings,
+    };
+}
+export function formatBrainNewReport(report) {
+    const lines = ['Sanook brain new'];
+    lines.push(`vault: ${report.brainPath ?? '(not configured)'}`);
+    if (report.type)
+        lines.push(`type: ${report.type}`);
+    lines.push(`title: ${report.title}`);
+    if (report.template)
+        lines.push(`template: ${report.template}`);
+    if (report.path)
+        lines.push(`created: ${report.path}`);
+    if (report.relPath)
+        lines.push(`link: [[${report.relPath.replace(/\.md$/i, '')}]]`);
+    if (report.indexed)
+        lines.push('index: updated');
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+function defaultTitleForType(type) {
+    switch (type) {
+        case 'session':
+            return 'session note';
+        case 'bug':
+            return 'bug report';
+        case 'handoff':
+            return 'project handoff';
+        case 'project':
+            return 'project overview';
+        case 'golden-case':
+            return 'golden case';
+        case 'checklist':
+            return 'preflight postflight';
+    }
+}
+async function readNoteTemplate(brainPath, type) {
+    for (const candidate of BRAIN_NOTE_TYPES[type].templateCandidates) {
+        const vaultPath = join(brainPath, candidate);
+        const fromVault = await readText(vaultPath);
+        if (fromVault)
+            return { path: candidate, content: fromVault, message: '' };
+        const bundledPath = join(TEMPLATE_ROOT, candidate);
+        const fromBundled = await readText(bundledPath);
+        if (fromBundled)
+            return { path: candidate, content: fromBundled, message: '' };
+    }
+    return { content: '', message: `No template found for ${type}.` };
+}
+async function maybeAppendDestinationIndex(brainPath, indexRel, noteRel, title, type) {
+    const indexPath = join(brainPath, `${indexRel}.md`);
+    const content = await readText(indexPath);
+    if (!content)
+        return false;
+    const note = noteRel.replace(/\.md$/i, '');
+    const link = `[[${note}]]`;
+    if (content.includes(link))
+        return false;
+    const line = `- ${link} — ${type}: ${title}`;
+    const marker = '\nup:: [[Home]]';
+    const next = content.includes(marker) ? content.replace(marker, `\n${line}\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
+    await writeFile(indexPath, next, 'utf8');
+    return true;
+}
+function slugify(value) {
+    const slug = value
+        .normalize('NFKD')
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80)
+        .replace(/-+$/g, '');
+    return slug || 'note';
+}
+function normalizeRelPath(path) {
+    return path.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+async function pathExistsAsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}