sanook-cli 0.5.2 → 0.5.5

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

package/dist/brain-repair.js

@@ -0,0 +1,280 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { FOLDERS } from './brain.js';
+import { checkBrainFolders } from './brain-doctor.js';
+import { inferParentRelPath } from './brain-new.js';
+import { extractPackDescription, normalizePackName as normalizeContextPackName } from './brain-pack.js';
+const ROOT_FILES_WITHOUT_PARENT = new Set(['Home.md', 'README.md', 'CLAUDE.md', 'GEMINI.md', 'AGENTS.md', 'SANOOK.md']);
+const ROOT_FILES_WITHOUT_UP = ROOT_FILES_WITHOUT_PARENT;
+const SKIP_DIRS = new Set(['.git', '.obsidian', 'node_modules', 'Shared/Context7-Docs']);
+const PURPOSE_PLACEHOLDER = '> _(purpose pending — fill in)_\n\n';
+export function parseBrainRepairArgs(args) {
+    for (const arg of args) {
+        if (arg === '--dry-run')
+            continue;
+        return { ok: false, message: `ไม่รู้จัก option: ${arg}` };
+    }
+    return { ok: true, dryRun: args.includes('--dry-run') };
+}
+export function planPurposeFix(relPath, content) {
+    if (/^>\s+/m.test(content))
+        return undefined;
+    return {
+        id: 'repair.purpose-blockquote',
+        relPath,
+        kind: 'markdown',
+        message: 'Add purpose blockquote after frontmatter.',
+    };
+}
+export function planParentFix(relPath, content) {
+    if (ROOT_FILES_WITHOUT_PARENT.has(relPath))
+        return undefined;
+    if (/^---[\s\S]*?^parent:/m.test(content))
+        return undefined;
+    const parent = inferParentRelPath(relPath);
+    return {
+        id: 'repair.parent-frontmatter',
+        relPath,
+        kind: 'markdown',
+        message: `Add parent frontmatter -> [[${parent}]]`,
+    };
+}
+export function planUpLinkFix(relPath, content) {
+    if (ROOT_FILES_WITHOUT_UP.has(relPath))
+        return undefined;
+    if (content.includes('up:: [['))
+        return undefined;
+    const parent = inferParentRelPath(relPath);
+    return {
+        id: 'repair.up-link',
+        relPath,
+        kind: 'markdown',
+        message: `Append up:: [[${parent}]]`,
+    };
+}
+export function applyPurposeFix(content) {
+    if (/^>\s+/m.test(content))
+        return content;
+    const match = content.match(/^---[\s\S]*?---\n?/);
+    if (match)
+        return content.replace(match[0], `${match[0]}${PURPOSE_PLACEHOLDER}`);
+    return `${PURPOSE_PLACEHOLDER}${content}`;
+}
+export function applyParentFix(content, relPath) {
+    if (/^---[\s\S]*?^parent:/m.test(content))
+        return content;
+    const parent = inferParentRelPath(relPath);
+    const parentLine = `parent: "[[${parent}]]"`;
+    const match = content.match(/^---\n([\s\S]*?)---\n/);
+    if (!match)
+        return `---\n${parentLine}\n---\n\n${content}`;
+    return content.replace(/^---\n/, `---\n${parentLine}\n`);
+}
+export function applyUpLinkFix(content, relPath) {
+    if (content.includes('up:: [['))
+        return content;
+    const parent = inferParentRelPath(relPath);
+    return `${content.trimEnd()}\n\nup:: [[${parent}]]\n`;
+}
+export function applyMarkdownRepairs(relPath, content) {
+    let next = content;
+    const applied = [];
+    if (planPurposeFix(relPath, next)) {
+        next = applyPurposeFix(next);
+        applied.push('purpose-blockquote');
+    }
+    if (planParentFix(relPath, next)) {
+        next = applyParentFix(next, relPath);
+        applied.push('parent-frontmatter');
+    }
+    if (planUpLinkFix(relPath, next)) {
+        next = applyUpLinkFix(next, relPath);
+        applied.push('up-link');
+    }
+    return { content: next, applied };
+}
+export function planContextPackIndexFix(packName, indexContent) {
+    const link = `[[Shared/Context-Packs/${packName}]]`;
+    if (indexContent.includes(link))
+        return undefined;
+    return {
+        id: 'repair.context-pack-index',
+        relPath: 'Shared/Context-Packs/_Index.md',
+        kind: 'index',
+        message: `Link ${packName} from Context-Packs/_Index.md`,
+    };
+}
+export function applyContextPackIndexFix(indexContent, packName, packContent) {
+    const link = `[[Shared/Context-Packs/${packName}]]`;
+    if (indexContent.includes(link))
+        return indexContent;
+    const description = extractBlockquotePurpose(packContent) || 'context pack';
+    const line = `- ${link} — ${description}`;
+    const marker = '\n## Use Rule';
+    if (indexContent.includes(marker))
+        return indexContent.replace(marker, `\n${line}\n${marker}`);
+    const upMarker = '\nup:: [[Shared/_Index]]';
+    if (indexContent.includes(upMarker))
+        return indexContent.replace(upMarker, `\n${line}\n${upMarker}`);
+    return `${indexContent.trimEnd()}\n${line}\n`;
+}
+export async function collectRepairActions(brainPath, expectedFolders = FOLDERS.map((folder) => folder.dir)) {
+    const actions = [];
+    const folderCheck = await checkBrainFolders(brainPath, expectedFolders);
+    for (const missing of folderCheck.details ?? []) {
+        actions.push({
+            id: 'repair.missing-folder',
+            relPath: missing,
+            kind: 'folder',
+            message: `Create missing folder: ${missing}`,
+        });
+    }
+    for (const relPath of await listMarkdown(brainPath)) {
+        const content = await readText(join(brainPath, relPath));
+        for (const plan of [planPurposeFix, planParentFix, planUpLinkFix]) {
+            const action = plan(relPath, content);
+            if (action)
+                actions.push(action);
+        }
+    }
+    const packsDir = join(brainPath, 'Shared', 'Context-Packs');
+    const indexPath = join(packsDir, '_Index.md');
+    const indexContent = await readText(indexPath);
+    let entries;
+    try {
+        entries = await readdir(packsDir, { withFileTypes: true });
+    }
+    catch {
+        return actions;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.md') || entry.name === '_Index.md')
+            continue;
+        const packName = normalizeContextPackName(entry.name);
+        const action = planContextPackIndexFix(packName, indexContent);
+        if (action)
+            actions.push(action);
+    }
+    return actions;
+}
+export async function repairBrain(options = {}) {
+    const dryRun = options.dryRun ?? false;
+    const warnings = [];
+    const brainPath = options.brainPath;
+    if (!brainPath) {
+        return { ok: false, dryRun, actions: [], applied: [], warnings: ['No second-brain path is configured.'] };
+    }
+    if (!(await pathExistsAsDir(brainPath))) {
+        return { ok: false, brainPath, dryRun, actions: [], applied: [], warnings: ['Configured second-brain path does not exist or is not a directory.'] };
+    }
+    const actions = await collectRepairActions(brainPath, options.expectedFolders);
+    if (dryRun) {
+        return { ok: true, brainPath, dryRun, actions, applied: [], warnings };
+    }
+    const applied = [];
+    const markdownUpdates = new Map();
+    for (const action of actions) {
+        if (action.kind === 'folder') {
+            await mkdir(join(brainPath, action.relPath), { recursive: true });
+            applied.push(`${action.relPath}: created folder`);
+            continue;
+        }
+        if (action.kind === 'index' && action.id === 'repair.context-pack-index') {
+            const indexPath = join(brainPath, action.relPath);
+            const indexContent = await readText(indexPath);
+            if (!indexContent) {
+                warnings.push(`Skipped ${action.relPath}: index file missing.`);
+                continue;
+            }
+            const packName = action.message.match(/Link ([^\s]+) from/)?.[1];
+            if (!packName)
+                continue;
+            const packContent = await readText(join(brainPath, 'Shared', 'Context-Packs', `${packName}.md`));
+            const next = applyContextPackIndexFix(indexContent, packName, packContent);
+            if (next !== indexContent) {
+                await writeFile(indexPath, next, 'utf8');
+                applied.push(`${action.relPath}: linked ${packName}`);
+            }
+            continue;
+        }
+        if (action.kind === 'markdown') {
+            const current = markdownUpdates.get(action.relPath)?.content ?? (await readText(join(brainPath, action.relPath)));
+            const repaired = applyMarkdownRepairs(action.relPath, current);
+            if (repaired.applied.length) {
+                const prior = markdownUpdates.get(action.relPath)?.applied ?? [];
+                markdownUpdates.set(action.relPath, { content: repaired.content, applied: uniqueSorted([...prior, ...repaired.applied]) });
+            }
+        }
+    }
+    for (const [relPath, update] of markdownUpdates) {
+        await writeFile(join(brainPath, relPath), update.content, 'utf8');
+        applied.push(`${relPath}: ${update.applied.join(', ')}`);
+    }
+    return { ok: true, brainPath, dryRun, actions, applied, warnings };
+}
+export function formatBrainRepairReport(report) {
+    const lines = ['Sanook brain repair', `vault: ${report.brainPath ?? '(not configured)'}`];
+    lines.push(`mode: ${report.dryRun ? 'dry-run' : 'apply'}`);
+    lines.push(`planned: ${report.actions.length} fix(es)`);
+    for (const action of report.actions) {
+        lines.push(`- [${action.id}] ${action.relPath} — ${action.message}`);
+    }
+    if (!report.dryRun) {
+        lines.push(`applied: ${report.applied.length}`);
+        for (const item of report.applied)
+            lines.push(`  ✓ ${item}`);
+    }
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+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 pathExistsAsDir(path) {
+    try {
+        const { stat } = await import('node:fs/promises');
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function extractBlockquotePurpose(content) {
+    const body = content.replace(/^---[\s\S]*?---\n?/, '');
+    const match = body.match(/^>\s*(.+)$/m);
+    return match?.[1]?.trim() ?? '';
+}
+function uniqueSorted(values) {
+    return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}

package/dist/brain.js

@@ -196,6 +196,9 @@ export async function scaffoldBrain(targetPath, cfg) {
     for (const rel of await walk(TEMPLATE_DIR)) {
         if (rel.split('/').pop() === '_Index.md')
             continue; // generated จาก FOLDERS[] แล้ว ไม่ copy ซ้ำจาก template source
+        // Projects/<slug>/ are per-user workspaces — scaffold via `sanook brain new project`, not bundled copy
+        if (rel.startsWith('Projects/') && rel !== 'Projects/_Index.md')
+            continue;
         const raw = await readFile(join(TEMPLATE_DIR, rel), 'utf8');
         await writeIfMissing(join(targetPath, rel), substitute(raw, cfg), created, skipped);
     }

package/dist/cli-args.js

@@ -13,9 +13,9 @@ export function parseBudgetUsd(value) {
 export function parseThinkingConfigValue(value) {
     const normalized = value.trim();
     const flag = normalized.toLowerCase();
-    if (flag === 'on' || flag === 'true')
+    if (flag === 'on' || flag === 'true' || flag === 'yes')
         return true;
-    if (flag === 'off' || flag === 'false')
+    if (flag === 'off' || flag === 'false' || flag === 'no')
         return false;
     if (!POSITIVE_INTEGER_RE.test(normalized))
         return undefined;
@@ -61,10 +61,20 @@ function parsePortValue(raw) {
 function portErrorValue(raw) {
     return raw === undefined || raw === '' ? 'ต้องระบุค่า' : raw;
 }
+function modelErrorValue(raw) {
+    return cleanModelValue(raw) ? undefined : 'ต้องระบุค่า';
+}
+function cleanModelValue(raw) {
+    const clean = raw?.trim();
+    return clean ? clean : undefined;
+}
 export function parseServeArgs(argv) {
     let port = 8787;
     let model;
     let portError;
+    let modelError;
+    let portSet = false;
+    let modelSet = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === '--port' || a.startsWith('--port=')) {
@@ -75,25 +85,49 @@ export function parseServeArgs(argv) {
             const parsed = parsePortValue(raw);
             if (parsed === undefined)
                 portError = portErrorValue(raw);
-            else
+            else if (portSet)
+                portError = 'ใช้ --port เพียงครั้งเดียว';
+            else {
                 port = parsed;
+                portSet = true;
+            }
         }
         else if (a === '--model' || a === '-m' || a.startsWith('--model=')) {
             if (a.startsWith('--model=')) {
-                model = inlineValue('--model', a);
+                const raw = inlineValue('--model', a);
+                const clean = cleanModelValue(raw);
+                const error = modelErrorValue(raw);
+                if (error)
+                    modelError = error;
+                else if (modelSet)
+                    modelError = 'ใช้ --model เพียงครั้งเดียว';
+                else {
+                    model = clean;
+                    modelSet = true;
+                }
             }
             else {
                 const next = takeValue(argv, i);
-                model = next.value;
+                const clean = cleanModelValue(next.value);
+                const error = modelErrorValue(next.value);
+                if (error)
+                    modelError = error;
+                else if (modelSet)
+                    modelError = 'ใช้ --model เพียงครั้งเดียว';
+                else {
+                    model = clean;
+                    modelSet = true;
+                }
                 i = next.nextIndex;
             }
         }
     }
-    return { port, model, portError };
+    return { port, model, portError, modelError };
 }
 export function parseArgs(argv) {
     let model;
     let budget;
+    let budgetInvalid = false;
     let json = false;
     let quiet = false;
     let planMode = false;
@@ -113,14 +147,18 @@ export function parseArgs(argv) {
             break;
         }
         if (a.startsWith('--model='))
-            model = inlineValue('--model', a);
+            model = cleanModelValue(inlineValue('--model', a));
         else if (a === '--model' || a === '-m')
-            model = takeArgValue(i);
+            model = cleanModelValue(takeArgValue(i));
         else if (a.startsWith('--budget=')) {
             budget = parseBudgetUsd(inlineValue('--budget', a));
+            if (budget === undefined)
+                budgetInvalid = true;
         }
         else if (a === '--budget' || a === '-b') {
             budget = parseBudgetUsd(takeArgValue(i));
+            if (budget === undefined)
+                budgetInvalid = true;
         }
         else if (a === '--json')
             json = true;
@@ -148,5 +186,5 @@ export function parseArgs(argv) {
         else
             rest.push(a);
     }
-    return { model, budget, json, quiet, prompt: rest.join(' ').trim(), planMode, yes, resume };
+    return { model, budget, budgetInvalid, json, quiet, prompt: rest.join(' ').trim(), planMode, yes, resume };
 }

package/dist/cli-option-values.js

@@ -10,7 +10,7 @@ export function inlineValue(flag, value) {
 }
 export function takeValue(argv, index) {
     const value = argv[index + 1];
-    if (value === undefined || isFlagLike(value))
+    if (value === undefined || value === '' || isFlagLike(value))
         return { nextIndex: index };
     return { value, nextIndex: index + 1 };
 }

package/dist/clipboard.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+const OSC52_MAX_CHARS = 100_000;
+function powershellSetClipboardScript(text) {
+    const b64 = Buffer.from(text, 'utf8').toString('base64');
+    return `Set-Clipboard -Value ([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${b64}')))`;
+}
+function clipboardWriteCommands(platform, env) {
+    if (platform === 'darwin')
+        return [{ args: [], command: 'pbcopy', stdin: true }];
+    if (platform === 'win32')
+        return [{ args: ['-NoProfile', '-NonInteractive'], command: 'powershell', stdin: false }];
+    const commands = [];
+    if (env.WSL_INTEROP || env.WSL_DISTRO_NAME) {
+        commands.push({ args: ['-NoProfile', '-NonInteractive'], command: 'powershell.exe', stdin: false });
+    }
+    if (env.WAYLAND_DISPLAY)
+        commands.push({ args: ['--type', 'text/plain'], command: 'wl-copy', stdin: true });
+    commands.push({ args: ['-selection', 'clipboard', '-in'], command: 'xclip', stdin: true });
+    commands.push({ args: ['--clipboard', '--input'], command: 'xsel', stdin: true });
+    return commands;
+}
+function runClipboardCommand(command, text, start) {
+    return new Promise((resolve) => {
+        const args = command.stdin ? command.args : [...command.args, '-Command', powershellSetClipboardScript(text)];
+        let child;
+        try {
+            child = start(command.command, args, { stdio: command.stdin ? ['pipe', 'ignore', 'ignore'] : ['ignore', 'ignore', 'ignore'], windowsHide: true });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        child.once('error', () => resolve(false));
+        child.once('close', (code) => resolve(code === 0));
+        if (command.stdin)
+            child.stdin?.end(text);
+    });
+}
+export async function writeSystemClipboard(text, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const start = options.spawn ?? spawn;
+    for (const command of clipboardWriteCommands(platform, env)) {
+        if (await runClipboardCommand(command, text, start))
+            return command.command;
+    }
+    return null;
+}
+export function osc52Sequence(text) {
+    const safe = text.length > OSC52_MAX_CHARS ? text.slice(0, OSC52_MAX_CHARS) : text;
+    return `\u001b]52;c;${Buffer.from(safe, 'utf8').toString('base64')}\u0007`;
+}
+export async function copyTextToClipboard(text, options = {}) {
+    const payload = text.trimEnd();
+    if (!payload.trim())
+        throw new Error('ไม่มีข้อความให้ copy');
+    const backend = await writeSystemClipboard(payload, options);
+    if (backend)
+        return { detail: backend, method: 'system' };
+    if (options.writeOsc52) {
+        options.writeOsc52(osc52Sequence(payload));
+        return { detail: 'OSC52', method: 'osc52' };
+    }
+    throw new Error('ไม่พบ clipboard backend และไม่มี OSC52 output');
+}