agent-profiler 0.1.0

package/dist/core/eventMetadata.js

@@ -0,0 +1,131 @@
+import crypto from "node:crypto";
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function pickFirstString(values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/** Split Codex-style `mcp__server__tool` or loose `MCP: server — tool`. */
+export function parseMcpToolName(canonical) {
+    const t = canonical.trim();
+    if (!t)
+        return { mcpServer: null, mcpTool: null };
+    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 };
+        }
+    }
+    if (t.toLowerCase().startsWith("mcp:")) {
+        const rest = t.slice(4).trim();
+        const sep = rest.indexOf(":");
+        if (sep > 0) {
+            return {
+                mcpServer: rest.slice(0, sep).trim() || null,
+                mcpTool: rest.slice(sep + 1).trim() || null,
+            };
+        }
+    }
+    return { mcpServer: null, mcpTool: null };
+}
+function fingerprintPrompt(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    return crypto.createHash("sha256").update(trimmed, "utf8").digest("hex");
+}
+function hookToInteractionKind(source, hookEventName) {
+    const cursorMap = {
+        beforeSubmitPrompt: { kind: "user_prompt_submit", toolPhase: null },
+        afterAgentResponse: { kind: "model_output", toolPhase: null },
+        afterAgentThought: { kind: "model_thought", toolPhase: null },
+        preToolUse: { kind: "tool_request", toolPhase: "pre" },
+        postToolUse: { kind: "tool_result_event", toolPhase: "post" },
+        postToolUseFailure: { kind: "tool_failure_event", toolPhase: "failure" },
+        beforeMCPExecution: { kind: "mcp_request", toolPhase: "pre" },
+        afterMCPExecution: { kind: "mcp_result_event", toolPhase: "post" },
+        beforeShellExecution: { kind: "shell_command_request", toolPhase: "pre" },
+        afterShellExecution: { kind: "shell_output", toolPhase: null },
+        afterFileEdit: { kind: "file_edit", toolPhase: null },
+        beforeReadFile: { kind: "file_read_request", toolPhase: "pre" },
+        start: { kind: "session_start", toolPhase: null },
+        sessionStart: { kind: "session_start", toolPhase: null },
+        stop: { kind: "session_stop", toolPhase: null },
+        sessionEnd: { kind: "session_end", toolPhase: null },
+        preCompact: { kind: "context_compact", toolPhase: null },
+    };
+    const codexMap = {
+        SessionStart: { kind: "session_start", toolPhase: null },
+        UserPromptSubmit: { kind: "user_prompt_submit", toolPhase: null },
+        PreToolUse: { kind: "tool_request", toolPhase: "pre" },
+        PostToolUse: { kind: "tool_result_event", toolPhase: "post" },
+        Stop: { kind: "session_stop", toolPhase: null },
+    };
+    const mapped = source === "codex" ? codexMap[hookEventName] : cursorMap[hookEventName];
+    if (mapped)
+        return mapped;
+    return { kind: `other:${hookEventName}`, toolPhase: null };
+}
+function extractCorrelationId(payload) {
+    return (pickFirstString([
+        payload.tool_use_id,
+        payload.toolUseId,
+        payload.toolCallId,
+        payload.callId,
+        payload.id,
+        payload.invocationId,
+    ]) ?? null);
+}
+function extractToolCanonicalName(payload) {
+    const name = pickFirstString([
+        payload.tool_name,
+        payload.toolName,
+        payload.tool,
+        payload.name,
+        payload.type,
+    ]) ?? null;
+    return name?.trim() || null;
+}
+/**
+ * Derives query-friendly fields + MCP split + span phase for tool correlation.
+ */
+export function deriveIngestFields(source, hookEventName, rawPayload, rawJsonText, normalized) {
+    const { kind, toolPhase } = hookToInteractionKind(source, hookEventName);
+    const payload = asRecord(rawPayload);
+    const correlationId = extractCorrelationId(payload);
+    let toolCanonicalName = extractToolCanonicalName(payload);
+    if (!toolCanonicalName && payload.tool_input && typeof payload.tool_input === "object") {
+        const ti = payload.tool_input;
+        toolCanonicalName =
+            pickFirstString([ti.command, ti.tool, ti.name])?.trim() ||
+                toolCanonicalName;
+    }
+    const { mcpServer, mcpTool } = toolCanonicalName
+        ? parseMcpToolName(toolCanonicalName)
+        : { mcpServer: null, mcpTool: null };
+    let promptFingerprint = null;
+    if (kind === "user_prompt_submit") {
+        const prompt = pickFirstString([payload.prompt, payload.text, payload.message]) ??
+            normalized.observableText;
+        promptFingerprint = fingerprintPrompt(prompt);
+    }
+    const payloadByteLength = Buffer.byteLength(rawJsonText, "utf8");
+    return {
+        interactionKind: kind,
+        correlationId,
+        toolCanonicalName,
+        mcpServer,
+        mcpTool,
+        payloadByteLength,
+        promptFingerprint,
+        toolPhase,
+    };
+}

package/dist/core/gitWorkspace.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+function trimmedOrNull(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const t = value.trim();
+    return t.length > 0 ? t : undefined;
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+/**
+ * Absolute path for “where this event ran”: adapter repoPath, then common payload cwd keys, then process.cwd().
+ */
+export function resolveHookWorkspacePath(normalizedRepoPath, rawPayload) {
+    const payload = asRecord(rawPayload);
+    const candidates = [
+        trimmedOrNull(normalizedRepoPath),
+        trimmedOrNull(payload.cwd),
+        trimmedOrNull(payload.workspacePath),
+        trimmedOrNull(payload.workspace),
+        trimmedOrNull(payload.projectPath),
+        trimmedOrNull(payload.rootPath),
+    ];
+    for (const c of candidates) {
+        if (!c)
+            continue;
+        return path.isAbsolute(c) ? path.normalize(c) : path.resolve(process.cwd(), c);
+    }
+    return path.resolve(process.cwd());
+}
+function gitOutput(workspacePath, args) {
+    try {
+        const r = spawnSync("git", ["-C", workspacePath, ...args], {
+            encoding: "utf8",
+            timeout: 2500,
+            maxBuffer: 2 * 1024 * 1024,
+        });
+        if (r.error || r.status !== 0)
+            return null;
+        const out = (r.stdout ?? "").trim();
+        return out.length > 0 ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Best-effort git context for `workspacePath`. Non-repo → git* fields null; `workspacePath` still set.
+ */
+export function resolveWorkspaceGitMeta(workspacePath) {
+    const inside = gitOutput(workspacePath, ["rev-parse", "--is-inside-work-tree"]);
+    if (inside !== "true") {
+        return {
+            workspacePath,
+            gitRepoRoot: null,
+            gitRepoName: null,
+            gitBranch: null,
+        };
+    }
+    const root = gitOutput(workspacePath, ["rev-parse", "--show-toplevel"]);
+    const branch = gitOutput(workspacePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const gitRepoRoot = root ? path.normalize(root) : null;
+    const gitRepoName = gitRepoRoot ? path.basename(gitRepoRoot) : null;
+    return {
+        workspacePath,
+        gitRepoRoot,
+        gitRepoName,
+        gitBranch: branch,
+    };
+}

package/dist/core/normalize.js

@@ -0,0 +1 @@
+export {};

package/dist/core/profile.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function getLocalProfileDir(cwd = process.cwd()) {
+    return path.join(cwd, ".agent-profiler");
+}
+export function getHomeProfileDir() {
+    return path.join(os.homedir(), ".agent-profiler");
+}
+export function getPreferredConfigPath(cwd = process.cwd()) {
+    const localConfig = path.join(getLocalProfileDir(cwd), "config.json");
+    if (fs.existsSync(localConfig))
+        return localConfig;
+    return path.join(getHomeProfileDir(), "config.json");
+}
+export function getConfiguredDatabasePath(cwd = process.cwd()) {
+    const configPath = getPreferredConfigPath(cwd);
+    const config = readJsonFile(configPath);
+    return config?.databasePath ?? null;
+}

package/dist/core/schema.sql

@@ -0,0 +1,56 @@
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  created_at TEXT NOT NULL,
+  source TEXT NOT NULL,
+  source_event TEXT NOT NULL,
+  repo_path TEXT,
+  session_id TEXT,
+  turn_id TEXT,
+  model TEXT,
+  role TEXT NOT NULL,
+  estimated_input_tokens INTEGER DEFAULT 0,
+  estimated_output_tokens INTEGER DEFAULT 0,
+  estimated_total_tokens INTEGER DEFAULT 0,
+  payload_hash TEXT NOT NULL,
+  raw_payload TEXT NOT NULL,
+  workspace_path TEXT,
+  git_repo_root TEXT,
+  git_repo_name TEXT,
+  git_branch TEXT,
+  interaction_kind TEXT,
+  correlation_id TEXT,
+  tool_canonical_name TEXT,
+  mcp_server TEXT,
+  mcp_tool TEXT,
+  payload_byte_length INTEGER,
+  prompt_fingerprint TEXT
+);
+
+CREATE TABLE IF NOT EXISTS interaction_spans (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_key TEXT NOT NULL,
+  source TEXT NOT NULL,
+  correlation_id TEXT NOT NULL,
+  turn_id TEXT,
+  tool_canonical_name TEXT,
+  mcp_server TEXT,
+  mcp_tool TEXT,
+  pre_event_id INTEGER,
+  post_event_id INTEGER,
+  failure_event_id INTEGER,
+  arg_token_estimate INTEGER DEFAULT 0,
+  result_token_estimate INTEGER DEFAULT 0,
+  workspace_path TEXT,
+  git_repo_root TEXT,
+  git_repo_name TEXT,
+  git_branch TEXT,
+  started_at TEXT,
+  completed_at TEXT,
+  UNIQUE(session_key, source, correlation_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session
+ON events(session_id, created_at);
+
+CREATE INDEX IF NOT EXISTS idx_events_source
+ON events(source, created_at);

package/dist/core/tokens.js

@@ -0,0 +1,5 @@
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.max(1, Math.ceil(text.length / 4));
+}