@winspan/claude-forge 8.41.0 → 8.51.0

package/src/core/storage/tasks.ts

@@ -0,0 +1,318 @@
+/**
+ * TaskOperations — tasks 表读写
+ *
+ * 拆分自 sqlite.ts。
+ */
+
+import type Database from 'better-sqlite3';
+import type { ForgeEvent } from '../types.js';
+import type { SkillInvocationRow } from './rows.js';
+import type { Injection } from './injections.js';
+
+export interface TaskRecord {
+  id: string;
+  session_id: string;
+  title: string;
+  description?: string;
+  start_time: string;
+  end_time?: string;
+  status: 'active' | 'completed' | 'abandoned';
+  event_count: number;
+  project_path?: string;
+  /** First UserPromptSubmit user_prompt text for this task's session window.
+   *  Populated by queryTasksFiltered via correlated subquery on idx_events_session_hook. */
+  first_prompt?: string | null;
+}
+
+export interface TaskFilter {
+  session_id?: string;
+  limit?: number;
+  offset?: number;
+  project?: string | string[];
+  from?: string;
+  to?: string;
+  search?: string;
+}
+
+export interface TaskPage {
+  items: TaskRecord[];
+  total: number;
+  has_more: boolean;
+}
+
+export class TaskOperations {
+  constructor(private db: Database.Database) {}
+
+  writeTask(task: { id: string; session_id: string; title: string; start_time: string }): void {
+    this.db.prepare(`
+      INSERT INTO tasks (id, session_id, title, start_time) VALUES (?, ?, ?, ?)
+    `).run(task.id, task.session_id, task.title, task.start_time);
+  }
+
+  updateTask(taskId: string, updates: { end_time?: string; status?: string; event_count?: number; title?: string }): void {
+    const sets: string[] = [];
+    const params: unknown[] = [];
+    if (updates.end_time !== undefined) { sets.push('end_time = ?'); params.push(updates.end_time); }
+    if (updates.status !== undefined) { sets.push('status = ?'); params.push(updates.status); }
+    if (updates.event_count !== undefined) { sets.push('event_count = ?'); params.push(updates.event_count); }
+    if (updates.title !== undefined) { sets.push('title = ?'); params.push(updates.title); }
+    if (sets.length === 0) return;
+    params.push(taskId);
+    this.db.prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+  }
+
+  linkEventToTask(taskId: string, eventId: string): void {
+    this.db.prepare(`INSERT OR IGNORE INTO task_events (task_id, event_id) VALUES (?, ?)`).run(taskId, eventId);
+    this.db.prepare(`UPDATE tasks SET event_count = event_count + 1, end_time = (SELECT timestamp FROM events WHERE event_id = ?) WHERE id = ?`).run(eventId, taskId);
+  }
+
+  /** Legacy simple query — returns bare array (used by detail route internally) */
+  queryTasks(filter: { session_id?: string; limit?: number } = {}): TaskRecord[] {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+    if (filter.session_id) { conditions.push('session_id = ?'); params.push(filter.session_id); }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filter.limit ?? 50;
+    params.push(limit);
+    const rows = this.db.prepare(`SELECT * FROM tasks ${where} ORDER BY start_time DESC LIMIT ?`).all(...params) as Array<Record<string, unknown>>;
+    return rows.map(r => this.mapRow(r));
+  }
+
+  /**
+   * queryTasksFiltered — paginated query with full filter support.
+   * JOINs sessions to expose project_path.
+   */
+  queryTasksFiltered(filter: TaskFilter = {}): TaskPage {
+    const { conditions, params } = this.buildWhereConditions(filter);
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+    const limit = Math.min(Math.max(filter.limit ?? 50, 1), 200);
+    const offset = Math.max(filter.offset ?? 0, 0);
+
+    // Count query
+    const countRow = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM tasks t JOIN sessions s ON t.session_id = s.session_id ${where}`
+    ).get(...params) as { cnt: number };
+    const total = countRow?.cnt ?? 0;
+
+    // Data query
+    const dataParams = [...params, limit, offset];
+    const rows = this.db.prepare(
+      `SELECT t.*, s.project_path,
+              (SELECT e.user_prompt
+               FROM events e
+               WHERE e.session_id = t.session_id
+                 AND e.hook_type = 'UserPromptSubmit'
+                 AND e.timestamp >= t.start_time
+                 AND (t.end_time IS NULL OR e.timestamp <= t.end_time)
+               ORDER BY e.timestamp ASC LIMIT 1) AS first_prompt
+       FROM tasks t
+       JOIN sessions s ON t.session_id = s.session_id
+       ${where}
+       ORDER BY t.start_time DESC
+       LIMIT ? OFFSET ?`
+    ).all(...dataParams) as Array<Record<string, unknown>>;
+
+    const items = rows.map(r => this.mapRow(r));
+    return { items, total, has_more: offset + items.length < total };
+  }
+
+  /** Count of tasks with start_time in [since, until?). */
+  countTasksByRange(opts: { since: string; until?: string }): number {
+    const conditions: string[] = ['start_time >= ?'];
+    const params: unknown[] = [opts.since];
+    if (opts.until !== undefined) {
+      conditions.push('start_time < ?');
+      params.push(opts.until);
+    }
+    const sql = `SELECT COUNT(*) as cnt FROM tasks WHERE ${conditions.join(' AND ')}`;
+    const row = this.db.prepare(sql).get(...params) as { cnt: number } | undefined;
+    return row?.cnt ?? 0;
+  }
+
+  /** Returns distinct project paths that have at least one task. */
+  queryTaskProjects(): string[] {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT s.project_path
+       FROM sessions s
+       JOIN tasks t ON t.session_id = s.session_id
+       ORDER BY s.project_path`
+    ).all() as Array<{ project_path: string }>;
+    return rows.map(r => r.project_path);
+  }
+
+  getTaskEventIds(taskId: string): string[] {
+    const rows = this.db.prepare(`SELECT event_id FROM task_events WHERE task_id = ?`).all(taskId) as Array<{ event_id: string }>;
+    return rows.map(r => r.event_id);
+  }
+
+  /**
+   * 将 idle 超过阈值的 active task 批量转为 completed。
+   * 条件：status='active' AND end_time IS NOT NULL
+   *       AND (now - end_time) > idleMinutes 分钟。
+   * 返回：受影响行数。
+   */
+  completeStaleActiveTasks(idleMinutes: number): number {
+    const result = this.db.prepare(`
+      UPDATE tasks
+      SET status = 'completed'
+      WHERE status = 'active'
+        AND end_time IS NOT NULL
+        AND (julianday('now') - julianday(end_time)) * 24 * 60 > ?
+    `).run(idleMinutes);
+    return result.changes as number;
+  }
+
+  // ── H1: detail route 用的 PK 直查 / JOIN 接口 ──────────────────────
+
+  /**
+   * 按 taskId 直查单个 task（LEFT JOIN sessions 取 project_path）。
+   * 替代旧 detail route 的「拉 5000 tasks 再 find(id)」。
+   */
+  getTask(taskId: string): TaskRecord | null {
+    const row = this.db.prepare(`
+      SELECT t.*, s.project_path
+      FROM tasks t
+      LEFT JOIN sessions s ON s.session_id = t.session_id
+      WHERE t.id = ?
+    `).get(taskId) as Record<string, unknown> | undefined;
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  /**
+   * 按 taskId JOIN task_events 拉关联事件，按 timestamp 升序。
+   * 默认 limit 5000（防御过大 task；前端不分页但要有上限）。
+   */
+  queryEventsByTaskId(taskId: string, opts: { limit?: number } = {}): ForgeEvent[] {
+    const limit = opts.limit ?? 5000;
+    const rows = this.db.prepare(`
+      SELECT e.*
+      FROM events e
+      JOIN task_events te ON te.event_id = e.event_id
+      WHERE te.task_id = ?
+      ORDER BY e.timestamp ASC
+      LIMIT ?
+    `).all(taskId, limit) as Array<Record<string, unknown>>;
+    return rows.map(r => this.rowToEvent(r));
+  }
+
+  /**
+   * 按 taskId JOIN task_events 拉关联 injections，按 timestamp 升序。
+   * 替代「拉 500 injections + JS Set.has 过滤」。
+   */
+  queryInjectionsByTaskId(taskId: string): Injection[] {
+    const rows = this.db.prepare(`
+      SELECT i.*
+      FROM injections i
+      JOIN task_events te ON te.event_id = i.event_id
+      WHERE te.task_id = ?
+      ORDER BY i.timestamp ASC
+    `).all(taskId) as Array<Record<string, unknown>>;
+    return rows.map(r => ({
+      id: r.id as string,
+      event_id: (r.event_id as string) || undefined,
+      session_id: r.session_id as string,
+      timestamp: r.timestamp as string,
+      source_handler: r.source_handler as string,
+      injection_type: r.injection_type as Injection['injection_type'],
+      content: r.content as string,
+    }));
+  }
+
+  /**
+   * 按 task 的时间窗口 + session_id 过滤 skill_invocations。
+   * 替代「拉 200 invocations + JS 时间比较」。
+   * `now_ms` 通过参数注入（end_time IS NULL 时取此值），便于测试时 mock。
+   *
+   * 时间转换：strftime('%s', ISO_TS) 返回 unix 秒（丢毫秒），× 1000 → ms。
+   * 与旧实现 `new Date(taskStart).getTime()` 相比可能损失最多 999ms，
+   * 但 task 时间窗口通常远大于秒级，对结果集影响可忽略。
+   */
+  querySkillInvocationsByTaskWindow(taskId: string, opts: { now_ms?: number } = {}): SkillInvocationRow[] {
+    const nowMs = opts.now_ms ?? Date.now();
+    const rows = this.db.prepare(`
+      SELECT si.*
+      FROM skill_invocations si
+      JOIN tasks t ON t.session_id = si.session_id
+      WHERE t.id = ?
+        AND si.timestamp >= CAST(strftime('%s', t.start_time) AS INTEGER) * 1000
+        AND si.timestamp <= COALESCE(
+              CAST(strftime('%s', t.end_time) AS INTEGER) * 1000 + 999,
+              ?
+            )
+      ORDER BY si.timestamp ASC
+    `).all(taskId, nowMs) as SkillInvocationRow[];
+    return rows;
+  }
+
+  /** Map a raw events row to ForgeEvent (parses JSON columns). */
+  private rowToEvent(row: Record<string, unknown>): ForgeEvent {
+    const parseJson = (val: unknown): unknown => {
+      if (val == null) return undefined;
+      if (typeof val !== 'string') return val;
+      try { return JSON.parse(val); } catch { return val; }
+    };
+    return {
+      event_id: row.event_id as string,
+      session_id: row.session_id as string,
+      project_path: row.project_path as string,
+      timestamp: row.timestamp as string,
+      hook_type: row.hook_type as ForgeEvent['hook_type'],
+      tool_name: (row.tool_name as string) || undefined,
+      tool_input: parseJson(row.tool_input) as ForgeEvent['tool_input'],
+      tool_output: parseJson(row.tool_output) as ForgeEvent['tool_output'],
+      user_prompt: (row.user_prompt as string) || undefined,
+      ai_response: (row.ai_response as string) || undefined,
+    };
+  }
+
+  private buildWhereConditions(filter: TaskFilter): { conditions: string[]; params: unknown[] } {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (filter.session_id) {
+      conditions.push('t.session_id = ?');
+      params.push(filter.session_id);
+    }
+
+    if (filter.project) {
+      const projects = Array.isArray(filter.project) ? filter.project : [filter.project];
+      const placeholders = projects.map(() => '?').join(', ');
+      conditions.push(`s.project_path IN (${placeholders})`);
+      params.push(...projects);
+    }
+
+    if (filter.from) {
+      conditions.push('t.start_time >= ?');
+      params.push(filter.from);
+    }
+
+    if (filter.to) {
+      conditions.push('t.start_time <= ?');
+      params.push(filter.to);
+    }
+
+    if (filter.search) {
+      conditions.push('t.title LIKE ?');
+      params.push(`%${filter.search}%`);
+    }
+
+    return { conditions, params };
+  }
+
+  private mapRow(r: Record<string, unknown>): TaskRecord {
+    return {
+      id: r.id as string,
+      session_id: r.session_id as string,
+      title: r.title as string,
+      description: (r.description as string) || undefined,
+      start_time: r.start_time as string,
+      end_time: (r.end_time as string) || undefined,
+      status: (r.status as TaskRecord['status']) || 'active',
+      event_count: (r.event_count as number) || 0,
+      project_path: (r.project_path as string) || undefined,
+      first_prompt: r.first_prompt !== undefined ? (r.first_prompt as string | null) : undefined,
+    };
+  }
+}

package/src/core/storage/token-usage.ts

@@ -0,0 +1,93 @@
+/**
+ * TokenUsageOperations — token_usage 表读写
+ *
+ * 拆分自 sqlite.ts。
+ */
+
+import type Database from 'better-sqlite3';
+import { logger } from '../utils/logger.js';
+
+export class TokenUsageOperations {
+  constructor(private db: Database.Database) {}
+
+  writeTokenUsage(params: {
+    session_id: string;
+    input_tokens: number;
+    output_tokens: number;
+    model?: string;
+    tool_name?: string;
+  }): void {
+    const total_tokens = params.input_tokens + params.output_tokens;
+    try {
+      this.db.prepare(`
+        INSERT INTO token_usage (session_id, timestamp,
+                                 input_tokens, output_tokens, total_tokens, model, tool_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        params.session_id,
+        Date.now(),
+        params.input_tokens,
+        params.output_tokens,
+        total_tokens,
+        params.model ?? null,
+        params.tool_name ?? null,
+      );
+    } catch (err) {
+      logger.debug(`[Storage] Failed to record token usage: ${err}`);
+    }
+  }
+
+  getTokenUsageBySession(session_id: string): {
+    total_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+  } {
+    const result = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(input_tokens), 0) as input_tokens,
+        COALESCE(SUM(output_tokens), 0) as output_tokens,
+        COALESCE(SUM(total_tokens), 0) as total_tokens
+      FROM token_usage WHERE session_id = ?
+    `).get(session_id) as { input_tokens: number; output_tokens: number; total_tokens: number };
+    return result;
+  }
+
+  listTokenUsage(filter: {
+    session_id?: string;
+    limit?: number;
+  } = {}): Array<{
+    id: number;
+    session_id: string;
+    timestamp: number;
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+    model: string | null;
+    tool_name: string | null;
+  }> {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (filter.session_id) {
+      conditions.push('session_id = ?');
+      params.push(filter.session_id);
+    }
+
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filter.limit ?? 100;
+    const sql = `SELECT * FROM token_usage ${where} ORDER BY timestamp DESC LIMIT ?`;
+
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
+    return rows.map(r => ({
+      id: r.id as number,
+      session_id: r.session_id as string,
+      timestamp: r.timestamp as number,
+      input_tokens: r.input_tokens as number,
+      output_tokens: r.output_tokens as number,
+      total_tokens: r.total_tokens as number,
+      model: (r.model as string) || null,
+      tool_name: (r.tool_name as string) || null,
+    }));
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,181 @@
+/**
+ * Core event types used by all Forge handlers.
+ *
+ * Two layers exposed:
+ *
+ * 1. **Wire shape** — `ForgeEvent`: a permissive interface that mirrors the
+ *    raw Hook payload coming off the Unix socket. All optional fields are
+ *    `?:` because the Hook envelope is the same regardless of `hook_type`.
+ *    Storage / wire-level code (event-parser, sqlite rowToEvent, daemon
+ *    router) keeps using this — it's still the source of truth on disk.
+ *
+ * 2. **Narrowed views** — `PreToolUseEvent` / `PostToolUseEvent` /
+ *    `UserPromptSubmitEvent` / `NotificationEvent` / `StopEvent`: per-hook
+ *    discriminated union with required fields filled in. Use these in
+ *    handlers and downstream services where the hook type is already known.
+ *
+ *    Convert with the type guards `isPreToolUse` / `isPostToolUse` / etc.
+ *    They narrow correctly under TS control flow analysis.
+ *
+ * The split exists so we get compile-time guarantees inside handlers
+ * (no more `event.tool_name!`) without forcing every caller of the wire
+ * shape to do a 5-way switch.
+ */
+/**
+ * Lenient bag of common tool_input fields across all Claude Code tools.
+ *
+ * Intentionally not a discriminated union — the tool set is open-ended and
+ * almost all access sites are defensive (`?.command ?? ''`). The index
+ * signature keeps forward compatibility with unknown tool kinds; prefer
+ * the typed getters in `core/event-fields.ts` over direct field access
+ * when the value is fed downstream as `string`.
+ */
+export interface ToolInputFields {
+  // Bash
+  command?: string;
+  description?: string;
+  // Edit / Write / Read / NotebookEdit
+  file_path?: string;
+  notebook_path?: string;
+  old_string?: string;
+  new_string?: string;
+  content?: string;
+  // Agent / Task
+  subagent_type?: string;
+  name?: string;
+  prompt?: string;
+  // UserPromptSubmit fallback envelope (some hook flows pack user_prompt here)
+  user_prompt?: string;
+  // Forward-compat for unknown tools / new Claude Code releases
+  [key: string]: unknown;
+}
+
+export interface ForgeEvent {
+  session_id: string;
+  project_path: string;
+  timestamp: string;
+  hook_type: 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Notification' | 'Stop';
+  tool_name?: string;
+  tool_input?: ToolInputFields;
+  tool_output?: Record<string, unknown>;
+  user_prompt?: string;
+  ai_response?: string;
+  event_id?: string;
+}
+
+interface BaseEvent {
+  session_id: string;
+  project_path: string;
+  timestamp: string;
+  event_id?: string;
+}
+
+export interface PreToolUseEvent extends BaseEvent {
+  hook_type: 'PreToolUse';
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+export interface PostToolUseEvent extends BaseEvent {
+  hook_type: 'PostToolUse';
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+  tool_output: Record<string, unknown>;
+}
+
+export interface UserPromptSubmitEvent extends BaseEvent {
+  hook_type: 'UserPromptSubmit';
+  user_prompt: string;
+}
+
+export interface NotificationEvent extends BaseEvent {
+  hook_type: 'Notification';
+  ai_response?: string;
+}
+
+export interface StopEvent extends BaseEvent {
+  hook_type: 'Stop';
+  ai_response?: string;
+}
+
+/** Narrow union for handlers / services that already know the hook type. */
+export type ForgeEventNarrow =
+  | PreToolUseEvent
+  | PostToolUseEvent
+  | UserPromptSubmitEvent
+  | NotificationEvent
+  | StopEvent;
+
+// ── Type Guards ──────────────────────────────────────────────────────────
+// Use these in handlers/services to narrow ForgeEvent → specific event type.
+// Under TS control-flow analysis they upgrade `event.tool_name` from
+// `string | undefined` to `string` without runtime asserts.
+
+export function isPreToolUse(e: ForgeEvent): e is PreToolUseEvent & ForgeEvent {
+  return e.hook_type === 'PreToolUse'
+    && typeof e.tool_name === 'string'
+    && e.tool_input !== undefined;
+}
+
+export function isPostToolUse(e: ForgeEvent): e is PostToolUseEvent & ForgeEvent {
+  return e.hook_type === 'PostToolUse'
+    && typeof e.tool_name === 'string'
+    && e.tool_input !== undefined
+    && e.tool_output !== undefined;
+}
+
+export function isUserPromptSubmit(e: ForgeEvent): e is UserPromptSubmitEvent & ForgeEvent {
+  return e.hook_type === 'UserPromptSubmit' && typeof e.user_prompt === 'string';
+}
+
+export function isNotification(e: ForgeEvent): e is NotificationEvent & ForgeEvent {
+  return e.hook_type === 'Notification';
+}
+
+export function isStop(e: ForgeEvent): e is StopEvent & ForgeEvent {
+  return e.hook_type === 'Stop';
+}
+
+/**
+ * Hook execution result
+ */
+export interface HookResult {
+  allow: boolean;
+  reason?: string;
+  systemMessage?: string;
+  additionalContext?: string;
+}
+
+/**
+ * Security configuration
+ */
+export interface SecurityConfig {
+  destructiveOps: boolean;
+  secretsCheck: boolean;
+  diffSizeCheck: boolean;
+  diffSizeThreshold: number;
+}
+
+/**
+ * Configuration structure
+ */
+export interface ForgeConfig {
+  ai: {
+    api_key: string;
+    model: string;
+    base_url?: string;
+    provider: string;
+  };
+  storage: {
+    path: string;
+    max_size_mb: number;
+  };
+  web: {
+    enabled: boolean;
+    port: number;
+  };
+  skill_matching?: {
+    api_key?: string;
+  };
+  security?: SecurityConfig;
+}