agent-profiler 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,253 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDefaultDbPath, getLastEventSummary, openDb, resolveUsableDbPath, } from "../core/db.js";
+import { getPreferredConfigPath } from "../core/profile.js";
+function hookEntryCommand(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value) || value.length === 0)
+        return "";
+    const first = value[0];
+    if (first && typeof first === "object" && typeof first.command === "string") {
+        return first.command;
+    }
+    return "";
+}
+function hookConfigured(hooks, eventName) {
+    return hookEntryCommand(hooks[eventName]).trim().length > 0;
+}
+const REQUIRED_CURSOR_EVENTS = [
+    "beforeSubmitPrompt",
+    "afterAgentResponse",
+    "afterShellExecution",
+    "afterFileEdit",
+    "stop",
+    "preToolUse",
+    "postToolUse",
+    "postToolUseFailure",
+    "beforeMCPExecution",
+    "afterMCPExecution",
+];
+const REQUIRED_CODEX_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "Stop",
+];
+function codexEventConfigured(hooks, eventName, marker) {
+    const groups = hooks[eventName] ?? [];
+    for (const g of groups) {
+        for (const h of g.hooks ?? []) {
+            if (typeof h.command === "string" && h.command.includes(marker))
+                return true;
+        }
+    }
+    return false;
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function getProfilerConfigPath(resolvedDbPath) {
+    return path.join(path.dirname(resolvedDbPath), "config.json");
+}
+function resolveStatusPaths(mode) {
+    const preferredConfigPath = mode === "prod"
+        ? path.join(process.env.HOME ?? "", ".agent-profiler", "config.json")
+        : getPreferredConfigPath(process.cwd());
+    const config = readJsonFile(preferredConfigPath);
+    if (config?.databasePath) {
+        const resolvedFromConfig = resolveUsableDbPath(config.databasePath);
+        return {
+            configuredDbPath: config.databasePath,
+            resolvedDbPath: resolvedFromConfig,
+            configPath: preferredConfigPath,
+        };
+    }
+    const defaultDbPath = resolveUsableDbPath(getDefaultDbPath());
+    const defaultConfigPath = getProfilerConfigPath(defaultDbPath);
+    return {
+        configuredDbPath: getDefaultDbPath(),
+        resolvedDbPath: defaultDbPath,
+        configPath: defaultConfigPath,
+    };
+}
+function commandExistsInPath(command) {
+    const pathValue = process.env.PATH ?? "";
+    for (const dir of pathValue.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const fullPath = path.join(dir, command);
+        if (fs.existsSync(fullPath))
+            return true;
+    }
+    return false;
+}
+function getCursorSetupStatus(configPath, mode) {
+    const config = readJsonFile(configPath);
+    const cursor = config?.adapters?.cursor;
+    if (!cursor?.enabled || !cursor.hookFile) {
+        return { state: "not yet", note: "run `agent-profiler init cursor`" };
+    }
+    const hooks = readJsonFile(cursor.hookFile)?.hooks ?? {};
+    const missing = REQUIRED_CURSOR_EVENTS.filter((eventName) => !hookConfigured(hooks, eventName));
+    if (missing.length > 0) {
+        return {
+            state: "partial",
+            note: `missing hooks: ${missing.join(", ")}`,
+        };
+    }
+    const sampleCommand = hookEntryCommand(hooks.beforeSubmitPrompt);
+    if (mode === "dev") {
+        if (!sampleCommand.startsWith("node ")) {
+            return { state: "partial", note: "dev mode expects hooks to use `node <abs>/dist/cli.js ...`" };
+        }
+        const cliPath = sampleCommand.split(" ")[1];
+        if (!cliPath || !fs.existsSync(cliPath)) {
+            return { state: "partial", note: "dev hook CLI path is missing or invalid" };
+        }
+    }
+    else {
+        if (!sampleCommand.startsWith("agent-profiler ")) {
+            return { state: "partial", note: "prod mode expects hooks to use `agent-profiler ...`" };
+        }
+        if (!commandExistsInPath("agent-profiler")) {
+            return { state: "partial", note: "`agent-profiler` is not on PATH" };
+        }
+    }
+    return { state: "yes", note: "configured via init" };
+}
+function getCodexSetupStatus(configPath, mode) {
+    const config = readJsonFile(configPath);
+    const codex = config?.adapters?.codex;
+    if (!codex?.enabled || !codex.hookFile) {
+        return { state: "not yet", note: "run `agent-profiler init codex`" };
+    }
+    const data = readJsonFile(codex.hookFile);
+    const hooks = data?.hooks ?? {};
+    const missing = REQUIRED_CODEX_EVENTS.filter((eventName) => !codexEventConfigured(hooks, eventName, `hook codex ${eventName}`));
+    if (missing.length > 0) {
+        return {
+            state: "partial",
+            note: `missing hooks: ${missing.join(", ")}`,
+        };
+    }
+    const userPromptGroups = hooks.UserPromptSubmit ?? [];
+    let sampleCommand = "";
+    outer: for (const g of userPromptGroups) {
+        for (const h of g.hooks ?? []) {
+            if (typeof h.command === "string" && h.command.includes("hook codex")) {
+                sampleCommand = h.command;
+                break outer;
+            }
+        }
+    }
+    if (!sampleCommand) {
+        return { state: "partial", note: "could not find agent-profiler command in Codex hooks" };
+    }
+    if (mode === "dev") {
+        if (!sampleCommand.startsWith("node ")) {
+            return { state: "partial", note: "dev mode expects hooks to use `node <abs>/dist/cli.js ...`" };
+        }
+        const cliPath = sampleCommand.split(" ")[1];
+        if (!cliPath || !fs.existsSync(cliPath)) {
+            return { state: "partial", note: "dev hook CLI path is missing or invalid" };
+        }
+    }
+    else {
+        if (!sampleCommand.startsWith("agent-profiler ")) {
+            return { state: "partial", note: "prod mode expects hooks to use `agent-profiler ...`" };
+        }
+        if (!commandExistsInPath("agent-profiler")) {
+            return { state: "partial", note: "`agent-profiler` is not on PATH" };
+        }
+    }
+    return { state: "yes", note: "configured via init" };
+}
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    return date.toLocaleString();
+}
+function formatCount(value) {
+    return new Intl.NumberFormat("en-US").format(value);
+}
+export function getStatusReport(mode = "dev") {
+    const { configuredDbPath, resolvedDbPath, configPath } = resolveStatusPaths(mode);
+    const cursorSetup = getCursorSetupStatus(configPath, mode);
+    const codexSetup = getCodexSetupStatus(configPath, mode);
+    let lastEvent = null;
+    try {
+        const db = openDb(configuredDbPath);
+        try {
+            lastEvent = getLastEventSummary(db);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        lastEvent = null;
+    }
+    return {
+        mode,
+        databasePath: resolvedDbPath,
+        adapters: {
+            cursor: {
+                state: cursorSetup.state,
+                setup: cursorSetup.note,
+            },
+            codex: {
+                state: codexSetup.state,
+                setup: codexSetup.note,
+            },
+        },
+        lastEvent: lastEvent
+            ? {
+                createdAt: lastEvent.createdAt,
+                source: lastEvent.source,
+                event: lastEvent.sourceEvent,
+                estimatedTokens: lastEvent.estimatedTotalTokens,
+            }
+            : null,
+        dashboard: "not running",
+    };
+}
+export function runStatus(mode = "dev") {
+    const report = getStatusReport(mode);
+    const lines = [];
+    lines.push("Agent Profiler Status");
+    lines.push("");
+    lines.push("Mode:");
+    lines.push(`  ${report.mode}`);
+    lines.push("");
+    lines.push("Database:");
+    lines.push(`  ${report.databasePath}`);
+    lines.push("");
+    lines.push("Configured adapters:");
+    lines.push(`  Cursor: ${report.adapters.cursor.state}`);
+    lines.push(`  setup: ${report.adapters.cursor.setup}`);
+    lines.push(`  Codex: ${report.adapters.codex.state}`);
+    lines.push(`  setup: ${report.adapters.codex.setup}`);
+    lines.push("");
+    lines.push("Last event:");
+    if (report.lastEvent) {
+        lines.push(`  ${formatTimestamp(report.lastEvent.createdAt)}`);
+        lines.push(`  source: ${report.lastEvent.source}`);
+        lines.push(`  event: ${report.lastEvent.event}`);
+        lines.push(`  estimated tokens: ${formatCount(report.lastEvent.estimatedTokens)}`);
+    }
+    else {
+        lines.push("  none yet");
+    }
+    lines.push("");
+    lines.push("Dashboard:");
+    lines.push("  not running");
+    console.log(lines.join("\n"));
+}

package/dist/core/contextAudit.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { estimateTokens } from "./tokens.js";
+const EXACT_FILES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".cursorrules",
+    ".codex/config.toml",
+    ".codex/hooks.json",
+    ".claude/settings.json",
+];
+const DIRS = [
+    ".cursor/rules",
+    ".cursor/skills",
+    ".claude/commands",
+    ".claude/agents",
+    ".claude/skills",
+];
+function readTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function walkFiles(dirPath) {
+    const out = [];
+    if (!fs.existsSync(dirPath))
+        return out;
+    const stack = [dirPath];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (entry.isFile()) {
+                out.push(fullPath);
+            }
+        }
+    }
+    return out;
+}
+export function runContextAudit(rootDir = process.cwd()) {
+    const candidates = new Set();
+    for (const relativePath of EXACT_FILES) {
+        const fullPath = path.join(rootDir, relativePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+            candidates.add(fullPath);
+        }
+    }
+    for (const relativeDir of DIRS) {
+        const fullDir = path.join(rootDir, relativeDir);
+        for (const filePath of walkFiles(fullDir)) {
+            candidates.add(filePath);
+        }
+    }
+    const files = [];
+    for (const fullPath of candidates) {
+        const text = readTextFile(fullPath);
+        const estimatedTokens = estimateTokens(text);
+        if (estimatedTokens > 0) {
+            files.push({
+                path: path.relative(rootDir, fullPath) || fullPath,
+                estimatedTokens,
+            });
+        }
+    }
+    files.sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+    const totalEstimatedTokens = files.reduce((sum, file) => sum + file.estimatedTokens, 0);
+    return { totalEstimatedTokens, files };
+}

package/dist/core/db.js

@@ -0,0 +1,276 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+import { getConfiguredDatabasePath } from "./profile.js";
+const HOME_DIR = path.join(os.homedir(), ".agent-profiler");
+const WORKSPACE_DIR = path.join(process.cwd(), ".agent-profiler");
+/** Same directory as this module: `src/core` when using tsx, `dist/core` when using build + copied schema. */
+const SCHEMA_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "schema.sql");
+export function getDefaultDbPath() {
+    const fromEnv = process.env.AGENT_PROFILER_DB_PATH;
+    if (fromEnv && fromEnv.trim().length > 0)
+        return fromEnv;
+    const configured = getConfiguredDatabasePath(process.cwd());
+    if (configured && configured.trim().length > 0)
+        return configured;
+    return path.join(HOME_DIR, "events.sqlite");
+}
+export function resolveWritableDbPath(dbPath) {
+    try {
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        return dbPath;
+    }
+    catch {
+        const fallbackPath = path.join(WORKSPACE_DIR, "events.sqlite");
+        fs.mkdirSync(path.dirname(fallbackPath), { recursive: true });
+        return fallbackPath;
+    }
+}
+export function openDb(dbPath = getDefaultDbPath()) {
+    const writableDbPath = resolveWritableDbPath(dbPath);
+    const db = new Database(writableDbPath);
+    db.pragma("journal_mode = WAL");
+    applySchema(db);
+    return db;
+}
+export function resolveUsableDbPath(preferredDbPath) {
+    const primary = resolveWritableDbPath(preferredDbPath);
+    try {
+        const db = new Database(primary);
+        db.pragma("journal_mode = WAL");
+        db.close();
+        return primary;
+    }
+    catch {
+        const fallbackPath = path.join(WORKSPACE_DIR, "events.sqlite");
+        fs.mkdirSync(path.dirname(fallbackPath), { recursive: true });
+        const db = new Database(fallbackPath);
+        db.pragma("journal_mode = WAL");
+        db.close();
+        return fallbackPath;
+    }
+}
+export function applySchema(db) {
+    const schemaSql = fs.readFileSync(SCHEMA_PATH, "utf8");
+    db.exec(schemaSql);
+    migrateEventsSchema(db);
+}
+function migrateEventsSchema(db) {
+    const columns = db.prepare(`PRAGMA table_info(events)`).all();
+    const names = new Set(columns.map((c) => c.name));
+    const add = (sql, colName) => {
+        if (!names.has(colName)) {
+            db.exec(sql);
+            names.add(colName);
+        }
+    };
+    add(`ALTER TABLE events ADD COLUMN workspace_path TEXT`, "workspace_path");
+    add(`ALTER TABLE events ADD COLUMN git_repo_root TEXT`, "git_repo_root");
+    add(`ALTER TABLE events ADD COLUMN git_repo_name TEXT`, "git_repo_name");
+    add(`ALTER TABLE events ADD COLUMN git_branch TEXT`, "git_branch");
+    add(`ALTER TABLE events ADD COLUMN interaction_kind TEXT`, "interaction_kind");
+    add(`ALTER TABLE events ADD COLUMN correlation_id TEXT`, "correlation_id");
+    add(`ALTER TABLE events ADD COLUMN tool_canonical_name TEXT`, "tool_canonical_name");
+    add(`ALTER TABLE events ADD COLUMN mcp_server TEXT`, "mcp_server");
+    add(`ALTER TABLE events ADD COLUMN mcp_tool TEXT`, "mcp_tool");
+    add(`ALTER TABLE events ADD COLUMN payload_byte_length INTEGER`, "payload_byte_length");
+    add(`ALTER TABLE events ADD COLUMN prompt_fingerprint TEXT`, "prompt_fingerprint");
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_events_workspace ON events(workspace_path, created_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_events_interaction_kind ON events(interaction_kind, created_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_events_correlation ON events(correlation_id, session_id)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_events_prompt_fingerprint ON events(prompt_fingerprint, created_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_spans_mcp ON interaction_spans(mcp_server, mcp_tool, started_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_spans_session ON interaction_spans(session_key, started_at)`);
+}
+export function insertEvent(db, event, payloadHash, workspaceGit, derived) {
+    const stmt = db.prepare(`
+    INSERT INTO events (
+      created_at,
+      source,
+      source_event,
+      repo_path,
+      session_id,
+      turn_id,
+      model,
+      role,
+      estimated_input_tokens,
+      estimated_output_tokens,
+      estimated_total_tokens,
+      payload_hash,
+      raw_payload,
+      workspace_path,
+      git_repo_root,
+      git_repo_name,
+      git_branch,
+      interaction_kind,
+      correlation_id,
+      tool_canonical_name,
+      mcp_server,
+      mcp_tool,
+      payload_byte_length,
+      prompt_fingerprint
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const info = stmt.run(new Date().toISOString(), event.source, event.sourceEvent, event.repoPath ?? null, event.sessionId ?? null, event.turnId ?? null, event.model ?? null, event.role, event.estimatedInputTokens, event.estimatedOutputTokens, event.estimatedTotalTokens, payloadHash, JSON.stringify(event.rawPayload), workspaceGit.workspacePath, workspaceGit.gitRepoRoot, workspaceGit.gitRepoName, workspaceGit.gitBranch, derived.interactionKind, derived.correlationId, derived.toolCanonicalName, derived.mcpServer, derived.mcpTool, derived.payloadByteLength, derived.promptFingerprint);
+    return Number(info.lastInsertRowid);
+}
+/**
+ * Links pre/post/failure hook rows for the same logical tool or MCP call via correlation_id.
+ */
+export function mergeInteractionSpan(db, eventId, normalized, workspaceGit, derived) {
+    if (!derived.correlationId || !derived.toolPhase)
+        return;
+    const sessionKey = normalized.sessionId ?? "";
+    const source = normalized.source;
+    const now = new Date().toISOString();
+    const existing = db
+        .prepare(`SELECT id, arg_token_estimate, result_token_estimate, pre_event_id, post_event_id, failure_event_id
+       FROM interaction_spans
+       WHERE session_key = ? AND source = ? AND correlation_id = ?`)
+        .get(sessionKey, source, derived.correlationId);
+    const argTok = Math.max(normalized.estimatedInputTokens, 0);
+    const resTok = Math.max(normalized.estimatedOutputTokens, 0);
+    const toolName = derived.toolCanonicalName;
+    const mcpS = derived.mcpServer;
+    const mcpT = derived.mcpTool;
+    if (!existing) {
+        const ins = db.prepare(`
+      INSERT INTO interaction_spans (
+        session_key, source, correlation_id, turn_id,
+        tool_canonical_name, mcp_server, mcp_tool,
+        pre_event_id, post_event_id, failure_event_id,
+        arg_token_estimate, result_token_estimate,
+        workspace_path, git_repo_root, git_repo_name, git_branch,
+        started_at, completed_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        if (derived.toolPhase === "pre") {
+            ins.run(sessionKey, source, derived.correlationId, normalized.turnId ?? null, toolName, mcpS, mcpT, eventId, null, null, argTok, 0, workspaceGit.workspacePath, workspaceGit.gitRepoRoot, workspaceGit.gitRepoName, workspaceGit.gitBranch, now, null);
+        }
+        else if (derived.toolPhase === "post") {
+            ins.run(sessionKey, source, derived.correlationId, normalized.turnId ?? null, toolName, mcpS, mcpT, null, eventId, null, 0, resTok, workspaceGit.workspacePath, workspaceGit.gitRepoRoot, workspaceGit.gitRepoName, workspaceGit.gitBranch, null, now);
+        }
+        else {
+            ins.run(sessionKey, source, derived.correlationId, normalized.turnId ?? null, toolName, mcpS, mcpT, null, null, eventId, 0, resTok, workspaceGit.workspacePath, workspaceGit.gitRepoRoot, workspaceGit.gitRepoName, workspaceGit.gitBranch, null, now);
+        }
+        return;
+    }
+    if (derived.toolPhase === "pre") {
+        db.prepare(`UPDATE interaction_spans SET
+        pre_event_id = COALESCE(pre_event_id, ?),
+        started_at = COALESCE(started_at, ?),
+        arg_token_estimate = ?,
+        tool_canonical_name = COALESCE(tool_canonical_name, ?),
+        mcp_server = COALESCE(mcp_server, ?),
+        mcp_tool = COALESCE(mcp_tool, ?),
+        turn_id = COALESCE(turn_id, ?)
+      WHERE id = ?`).run(eventId, now, Math.max(existing.arg_token_estimate, argTok), toolName, mcpS, mcpT, normalized.turnId ?? null, existing.id);
+    }
+    else if (derived.toolPhase === "post") {
+        db.prepare(`UPDATE interaction_spans SET
+        post_event_id = COALESCE(post_event_id, ?),
+        completed_at = COALESCE(completed_at, ?),
+        result_token_estimate = ?,
+        tool_canonical_name = COALESCE(tool_canonical_name, ?),
+        mcp_server = COALESCE(mcp_server, ?),
+        mcp_tool = COALESCE(mcp_tool, ?),
+        turn_id = COALESCE(turn_id, ?)
+      WHERE id = ?`).run(eventId, now, Math.max(existing.result_token_estimate, resTok), toolName, mcpS, mcpT, normalized.turnId ?? null, existing.id);
+    }
+    else {
+        db.prepare(`UPDATE interaction_spans SET
+        failure_event_id = COALESCE(failure_event_id, ?),
+        completed_at = COALESCE(completed_at, ?),
+        result_token_estimate = ?,
+        tool_canonical_name = COALESCE(tool_canonical_name, ?),
+        mcp_server = COALESCE(mcp_server, ?),
+        mcp_tool = COALESCE(mcp_tool, ?),
+        turn_id = COALESCE(turn_id, ?)
+      WHERE id = ?`).run(eventId, now, Math.max(existing.result_token_estimate, resTok), toolName, mcpS, mcpT, normalized.turnId ?? null, existing.id);
+    }
+}
+export function getLastEventSummary(db) {
+    const row = db
+        .prepare(`
+      SELECT
+        created_at AS createdAt,
+        source,
+        source_event AS sourceEvent,
+        estimated_total_tokens AS estimatedTotalTokens
+      FROM events
+      ORDER BY created_at DESC
+      LIMIT 1
+      `)
+        .get();
+    return row ?? null;
+}
+export function getEventsForLatestSession(db) {
+    const latest = db
+        .prepare(`
+      SELECT source, session_id AS sessionId, repo_path AS repoPath
+      FROM events
+      ORDER BY created_at DESC
+      LIMIT 1
+      `)
+        .get();
+    if (!latest)
+        return [];
+    const rows = latest.sessionId
+        ? db
+            .prepare(`
+          SELECT
+            id,
+            created_at AS createdAt,
+            source,
+            source_event AS sourceEvent,
+            repo_path AS repoPath,
+            session_id AS sessionId,
+            turn_id AS turnId,
+            model,
+            role,
+            estimated_input_tokens AS estimatedInputTokens,
+            estimated_output_tokens AS estimatedOutputTokens,
+            estimated_total_tokens AS estimatedTotalTokens,
+            raw_payload AS rawPayload,
+            workspace_path AS workspacePath,
+            git_repo_root AS gitRepoRoot,
+            git_repo_name AS gitRepoName,
+            git_branch AS gitBranch
+          FROM events
+          WHERE source = ? AND session_id = ?
+          ORDER BY created_at ASC, id ASC
+          `)
+            .all(latest.source, latest.sessionId)
+        : db
+            .prepare(`
+          SELECT
+            id,
+            created_at AS createdAt,
+            source,
+            source_event AS sourceEvent,
+            repo_path AS repoPath,
+            session_id AS sessionId,
+            turn_id AS turnId,
+            model,
+            role,
+            estimated_input_tokens AS estimatedInputTokens,
+            estimated_output_tokens AS estimatedOutputTokens,
+            estimated_total_tokens AS estimatedTotalTokens,
+            raw_payload AS rawPayload,
+            workspace_path AS workspacePath,
+            git_repo_root AS gitRepoRoot,
+            git_repo_name AS gitRepoName,
+            git_branch AS gitBranch
+          FROM events
+          WHERE source = ? AND repo_path IS ?
+          ORDER BY created_at DESC, id DESC
+          LIMIT 200
+          `)
+            .all(latest.source, latest.repoPath ?? null)
+            .reverse();
+    return rows;
+}