dsh-codinput 0.1.0

package/src/client/sideinput.ts

@@ -0,0 +1,171 @@
+/**
+ * 侧栏输入承载总线：侧栏 Codinput 标签 body **挂载**即声明「本会话的输入由
+ * 侧栏承载」（侧栏形态 = 三态里的 `side`），主输入遮蔽条目（conversation.
+ * composer.bar）据此渲染 null，保证屏幕上只有一个输入组件。
+ *
+ * 关键：可见性不再参与承载判定。侧栏收起是 CSS 隐藏（body 仍挂载），若按
+ * 可见性让位，收起侧栏会唤回普通模式/官方输入框——产品上不允许（收起只
+ * 是「输入入口被收进侧栏且不可见」，入口仍是侧栏那一个，经右上角小球唤出）。
+ * `visible` 与 `expanded` 仍逐拍上报，供小球判断「侧栏已收起」用。
+ *
+ * 总线是纯模块态：侧栏与主输入分属两棵 React 树，唯一的通信面就是这里。
+ */
+
+import { useEffect, useState } from 'react';
+
+export interface SidebarCarryState {
+  /** 官方可见判定（useTabInfo().tab.visible）：展开且为激活标签，或浮动面板。 */
+  visible: boolean;
+  /** 右侧栏是否展开（useTabInfo().sidebar.expanded）。 */
+  expanded: boolean;
+}
+
+export interface SidebarCarry {
+  /** 本次承载的令牌（同会话多 body 时，最早的持令牌者渲染编辑面）。 */
+  readonly token: number;
+  /** 可见性/展开态变化时更新（同一 body 生命周期内）。 */
+  set(state: SidebarCarryState): void;
+  /** body 卸载时释放。 */
+  release(): void;
+}
+
+const claims = new Map<number, SidebarCarryState & { sessionId: string }>();
+const listeners = new Set<() => void>();
+let nextToken = 1;
+/** 快照：被侧栏承载的会话（挂载即承载）→ 可见性/展开态 + 编辑面持有者令牌。 */
+let snapshot: ReadonlyMap<string, SidebarCarryState & { owner: number }> = new Map();
+
+function sameState(a: SidebarCarryState, b: SidebarCarryState): boolean {
+  return a.visible === b.visible && a.expanded === b.expanded;
+}
+
+function sameSnapshot(next: Map<string, SidebarCarryState & { owner: number }>): boolean {
+  if (next.size !== snapshot.size) return false;
+  for (const [id, state] of next) {
+    const prev = snapshot.get(id);
+    if (!prev || !sameState(prev, state) || prev.owner !== state.owner) return false;
+  }
+  return true;
+}
+
+function recompute(): void {
+  const next = new Map<string, SidebarCarryState & { owner: number }>();
+  for (const [token, claim] of claims) {
+    const prev = next.get(claim.sessionId);
+    // 同一会话多 body（分栏里复制出第二个 Codinput 标签）时取「最可见」的一份，
+    // 编辑面归属最早声明者（owner），其余 body 只出提示，杜绝双编辑面。
+    if (!prev) {
+      next.set(claim.sessionId, { visible: claim.visible, expanded: claim.expanded, owner: token });
+    } else if (!prev.visible && claim.visible) {
+      next.set(claim.sessionId, { ...prev, visible: true, expanded: claim.expanded });
+    }
+  }
+  if (sameSnapshot(next)) return;
+  snapshot = next;
+  for (const fn of listeners) fn();
+}
+
+/** 侧栏 body 声明承载本会话输入；返回句柄，卸载时 release。 */
+export function claimSidebarInput(sessionId: string, state: SidebarCarryState): SidebarCarry {
+  const token = nextToken++;
+  claims.set(token, { sessionId, ...state });
+  recompute();
+  let released = false;
+  return {
+    token,
+    set(next: SidebarCarryState): void {
+      const claim = claims.get(token);
+      if (claim && !sameState(claim, next)) {
+        claims.set(token, { sessionId: claim.sessionId, ...next });
+        recompute();
+      }
+    },
+    release(): void {
+      if (released) return;
+      released = true;
+      if (claims.delete(token)) recompute();
+    },
+  };
+}
+
+/** 本会话的输入是否由侧栏承载（主输入应渲染 null；即形态 = side）。 */
+export function isSidebarInputCarried(sessionId: string | undefined): boolean {
+  return sessionId !== undefined && snapshot.has(sessionId);
+}
+
+/** 任一会话被侧栏承载（主遮蔽条目需保持挂载以执行隐藏）。 */
+export function isAnySidebarInputCarried(): boolean {
+  return snapshot.size > 0;
+}
+
+/** 本会话的侧栏承载态快照（未承载时 undefined）。 */
+export function sidebarCarryState(sessionId: string | undefined): SidebarCarryState | undefined {
+  return sessionId === undefined ? undefined : snapshot.get(sessionId);
+}
+
+/**
+ * 编辑面归属：同会话被多个 body 承载（分栏里复制出第二个 Codinput 标签）时，
+ * 只有最早声明者渲染编辑面。`token === 0`（尚未声明）一律返回 true——避免
+ * 首帧把还没拿到令牌的自己判成非归属者。
+ */
+export function isSidebarCarryOwner(sessionId: string | undefined, token: number): boolean {
+  if (token === 0 || sessionId === undefined) return true;
+  return snapshot.get(sessionId)?.owner === token;
+}
+
+/** 归属订阅（body 用）：令牌变化、其他 body 挂载/卸载都会重渲染。 */
+export function useSidebarCarryOwner(sessionId: string | undefined, token: number): boolean {
+  const [owner, setOwner] = useState(() => isSidebarCarryOwner(sessionId, token));
+  useEffect(() => {
+    const sync = (): void => {
+      const now = isSidebarCarryOwner(sessionId, token);
+      setOwner((prev) => (prev === now ? prev : now));
+    };
+    sync();
+    return subscribeSidebarInput(sync);
+  }, [sessionId, token]);
+  return owner;
+}
+
+export function subscribeSidebarInput(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}
+
+/** 主输入组件订阅：本会话输入是否已由侧栏承载。 */
+export function useSidebarInputCarried(sessionId: string | undefined): boolean {
+  const [carried, setCarried] = useState(() => isSidebarInputCarried(sessionId));
+  useEffect(() => {
+    const sync = (): void => {
+      const now = isSidebarInputCarried(sessionId);
+      setCarried((prev) => (prev === now ? prev : now));
+    };
+    sync();
+    return subscribeSidebarInput(sync);
+  }, [sessionId]);
+  return carried;
+}
+
+/**
+ * 侧栏承载态订阅（小球用）：`carried` = 本会话输入在侧栏里，
+ * `collapsed` = 侧栏已收起（承载但不可见 → 输入入口需要小球唤出）。
+ */
+export function useSidebarCarry(sessionId: string | undefined): { carried: boolean; collapsed: boolean } {
+  const read = (): { carried: boolean; collapsed: boolean } => {
+    const state = sidebarCarryState(sessionId);
+    return { carried: state !== undefined, collapsed: state !== undefined && state.expanded === false };
+  };
+  const [value, setValue] = useState(read);
+  useEffect(() => {
+    const sync = (): void => {
+      const next = read();
+      setValue((prev) => (prev.carried === next.carried && prev.collapsed === next.collapsed ? prev : next));
+    };
+    sync();
+    return subscribeSidebarInput(sync);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId]);
+  return value;
+}

package/src/client/stats.ts

@@ -0,0 +1,166 @@
+/**
+ * 数据行数据源（卡片下方）：会话统计投影探测 + 归一化。
+ * 官方投影键（实测确认）：tokenUsage（cacheRead/cacheWrite/output/
+ * uncachedInput）、contextPressure（contextWindow/pressureTokens/
+ * projectedTokens）；轮/步按别名键探测。tok/s 为输出令牌的实时采样速率。
+ * 注意：useProjection 是真实 hook，键探测必须是固定次数的顶层调用。
+ */
+
+import type { UseProjection } from './host-types';
+
+const PROJECTION_KEYS = [
+  'tokenUsage',
+  'contextPressure',
+  'sessionUsage',
+  'usage',
+  'sessionStats',
+] as const;
+
+export interface SessionStats {
+  turns?: number;
+  steps?: number;
+  /** 实时输出速率（tok/s），运行期间采样更新，空闲时保留最后一次。 */
+  tokensPerSecond?: number;
+  totalTokens?: number;
+  cacheHitPct?: number;
+  /** 上下文占用百分比（pressureTokens / contextWindow）。 */
+  contextPct?: number;
+  /** 会话统计面板：模型用时（流式活跃累计毫秒）与首 token 延迟。 */
+  modelMs?: number;
+  ttftMs?: number;
+  /** Token 用量面板：原始分段。 */
+  uncachedInputTokens?: number;
+  cacheReadTokens?: number;
+  outputTokens?: number;
+}
+
+interface TokenUsage {
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  outputTokens?: number;
+  uncachedInputTokens?: number;
+}
+
+interface ContextPressure {
+  contextWindow?: number;
+  pressureTokens?: number;
+  projectedTokens?: number;
+}
+
+function num(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function readTokenUsage(raw: unknown): TokenUsage | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const r = raw as Record<string, unknown>;
+  const usage: TokenUsage = {
+    cacheReadTokens: num(r['cacheReadTokens']),
+    cacheWriteTokens: num(r['cacheWriteTokens']),
+    outputTokens: num(r['outputTokens']),
+    uncachedInputTokens: num(r['uncachedInputTokens']),
+  };
+  return Object.values(usage).some((v) => v !== undefined) ? usage : undefined;
+}
+
+function readContextPressure(raw: unknown): ContextPressure | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const r = raw as Record<string, unknown>;
+  const cp: ContextPressure = {
+    contextWindow: num(r['contextWindow']),
+    pressureTokens: num(r['pressureTokens']),
+    projectedTokens: num(r['projectedTokens']),
+  };
+  return cp.contextWindow !== undefined && cp.pressureTokens !== undefined ? cp : undefined;
+}
+
+function readTurnsSteps(raw: unknown): { turns?: number; steps?: number } {
+  if (!raw || typeof raw !== 'object') return {};
+  const r = raw as Record<string, unknown>;
+  const turns = num(r['turns']) ?? num(r['turnCount']);
+  const steps = num(r['steps']) ?? num(r['stepCount']);
+  return { turns, steps };
+}
+
+/** 实时速率与用时采样：模块级（按 sessionId 记录上次输出令牌数与时刻）。 */
+const rateSamples = new Map<string, { tokens: number; time: number; rate?: number; modelMs: number }>();
+
+export function sampleTokensPerSecond(
+  sessionId: string | undefined,
+  outputTokens: number | undefined,
+): { rate?: number; modelMs?: number; ttftMs?: number } {
+  if (!sessionId || outputTokens === undefined) return {};
+  const now = Date.now();
+  const last = rateSamples.get(sessionId);
+  let rate: number | undefined = last?.rate;
+  let modelMs = last?.modelMs ?? 0;
+  let ttftMs: number | undefined;
+  if (!last) {
+    // 首个样本：无从计算速率；当前值即初始输出。
+    rateSamples.set(sessionId, { tokens: outputTokens, time: now, modelMs: 0 });
+    return {};
+  }
+  const dt = now - last.time;
+  if (outputTokens > last.tokens && dt > 0) {
+    rate = ((outputTokens - last.tokens) / dt) * 1000;
+    modelMs += dt;
+    // 空闲较久后恢复增长：这段等待近似 TTFT。
+    if (dt > 600) ttftMs = dt;
+  }
+  rateSamples.set(sessionId, { tokens: outputTokens, time: now, rate, modelMs });
+  return { rate, modelMs, ttftMs };
+}
+
+/** 每个键一个固定位置的 hook 调用——跨渲染的调用次数与顺序恒定。 */
+export function useSessionStats(
+  useProjection: UseProjection | undefined,
+  sessionId: string | undefined,
+): SessionStats | null {
+  const k0 = useProjection ? useProjection(PROJECTION_KEYS[0]) : undefined;
+  const k1 = useProjection ? useProjection(PROJECTION_KEYS[1]) : undefined;
+  const k2 = useProjection ? useProjection(PROJECTION_KEYS[2]) : undefined;
+  const k3 = useProjection ? useProjection(PROJECTION_KEYS[3]) : undefined;
+  const k4 = useProjection ? useProjection(PROJECTION_KEYS[4]) : undefined;
+
+  const usage = readTokenUsage(k0);
+  const pressure = readContextPressure(k1);
+  const { turns, steps } = readTurnsSteps(k2) ?? {};
+  const alt = readTurnsSteps(k3) ?? {};
+  const alt2 = readTurnsSteps(k4) ?? {};
+
+  const stats: SessionStats = {};
+  if (turns !== undefined || steps !== undefined) Object.assign(stats, { turns, steps });
+  else if (alt.turns !== undefined || alt.steps !== undefined) Object.assign(stats, alt);
+  else if (alt2.turns !== undefined || alt2.steps !== undefined) Object.assign(stats, alt2);
+  if (usage) {
+    const total =
+      (usage.cacheReadTokens ?? 0) +
+      (usage.cacheWriteTokens ?? 0) +
+      (usage.outputTokens ?? 0) +
+      (usage.uncachedInputTokens ?? 0);
+    if (total > 0) {
+      stats.totalTokens = total;
+      stats.uncachedInputTokens = usage.uncachedInputTokens;
+      stats.cacheReadTokens = usage.cacheReadTokens;
+      stats.outputTokens = usage.outputTokens;
+    }
+    const inputTotal = (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + (usage.uncachedInputTokens ?? 0);
+    if (inputTotal > 0) stats.cacheHitPct = ((usage.cacheReadTokens ?? 0) / inputTotal) * 100;
+    const sample = sampleTokensPerSecond(sessionId, usage.outputTokens);
+    if (sample.rate !== undefined && sample.rate > 0) stats.tokensPerSecond = sample.rate;
+    if (sample.modelMs !== undefined && sample.modelMs > 0) stats.modelMs = sample.modelMs;
+    if (sample.ttftMs !== undefined && sample.ttftMs > 0) stats.ttftMs = sample.ttftMs;
+  }
+  const window_ = pressure?.contextWindow;
+  const pressured = pressure?.pressureTokens;
+  if (window_ !== undefined && window_ > 0 && pressured !== undefined) {
+    stats.contextPct = (pressured / window_) * 100;
+  }
+  return Object.keys(stats).length > 0 ? stats : null;
+}
+
+export function formatTokens(tokens: number): string {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(tokens % 1_000_000 === 0 ? 0 : 1)}M tok`;
+  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(tokens % 1_000 === 0 ? 0 : 1)}K tok`;
+  return `${tokens} tok`;
+}