ai-wrapped 0.0.1

package/src/shared/schema.ts

@@ -0,0 +1,71 @@
+export type SessionSource = "claude" | "codex" | "gemini" | "opencode" | "droid" | "copilot";
+
+export const SESSION_SOURCES: SessionSource[] = ["claude", "codex", "gemini", "opencode", "droid", "copilot"];
+
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  reasoningTokens: number;
+}
+
+export type { Session, SessionEvent, SessionEventKind, SessionFilters, SessionSortBy, SessionSortDir } from "./session-types";
+
+export const EMPTY_TOKEN_USAGE: TokenUsage = {
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  reasoningTokens: 0,
+};
+
+export interface DailyAggregate {
+  date: string;
+  source: SessionSource | "all";
+  model: string | "all";
+  sessionCount: number;
+  messageCount: number;
+  toolCallCount: number;
+  tokens: TokenUsage;
+  costUsd: number;
+  totalDurationMs: number;
+}
+
+export interface DashboardSummary {
+  totals: {
+    sessions: number;
+    events: number;
+    messages: number;
+    toolCalls: number;
+    tokens: TokenUsage;
+    costUsd: number;
+    durationMs: number;
+  };
+  byAgent: Record<
+    SessionSource,
+    {
+      sessions: number;
+      events: number;
+      tokens: TokenUsage;
+      costUsd: number;
+    }
+  >;
+  byModel: Array<{
+    model: string;
+    sessions: number;
+    tokens: TokenUsage;
+    costUsd: number;
+  }>;
+  dailyTimeline: DailyAggregate[];
+  topRepos: Array<{ repo: string; sessions: number; costUsd: number }>;
+  topTools: Array<{ tool: string; count: number }>;
+}
+
+export interface TrayStats {
+  todayTokens: number;
+  todayCost: number;
+  todaySessions: number;
+  todayEvents: number;
+  activeSessions: number;
+}

package/src/shared/session-types.ts

@@ -0,0 +1,61 @@
+import type { SessionSource, TokenUsage } from "./schema";
+
+export type SessionEventKind = "user" | "assistant" | "tool_call" | "tool_result" | "error" | "meta";
+
+export interface SessionEvent {
+  id: string;
+  sessionId: string;
+  kind: SessionEventKind;
+  timestamp: string | null;
+  role: string | null;
+  text: string | null;
+  toolName: string | null;
+  toolInput: string | null;
+  toolOutput: string | null;
+  model: string | null;
+  parentId: string | null;
+  messageId: string | null;
+  isDelta: boolean;
+  tokens: TokenUsage | null;
+  costUsd: number | null;
+}
+
+export interface Session {
+  id: string;
+  source: SessionSource;
+  filePath: string;
+  fileSizeBytes: number;
+  startTime: string | null;
+  endTime: string | null;
+  durationMs: number | null;
+  title: string | null;
+  model: string | null;
+  cwd: string | null;
+  repoName: string | null;
+  gitBranch: string | null;
+  cliVersion: string | null;
+  eventCount: number;
+  messageCount: number;
+  totalTokens: TokenUsage;
+  totalCostUsd: number | null;
+  toolCallCount: number;
+  isHousekeeping: boolean;
+  parsedAt: string;
+}
+
+export type SessionSortBy = "date" | "cost" | "tokens" | "duration";
+export type SessionSortDir = "asc" | "desc";
+
+export interface SessionFilters {
+  query: string;
+  sources: SessionSource[];
+  models: string[];
+  dateFrom: string | null;
+  dateTo: string | null;
+  repoName: string | null;
+  minCost: number | null;
+  sortBy: SessionSortBy;
+  sortDir: SessionSortDir;
+  offset: number;
+  limit: number;
+}

package/src/shared/types.ts

@@ -0,0 +1,59 @@
+import type { RPCSchema } from "electrobun/bun";
+import type { DailyAggregate, DashboardSummary, SessionSource, TrayStats } from "./schema";
+
+export interface AppSettings {
+  scanOnLaunch: boolean;
+  scanIntervalMinutes: number;
+  theme: "system" | "light" | "dark";
+  customPaths: Partial<Record<SessionSource, string>>;
+}
+
+export type AIStatsRPC = {
+  bun: RPCSchema<{
+    requests: {
+      getDashboardSummary: {
+        params: { dateFrom?: string; dateTo?: string };
+        response: DashboardSummary;
+      };
+      getDailyTimeline: {
+        params: { dateFrom: string; dateTo: string; source?: SessionSource };
+        response: DailyAggregate[];
+      };
+      triggerScan: {
+        params: { fullScan?: boolean };
+        response: { scanned: number; total: number };
+      };
+      getScanStatus: {
+        params: {};
+        response: { isScanning: boolean; lastScanAt: string | null; sessionCount: number };
+      };
+      getTrayStats: {
+        params: {};
+        response: TrayStats;
+      };
+      getSettings: {
+        params: {};
+        response: AppSettings;
+      };
+      updateSettings: {
+        params: Partial<AppSettings>;
+        response: boolean;
+      };
+    };
+    messages: {
+      log: { msg: string; level?: "info" | "warn" | "error" };
+    };
+  }>;
+
+  webview: RPCSchema<{
+    requests: {};
+    messages: {
+      sessionsUpdated: { scanResult: { scanned: number; total: number } };
+      scanProgress: { phase: string; current: number; total: number };
+      scanStarted: {};
+      scanCompleted: { scanned: number; total: number };
+      navigate: { view: "dashboard" | "settings" };
+      themeChanged: { theme: AppSettings["theme"] };
+    };
+  }>;
+};

package/src/types/electrobun-bun.d.ts

@@ -0,0 +1,117 @@
+declare module "electrobun/bun" {
+  type AnyRequests = Record<string, { params: unknown; response: unknown }>;
+  type AnyMessages = Record<string, unknown>;
+
+  export type RPCSchema<T extends { requests?: unknown; messages?: unknown }> = {
+    requests: T extends { requests: infer R } ? R : AnyRequests;
+    messages: T extends { messages: infer M } ? M : AnyMessages;
+  };
+
+  export interface ElectrobunRPCSchema {
+    bun: { requests: AnyRequests; messages: AnyMessages };
+    webview: { requests: AnyRequests; messages: AnyMessages };
+  }
+
+  type Side = "bun" | "webview";
+  type OtherSide<S extends Side> = S extends "bun" ? "webview" : "bun";
+
+  type RequestHandlers<Requests extends AnyRequests> = {
+    [K in keyof Requests]?: (
+      params: Requests[K]["params"],
+    ) => Requests[K]["response"] | Promise<Requests[K]["response"]>;
+  };
+
+  type MessageHandlers<Messages extends AnyMessages> = {
+    [K in keyof Messages]?: (payload: Messages[K]) => void;
+  } & {
+    "*"?:
+      | ((messageName: keyof Messages, payload: Messages[keyof Messages]) => void)
+      | undefined;
+  };
+
+  type RPCInstance<Schema extends ElectrobunRPCSchema, S extends Side> = {
+    request: {
+      [K in keyof Schema[OtherSide<S>]["requests"]]: (
+        params: Schema[OtherSide<S>]["requests"][K]["params"],
+      ) => Promise<Schema[OtherSide<S>]["requests"][K]["response"]>;
+    };
+    send: {
+      [K in keyof Schema[OtherSide<S>]["messages"]]: (
+        payload: Schema[OtherSide<S>]["messages"][K],
+      ) => void;
+    };
+    addMessageListener: (
+      message: keyof Schema[S]["messages"] | "*",
+      listener: (...args: unknown[]) => void,
+    ) => void;
+    removeMessageListener: (
+      message: keyof Schema[S]["messages"] | "*",
+      listener: (...args: unknown[]) => void,
+    ) => void;
+  };
+
+  export type MenuItemConfig = {
+    type?: string;
+    label?: string;
+    tooltip?: string;
+    action?: string;
+    role?: string;
+    data?: unknown;
+    submenu?: Array<MenuItemConfig>;
+    enabled?: boolean;
+    checked?: boolean;
+    hidden?: boolean;
+    accelerator?: string;
+  };
+
+  export type ApplicationMenuItemConfig = MenuItemConfig;
+
+  export class BrowserView {
+    static defineRPC<Schema extends ElectrobunRPCSchema>(config: {
+      handlers: {
+        requests?: RequestHandlers<Schema["bun"]["requests"]>;
+        messages?: MessageHandlers<Schema["bun"]["messages"]>;
+      };
+      maxRequestTime?: number;
+    }): RPCInstance<Schema, "bun">;
+  }
+
+  export class BrowserWindow<T = unknown> {
+    constructor(options?: Record<string, unknown>);
+    readonly webview: { rpc?: T };
+    show(): void;
+    focus(): void;
+    minimize(): void;
+    unminimize(): void;
+    isMinimized(): boolean;
+    on(name: string, handler: (event: unknown) => void): void;
+  }
+
+  export class Tray {
+    constructor(options?: {
+      title?: string;
+      image?: string;
+      template?: boolean;
+      width?: number;
+      height?: number;
+    });
+    setTitle(title: string): void;
+    setImage(path: string): void;
+    setMenu(menu: Array<MenuItemConfig>): void;
+    on(name: "tray-clicked", handler: (event: unknown) => void): void;
+    remove(): void;
+  }
+
+  export const ApplicationMenu: {
+    setApplicationMenu: (menu: Array<ApplicationMenuItemConfig>) => void;
+    on: (name: "application-menu-clicked", handler: (event: unknown) => void) => void;
+  };
+
+  export const Utils: {
+    quit: () => void;
+  };
+
+  export const PATHS: {
+    VIEWS_FOLDER: string;
+  };
+}

package/src/types/electrobun-root.d.ts

@@ -0,0 +1,3 @@
+declare module "electrobun" {
+  export type ElectrobunConfig = Record<string, unknown>;
+}

package/src/types/electrobun-view.d.ts

@@ -0,0 +1,38 @@
+declare module "electrobun/view" {
+  import type { ElectrobunRPCSchema } from "electrobun/bun";
+
+  type RPCInstance<Schema extends ElectrobunRPCSchema> = {
+    request: {
+      [K in keyof Schema["bun"]["requests"]]: (
+        params: Schema["bun"]["requests"][K]["params"],
+      ) => Promise<Schema["bun"]["requests"][K]["response"]>;
+    };
+    send: {
+      [K in keyof Schema["bun"]["messages"]]: (
+        payload: Schema["bun"]["messages"][K],
+      ) => void;
+    };
+    addMessageListener: (
+      message: keyof Schema["webview"]["messages"] | "*",
+      listener: (...args: unknown[]) => void,
+    ) => void;
+    removeMessageListener: (
+      message: keyof Schema["webview"]["messages"] | "*",
+      listener: (...args: unknown[]) => void,
+    ) => void;
+  };
+
+  export class Electroview<Schema extends ElectrobunRPCSchema = ElectrobunRPCSchema> {
+    constructor(config: {
+      rpc: RPCInstance<Schema>;
+    });
+
+    static defineRPC<Schema extends ElectrobunRPCSchema>(config: {
+      handlers: {
+        requests?: Record<string, (params: unknown) => unknown>;
+        messages?: Record<string, (payload: unknown) => void>;
+      };
+      maxRequestTime?: number;
+    }): RPCInstance<Schema>;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@shared/*": ["src/shared/*"]
+    },
+    "types": ["bun"]
+  },
+  "include": ["src", "electrobun.config.ts", "vite.config.ts"]
+}

package/tsconfig.typecheck.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@shared/*": ["src/shared/*"],
+      "electrobun": ["src/types/electrobun-root.d.ts"],
+      "electrobun/bun": ["src/types/electrobun-bun.d.ts"],
+      "electrobun/view": ["src/types/electrobun-view.d.ts"]
+    }
+  }
+}

package/vite.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { fileURLToPath, URL } from "node:url";
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  root: "src/mainview",
+  publicDir: "../../public",
+  build: {
+    outDir: "../../dist",
+    emptyOutDir: true,
+  },
+  server: {
+    port: 5173,
+    strictPort: true,
+  },
+  resolve: {
+    alias: {
+      "@shared": fileURLToPath(new URL("./src/shared", import.meta.url)),
+    },
+  },
+});