@winspan/claude-forge 8.53.2 → 8.54.4

package/src/core/storage/tasks.ts

@@ -1,318 +0,0 @@
-/**
- * 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

@@ -1,93 +0,0 @@
-/**
- * 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

@@ -1,181 +0,0 @@
-/**
- * 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;
-}