sanook-cli 0.5.1 → 0.5.5

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 '';
+    }
+}

package/dist/brain-pack.js

@@ -0,0 +1,210 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+const CONTEXT_PACKS_DIR = join('Shared', 'Context-Packs');
+export function parseBrainPackArgs(args) {
+    const [action, ...rest] = args;
+    if (action === 'list') {
+        if (rest.length)
+            return { ok: false, message: `ไม่รู้จัก option: ${rest.join(' ')}` };
+        return { ok: true, action: 'list' };
+    }
+    if (action === 'show') {
+        const name = rest.join(' ').trim();
+        if (!name)
+            return { ok: false, message: 'ต้องระบุชื่อ context pack' };
+        return { ok: true, action: 'show', name };
+    }
+    if (!action)
+        return { ok: false, message: 'ต้องระบุ subcommand: list หรือ show <name>' };
+    return { ok: false, message: `ไม่รู้จัก subcommand: ${action}` };
+}
+export function normalizePackName(name) {
+    return name
+        .trim()
+        .replace(/^Shared\/Context-Packs\//i, '')
+        .replace(/\.md$/i, '');
+}
+export function extractPackDescription(indexContent, packName) {
+    const link = `[[Shared/Context-Packs/${packName}]]`;
+    for (const line of indexContent.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('- ') || !trimmed.includes(link))
+            continue;
+        const dash = trimmed.indexOf('—');
+        if (dash >= 0)
+            return trimmed.slice(dash + 1).trim();
+        const hyphen = trimmed.indexOf(' - ');
+        if (hyphen >= 0)
+            return trimmed.slice(hyphen + 3).trim();
+    }
+    return undefined;
+}
+export function extractBlockquotePurpose(content) {
+    const body = content.replace(/^---[\s\S]*?---\n?/, '');
+    const match = body.match(/^>\s*(.+)$/m);
+    return match?.[1]?.trim() ?? '';
+}
+export function extractSectionBullets(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('- '))
+            out.push(trimmed.slice(2).trim());
+        else {
+            const numbered = trimmed.match(/^\d+\.\s+(.+)$/);
+            if (numbered)
+                out.push(numbered[1].trim());
+        }
+    }
+    return out;
+}
+export function extractWikiLinks(value) {
+    return [...value.matchAll(/\[\[([^\]]+)\]\]/g)].map((match) => match[1].trim());
+}
+export function buildContextPackSummary(packName, content, indexContent) {
+    const relPath = `${CONTEXT_PACKS_DIR}/${packName}.md`;
+    const link = `[[Shared/Context-Packs/${packName}]]`;
+    return {
+        name: packName,
+        relPath,
+        description: extractPackDescription(indexContent, packName) || extractBlockquotePurpose(content),
+        indexed: indexContent.includes(link),
+        hasLoadOrder: content.includes('## Load Order'),
+        hasDoneCriteria: content.includes('## Done Criteria'),
+    };
+}
+export function buildContextPackDetail(packName, content, indexContent) {
+    const summary = buildContextPackSummary(packName, content, indexContent);
+    const loadOrder = extractSectionBullets(content, 'Load Order');
+    const doneCriteria = extractSectionBullets(content, 'Done Criteria');
+    const roleLines = extractSectionBullets(content, 'Required Role');
+    return {
+        ...summary,
+        useCase: extractBlockquotePurpose(content),
+        loadOrder,
+        doneCriteria,
+        requiredRole: roleLines.length ? roleLines.join(' · ') : undefined,
+        sources: uniqueSorted(loadOrder.flatMap(extractWikiLinks)),
+    };
+}
+export async function listContextPacks(brainPath) {
+    const warnings = [];
+    if (!(await pathExistsAsDir(brainPath))) {
+        return { ok: false, packs: [], warnings: ['Configured second-brain path does not exist or is not a directory.'] };
+    }
+    const dir = join(brainPath, CONTEXT_PACKS_DIR);
+    const indexPath = join(dir, '_Index.md');
+    const indexContent = await readText(indexPath);
+    if (!indexContent)
+        warnings.push('Context-Packs index is missing.');
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return { ok: false, brainPath, packs: [], warnings: ['Context-Packs directory is missing.'] };
+    }
+    const packs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name !== '_Index.md')
+        .map((entry) => normalizePackName(entry.name))
+        .sort((a, b) => a.localeCompare(b));
+    const summaries = [];
+    for (const name of packs) {
+        const content = await readText(join(dir, `${name}.md`));
+        if (!content) {
+            warnings.push(`Unreadable context pack: ${name}.md`);
+            continue;
+        }
+        summaries.push(buildContextPackSummary(name, content, indexContent));
+    }
+    return { ok: true, brainPath, packs: summaries, warnings };
+}
+export async function showContextPack(brainPath, rawName) {
+    const warnings = [];
+    const name = normalizePackName(rawName);
+    if (!(await pathExistsAsDir(brainPath))) {
+        return { ok: false, warnings: ['Configured second-brain path does not exist or is not a directory.'] };
+    }
+    const dir = join(brainPath, CONTEXT_PACKS_DIR);
+    const packPath = join(dir, `${name}.md`);
+    const content = await readText(packPath);
+    if (!content) {
+        return { ok: false, brainPath, warnings: [`Context pack not found: ${name}`] };
+    }
+    const indexContent = await readText(join(dir, '_Index.md'));
+    if (!indexContent)
+        warnings.push('Context-Packs index is missing.');
+    const pack = buildContextPackDetail(name, content, indexContent);
+    if (!pack.indexed)
+        warnings.push(`${name} is not linked from Context-Packs/_Index.md.`);
+    return { ok: true, brainPath, pack, warnings };
+}
+export function formatBrainPackListReport(report) {
+    const lines = ['Sanook brain pack list', `vault: ${report.brainPath ?? '(not configured)'}`];
+    lines.push(`packs: ${report.packs.length}`);
+    for (const pack of report.packs) {
+        const flags = [
+            pack.indexed ? 'indexed' : 'missing-index-link',
+            pack.hasLoadOrder ? 'load-order' : 'no-load-order',
+            pack.hasDoneCriteria ? 'done-criteria' : 'no-done-criteria',
+        ].join(', ');
+        lines.push(`- ${pack.name} — ${pack.description || '(no description)'} [${flags}]`);
+        lines.push(`  ${pack.relPath}`);
+    }
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+export function formatBrainPackShowReport(report) {
+    const lines = ['Sanook brain pack show', `vault: ${report.brainPath ?? '(not configured)'}`];
+    if (!report.pack) {
+        for (const warning of report.warnings)
+            lines.push(`warning: ${warning}`);
+        return lines.join('\n');
+    }
+    const pack = report.pack;
+    lines.push(`name: ${pack.name}`);
+    lines.push(`path: ${pack.relPath}`);
+    lines.push(`use-case: ${pack.useCase || '(none)'}`);
+    if (pack.requiredRole)
+        lines.push(`role: ${pack.requiredRole}`);
+    lines.push('load-order:');
+    for (const item of pack.loadOrder.length ? pack.loadOrder : ['(missing ## Load Order section)'])
+        lines.push(`  - ${item}`);
+    lines.push('done-criteria:');
+    for (const item of pack.doneCriteria.length ? pack.doneCriteria : ['(missing ## Done Criteria section)'])
+        lines.push(`  - ${item}`);
+    if (pack.sources.length) {
+        lines.push('sources:');
+        for (const source of pack.sources)
+            lines.push(`  - [[${source}]]`);
+    }
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+async function pathExistsAsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function uniqueSorted(values) {
+    return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}