agent-profiler 1.0.0 → 1.0.1

package/dist/core/db.js

@@ -70,7 +70,10 @@ function migrateTableColumns(db, tableName, columnsToAdd) {
 }
 function migrateEventsSchema(db) {
     migrateTableColumns(db, "events", [
-        { name: "workspace_path", sql: `ALTER TABLE events ADD COLUMN workspace_path TEXT` },
+        {
+            name: "workspace_path",
+            sql: `ALTER TABLE events ADD COLUMN workspace_path TEXT`,
+        },
         {
             name: "workspace_home_rel_path",
             sql: `ALTER TABLE events ADD COLUMN workspace_home_rel_path TEXT`,
@@ -79,7 +82,10 @@ function migrateEventsSchema(db) {
             name: "workspace_display_path",
             sql: `ALTER TABLE events ADD COLUMN workspace_display_path TEXT`,
         },
-        { name: "git_repo_root", sql: `ALTER TABLE events ADD COLUMN git_repo_root TEXT` },
+        {
+            name: "git_repo_root",
+            sql: `ALTER TABLE events ADD COLUMN git_repo_root TEXT`,
+        },
         {
             name: "git_repo_root_home_rel_path",
             sql: `ALTER TABLE events ADD COLUMN git_repo_root_home_rel_path TEXT`,
@@ -88,18 +94,30 @@ function migrateEventsSchema(db) {
             name: "git_repo_root_display_path",
             sql: `ALTER TABLE events ADD COLUMN git_repo_root_display_path TEXT`,
         },
-        { name: "git_repo_name", sql: `ALTER TABLE events ADD COLUMN git_repo_name TEXT` },
-        { name: "git_branch", sql: `ALTER TABLE events ADD COLUMN git_branch TEXT` },
+        {
+            name: "git_repo_name",
+            sql: `ALTER TABLE events ADD COLUMN git_repo_name TEXT`,
+        },
+        {
+            name: "git_branch",
+            sql: `ALTER TABLE events ADD COLUMN git_branch TEXT`,
+        },
         {
             name: "interaction_kind",
             sql: `ALTER TABLE events ADD COLUMN interaction_kind TEXT`,
         },
-        { name: "correlation_id", sql: `ALTER TABLE events ADD COLUMN correlation_id TEXT` },
+        {
+            name: "correlation_id",
+            sql: `ALTER TABLE events ADD COLUMN correlation_id TEXT`,
+        },
         {
             name: "tool_canonical_name",
             sql: `ALTER TABLE events ADD COLUMN tool_canonical_name TEXT`,
         },
-        { name: "mcp_server", sql: `ALTER TABLE events ADD COLUMN mcp_server TEXT` },
+        {
+            name: "mcp_server",
+            sql: `ALTER TABLE events ADD COLUMN mcp_server TEXT`,
+        },
         { name: "mcp_tool", sql: `ALTER TABLE events ADD COLUMN mcp_tool TEXT` },
         {
             name: "payload_byte_length",
@@ -113,13 +131,22 @@ function migrateEventsSchema(db) {
 }
 function migrateInteractionSpansSchema(db) {
     migrateTableColumns(db, "interaction_spans", [
-        { name: "turn_id", sql: `ALTER TABLE interaction_spans ADD COLUMN turn_id TEXT` },
+        {
+            name: "turn_id",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN turn_id TEXT`,
+        },
         {
             name: "tool_canonical_name",
             sql: `ALTER TABLE interaction_spans ADD COLUMN tool_canonical_name TEXT`,
         },
-        { name: "mcp_server", sql: `ALTER TABLE interaction_spans ADD COLUMN mcp_server TEXT` },
-        { name: "mcp_tool", sql: `ALTER TABLE interaction_spans ADD COLUMN mcp_tool TEXT` },
+        {
+            name: "mcp_server",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN mcp_server TEXT`,
+        },
+        {
+            name: "mcp_tool",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN mcp_tool TEXT`,
+        },
         {
             name: "pre_event_id",
             sql: `ALTER TABLE interaction_spans ADD COLUMN pre_event_id INTEGER`,
@@ -168,9 +195,18 @@ function migrateInteractionSpansSchema(db) {
             name: "git_repo_name",
             sql: `ALTER TABLE interaction_spans ADD COLUMN git_repo_name TEXT`,
         },
-        { name: "git_branch", sql: `ALTER TABLE interaction_spans ADD COLUMN git_branch TEXT` },
-        { name: "started_at", sql: `ALTER TABLE interaction_spans ADD COLUMN started_at TEXT` },
-        { name: "completed_at", sql: `ALTER TABLE interaction_spans ADD COLUMN completed_at TEXT` },
+        {
+            name: "git_branch",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN git_branch TEXT`,
+        },
+        {
+            name: "started_at",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN started_at TEXT`,
+        },
+        {
+            name: "completed_at",
+            sql: `ALTER TABLE interaction_spans ADD COLUMN completed_at TEXT`,
+        },
     ]);
     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)`);
@@ -351,27 +387,7 @@ export function getEventsForLatestSession(db) {
         ? 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,
-            workspace_home_rel_path AS workspaceHomeRelPath,
-            workspace_display_path AS workspaceDisplayPath,
-            git_repo_root AS gitRepoRoot,
-            git_repo_root_home_rel_path AS gitRepoRootHomeRelPath,
-            git_repo_root_display_path AS gitRepoRootDisplayPath,
-            git_repo_name AS gitRepoName,
-            git_branch AS gitBranch
+${STORED_EVENT_SELECT}
           FROM events
           WHERE source = ? AND session_id = ?
           ORDER BY created_at ASC, id ASC
@@ -380,27 +396,7 @@ export function getEventsForLatestSession(db) {
         : 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,
-            workspace_home_rel_path AS workspaceHomeRelPath,
-            workspace_display_path AS workspaceDisplayPath,
-            git_repo_root AS gitRepoRoot,
-            git_repo_root_home_rel_path AS gitRepoRootHomeRelPath,
-            git_repo_root_display_path AS gitRepoRootDisplayPath,
-            git_repo_name AS gitRepoName,
-            git_branch AS gitBranch
+${STORED_EVENT_SELECT}
           FROM events
           WHERE source = ? AND repo_path IS ?
           ORDER BY created_at DESC, id DESC
@@ -410,3 +406,117 @@ export function getEventsForLatestSession(db) {
             .reverse();
     return rows;
 }
+const STORED_EVENT_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,
+          workspace_home_rel_path AS workspaceHomeRelPath,
+          workspace_display_path AS workspaceDisplayPath,
+          git_repo_root AS gitRepoRoot,
+          git_repo_root_home_rel_path AS gitRepoRootHomeRelPath,
+          git_repo_root_display_path AS gitRepoRootDisplayPath,
+          git_repo_name AS gitRepoName,
+          git_branch AS gitBranch
+`;
+export function getLatestSessionDescriptor(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();
+    return latest ?? null;
+}
+export function listRecentSessions(db, limit) {
+    const rows = db
+        .prepare(`
+      SELECT
+        source AS source,
+        session_id AS sessionId,
+        MAX(repo_path) AS repoPath,
+        MIN(created_at) AS startedAt,
+        MAX(created_at) AS endedAt,
+        COUNT(*) AS eventCount
+      FROM events
+      WHERE session_id IS NOT NULL AND LENGTH(TRIM(session_id)) > 0
+      GROUP BY source, session_id
+      ORDER BY endedAt DESC
+      LIMIT ?
+      `)
+        .all(limit);
+    return rows;
+}
+export function getEventsForSession(db, source, sessionId) {
+    const rows = db
+        .prepare(`
+          SELECT
+      ${STORED_EVENT_SELECT}
+          FROM events
+          WHERE source = ? AND session_id = ?
+          ORDER BY created_at ASC, id ASC
+          `)
+        .all(source, sessionId);
+    return rows;
+}
+/** Latest window used when session_id is absent (matches getEventsForLatestSession fallback). */
+export function getEventsForLegacyRepoWindow(db, source, repoPath) {
+    const rows = db
+        .prepare(`
+          SELECT
+      ${STORED_EVENT_SELECT}
+          FROM events
+          WHERE source = ? AND repo_path IS ?
+          ORDER BY created_at DESC, id DESC
+          LIMIT 200
+          `)
+        .all(source, repoPath ?? null);
+    return rows.reverse();
+}
+export function getSessionTimeline(db, source, sessionId) {
+    const rows = db
+        .prepare(`
+      SELECT
+        id,
+        created_at AS createdAt,
+        role,
+        turn_id AS turnId,
+        estimated_total_tokens AS estimatedTotalTokens,
+        source_event AS sourceEvent
+      FROM events
+      WHERE source = ? AND session_id = ?
+      ORDER BY created_at ASC, id ASC
+      `)
+        .all(source, sessionId);
+    return rows;
+}
+export function getLegacyRepoTimeline(db, source, repoPath) {
+    const rows = db
+        .prepare(`
+      SELECT
+        id,
+        created_at AS createdAt,
+        role,
+        turn_id AS turnId,
+        estimated_total_tokens AS estimatedTotalTokens,
+        source_event AS sourceEvent
+      FROM events
+      WHERE source = ? AND repo_path IS ?
+      ORDER BY created_at DESC, id DESC
+      LIMIT 200
+      `)
+        .all(source, repoPath ?? null);
+    return rows.reverse();
+}

package/dist/core/eventMetadata.js

@@ -21,7 +21,10 @@ export function parseMcpToolName(canonical) {
     if (t.startsWith("mcp__")) {
         const parts = t.split("__").filter(Boolean);
         if (parts.length >= 3) {
-            return { mcpServer: parts[1] ?? null, mcpTool: parts.slice(2).join("__") || null };
+            return {
+                mcpServer: parts[1] ?? null,
+                mcpTool: parts.slice(2).join("__") || null,
+            };
         }
     }
     if (t.toLowerCase().startsWith("mcp:")) {
@@ -102,7 +105,9 @@ export function deriveIngestFields(source, hookEventName, rawPayload, rawJsonTex
     const payload = asRecord(rawPayload);
     const correlationId = extractCorrelationId(payload);
     let toolCanonicalName = extractToolCanonicalName(payload);
-    if (!toolCanonicalName && payload.tool_input && typeof payload.tool_input === "object") {
+    if (!toolCanonicalName &&
+        payload.tool_input &&
+        typeof payload.tool_input === "object") {
         const ti = payload.tool_input;
         toolCanonicalName =
             pickFirstString([ti.command, ti.tool, ti.name])?.trim() ||

package/dist/core/gitWorkspace.js

@@ -58,7 +58,9 @@ export function resolveHookWorkspacePath(normalizedRepoPath, rawPayload) {
     for (const c of candidates) {
         if (!c)
             continue;
-        return path.isAbsolute(c) ? path.normalize(c) : path.resolve(process.cwd(), c);
+        return path.isAbsolute(c)
+            ? path.normalize(c)
+            : path.resolve(process.cwd(), c);
     }
     return path.resolve(process.cwd());
 }
@@ -84,7 +86,10 @@ function gitOutput(workspacePath, args) {
 export function resolveWorkspaceGitMeta(workspacePath) {
     const normalizedWorkspacePath = path.normalize(workspacePath);
     const workspaceHomePath = deriveHomePath(normalizedWorkspacePath);
-    const inside = gitOutput(normalizedWorkspacePath, ["rev-parse", "--is-inside-work-tree"]);
+    const inside = gitOutput(normalizedWorkspacePath, [
+        "rev-parse",
+        "--is-inside-work-tree",
+    ]);
     if (inside !== "true") {
         return {
             workspacePath: normalizedWorkspacePath,
@@ -97,8 +102,15 @@ export function resolveWorkspaceGitMeta(workspacePath) {
             gitBranch: null,
         };
     }
-    const root = gitOutput(normalizedWorkspacePath, ["rev-parse", "--show-toplevel"]);
-    const branch = gitOutput(normalizedWorkspacePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const root = gitOutput(normalizedWorkspacePath, [
+        "rev-parse",
+        "--show-toplevel",
+    ]);
+    const branch = gitOutput(normalizedWorkspacePath, [
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]);
     const gitRepoRoot = root ? path.normalize(root) : null;
     const gitRepoRootHomePath = deriveHomePath(gitRepoRoot);
     const gitRepoName = gitRepoRoot ? path.basename(gitRepoRoot) : null;

package/dist/core/sessionAnalytics.js

@@ -0,0 +1,204 @@
+import { runContextAudit } from "./contextAudit.js";
+function parsePayload(rawPayload) {
+    try {
+        const parsed = JSON.parse(rawPayload);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore malformed payloads
+    }
+    return {};
+}
+export function formatTokens(value) {
+    return `~${new Intl.NumberFormat("en-US").format(value)} tokens`;
+}
+function normalizeSnippet(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 160);
+}
+export const LARGEST_EVENTS_LIMIT = 10;
+function sessionKeyLabel(first) {
+    if (first.sessionId && first.sessionId.trim().length > 0) {
+        return first.sessionId;
+    }
+    return first.repoPath ?? "(no-session-id)";
+}
+/**
+ * Builds the same report shape as the CLI `last` command from ordered session events.
+ */
+export function analyzeSession(events, options) {
+    if (events.length === 0) {
+        return null;
+    }
+    const first = events[0];
+    const lastEv = events[events.length - 1];
+    const start = new Date(first.createdAt).getTime();
+    const end = new Date(lastEv.createdAt).getTime();
+    const durationMinutes = Math.max(0, Math.round((end - start) / 60000));
+    let input = 0;
+    let output = 0;
+    let total = 0;
+    let shellOutput = 0;
+    let toolResults = 0;
+    const turnIds = new Set();
+    let fileEdits = 0;
+    let shellCalls = 0;
+    let toolCalls = 0;
+    const fileEditCounts = new Map();
+    const redFlags = [];
+    let recommendations = [];
+    const shellFailureBuckets = new Map();
+    for (const event of events) {
+        input += event.estimatedInputTokens;
+        output += event.estimatedOutputTokens;
+        total += event.estimatedTotalTokens;
+        if (event.turnId)
+            turnIds.add(event.turnId);
+        if (event.role === "file_edit") {
+            fileEdits += 1;
+            const payload = parsePayload(event.rawPayload);
+            const file = (payload.filePath ??
+                payload.path ??
+                payload.relativePath);
+            if (file) {
+                fileEditCounts.set(file, (fileEditCounts.get(file) ?? 0) + 1);
+            }
+        }
+        if (event.role === "shell_command")
+            shellCalls += 1;
+        if (event.role === "shell_output") {
+            shellCalls += 1;
+            shellOutput += event.estimatedTotalTokens;
+            const payload = parsePayload(event.rawPayload);
+            const command = typeof payload.command === "string" ? payload.command : null;
+            const stderr = typeof payload.stderr === "string" ? payload.stderr : "";
+            const stdout = typeof payload.stdout === "string" ? payload.stdout : "";
+            const outputSnippet = normalizeSnippet(stderr || stdout);
+            const looksFailed = outputSnippet.includes("error") ||
+                outputSnippet.includes("failed") ||
+                outputSnippet.includes("exception") ||
+                outputSnippet.includes("traceback");
+            if (command && looksFailed) {
+                const key = `${normalizeSnippet(command)}|${outputSnippet}`;
+                const prev = shellFailureBuckets.get(key) ?? { runs: 0, tokenTotal: 0 };
+                shellFailureBuckets.set(key, {
+                    runs: prev.runs + 1,
+                    tokenTotal: prev.tokenTotal + event.estimatedTotalTokens,
+                });
+            }
+        }
+        if (event.role === "tool_call")
+            toolCalls += 1;
+        if (event.role === "tool_result" || event.role === "tool_failure")
+            toolResults += event.estimatedTotalTokens;
+    }
+    let score = 100;
+    const topChurn = [...fileEditCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+    if (topChurn && topChurn[1] >= 5) {
+        redFlags.push({
+            severity: "HIGH",
+            title: "same-file churn",
+            detail: `${topChurn[0]} was edited ${topChurn[1]} times.`,
+            recommendation: "Add a focused repo rule or skill note for this file's recurring failure pattern.",
+            penalty: 15,
+        });
+    }
+    if (shellOutput > 4000) {
+        redFlags.push({
+            severity: "HIGH",
+            title: "shell output noise",
+            detail: `Shell output produced ${formatTokens(shellOutput)} in this session.`,
+            recommendation: "Capture key test/build failures once, then summarize repeated output.",
+            penalty: 12,
+        });
+    }
+    if (toolResults > 4000) {
+        redFlags.push({
+            severity: "MEDIUM",
+            title: "large tool result",
+            detail: `Tool results produced ${formatTokens(toolResults)} in this session.`,
+            recommendation: "Request narrower tool queries and summarize oversized tool responses.",
+            penalty: 10,
+        });
+    }
+    const worstFailureLoop = [...shellFailureBuckets.entries()].sort((a, b) => b[1].runs - a[1].runs || b[1].tokenTotal - a[1].tokenTotal)[0];
+    if (worstFailureLoop && worstFailureLoop[1].runs >= 3) {
+        redFlags.push({
+            severity: "HIGH",
+            title: "thrashing loop",
+            detail: `A similar failing shell command looped ${worstFailureLoop[1].runs} times (${formatTokens(worstFailureLoop[1].tokenTotal)}).`,
+            recommendation: "Pause after repeated failures, capture one root error, then adjust strategy.",
+            penalty: 14,
+        });
+    }
+    const largestPrompt = events
+        .filter((e) => e.role === "user_prompt")
+        .reduce((max, cur) => Math.max(max, cur.estimatedTotalTokens), 0);
+    if (largestPrompt > 8000) {
+        redFlags.push({
+            severity: "MEDIUM",
+            title: "oversized prompt",
+            detail: `Largest prompt was ${formatTokens(largestPrompt)}.`,
+            recommendation: "Split goals into smaller requests and load reference docs on demand.",
+            penalty: 8,
+        });
+    }
+    if (total > 12000 && fileEdits === 0) {
+        redFlags.push({
+            severity: "MEDIUM",
+            title: "low-signal session",
+            detail: `High observable usage (${formatTokens(total)}) with no file edits.`,
+            recommendation: "Push for earlier implementation checkpoints instead of extended analysis.",
+            penalty: 10,
+        });
+    }
+    const contextAudit = runContextAudit(options.contextAuditRoot);
+    if (contextAudit.totalEstimatedTokens > 6000) {
+        redFlags.push({
+            severity: "MEDIUM",
+            title: "context bloat",
+            detail: `Always-on instruction files estimate ${formatTokens(contextAudit.totalEstimatedTokens)}.`,
+            recommendation: "Move large static references into on-demand skills or targeted commands.",
+            penalty: 10,
+        });
+    }
+    for (const flag of redFlags)
+        score -= flag.penalty;
+    score = Math.max(0, score);
+    recommendations = [...new Set(redFlags.map((r) => r.recommendation))];
+    if (recommendations.length === 0) {
+        recommendations = [
+            "No major waste pattern detected. Keep prompts scoped and continue tracking trends.",
+        ];
+    }
+    const largestEvents = [...events]
+        .sort((a, b) => b.estimatedTotalTokens - a.estimatedTotalTokens)
+        .slice(0, LARGEST_EVENTS_LIMIT)
+        .map((e) => ({
+        role: e.role,
+        sourceEvent: e.sourceEvent,
+        estimatedTotalTokens: e.estimatedTotalTokens,
+    }));
+    return {
+        source: first.source,
+        sessionKey: sessionKeyLabel(first),
+        repo: first.repoPath ?? options.contextAuditRoot,
+        durationMinutes,
+        usage: { input, output, toolResults, shellOutput, total },
+        sessionShape: {
+            turns: turnIds.size,
+            fileEdits,
+            shellCalls,
+            toolCalls,
+        },
+        largestEvents,
+        efficiencyScore: score,
+        redFlags: redFlags.map((flag) => ({
+            severity: flag.severity,
+            title: flag.title,
+            detail: flag.detail,
+        })),
+        recommendations,
+    };
+}