sanook-cli 0.5.1 → 0.5.5

package/dist/ui/tool-trail.js

@@ -0,0 +1,97 @@
+import { inspect } from 'node:util';
+export const TOOL_TRAIL_LIMIT = 6;
+function clip(text, width) {
+    if (width <= 0)
+        return '';
+    return text.length > width ? `${text.slice(0, Math.max(0, width - 3))}...` : text;
+}
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export function compactToolDetail(detail, width = 64) {
+    if (detail === undefined || detail === null)
+        return '';
+    const text = typeof detail === 'string'
+        ? detail
+        : (() => {
+            try {
+                return JSON.stringify(detail);
+            }
+            catch {
+                return inspect(detail, { breakLength: Infinity, depth: 2 });
+            }
+        })();
+    return clip(normalizeWhitespace(text), width);
+}
+function trimItems(items) {
+    return items.slice(Math.max(0, items.length - TOOL_TRAIL_LIMIT));
+}
+function latestRunningToolIndex(items, tool) {
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const item = items[i];
+        if (item.status !== 'running')
+            continue;
+        if (!tool || item.name === tool)
+            return i;
+    }
+    return -1;
+}
+export function updateToolTrailOnEvent(items, event, nextId) {
+    if (event.type === 'tool-call') {
+        const name = event.tool?.trim() || 'tool';
+        return {
+            items: trimItems([...items, { detail: compactToolDetail(event.detail), id: nextId, name, status: 'running' }]),
+            nextId: nextId + 1,
+        };
+    }
+    if (event.type === 'tool-result') {
+        const index = latestRunningToolIndex(items, event.tool);
+        const detail = compactToolDetail(event.detail);
+        if (index === -1) {
+            const name = event.tool?.trim() || 'tool';
+            return {
+                items: trimItems([...items, { detail, id: nextId, name, status: 'done' }]),
+                nextId: nextId + 1,
+            };
+        }
+        const next = [...items];
+        next[index] = { ...next[index], detail: detail || next[index].detail, status: 'done' };
+        return { items: trimItems(next), nextId };
+    }
+    const index = latestRunningToolIndex(items);
+    const detail = compactToolDetail(event.detail ?? event.text);
+    if (index === -1)
+        return { items, nextId };
+    const next = [...items];
+    next[index] = { ...next[index], detail: detail || next[index].detail, status: 'error' };
+    return { items: trimItems(next), nextId };
+}
+function markerForStatus(status) {
+    return status === 'running' ? '>' : status === 'done' ? '+' : '!';
+}
+function statusSummary(items) {
+    const running = items.filter((item) => item.status === 'running').length;
+    const done = items.filter((item) => item.status === 'done').length;
+    const error = items.filter((item) => item.status === 'error').length;
+    return [`${done} done`, running ? `${running} running` : '', error ? `${error} error` : ''].filter(Boolean).join(' / ');
+}
+export function toolTrailLines(items, columns, mode = 'expanded') {
+    if (mode === 'hidden')
+        return [];
+    if (!items.length)
+        return [];
+    const width = Math.max(24, Math.min(Math.max(30, columns - 4), 96));
+    const nameWidth = Math.max(8, Math.min(24, Math.floor(width * 0.34)));
+    const detailWidth = Math.max(0, width - nameWidth - 18);
+    const lines = [`Sanook tool trail (${items.length})`, `view: ${mode} | ${statusSummary(items)} | Ctrl+T / /trail`];
+    if (mode === 'compact') {
+        lines.push(`tools: ${items.map((item) => `${markerForStatus(item.status)}${item.name}`).join(' ')}`);
+        return lines.map((line) => clip(line, width));
+    }
+    for (const item of items) {
+        const marker = markerForStatus(item.status);
+        const detail = item.detail ? ` ${clip(item.detail, detailWidth)}` : '';
+        lines.push(`${marker} ${clip(item.name, nameWidth).padEnd(nameWidth)} ${item.status.padEnd(7)}${detail}`);
+    }
+    return lines.map((line) => clip(line, width));
+}

package/dist/ui/transcript.js

@@ -0,0 +1,26 @@
+export const DEFAULT_TRANSCRIPT_WINDOW = 30;
+/** Window into conversation turns — scrollFromBottom=0 pins to the latest messages. */
+export function getTranscriptWindow(totalLength, windowSize, scrollFromBottom = 0) {
+    if (totalLength <= 0) {
+        return { end: 0, scrollFromBottom: 0, showNewer: false, showOlder: false, start: 0 };
+    }
+    const size = Math.max(1, Math.min(windowSize, totalLength));
+    const maxScroll = Math.max(0, totalLength - size);
+    const scroll = Math.max(0, Math.min(scrollFromBottom, maxScroll));
+    const end = totalLength - scroll;
+    const start = Math.max(0, end - size);
+    return {
+        end,
+        scrollFromBottom: scroll,
+        showNewer: scroll > 0,
+        showOlder: start > 0,
+        start,
+    };
+}
+export function transcriptWindowSize(rows, min = 8, max = 40) {
+    const terminalRows = rows ?? 24;
+    return Math.max(min, Math.min(max, terminalRows - 12));
+}
+export function transcriptScrollStep(windowSize) {
+    return Math.max(3, Math.floor(windowSize / 2));
+}

package/dist/ui/useBusyElapsed.js

@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+export function useBusyElapsedSeconds(busy) {
+    const [startedAt, setStartedAt] = useState(null);
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        if (!busy) {
+            setStartedAt(null);
+            return;
+        }
+        const started = Date.now();
+        setStartedAt(started);
+        setNow(started);
+        const interval = setInterval(() => setNow(Date.now()), 1_000);
+        return () => clearInterval(interval);
+    }, [busy]);
+    if (startedAt == null)
+        return undefined;
+    return Math.max(0, Math.floor((now - startedAt) / 1_000));
+}

package/dist/ui/useEditor.js

@@ -1,15 +1,148 @@
 import { useState, useRef } from 'react';
+export const PASTE_COLLAPSE_LINES = 5;
+export const PASTE_COLLAPSE_CHARS = 2000;
+export const PASTE_SNIPPET_RE = /\[\[ paste [^\n]*?\]\]/g;
+const segmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+const BRACKETED_PASTE_RE = /\x1b?\[20[01]~/g;
+const BRACKETED_PASTE_TEST_RE = /\x1b?\[20[01]~/;
+const COMPACT_NUMBER = new Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' });
+function compactNumber(n) {
+    return COMPACT_NUMBER.format(n).replace(/[KMBT]$/, (suffix) => suffix.toLowerCase());
+}
+function oneLinePreview(text) {
+    return text.replace(/\s+/g, ' ').trim().replace(/\]\]/g, '] ]');
+}
+export function stripTrailingPasteNewlines(text) {
+    return /[^\n]/.test(text) ? text.replace(/\n+$/, '') : text;
+}
+export function normalizePastedInput(input) {
+    return stripTrailingPasteNewlines(input.replace(BRACKETED_PASTE_RE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
+}
+export function isPasteLikeInput(input) {
+    return BRACKETED_PASTE_TEST_RE.test(input) || input.includes('\n');
+}
+export function pasteTokenLabel(text, lineCount) {
+    const preview = oneLinePreview(text);
+    const count = `${compactNumber(lineCount)} lines`;
+    if (!preview)
+        return `[[ paste ${count} ]]`;
+    const headWidth = 20;
+    const tailWidth = 28;
+    const body = preview.length <= headWidth + tailWidth + 5
+        ? preview
+        : `${preview.slice(0, headWidth).trimEnd()}.. ${preview.slice(-tailWidth).trimStart()}`;
+    return `[[ paste ${count} · ${body} ]]`;
+}
+function insertToken(value, cursor, token) {
+    const lead = cursor > 0 && !/\s/.test(value[cursor - 1] ?? '') ? ' ' : '';
+    const tail = cursor < value.length && !/\s/.test(value[cursor] ?? '') ? ' ' : '';
+    const insert = `${lead}${token}${tail}`;
+    return { cursor: cursor + insert.length, value: value.slice(0, cursor) + insert + value.slice(cursor) };
+}
+export function trimPasteSnips(snips) {
+    const maxCount = 32;
+    const maxChars = 4 * 1024 * 1024;
+    const out = [];
+    let chars = 0;
+    for (let i = snips.length - 1; i >= 0; i -= 1) {
+        const snip = snips[i];
+        if (out.length >= maxCount || chars + snip.text.length > maxChars)
+            break;
+        chars += snip.text.length;
+        out.unshift(snip);
+    }
+    return out.length === snips.length ? snips : out;
+}
+export function applyPasteInput(value, cursor, input, pasteSnips) {
+    const text = normalizePastedInput(input);
+    if (!text)
+        return { cursor, pasteSnips, value };
+    const lineCount = text.split('\n').length;
+    const shouldCollapse = lineCount >= PASTE_COLLAPSE_LINES || text.length >= PASTE_COLLAPSE_CHARS;
+    if (!shouldCollapse) {
+        return {
+            cursor: cursor + text.length,
+            pasteSnips,
+            value: value.slice(0, cursor) + text + value.slice(cursor),
+        };
+    }
+    const label = pasteTokenLabel(text, lineCount);
+    const inserted = insertToken(value, cursor, label);
+    return {
+        ...inserted,
+        pasteSnips: trimPasteSnips([...pasteSnips, { label, text }]),
+    };
+}
+export function expandPasteSnippets(value, pasteSnips) {
+    const byLabel = new Map();
+    for (const { label, text } of pasteSnips) {
+        const matches = byLabel.get(label);
+        if (matches)
+            matches.push(text);
+        else
+            byLabel.set(label, [text]);
+    }
+    return value.replace(PASTE_SNIPPET_RE, (token) => byLabel.get(token)?.shift() ?? token);
+}
+export function graphemeBoundaries(text) {
+    const boundaries = [0];
+    if (segmenter) {
+        for (const segment of segmenter.segment(text))
+            boundaries.push(segment.index + segment.segment.length);
+    }
+    else {
+        let index = 0;
+        for (const point of Array.from(text)) {
+            index += point.length;
+            boundaries.push(index);
+        }
+    }
+    return boundaries.at(-1) === text.length ? boundaries : [...boundaries, text.length];
+}
+export function clampCursorToGrapheme(text, cursor) {
+    const target = Math.max(0, Math.min(cursor, text.length));
+    const boundaries = graphemeBoundaries(text);
+    let best = 0;
+    for (const boundary of boundaries) {
+        if (boundary > target)
+            break;
+        best = boundary;
+    }
+    return best;
+}
+export function previousGraphemeCursor(text, cursor) {
+    const target = clampCursorToGrapheme(text, cursor);
+    let previous = 0;
+    for (const boundary of graphemeBoundaries(text)) {
+        if (boundary >= target)
+            return previous;
+        previous = boundary;
+    }
+    return previous;
+}
+export function nextGraphemeCursor(text, cursor) {
+    const target = clampCursorToGrapheme(text, cursor);
+    for (const boundary of graphemeBoundaries(text)) {
+        if (boundary > target)
+            return boundary;
+    }
+    return text.length;
+}
 export function useEditor(history) {
     const [value, setValue] = useState('');
     const [cursor, setCursor] = useState(0);
+    const [pasteSnips, setPasteSnips] = useState([]);
     const histIndex = useRef(null); // null = กำลังแก้ draft (ไม่ได้อยู่ในประวัติ)
     const draft = useRef('');
     const set = (v, c = v.length) => {
         setValue(v);
-        setCursor(Math.max(0, Math.min(c, v.length)));
+        setCursor(clampCursorToGrapheme(v, c));
     };
     const reset = () => {
         histIndex.current = null;
+        setPasteSnips([]);
         set('');
     };
     const insert = (s) => set(value.slice(0, cursor) + s + value.slice(cursor), cursor + s.length);
@@ -51,9 +184,9 @@ export function useEditor(history) {
         if (key.downArrow)
             return historyNext(), 'handled';
         if (key.leftArrow)
-            return setCursor(Math.max(0, cursor - 1)), 'handled';
+            return setCursor(previousGraphemeCursor(value, cursor)), 'handled';
         if (key.rightArrow)
-            return setCursor(Math.min(value.length, cursor + 1)), 'handled';
+            return setCursor(nextGraphemeCursor(value, cursor)), 'handled';
         if (key.ctrl) {
             switch (input) {
                 case 'a': return setCursor(0), 'handled';
@@ -71,13 +204,19 @@ export function useEditor(history) {
         if (key.backspace || key.delete) {
             if (cursor === 0)
                 return 'handled';
-            return set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1), 'handled';
+            const previous = previousGraphemeCursor(value, cursor);
+            return set(value.slice(0, previous) + value.slice(cursor), previous), 'handled';
         }
         if (input && !key.meta) {
             histIndex.current = null; // เริ่มพิมพ์ = ออกจากโหมดดูประวัติ
+            if (isPasteLikeInput(input)) {
+                const pasted = applyPasteInput(value, cursor, input, pasteSnips);
+                setPasteSnips(pasted.pasteSnips);
+                return set(pasted.value, pasted.cursor), 'handled';
+            }
             return insert(input), 'handled';
         }
         return 'none';
     };
-    return { value, cursor, setValue: (v) => set(v), reset, handleKey };
+    return { value, cursor, pasteSnips, expandValue: (v = value) => expandPasteSnippets(v, pasteSnips), setValue: (v) => set(v), reset, handleKey };
 }

package/dist/ui/useGitBranch.js

@@ -0,0 +1,57 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { useEffect, useState } from 'react';
+const execFileP = promisify(execFile);
+const BRANCH_CACHE_MS = 15_000;
+const BRANCH_TIMEOUT_MS = 700;
+const cache = new Map();
+const inflight = new Map();
+export async function resolveGitBranch(cwd) {
+    try {
+        const { stdout } = await execFileP('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            timeout: BRANCH_TIMEOUT_MS,
+        });
+        const branch = stdout.trim();
+        return branch && branch !== 'HEAD' ? branch : null;
+    }
+    catch {
+        return null;
+    }
+}
+function loadCachedGitBranch(cwd) {
+    const active = inflight.get(cwd);
+    if (active)
+        return active;
+    const load = resolveGitBranch(cwd).finally(() => inflight.delete(cwd));
+    inflight.set(cwd, load);
+    return load;
+}
+export function useGitBranch(cwd) {
+    const [branch, setBranch] = useState(() => cache.get(cwd)?.branch ?? null);
+    useEffect(() => {
+        let cancelled = false;
+        const refresh = async () => {
+            const cached = cache.get(cwd);
+            if (cached && Date.now() - cached.at < BRANCH_CACHE_MS) {
+                if (!cancelled)
+                    setBranch(cached.branch);
+                return;
+            }
+            const branch = await loadCachedGitBranch(cwd);
+            cache.set(cwd, { at: Date.now(), branch });
+            if (!cancelled)
+                setBranch(branch);
+        };
+        void refresh();
+        const interval = setInterval(() => void refresh(), BRANCH_CACHE_MS);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [cwd]);
+    return branch;
+}
+export function clearGitBranchCacheForTests() {
+    cache.clear();
+    inflight.clear();
+}

package/dist/update.js

@@ -1,16 +1,45 @@
 import { spawn } from 'node:child_process';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
 export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const SEMVER_NUMERIC_IDENTIFIER = '(?:0|[1-9]\\d*)';
+const SEMVER_NON_NUMERIC_PRERELEASE_IDENTIFIER = '\\d*[A-Za-z-][0-9A-Za-z-]*';
+const SEMVER_PRERELEASE_IDENTIFIER = `(?:${SEMVER_NUMERIC_IDENTIFIER}|${SEMVER_NON_NUMERIC_PRERELEASE_IDENTIFIER})`;
+const NPM_VERSION_PATTERN = new RegExp(`^v?${SEMVER_NUMERIC_IDENTIFIER}\\.${SEMVER_NUMERIC_IDENTIFIER}\\.${SEMVER_NUMERIC_IDENTIFIER}` +
+    `(?:-${SEMVER_PRERELEASE_IDENTIFIER}(?:\\.${SEMVER_PRERELEASE_IDENTIFIER})*)?` +
+    `(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`);
+function isAbortError(err) {
+    return typeof err === 'object' && err !== null && 'name' in err && err.name === 'AbortError';
+}
+function readLatestDistTag(body) {
+    if (typeof body !== 'object' || body === null)
+        return undefined;
+    const distTags = body['dist-tags'];
+    if (typeof distTags !== 'object' || distTags === null)
+        return undefined;
+    return distTags.latest;
+}
 function packageUrl(registry, packageName) {
-    const base = registry.replace(/\/+$/, '') || DEFAULT_REGISTRY;
+    const base = registry.trim().replace(/\/+$/, '') || DEFAULT_REGISTRY;
     const encoded = encodeURIComponent(packageName).replace(/^%40/, '@');
     return `${base}/${encoded}`;
 }
+function normalizeNumericIdentifier(part) {
+    return /^\d+$/.test(part) ? part.replace(/^0+/, '') || '0' : undefined;
+}
+function compareNumericIdentifiers(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length !== b.length)
+        return a.length > b.length ? 1 : -1;
+    return a > b ? 1 : -1;
+}
 function splitVersion(version) {
     const [withoutBuild] = version.trim().replace(/^v/, '').split('+');
-    const [corePart, prereleasePart = ''] = withoutBuild.split('-', 2);
+    const prereleaseIndex = withoutBuild.indexOf('-');
+    const corePart = prereleaseIndex === -1 ? withoutBuild : withoutBuild.slice(0, prereleaseIndex);
+    const prereleasePart = prereleaseIndex === -1 ? '' : withoutBuild.slice(prereleaseIndex + 1);
     return {
-        core: corePart.split('.').map((part) => Number.parseInt(part, 10)).map((n) => (Number.isFinite(n) ? n : 0)),
+        core: corePart.split('.').map((part) => normalizeNumericIdentifier(part) ?? '0'),
         prerelease: prereleasePart ? prereleasePart.split('.') : [],
     };
 }
@@ -29,12 +58,13 @@ function comparePrerelease(a, b) {
             return -1;
         if (pb === undefined)
             return 1;
-        const na = /^\d+$/.test(pa) ? Number(pa) : Number.NaN;
-        const nb = /^\d+$/.test(pb) ? Number(pb) : Number.NaN;
-        if (Number.isFinite(na) && Number.isFinite(nb) && na !== nb)
-            return na > nb ? 1 : -1;
-        if (Number.isFinite(na) !== Number.isFinite(nb))
-            return Number.isFinite(na) ? -1 : 1;
+        const na = normalizeNumericIdentifier(pa);
+        const nb = normalizeNumericIdentifier(pb);
+        if (na !== undefined && nb !== undefined && na !== nb) {
+            return compareNumericIdentifiers(na, nb);
+        }
+        if ((na !== undefined) !== (nb !== undefined))
+            return na !== undefined ? -1 : 1;
         if (pa !== pb)
             return pa > pb ? 1 : -1;
     }
@@ -45,10 +75,10 @@ export function compareVersions(a, b) {
     const vb = splitVersion(b);
     const len = Math.max(va.core.length, vb.core.length, 3);
     for (let i = 0; i < len; i++) {
-        const na = va.core[i] ?? 0;
-        const nb = vb.core[i] ?? 0;
+        const na = va.core[i] ?? '0';
+        const nb = vb.core[i] ?? '0';
         if (na !== nb)
-            return na > nb ? 1 : -1;
+            return compareNumericIdentifiers(na, nb);
     }
     return comparePrerelease(va.prerelease, vb.prerelease);
 }
@@ -71,7 +101,8 @@ export function shouldCheckForUpdate(cache, nowMs = Date.now(), intervalMs = UPD
 export async function fetchLatestVersion(meta, opts = {}) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 8000);
+    const timeoutMs = opts.timeoutMs ?? 8000;
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
     try {
         const res = await fetchImpl(packageUrl(opts.registry ?? process.env.npm_config_registry ?? DEFAULT_REGISTRY, meta.name), {
             headers: { accept: 'application/vnd.npm.install-v1+json' },
@@ -80,11 +111,19 @@ export async function fetchLatestVersion(meta, opts = {}) {
         if (!res.ok) {
             throw new Error(`npm registry ตอบ ${res.status}${res.statusText ? ` ${res.statusText}` : ''}`);
         }
-        const body = (await res.json());
-        const latest = body['dist-tags']?.latest;
-        if (!latest)
+        const body = await res.json();
+        const latest = readLatestDistTag(body);
+        if (typeof latest !== 'string' || !latest.trim())
             throw new Error('npm registry ไม่มี dist-tag "latest"');
-        return latest;
+        const trimmedLatest = latest.trim();
+        if (!NPM_VERSION_PATTERN.test(trimmedLatest))
+            throw new Error('npm registry dist-tag "latest" ไม่ใช่ semver');
+        return trimmedLatest;
+    }
+    catch (err) {
+        if (ctrl.signal.aborted && isAbortError(err))
+            throw new Error(`npm registry timeout after ${timeoutMs}ms`);
+        throw err;
     }
     finally {
         clearTimeout(timer);