lark-remote 0.1.0

package/dist/card/run-state.d.ts

@@ -0,0 +1,103 @@
+import type { AgentEvent } from '../runner/index.js';
+export type RunTerminal = 'running' | 'finalizing' | 'done' | 'error' | 'interrupted' | 'idle_timeout';
+export type RunFooter = 'thinking' | 'tool_running' | 'streaming' | null;
+type ToolStatus = 'running' | 'ok' | 'error';
+export interface ToolEntry {
+    id: string;
+    name: string;
+    input: unknown;
+    /**
+     * P3-6: cached parse of `input` (the truncated string) into a record, so
+     * `tool-render.ts`'s `asRecord` does not re-`JSON.parse` on every render.
+     * Computed once at store time in `reduceAssistantEvent` from the SAME
+     * truncated string that the old per-render `asRecord` parsed — so a
+     * truncation-broken JSON still yields `null` here (preserving the "over-cap
+     * input renders no summary" behavior). `undefined` means "not computed"
+     * (ToolEntries built outside the reduce path fall back to parsing `input`).
+     */
+    parsedInput?: Record<string, unknown> | null;
+    output?: string;
+    status: ToolStatus;
+    startedAt?: string;
+    completedAt?: string;
+}
+export type RunBlock = {
+    kind: 'thinking';
+    content: string;
+    active: boolean;
+    timestamp?: string;
+} | {
+    kind: 'text';
+    content: string;
+    timestamp?: string;
+} | {
+    kind: 'tool';
+    tool: ToolEntry;
+} | {
+    kind: 'plan';
+    content: string;
+    active: boolean;
+    timestamp?: string;
+} | {
+    kind: 'file_change';
+    path: string;
+    operation: 'create' | 'edit' | 'delete' | 'read';
+    diff?: string;
+    timestamp?: string;
+};
+export interface RunState {
+    runId: string;
+    terminal: RunTerminal;
+    footer: RunFooter;
+    blocks: RunBlock[];
+    sessionId?: string;
+    resultSubtype?: 'success' | 'error';
+    contextLength?: number;
+    errorMsg?: string;
+    idleTimeoutMinutes?: number;
+    compactCount?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    /** Agent-declared total; the done card uses max(total, sum of parts). */
+    totalTokens?: number;
+    /** Real input tokens from the agent's result event (codex/opencode).
+     *  When present, the done card shows the real value instead of the
+     *  contextLength-based estimate. */
+    inputTokens?: number;
+    /** Real output tokens from the agent's result event. */
+    outputTokens?: number;
+    /** 会话累计 total/input/output（所有 run 之和），Run 卡片展示"累计"。 */
+    cumulativeTotalTokens?: number;
+    cumulativeInputTokens?: number;
+    cumulativeOutputTokens?: number;
+    /** 会话累计 cache read token（所有 run 之和）。 */
+    cumulativeCacheReadTokens?: number;
+    /** 会话累计 cache creation token（所有 run 之和）。 */
+    cumulativeCacheCreationTokens?: number;
+    plan?: string;
+}
+export interface FinishMeta {
+    resultSubtype?: 'success' | 'error';
+    contextLength?: number;
+    errorMsg?: string;
+    idleTimeoutMinutes?: number;
+    compactCount?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    /** Agent-declared total; threaded to RunState for the done card. */
+    totalTokens?: number;
+    /** Real input/output tokens from the agent's result event. Threaded through
+     *  to RunState so the done card can display real values instead of estimates. */
+    inputTokens?: number;
+    outputTokens?: number;
+    /** 会话累计 total/input/output（所有 run 之和），从 session jsonl 读取。 */
+    cumulativeTotalTokens?: number;
+    cumulativeInputTokens?: number;
+    cumulativeOutputTokens?: number;
+    cumulativeCacheReadTokens?: number;
+    cumulativeCacheCreationTokens?: number;
+}
+export declare function createInitialRunState(runId: string): RunState;
+export declare function reduceRunState(state: RunState, event: AgentEvent): RunState;
+export declare function finishRun(state: RunState, terminal: Exclude<RunTerminal, 'running' | 'finalizing'>, meta?: FinishMeta): RunState;
+export {};

package/dist/card/run-state.js

@@ -0,0 +1,313 @@
+const MAX_REASONING_CHARS = 4_000;
+const MAX_TEXT_CHARS = 12_000;
+const MAX_TOOL_DETAIL_CHARS = 3_000;
+const MAX_BLOCKS = 24;
+export function createInitialRunState(runId) {
+    return {
+        runId,
+        terminal: 'running',
+        footer: 'thinking',
+        blocks: [],
+    };
+}
+export function reduceRunState(state, event) {
+    // 只有终态才阻止事件处理。finalizing 是非终态，
+    // 仍需累积 assistant 内容（thinking、text、tool_use、后台任务输出）。
+    const terminal = state.terminal;
+    if (terminal === 'done' ||
+        terminal === 'error' ||
+        terminal === 'interrupted' ||
+        terminal === 'idle_timeout') {
+        return state;
+    }
+    if (event.type === 'system')
+        return reduceSystemEvent(state, event);
+    if (event.type === 'result')
+        return reduceResultEvent(state, event);
+    if (event.type === 'assistant')
+        return reduceAssistantEvent(state, event);
+    if (event.type === 'user')
+        return reduceToolResultEvent(state, event);
+    if (event.type === 'plan')
+        return reducePlanEvent(state, event);
+    if (event.type === 'file_change')
+        return reduceFileChangeEvent(state, event);
+    return state;
+}
+/** Handle system init and compact_boundary events. */
+function reduceSystemEvent(state, event) {
+    if (event.type !== 'system')
+        return state;
+    if (event.subtype === 'init') {
+        return { ...state, sessionId: event.session_id, footer: 'thinking' };
+    }
+    if (event.subtype === 'compact_boundary' && event.compactMetadata) {
+        return {
+            ...state,
+            contextLength: event.compactMetadata.postTokens,
+            compactCount: (state.compactCount ?? 0) + 1,
+        };
+    }
+    return state;
+}
+/** Handle result event - transition to finalizing (non-terminal).
+ *
+ *  进程退出是唯一终态触发源。result 事件只暂存 resultSubtype +
+ *  errorMsg（终态判定必需），不暂存 usage（由 bridge 局部变量捕获）。
+ *  合并语义：多个 result 事件（agent 自身 + SpawningRunner.buildResultEvent 合成）
+ *  - resultSubtype: error 优先（任一为 error 即 error）
+ *  - errorMsg: 首个非 undefined 胜出（agent 的更具体）
+ */
+function reduceResultEvent(state, event) {
+    if (event.type !== 'result')
+        return state;
+    const resultEvent = event;
+    const incomingSubtype = event.subtype;
+    const incomingErrorMsg = incomingSubtype === 'error' ? (resultEvent.errorMessage ?? 'Agent 返回错误结果') : undefined;
+    // 合并 subtype：error 优先（任一为 error 即 error）
+    const mergedSubtype = state.resultSubtype === 'error' || incomingSubtype === 'error' ? 'error' : 'success';
+    // 合并 errorMsg：首个非 undefined 胜出（existing ?? incoming）
+    const mergedErrorMsg = state.errorMsg ?? incomingErrorMsg;
+    return {
+        ...state,
+        terminal: 'finalizing',
+        footer: null,
+        blocks: markThinkingInactive(state.blocks),
+        resultSubtype: mergedSubtype,
+        errorMsg: mergedErrorMsg,
+    };
+}
+/** Handle assistant thinking/text/tool_use content blocks. */
+function reduceAssistantEvent(state, event) {
+    if (event.type !== 'assistant')
+        return state;
+    let next = state;
+    for (const content of event.message.content) {
+        if (content.type === 'thinking') {
+            const last = next.blocks[next.blocks.length - 1];
+            const newBlocks = last?.kind === 'thinking'
+                ? [
+                    ...next.blocks.slice(0, -1),
+                    {
+                        kind: 'thinking',
+                        content: keepLatest(last.content + '\n' + content.thinking, MAX_REASONING_CHARS),
+                        active: true,
+                        timestamp: last.timestamp ?? event.timestamp,
+                    },
+                ]
+                : [
+                    ...next.blocks,
+                    {
+                        kind: 'thinking',
+                        content: keepLatest(content.thinking, MAX_REASONING_CHARS),
+                        active: true,
+                        timestamp: event.timestamp,
+                    },
+                ];
+            next = {
+                ...next,
+                blocks: keepLatestBlocks(newBlocks),
+                footer: 'thinking',
+            };
+        }
+        else if (content.type === 'text') {
+            const blocks = markThinkingInactive(next.blocks);
+            const last = blocks[blocks.length - 1];
+            const newBlocks = last?.kind === 'text'
+                ? [
+                    ...blocks.slice(0, -1),
+                    {
+                        kind: 'text',
+                        content: keepLatest(last.content + content.text, MAX_TEXT_CHARS),
+                        timestamp: last.timestamp ?? event.timestamp,
+                    },
+                ]
+                : [
+                    ...blocks,
+                    {
+                        kind: 'text',
+                        content: keepLatest(content.text, MAX_TEXT_CHARS),
+                        timestamp: event.timestamp,
+                    },
+                ];
+            next = {
+                ...next,
+                blocks: keepLatestBlocks(newBlocks),
+                footer: 'streaming',
+            };
+        }
+        else {
+            // P3-6: parse the truncated stored string ONCE here (not on every render)
+            // and cache the result on `parsedInput`. tool-render's asRecord then hits
+            // the object branch with zero parsing. The parse uses the SAME truncated
+            // string as the old per-render parse, so truncation-broken JSON still
+            // yields null (over-cap input renders no summary — behavior preserved).
+            const inputStr = truncateDetail(stringifyUnknown(content.input));
+            next = {
+                ...next,
+                blocks: keepLatestBlocks([
+                    ...markThinkingInactive(next.blocks),
+                    {
+                        kind: 'tool',
+                        tool: {
+                            id: content.id,
+                            name: content.name,
+                            input: inputStr,
+                            parsedInput: tryParseRecord(inputStr),
+                            status: 'running',
+                            startedAt: event.timestamp,
+                        },
+                    },
+                ]),
+                footer: 'tool_running',
+            };
+        }
+    }
+    return next;
+}
+/** Handle tool_result content blocks (user message with tool results).
+ *  P3-4: rebuild ONLY the block matching `tool_use_id`, copying every other
+ *  block by reference. The old `.map()` recreated all block objects per
+ *  tool_result (O(N) allocations on the run-card hot path). Footer still
+ *  advances to 'streaming' on every content block (parity with old behavior);
+ *  only the blocks array is preserved by reference when nothing matches. */
+function reduceToolResultEvent(state, event) {
+    if (event.type !== 'user')
+        return state;
+    let next = state;
+    for (const content of event.message.content) {
+        const targetId = content.tool_use_id;
+        const matchIndex = next.blocks.findIndex((block) => block.kind === 'tool' && block.tool.id === targetId);
+        if (matchIndex === -1) {
+            if (next.footer !== 'streaming')
+                next = { ...next, footer: 'streaming' };
+            continue;
+        }
+        const matched = next.blocks[matchIndex];
+        const updated = {
+            kind: 'tool',
+            tool: {
+                ...matched.tool,
+                output: truncateDetail(stringifyUnknown(content.content)),
+                status: content.is_error ? 'error' : 'ok',
+                completedAt: event.timestamp,
+            },
+        };
+        const blocks = next.blocks.slice();
+        blocks[matchIndex] = updated;
+        next = { ...next, blocks, footer: 'streaming' };
+    }
+    return next;
+}
+/** Handle plan event — accumulate plan text for Codex-style agents. */
+function reducePlanEvent(state, event) {
+    if (event.type !== 'plan')
+        return state;
+    const currentPlan = state.plan ?? '';
+    const newPlan = keepLatest(currentPlan + '\n' + event.plan, MAX_REASONING_CHARS * 2);
+    // Plan is a single evolving document — replace the existing plan block
+    // instead of appending a new one (avoids N overlapping blocks after N events).
+    const withoutOldPlan = state.blocks.filter((b) => b.kind !== 'plan');
+    const newBlocks = [
+        ...withoutOldPlan,
+        { kind: 'plan', content: newPlan, active: true, timestamp: event.timestamp },
+    ];
+    return {
+        ...state,
+        plan: newPlan,
+        blocks: keepLatestBlocks(newBlocks),
+    };
+}
+/** Handle file_change event — emit a file_change block for rendering (Codex-style agents). */
+function reduceFileChangeEvent(state, event) {
+    if (event.type !== 'file_change')
+        return state;
+    // Add file_change block for rendering (collapsed by default)
+    const newBlocks = [
+        ...state.blocks,
+        {
+            kind: 'file_change',
+            path: event.path,
+            operation: event.operation,
+            diff: event.diff,
+            timestamp: event.timestamp,
+        },
+    ];
+    return {
+        ...state,
+        blocks: keepLatestBlocks(newBlocks),
+    };
+}
+export function finishRun(state, terminal, meta = {}) {
+    // 允许从 running 或 finalizing finish（/stop、idle watchdog、进程退出 finally）。
+    // finalizing 是非终态（result 已收到，进程未退出），可被 finish 转终态。
+    // 如果已经是终态，仍然允许补充 meta 信息（如 usage 等，bridge finally 的
+    // else-if-sawResult 分支用此路径补充 token 统计）。
+    if (state.terminal !== 'running' && state.terminal !== 'finalizing') {
+        // Already terminal: apply meta fields if provided (e.g. usage from jsonl)
+        const hasMeta = Object.keys(meta).some((k) => meta[k] !== undefined);
+        if (!hasMeta)
+            return state;
+        return { ...state, ...sanitizeMeta(meta) };
+    }
+    return {
+        ...state,
+        terminal,
+        footer: null,
+        blocks: markThinkingInactive(state.blocks),
+        ...sanitizeMeta(meta),
+    };
+}
+/** Remove undefined/null meta fields to avoid overwriting existing state with nullish values. */
+function sanitizeMeta(meta) {
+    const result = {};
+    for (const [k, v] of Object.entries(meta)) {
+        if (v !== undefined && v !== null)
+            result[k] = v;
+    }
+    return result;
+}
+/** Mark all thinking blocks in the array as inactive. */
+function markThinkingInactive(blocks) {
+    return blocks.map((b) => (b.kind === 'thinking' && b.active ? { ...b, active: false } : b));
+}
+function stringifyUnknown(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/**
+ * P3-6: parse a (possibly truncated) string into a record, mirroring what
+ * `tool-render.ts`'s `asRecord` did on every render. Returns `null` when the
+ * string is empty, non-JSON, or parses to a non-object — so a truncation-broken
+ * JSON yields `null` exactly as the old per-render parse did. Computed once at
+ * store time and cached on `ToolEntry.parsedInput`.
+ */
+function tryParseRecord(input) {
+    if (!input)
+        return null;
+    try {
+        const p = JSON.parse(input);
+        return p && typeof p === 'object' ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+function keepLatest(value, maxChars) {
+    return value.length <= maxChars ? value : value.slice(-maxChars);
+}
+function keepLatestBlocks(blocks) {
+    return blocks.length <= MAX_BLOCKS ? blocks : blocks.slice(-MAX_BLOCKS);
+}
+function truncateDetail(value) {
+    return value.length <= MAX_TOOL_DETAIL_CHARS
+        ? value
+        : `${value.slice(0, MAX_TOOL_DETAIL_CHARS)}…（已截断）`;
+}
+//# sourceMappingURL=run-state.js.map

package/dist/card/text-truncate.d.ts

@@ -0,0 +1,56 @@
+/**
+ * UTF-8 byte-safe text truncation primitives.
+ *
+ * Shared by the live run renderer (`run-renderer.ts`), the static card budget
+ * enforcer (`card-budget.ts`), and the opencode session reader
+ * (`src/session/opencode/sessions.ts`) so that huge tool outputs are folded at a single
+ * place instead of being reimplemented per consumer.
+ *
+ * Why byte-safe: Feishu card size limits are measured in UTF-8 bytes, and a
+ * naive `str.slice(0, n)` can split a multi-byte CJK/emoji codepoint, yielding
+ * invalid UTF-8. `fitUtf8` iterates by Unicode codepoint (via `Array.from` /
+ * `for...of`) so it never breaks a surrogate pair or a multi-byte sequence.
+ */
+/** Feishu 11310 limit: max markdown tables per card. */
+export declare const FEISHU_MAX_TABLES = 5;
+/** Default truncation suffix, shared across all consumers for UX consistency. */
+export declare const DEFAULT_TRUNCATE_SUFFIX = "\u2026\uFF08\u5DF2\u622A\u65AD\uFF09";
+/**
+ * Max byte budget for a single session `tool_result` event's content when
+ * replaying an opencode session (L2 pre-fold). The static card budget enforcer
+ * (`enforceCardBudget`, maxPanelContentBytes = 2000) would truncate it again at
+ * render time anyway; pre-folding here bounds the in-memory `events[]` array
+ * and the intermediate card JSON so a single pathological tool_result (e.g. a
+ * 500KB file listing) never inflates the replay payload to megabytes.
+ */
+export declare const TOOL_RESULT_MAX_BYTES = 4000;
+/**
+ * Truncate a UTF-8 string to fit within `maxBytes`, appending `suffix`
+ * (default `…（已截断）`) when truncation occurs. When `fromEnd` is true, keeps
+ * the tail and prepends the suffix (useful for "show the most recent N bytes").
+ */
+export declare function truncateUtf8(value: string, maxBytes: number, fromEnd?: boolean, suffix?: string): string;
+/**
+ * Count the number of markdown tables in a string.
+ *
+ * A markdown table is identified by a separator line matching `/^\|[-: |]+\$/m`
+ * (i.e. a line that starts with `|` and contains only `|`, `-`, `:`, spaces).
+ * Each separator line corresponds to exactly one table.
+ */
+export declare function countMarkdownTables(text: string): number;
+/**
+ * Truncate markdown tables in a string to at most `maxTables`, keeping the
+ * **newest** (last) tables and removing the oldest ones.
+ *
+ * Strategy: find all table separator lines, determine which tables to remove
+ * (those whose separator is among the oldest `count - maxTables`), then remove
+ * each such table entirely (header row + separator row + data rows).
+ *
+ * A "table block" is a contiguous run of lines where the first line is the
+ * header row, the second is the separator row (`|---|`), and subsequent lines
+ * are data rows. We remove entire table blocks from the text.
+ *
+ * When tables are removed, a hint is inserted at the removal point indicating
+ * how many earlier tables were omitted.
+ */
+export declare function truncateMarkdownTables(text: string, maxTables?: number): string;

package/dist/card/text-truncate.js

@@ -0,0 +1,184 @@
+/**
+ * UTF-8 byte-safe text truncation primitives.
+ *
+ * Shared by the live run renderer (`run-renderer.ts`), the static card budget
+ * enforcer (`card-budget.ts`), and the opencode session reader
+ * (`src/session/opencode/sessions.ts`) so that huge tool outputs are folded at a single
+ * place instead of being reimplemented per consumer.
+ *
+ * Why byte-safe: Feishu card size limits are measured in UTF-8 bytes, and a
+ * naive `str.slice(0, n)` can split a multi-byte CJK/emoji codepoint, yielding
+ * invalid UTF-8. `fitUtf8` iterates by Unicode codepoint (via `Array.from` /
+ * `for...of`) so it never breaks a surrogate pair or a multi-byte sequence.
+ */
+/** Feishu 11310 limit: max markdown tables per card. */
+export const FEISHU_MAX_TABLES = 5;
+/** Default truncation suffix, shared across all consumers for UX consistency. */
+export const DEFAULT_TRUNCATE_SUFFIX = '…（已截断）';
+/**
+ * Max byte budget for a single session `tool_result` event's content when
+ * replaying an opencode session (L2 pre-fold). The static card budget enforcer
+ * (`enforceCardBudget`, maxPanelContentBytes = 2000) would truncate it again at
+ * render time anyway; pre-folding here bounds the in-memory `events[]` array
+ * and the intermediate card JSON so a single pathological tool_result (e.g. a
+ * 500KB file listing) never inflates the replay payload to megabytes.
+ */
+export const TOOL_RESULT_MAX_BYTES = 4000;
+/**
+ * Fit a UTF-8 string into `maxBytes` by iterating Unicode codepoints, never
+ * splitting a multi-byte sequence. When `fromEnd` is true, keeps the TAIL
+ * (useful for logs/tails); otherwise keeps the HEAD.
+ *
+ * P1-2 (2026-08-02): 单遍累计单字符字节数，替代逐字符 `Buffer.byteLength(result +
+ * char)` + `result += char`（后者每轮新建并扫描不断增长的字符串，O(budget²)）。
+ * 字节长度对拼接可加（byteLength(a+b) = byteLength(a) + byteLength(b)），故累计
+ * 与旧实现的逐字符判断逐字节等价；最后一次 slice/join 物化结果。混合 CJK/emoji
+ * 样本实测 ~150× 提速（33.7ms/次 → 0.2ms/次，见 tests/anchor/priority/p0-fit-utf8.test.ts）。
+ */
+function fitUtf8(value, maxBytes, fromEnd = false) {
+    if (fromEnd) {
+        // tail 分支：需要从末尾找截断起点，Array.from 一次物化（旧实现同样 Array.from().reverse()，
+        // 无内存回归）；数组仅用于定位，之后 slice+join。
+        const codepoints = Array.from(value);
+        let bytes = 0;
+        let start = codepoints.length;
+        for (let i = codepoints.length - 1; i >= 0; i--) {
+            const cb = Buffer.byteLength(codepoints[i], 'utf8');
+            if (bytes + cb > maxBytes)
+                break;
+            bytes += cb;
+            start = i;
+        }
+        return codepoints.slice(start).join('');
+    }
+    // head 分支：惰性 for-of 迭代 + 字符串索引累计（旧实现同 O(1) 内存）。
+    // 不物化数组——opencode-sessions 会对 MB 级 tool_result 做 head 截断，
+    // Array.from 全量分配会引入不必要的瞬态内存。
+    let bytes = 0;
+    let end = 0;
+    for (const char of value) {
+        const cb = Buffer.byteLength(char, 'utf8');
+        if (bytes + cb > maxBytes)
+            break;
+        bytes += cb;
+        end += char.length; // for-of 产出完整码点；char.length 为 1 或 2（代理对），
+        // end 落在码点边界上，value.slice(0, end) 不会切分代理对
+    }
+    return value.slice(0, end);
+}
+/**
+ * Truncate a UTF-8 string to fit within `maxBytes`, appending `suffix`
+ * (default `…（已截断）`) when truncation occurs. When `fromEnd` is true, keeps
+ * the tail and prepends the suffix (useful for "show the most recent N bytes").
+ */
+export function truncateUtf8(value, maxBytes, fromEnd = false, suffix = DEFAULT_TRUNCATE_SUFFIX) {
+    if (Buffer.byteLength(value, 'utf8') <= maxBytes)
+        return value;
+    const suffixBytes = Buffer.byteLength(suffix, 'utf8');
+    const budget = maxBytes - suffixBytes;
+    if (budget <= 0)
+        return suffix;
+    const truncated = fitUtf8(value, budget, fromEnd);
+    return fromEnd ? `${suffix}\n${truncated}` : `${truncated}${suffix}`;
+}
+/**
+ * Count the number of markdown tables in a string.
+ *
+ * A markdown table is identified by a separator line matching `/^\|[-: |]+\$/m`
+ * (i.e. a line that starts with `|` and contains only `|`, `-`, `:`, spaces).
+ * Each separator line corresponds to exactly one table.
+ */
+export function countMarkdownTables(text) {
+    let count = 0;
+    for (const line of text.split('\n')) {
+        if (/^\|[-: |]+$/.test(line.trim())) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Truncate markdown tables in a string to at most `maxTables`, keeping the
+ * **newest** (last) tables and removing the oldest ones.
+ *
+ * Strategy: find all table separator lines, determine which tables to remove
+ * (those whose separator is among the oldest `count - maxTables`), then remove
+ * each such table entirely (header row + separator row + data rows).
+ *
+ * A "table block" is a contiguous run of lines where the first line is the
+ * header row, the second is the separator row (`|---|`), and subsequent lines
+ * are data rows. We remove entire table blocks from the text.
+ *
+ * When tables are removed, a hint is inserted at the removal point indicating
+ * how many earlier tables were omitted.
+ */
+export function truncateMarkdownTables(text, maxTables = FEISHU_MAX_TABLES) {
+    if (maxTables <= 0)
+        return text;
+    const tableCount = countMarkdownTables(text);
+    if (tableCount <= maxTables)
+        return text;
+    const lines = text.split('\n');
+    // Step 1: Find all table separator line indices
+    const separatorIndices = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (/^\|[-: |]+$/.test(lines[i].trim())) {
+            separatorIndices.push(i);
+        }
+    }
+    const blocks = [];
+    for (const sepIdx of separatorIndices) {
+        // Header is the line just before the separator
+        let start = sepIdx - 1;
+        if (start < 0)
+            continue; // malformed table, skip
+        // Expand start upward to include preceding heading (### ...) and blank lines
+        // that belong to this table block. Stop at the first non-blank, non-heading line
+        // or at the start of the text.
+        while (start > 0) {
+            const prevLine = lines[start - 1].trim();
+            if (prevLine === '' || /^#{1,6}\s/.test(prevLine)) {
+                start--;
+            }
+            else {
+                break;
+            }
+        }
+        // Data rows: lines after separator that start with '|'
+        let end = sepIdx + 1;
+        while (end < lines.length && /^\|/.test(lines[end].trim())) {
+            end++;
+        }
+        blocks.push({ start, end, separatorIdx: sepIdx });
+    }
+    // Step 3: Determine which blocks to remove (oldest first)
+    const toRemoveCount = blocks.length - maxTables;
+    // blocks are in document order (oldest first), so remove from the front
+    const blocksToRemove = new Set(blocks.slice(0, toRemoveCount));
+    // Map: start line index → block (for lookup when processing lines)
+    const blockByStart = new Map();
+    for (const b of blocks) {
+        blockByStart.set(b.start, b);
+    }
+    // Step 4: Rebuild the text, skipping removed table blocks and inserting hints
+    const result = [];
+    let i = 0;
+    let removedSoFar = 0;
+    while (i < lines.length) {
+        const block = blockByStart.get(i);
+        if (block && blocksToRemove.has(block)) {
+            // Skip the entire table block
+            removedSoFar++;
+            i = block.end;
+            // Insert hint at the removal point
+            if (removedSoFar === toRemoveCount) {
+                result.push(`_💡 前 ${toRemoveCount} 个表格已省略_`);
+            }
+            continue;
+        }
+        result.push(lines[i]);
+        i++;
+    }
+    return result.join('\n');
+}
+//# sourceMappingURL=text-truncate.js.map

package/dist/card/time.d.ts

@@ -0,0 +1 @@
+export declare function formatTimestamp(ts: string | number | undefined): string;

package/dist/card/time.js

@@ -0,0 +1,14 @@
+export function formatTimestamp(ts) {
+    if (!ts)
+        return '';
+    const d = new Date(ts);
+    if (isNaN(d.getTime()))
+        return '';
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mi = String(d.getMinutes()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd} ${hh}:${mi}`;
+}
+//# sourceMappingURL=time.js.map