sanook-cli 0.5.2 → 0.5.7

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,8 +1,25 @@
 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}`;
 }
@@ -84,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' },
@@ -93,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);

package/dist/usage-cli.js

@@ -0,0 +1,160 @@
+import { BRAND } from './brand.js';
+import { takeValue } from './cli-option-values.js';
+import { aggregateUsageEvents, loadUsageEvents, usageEventsPath } from './usage-ledger.js';
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function shiftDays(days) {
+    const d = new Date();
+    d.setDate(d.getDate() - days);
+    return d.toISOString().slice(0, 10);
+}
+export function parseUsageArgs(args) {
+    if (args.includes('-h') || args.includes('--help'))
+        return null;
+    let mode = 'daily';
+    let since;
+    let until;
+    let days = 30;
+    let json = false;
+    let noColor = false;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--json')
+            json = true;
+        else if (arg === '--no-color')
+            noColor = true;
+        else if (arg === '--since') {
+            const picked = takeValue(args, i);
+            if (!picked.value || !DATE_RE.test(picked.value))
+                return null;
+            since = picked.value;
+            i = picked.nextIndex;
+        }
+        else if (arg.startsWith('--since=')) {
+            since = arg.slice('--since='.length);
+            if (!DATE_RE.test(since))
+                return null;
+        }
+        else if (arg === '--until') {
+            const picked = takeValue(args, i);
+            if (!picked.value || !DATE_RE.test(picked.value))
+                return null;
+            until = picked.value;
+            i = picked.nextIndex;
+        }
+        else if (arg.startsWith('--until=')) {
+            until = arg.slice('--until='.length);
+            if (!DATE_RE.test(until))
+                return null;
+        }
+        else if (arg === '--days') {
+            const picked = takeValue(args, i);
+            const n = Number(picked.value);
+            if (!Number.isInteger(n) || n <= 0)
+                return null;
+            days = n;
+            i = picked.nextIndex;
+        }
+        else if (arg.startsWith('--days=')) {
+            const n = Number(arg.slice('--days='.length));
+            if (!Number.isInteger(n) || n <= 0)
+                return null;
+            days = n;
+        }
+        else if (!arg.startsWith('-'))
+            positional.push(arg);
+        else
+            return null;
+    }
+    if (positional[0]) {
+        if (!['daily', 'weekly', 'monthly', 'session'].includes(positional[0]))
+            return null;
+        mode = positional[0];
+    }
+    if (!since)
+        since = shiftDays(days - 1);
+    if (!until)
+        until = new Date().toISOString().slice(0, 10);
+    return { mode, since, until, days, json, noColor };
+}
+function fmt(n) {
+    return n.toLocaleString('en-US');
+}
+function fmtCost(n) {
+    return n > 0 ? `$${n.toFixed(2)}` : '$0.00';
+}
+function renderTable(title, rows, wide) {
+    if (!rows.length) {
+        return [
+            `╭${'─'.repeat(Math.max(42, title.length + 4))}╮`,
+            `│ ${title.padEnd(Math.max(40, title.length + 2))} │`,
+            `╰${'─'.repeat(Math.max(42, title.length + 4))}╯`,
+            '',
+            `(no usage recorded — run ${BRAND.cliName} and complete a turn first)`,
+            `ledger: ${usageEventsPath()}`,
+        ].join('\n');
+    }
+    const lines = [];
+    lines.push(`╭${'─'.repeat(title.length + 4)}╮`);
+    lines.push(`│ ${title} │`);
+    lines.push(`╰${'─'.repeat(title.length + 4)}╯`);
+    lines.push('');
+    if (wide) {
+        lines.push('┌────────────┬─────────┬──────────────────┬─────────┬─────────┬────────────┬────────────┐');
+        lines.push('│ Period     │ Turns   │ Models           │ Input   │ Output  │ Cache R/W  │ Cost (USD) │');
+        lines.push('├────────────┼─────────┼──────────────────┼─────────┼─────────┼────────────┼────────────┤');
+        for (const row of rows) {
+            const models = row.models.join(' ').slice(0, 16).padEnd(16);
+            const cache = `${fmt(row.cacheReadTokens)}/${fmt(row.cacheWriteTokens)}`.padStart(10);
+            lines.push(`│ ${row.label.padEnd(10)} │ ${String(row.turns).padStart(7)} │ ${models} │ ${fmt(row.inputTokens).padStart(7)} │ ${fmt(row.outputTokens).padStart(7)} │ ${cache} │ ${fmtCost(row.costUsd).padStart(10)} │`);
+        }
+        lines.push('└────────────┴─────────┴──────────────────┴─────────┴─────────┴────────────┴────────────┘');
+    }
+    else {
+        lines.push('┌────────────┬──────────────────┬─────────┬─────────┬────────────┐');
+        lines.push('│ Period     │ Models           │ Input   │ Output  │ Cost (USD) │');
+        lines.push('├────────────┼──────────────────┼─────────┼─────────┼────────────┤');
+        for (const row of rows) {
+            const models = row.models.join(' ').slice(0, 16).padEnd(16);
+            lines.push(`│ ${row.label.padEnd(10)} │ ${models} │ ${fmt(row.inputTokens).padStart(7)} │ ${fmt(row.outputTokens).padStart(7)} │ ${fmtCost(row.costUsd).padStart(10)} │`);
+        }
+        lines.push('└────────────┴──────────────────┴─────────┴─────────┴────────────┘');
+    }
+    const totalCost = rows.reduce((sum, row) => sum + row.costUsd, 0);
+    const totalTokens = rows.reduce((sum, row) => sum + row.totalTokens, 0);
+    lines.push('');
+    lines.push(`totals: ${fmt(totalTokens)} tokens · ${fmtCost(totalCost)} estimated · ledger: ${usageEventsPath()}`);
+    return lines.join('\n');
+}
+export async function renderUsageReport(options) {
+    const events = await loadUsageEvents({ since: options.since, until: options.until });
+    const rows = aggregateUsageEvents(events, options.mode);
+    if (options.json) {
+        return JSON.stringify({
+            agent: BRAND.cliName,
+            mode: options.mode,
+            since: options.since,
+            until: options.until,
+            events: events.length,
+            rows,
+            ledger: usageEventsPath(),
+        }, null, 2);
+    }
+    const title = options.mode === 'daily'
+        ? `${BRAND.productName} Usage Report — Daily`
+        : options.mode === 'weekly'
+            ? `${BRAND.productName} Usage Report — Weekly`
+            : options.mode === 'monthly'
+                ? `${BRAND.productName} Usage Report — Monthly`
+                : `${BRAND.productName} Usage Report — Sessions`;
+    const wide = (process.stdout.columns ?? 100) >= 100;
+    return renderTable(title, rows, wide);
+}
+export function usageHelpText() {
+    return [
+        `ใช้: ${BRAND.cliName} usage [daily|weekly|monthly|session] [--days N] [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--json]`,
+        '',
+        'บันทึก token/cost ทุก agent turn ลง ~/.sanook/usage/events.jsonl (ccusage-style local ledger).',
+        'ปิดได้ด้วย SANOOK_DISABLE_USAGE=1',
+    ].join('\n');
+}