@morlay/session-rdb 0.0.19 → 0.0.21-alpha.0

package/src/postgres.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { readdirSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { and, desc, eq, gte, sql } from "drizzle-orm";
+import { and, desc, eq, gte, inArray, lt, notInArray, sql } from "drizzle-orm";
 import type { PgAsyncDatabase, PgAsyncTransaction } from "drizzle-orm/pg-core";
 import type { NodePgDatabase, NodePgQueryResultHKT } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
@@ -16,13 +16,36 @@ import {
 } from "./backend.ts";
 import { toPostgresSchema } from "./adapters/index.ts";
 import { postgresTableDefs } from "./entities/index.ts";
-import { sessionConflictRow, sessionInsertRow, titleOfEventData } from "./log.ts";
+import { sessionConflictRow, sessionInsertRow, titleOfEventData, usageRowOf } from "./log.ts";
 import { createStorageRepository } from "./storage-takeover/repository.ts";
 import type { StorageRepository } from "./storage-takeover/types.ts";
+import type { UsageAggregate, UsageTotals } from "./usage.ts";
 
-/** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
 const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
 
+/** pg 的 text 列窄化：非字符串（含 null）都不当作文本。 */
+function text(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+/** pg 的 count/sum 回落成字符串：统一转成有限数。 */
+function numeric(value: unknown): number {
+  const parsed = typeof value === "number" ? value : Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
+function totalsOfRow(row: Record<string, unknown>): UsageTotals {
+  return {
+    events: numeric(row["events"]),
+    inputTokens: numeric(row["input_tokens"]),
+    outputTokens: numeric(row["output_tokens"]),
+    cacheReadTokens: numeric(row["cache_read_tokens"]),
+    reasoningTokens: numeric(row["reasoning_tokens"]),
+    totalTokens: numeric(row["total_tokens"]),
+  };
+}
+
 export interface PostgresBackendOptions {
   identityBase: string;
 
@@ -37,13 +60,12 @@ export class PostgresBackend implements Backend {
 
   private readonly tables: Record<string, any>;
 
-  /** storages 接管表访问层；句柄在 open()（含迁移）完成后解析。 */
   readonly storage: StorageRepository;
 
   private readonly opened: Promise<void>;
   private resolveOpened!: () => void;
   private rejectOpened!: (error: unknown) => void;
-  /** 事务期间的连接覆盖：storage 写方法经它加入当前事务。 */
+
   private txOverride: unknown;
 
   constructor(
@@ -55,14 +77,11 @@ export class PostgresBackend implements Backend {
       this.resolveOpened = resolve;
       this.rejectOpened = reject;
     });
-    // 每个 storage 原语都会重新 await 同一 promise，失败仍逐一可见；这个
-    // 守卫只防止 open 失败早于首次使用时的 unhandled rejection。
+
     this.opened.catch(() => {});
     this.storage = createStorageRepository({
       db: () => this.opened.then(() => this.txOverride ?? this.db),
-      // storages 写事务用 serializable：workspace 域是整记录替换，多实例并发写
-      // 同一记录在 read committed 下是「最后提交者赢」的静默覆盖；提升隔离级别
-      // 后冲突以序列化失败暴露（与「并发写入 fail loud」一致），调用方重试即可。
+
       writeAtomically: (fn) =>
         this.db.transaction(
           async (tx) => {
@@ -92,8 +111,7 @@ export class PostgresBackend implements Backend {
 
   private async doOpen(): Promise<void> {
     const schema = this.options.schema ?? "public";
-    // drizzle-kit 迁移：v2 baseline 由旧版本建表（首次打开时标记为已应用），
-    // 本版本只执行 v3 diff（删 f_original_seq）。
+
     const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
     const probe = (await this.db.execute(
       sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`,
@@ -106,6 +124,7 @@ export class PostgresBackend implements Backend {
       }
     }
     await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
+    await this.backfillEventUsage();
     const storeId = await this.db.transaction(async (tx) => {
       await tx
         .insert(this.tables["t_persistence_state"])
@@ -126,9 +145,8 @@ export class PostgresBackend implements Backend {
     this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
   }
 
-  /** 标记 v2 baseline 已应用（迁移表 v1 结构：id/hash/created_at/name/applied_at）。 */
   private async baselineV2(): Promise<void> {
-    const dir = readdirSync(postgresMigrationsDir).find((name) => name.endsWith("_v2_initial"));
+    const dir = (await readdir(postgresMigrationsDir)).find((name) => name.endsWith("_v2_initial"));
     if (dir === undefined) throw new Error("missing v2 baseline migration in drizzle/postgres");
     await this.db.execute(sql`
       CREATE SCHEMA IF NOT EXISTS drizzle
@@ -176,6 +194,28 @@ export class PostgresBackend implements Backend {
       .execute() as unknown as EventRow[];
   }
 
+  async getEventTypeAt(id: SessionId, sequence: number): Promise<string | undefined> {
+    const table = this.tables["t_session_events"];
+    const rows = (await this.eventRows(this.db)
+      .where(and(eq(table.fSessionId, id), eq(table.fSequence, sequence)))
+      .limit(1)
+      .execute()) as Array<{ fType?: string }>;
+    return rows[0]?.fType;
+  }
+
+  async getEventTypesBefore(
+    id: SessionId,
+    beforeSequence: number,
+    limit: number,
+  ): Promise<Array<Pick<EventRow, "fSequence" | "fType">>> {
+    const table = this.tables["t_session_events"];
+    return (await this.eventRows(this.db)
+      .where(and(eq(table.fSessionId, id), lt(table.fSequence, beforeSequence)))
+      .orderBy(desc(table.fSequence))
+      .limit(limit)
+      .execute()) as unknown as Array<Pick<EventRow, "fSequence" | "fType">>;
+  }
+
   async listSessions(): Promise<SessionRow[]> {
     return this.db.select().from(this.tables["t_sessions"]).execute() as unknown as Promise<
       SessionRow[]
@@ -200,11 +240,11 @@ export class PostgresBackend implements Backend {
       refreshTitle: (id) => this.refreshTitle(tx, id),
       deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
       getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
+      deleteSession: (id) => this.deleteSession(tx, id),
+      deleteSessions: (ids) => this.deleteSessions(tx, ids),
     };
   }
 
-  // --- meta helpers ---
-
   private async readMeta(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     key: string,
@@ -217,8 +257,6 @@ export class PostgresBackend implements Backend {
     return rows[0]?.fValue;
   }
 
-  // --- row primitives (transaction-internal) ---
-
   private async upsertSession(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     storage: SessionStorageMetadata,
@@ -248,7 +286,7 @@ export class PostgresBackend implements Backend {
         .where(eq(this.tables["t_sessions"].fSessionId, id))
         .execute()
     )[0] as Pick<SessionRow, "fHeadEventId" | "fHeadSequence"> | undefined;
-    /* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
+
     if (head === undefined) throw new Error(`session "${id}" has no materialized row`);
     return head;
   }
@@ -264,7 +302,7 @@ export class PostgresBackend implements Backend {
         .where(eq(this.tables["t_sessions"].fSessionId, id))
         .execute()
     )[0] as { fSeedLength: number | null } | undefined;
-    /* v8 ignore next -- rewind always materializes the row before reading the seed length */
+
     if (row === undefined) throw new Error(`session "${id}" has no materialized row`);
     return row.fSeedLength;
   }
@@ -296,6 +334,14 @@ export class PostgresBackend implements Backend {
         )
         .execute();
     }
+    // 用量顺带落 t_event_usage：统计不再逐行解析事件 JSON。
+    const usage = events.flatMap((event) => {
+      const row = usageRowOf(event);
+      return row === undefined ? [] : [row];
+    });
+    if (usage.length > 0) {
+      await exec.insert(this.tables["t_event_usage"]).values(usage).onConflictDoNothing().execute();
+    }
   }
 
   private async insertBridges(
@@ -340,7 +386,6 @@ export class PostgresBackend implements Backend {
       .execute();
   }
 
-  /** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
   private async refreshTitle(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
@@ -381,6 +426,188 @@ export class PostgresBackend implements Backend {
       .execute();
   }
 
+  private async deleteSession(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    id: SessionId,
+  ): Promise<void> {
+    await exec
+      .delete(this.tables["t_session_events"])
+      .where(eq(this.tables["t_session_events"].fSessionId, id))
+      .execute();
+    await exec
+      .delete(this.tables["t_workspace_sessions"])
+      .where(eq(this.tables["t_workspace_sessions"].fSessionId, id))
+      .execute();
+    await exec
+      .delete(this.tables["t_session_projcache_row"])
+      .where(eq(this.tables["t_session_projcache_row"].fSessionId, id))
+      .execute();
+    await exec
+      .delete(this.tables["t_sessions"])
+      .where(eq(this.tables["t_sessions"].fSessionId, id))
+      .execute();
+  }
+
+  /** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
+  async collectOrphans(): Promise<number> {
+    const tEvents = this.tables["t_events"];
+    const tEventUsage = this.tables["t_event_usage"];
+    const tSessionEvents = this.tables["t_session_events"];
+    const result = (await this.db
+      .delete(tEvents)
+      .where(
+        notInArray(
+          tEvents.fEventId,
+          this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents),
+        ),
+      )
+      .execute()) as unknown as { rowCount?: number | null };
+    // 用量行跟着事件行走：没有事件行的用量不再计入统计。
+    await this.db
+      .delete(tEventUsage)
+      .where(
+        notInArray(
+          tEventUsage.fEventId,
+          this.db.select({ fEventId: tEvents.fEventId }).from(tEvents),
+        ),
+      )
+      .execute();
+    return result.rowCount ?? 0;
+  }
+
+  /** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
+  async listOrphanSubagentSessions(): Promise<SessionId[]> {
+    const tSessions = this.tables["t_sessions"];
+    const result = (await this.db.execute(sql`
+      SELECT s.f_session_id AS id FROM ${tSessions} AS s
+      WHERE s.f_origin = 'subagent'
+        AND (s.f_parent_session IS NULL
+             OR s.f_parent_session NOT IN (SELECT p.f_session_id FROM ${tSessions} AS p))
+    `)) as unknown as { rows: Array<{ id: string }> };
+    return result.rows.map((row) => row.id as SessionId);
+  }
+
+  private async deleteSessions(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    ids: SessionId[],
+  ): Promise<number> {
+    if (ids.length === 0) return 0;
+    await exec
+      .delete(this.tables["t_session_events"])
+      .where(inArray(this.tables["t_session_events"].fSessionId, ids))
+      .execute();
+    await exec
+      .delete(this.tables["t_workspace_sessions"])
+      .where(inArray(this.tables["t_workspace_sessions"].fSessionId, ids))
+      .execute();
+    await exec
+      .delete(this.tables["t_session_projcache_row"])
+      .where(inArray(this.tables["t_session_projcache_row"].fSessionId, ids))
+      .execute();
+    const result = (await exec
+      .delete(this.tables["t_sessions"])
+      .where(inArray(this.tables["t_sessions"].fSessionId, ids))
+      .execute()) as unknown as { rowCount?: number | null };
+    return result.rowCount ?? 0;
+  }
+
+  async vacuum(): Promise<void> {
+    await this.db.execute(sql`VACUUM ANALYZE`);
+  }
+
+  /** 一次性回填：旧库没写过 `t_event_usage`，建表后按事件行补一次（表非空即跳过）。 */
+  private async backfillEventUsage(): Promise<void> {
+    const tEventUsage = this.tables["t_event_usage"];
+    const tEvents = this.tables["t_events"];
+    const existing = (await this.db.execute(
+      sql`SELECT count(*) AS n FROM ${tEventUsage}`,
+    )) as unknown as { rows: Array<{ n: string }> };
+    if (Number(existing.rows[0]?.["n"] ?? 0) > 0) return;
+    await this.db.execute(sql`
+      INSERT INTO ${tEventUsage} (
+        f_event_id, f_created_at, f_provider, f_model,
+        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
+      SELECT e.f_event_id, e.f_created_at,
+             coalesce(e.f_data::json #>> '{data,message,source,provider}',
+                      e.f_data::json #>> '{message,source,provider}'),
+             coalesce(e.f_data::json #>> '{data,message,source,model}',
+                      e.f_data::json #>> '{message,source,model}'),
+             coalesce((e.f_data::json #>> '{data,usage,inputTokens}')::integer,
+                      (e.f_data::json #>> '{usage,inputTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,outputTokens}')::integer,
+                      (e.f_data::json #>> '{usage,outputTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,cacheReadTokens}')::integer,
+                      (e.f_data::json #>> '{usage,cacheReadTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,reasoningTokens}')::integer,
+                      (e.f_data::json #>> '{usage,reasoningTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,totalTokens}')::integer,
+                      (e.f_data::json #>> '{usage,totalTokens}')::integer, 0)
+        FROM ${tEvents} e
+       WHERE e.f_type = 'assistant/message'
+         AND (e.f_data::json #> '{data,usage}' IS NOT NULL
+              OR e.f_data::json #> '{usage}' IS NOT NULL)
+      ON CONFLICT DO NOTHING
+    `);
+  }
+
+  /** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
+  async usageReport(sinceMs?: number): Promise<UsageAggregate> {
+    const sinceClause = sinceMs === undefined ? sql`` : sql` AND u.f_created_at >= ${sinceMs}`;
+    const tEventUsage = this.tables["t_event_usage"];
+    const tSessionEvents = this.tables["t_session_events"];
+    const tSessions = this.tables["t_sessions"];
+    const buckets = (await this.db.execute(sql`
+      SELECT to_char(to_timestamp(u.f_created_at / 1000.0), 'YYYY-MM-DD') AS day,
+             u.f_provider AS provider,
+             u.f_model AS model,
+             EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                       JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                      WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
+             count(*) AS events,
+             sum(u.f_input_tokens) AS input_tokens,
+             sum(u.f_output_tokens) AS output_tokens,
+             sum(u.f_cache_read_tokens) AS cache_read_tokens,
+             sum(u.f_reasoning_tokens) AS reasoning_tokens,
+             sum(u.f_total_tokens) AS total_tokens
+        FROM ${tEventUsage} u
+       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
+       GROUP BY 1, 2, 3, 4
+    `)) as unknown as { rows: Array<Record<string, unknown>> };
+    const sessions = (await this.db.execute(sql`
+      SELECT b.f_session_id AS session_id,
+             s.f_title AS title,
+             (s.f_origin = 'subagent') AS subagent,
+             (s.f_archived_at IS NOT NULL) AS archived,
+             count(*) AS events,
+             sum(u.f_input_tokens) AS input_tokens,
+             sum(u.f_output_tokens) AS output_tokens,
+             sum(u.f_cache_read_tokens) AS cache_read_tokens,
+             sum(u.f_reasoning_tokens) AS reasoning_tokens,
+             sum(u.f_total_tokens) AS total_tokens
+        FROM ${tSessionEvents} b
+        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
+        JOIN ${tSessions} s ON s.f_session_id = b.f_session_id
+       WHERE 1 = 1${sinceClause}
+       GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at
+    `)) as unknown as { rows: Array<Record<string, unknown>> };
+    return {
+      buckets: buckets.rows.map((row) => ({
+        day: String(row["day"]),
+        provider: text(row["provider"]),
+        model: text(row["model"]),
+        subagent: row["subagent"] === true,
+        ...totalsOfRow(row),
+      })),
+      sessions: sessions.rows.map((row) => ({
+        sessionId: String(row["session_id"]),
+        title: text(row["title"]),
+        subagent: row["subagent"] === true,
+        archived: row["archived"] === true,
+        ...totalsOfRow(row),
+      })),
+    };
+  }
+
   private async getPrevBridge(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,

package/src/schema.ts

@@ -8,7 +8,6 @@ export const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 0x44534850;
 
 export const EVENT_ENCODING = "json";
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const sqliteTables: Record<string, any> = toSqliteSchema(sqliteTableDefs);
 
 export const tPersistenceState = sqliteTables["t_persistence_state"]!;
@@ -31,6 +30,8 @@ export const tWorkspaceState = sqliteTables["t_workspace_state"]!;
 
 export const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"]!;
 
+export const tEventUsage = sqliteTables["t_event_usage"]!;
+
 export type { SessionRow } from "./backend.ts";
 
 export type { EventRow } from "./backend.ts";
@@ -82,7 +83,7 @@ export function eventKind(event: { type: string; data?: unknown }): EventKind |
     case "tool/result":
     case "tool/ptc-dispatch-start":
     case "tool/ptc-dispatch":
-    case "tool/code-dispatch-start": // v2 旧名（读路径归一为 ptc）
+    case "tool/code-dispatch-start":
     case "tool/code-dispatch":
       return "tool";
     case "request/header":
@@ -139,7 +140,7 @@ export function eventKind(event: { type: string; data?: unknown }): EventKind |
     case "web/deepseek-search-llm-request":
       return "web";
     default:
-      return ""; // unknown plugin-merged type
+      return "";
   }
 }
 
@@ -150,7 +151,7 @@ export function eventDimensions(event: SessionEvent): {
   actionId: string;
 } {
   const kind = eventKind(event);
-  // 插件合并类型不在 core 的判别联合内，type/data 经结构化视图访问。
+
   const type = event.type as string;
   const data = event.data as Record<string, unknown>;
   switch (type) {
@@ -159,7 +160,6 @@ export function eventDimensions(event: SessionEvent): {
     case "assistant/message":
       return { kind, role: "assistant", name: "", actionId: "" };
     case "tool/result": {
-      // append 可能携带旧形状（无 message）；可选链容忍。
       const message = data["message"] as { content?: Array<{ toolCallId?: string }> } | undefined;
       return { kind, role: "tool", name: "", actionId: message?.content?.[0]?.toolCallId ?? "" };
     }
@@ -172,7 +172,7 @@ export function eventDimensions(event: SessionEvent): {
       };
     case "tool/ptc-dispatch-start":
     case "tool/ptc-dispatch":
-    case "tool/code-dispatch-start": // v2 旧名（读路径归一为 ptc）
+    case "tool/code-dispatch-start":
     case "tool/code-dispatch":
       return {
         kind,

package/src/session-query.ts

@@ -1,10 +1,6 @@
 import type { Context } from "@deepseek-ai/cordis";
 import { SessionQueryEngine, SessionQueryError, type Config } from "@deepseek-ai/dsh-session-query";
 
-// 会话查询服务的 rdb 实现：精确读 / 过滤 / 血缘全部复用上游基类（数据面走
-// ctx.sessions 与我们的 ctx.sessionPersistence），这里只接管服务所有权。
-// 全文检索与官方 `openAt: never` 装配保持一致——直接拒绝，不引入 FTS 索引、
-// node:sqlite 或派生库，搜索语义留待显式实现（见 ADR 0006）。
 export class SessionQueryRdb extends SessionQueryEngine {
   constructor(ctx: Context, config: Config = {}) {
     super(ctx, config);