@kennykeni/agent-trace 0.1.0

package/src/providers/cursor.ts

@@ -0,0 +1,127 @@
+import type { FileEdit, HookInput, TraceEvent } from "../core/types";
+import { textFromUnknown } from "../core/utils";
+import { normalizeModelId, sessionIdFor } from "./utils";
+
+export interface CursorHookInput extends HookInput {
+  file_path?: string;
+  edits?: FileEdit[];
+  command?: string;
+  duration?: number;
+  duration_ms?: number;
+  is_background_agent?: boolean;
+  composer_mode?: string;
+  reason?: string;
+  prompt?: unknown;
+  message?: unknown;
+  content?: unknown;
+}
+
+export { sessionIdFor } from "./utils";
+
+export function adapt(input: HookInput): TraceEvent | TraceEvent[] | undefined {
+  const ci = input as CursorHookInput;
+  const sessionId = sessionIdFor(input);
+  const model = normalizeModelId(input.model);
+
+  switch (input.hook_event_name) {
+    case "afterFileEdit": {
+      if (!ci.file_path) return undefined;
+      return {
+        kind: "file_edit",
+        provider: "cursor",
+        sessionId,
+        filePath: ci.file_path,
+        edits: ci.edits ?? [],
+        model,
+        transcript: input.transcript_path,
+        readContent: true,
+        eventName: "afterFileEdit",
+        meta: {
+          conversation_id: input.conversation_id,
+          generation_id: input.generation_id,
+        },
+      };
+    }
+
+    case "afterTabFileEdit": {
+      if (!ci.file_path) return undefined;
+      return {
+        kind: "file_edit",
+        provider: "cursor",
+        sessionId,
+        filePath: ci.file_path,
+        edits: ci.edits ?? [],
+        model,
+        eventName: "afterTabFileEdit",
+        meta: {
+          conversation_id: input.conversation_id,
+          generation_id: input.generation_id,
+        },
+      };
+    }
+
+    case "afterShellExecution": {
+      return {
+        kind: "shell",
+        provider: "cursor",
+        sessionId,
+        model,
+        transcript: input.transcript_path,
+        meta: {
+          conversation_id: input.conversation_id,
+          generation_id: input.generation_id,
+          command: ci.command,
+          duration_ms: ci.duration_ms ?? ci.duration,
+        },
+      };
+    }
+
+    case "sessionStart": {
+      return {
+        kind: "session_start",
+        provider: "cursor",
+        sessionId,
+        model,
+        meta: {
+          session_id: input.session_id,
+          conversation_id: input.conversation_id,
+          is_background_agent: ci.is_background_agent,
+          composer_mode: ci.composer_mode,
+        },
+      };
+    }
+
+    case "sessionEnd": {
+      return {
+        kind: "session_end",
+        provider: "cursor",
+        sessionId,
+        model,
+        meta: {
+          session_id: input.session_id,
+          conversation_id: input.conversation_id,
+          reason: ci.reason,
+          duration_ms: ci.duration_ms,
+        },
+      };
+    }
+
+    case "beforeSubmitPrompt": {
+      const text = textFromUnknown(ci.prompt ?? ci.message ?? ci.content);
+      if (!text) return undefined;
+      return {
+        kind: "message",
+        provider: "cursor",
+        sessionId,
+        role: "user",
+        content: text,
+        eventName: "beforeSubmitPrompt",
+        model,
+        meta: {},
+      };
+    }
+
+    default:
+      return undefined;
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,19 @@
+import { registerProvider } from "../core/trace-hook";
+import * as claude from "./claude";
+import * as cursor from "./cursor";
+import * as opencode from "./opencode";
+
+registerProvider("claude", {
+  ...claude,
+  toolInfo: () => ({ name: "claude-code" }),
+});
+
+registerProvider("cursor", {
+  ...cursor,
+  toolInfo: () => ({ name: "cursor", version: process.env.CURSOR_VERSION }),
+});
+
+registerProvider("opencode", {
+  ...opencode,
+  toolInfo: () => ({ name: "opencode" }),
+});

package/src/providers/opencode.ts

@@ -0,0 +1,239 @@
+import type { FileEdit, HookInput, TraceEvent } from "../core/types";
+import { maybeString, safeRecord, textFromUnknown } from "../core/utils";
+import { normalizeModelId } from "./utils";
+
+export interface OpenCodeHookInput extends HookInput {
+  event?: unknown;
+  file_path?: string;
+  content?: unknown;
+  tool_name?: string;
+  command?: string;
+  message_id?: string;
+  agent?: string;
+  call_id?: string;
+  files?: Array<{
+    file: string;
+    before?: string;
+    after?: string;
+    additions?: number;
+    deletions?: number;
+  }>;
+}
+
+function extractEventField(
+  event: Record<string, unknown>,
+  keys: string[],
+): unknown {
+  for (const key of keys) {
+    if (Object.hasOwn(event, key)) return event[key];
+  }
+  return undefined;
+}
+
+export function sessionIdFor(input: HookInput): string | undefined {
+  const oi = input as OpenCodeHookInput;
+  const event = safeRecord(oi.event);
+  const info = safeRecord(event?.info);
+  const part = safeRecord(event?.part);
+  return (
+    maybeString(input.session_id) ??
+    maybeString(event?.sessionID) ??
+    maybeString(info?.sessionID) ??
+    maybeString(info?.id) ??
+    maybeString(part?.sessionID)
+  );
+}
+
+export function adapt(input: HookInput): TraceEvent | TraceEvent[] | undefined {
+  const oi = input as OpenCodeHookInput;
+  const sessionId = sessionIdFor(input);
+  const model = normalizeModelId(input.model);
+
+  switch (input.hook_event_name) {
+    case "session.created": {
+      return {
+        kind: "session_start",
+        provider: "opencode",
+        sessionId,
+        model,
+        meta: {
+          session_id: sessionId,
+          source: "opencode",
+        },
+      };
+    }
+
+    case "session.deleted": {
+      return {
+        kind: "session_end",
+        provider: "opencode",
+        sessionId,
+        model,
+        meta: {
+          session_id: sessionId,
+          source: "opencode",
+          reason: "session.deleted",
+        },
+      };
+    }
+
+    case "session.idle": {
+      return {
+        kind: "session_end",
+        provider: "opencode",
+        sessionId,
+        model,
+        meta: {
+          session_id: sessionId,
+          source: "opencode",
+          reason: "session.idle",
+        },
+      };
+    }
+
+    case "message.updated": {
+      const event = safeRecord(oi.event);
+      if (!event) return undefined;
+      const info = safeRecord(event.info);
+      if (!info) return undefined;
+      const roleRaw = maybeString(info.role);
+      const role =
+        roleRaw === "assistant" || roleRaw === "system" ? roleRaw : "user";
+      const content =
+        textFromUnknown(info.content) ??
+        textFromUnknown(info.text) ??
+        textFromUnknown(info.parts);
+      if (!content) return undefined;
+      return {
+        kind: "message",
+        provider: "opencode",
+        sessionId,
+        role,
+        content,
+        eventName: "message.updated",
+        model: normalizeModelId(maybeString(info.modelID)) ?? model,
+        meta: { source: "opencode.event" },
+      };
+    }
+
+    case "command.executed": {
+      const event = safeRecord(oi.event);
+      if (!event) return undefined;
+      return {
+        kind: "shell",
+        provider: "opencode",
+        sessionId,
+        model,
+        transcript: input.transcript_path,
+        meta: {
+          event: "command.executed",
+          session_id: sessionId,
+          source: "opencode",
+          command: extractEventField(event, ["name", "command", "cmd"]),
+          arguments: extractEventField(event, ["arguments"]),
+          messageID: extractEventField(event, ["messageID"]),
+        },
+      };
+    }
+
+    case "file.edited": {
+      const event = safeRecord(oi.event);
+      if (!event) return undefined;
+      const path =
+        maybeString(
+          extractEventField(event, ["file", "file_path", "filePath", "path"]),
+        ) ?? maybeString(oi.file_path);
+      if (!path) return undefined;
+      return {
+        kind: "file_edit",
+        provider: "opencode",
+        sessionId,
+        filePath: path,
+        edits: [],
+        model,
+        diffs: false,
+        eventName: "file.edited",
+        meta: {
+          event: "file.edited",
+          session_id: sessionId,
+          source: "opencode",
+        },
+      };
+    }
+
+    case "hook:chat.message": {
+      const content = typeof oi.content === "string" ? oi.content : undefined;
+      if (!content) return undefined;
+      return {
+        kind: "message",
+        provider: "opencode",
+        sessionId,
+        role: "user",
+        content,
+        eventName: "hook:chat.message",
+        model,
+        meta: {
+          source: "opencode.hook",
+          message_id: oi.message_id,
+          agent: oi.agent,
+        },
+      };
+    }
+
+    case "hook:tool.execute.after": {
+      const toolName = oi.tool_name ?? "";
+      const shellTools = ["bash", "shell"];
+
+      if (shellTools.includes(toolName)) {
+        return {
+          kind: "shell",
+          provider: "opencode",
+          sessionId,
+          model,
+          meta: {
+            event: "hook:tool.execute.after",
+            session_id: sessionId,
+            source: "opencode.hook",
+            tool_name: toolName,
+            command: oi.command,
+          },
+        };
+      }
+
+      const files = oi.files;
+      if (!files || files.length === 0) return undefined;
+
+      const events: TraceEvent[] = [];
+      for (const f of files) {
+        const edits: FileEdit[] = [
+          {
+            old_string: f.before ?? "",
+            new_string: f.after ?? "",
+          },
+        ];
+        events.push({
+          kind: "file_edit",
+          provider: "opencode",
+          sessionId,
+          filePath: f.file,
+          edits,
+          diffs: true,
+          eventName: "hook:tool.execute.after",
+          model,
+          meta: {
+            event: "hook:tool.execute.after",
+            session_id: sessionId,
+            source: "opencode.hook",
+            tool_name: toolName,
+            call_id: oi.call_id,
+          },
+        });
+      }
+
+      return events.length === 1 ? events[0] : events;
+    }
+
+    default:
+      return undefined;
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,6 @@
+export const PROVIDERS = ["cursor", "claude", "opencode"] as const;
+export type Provider = (typeof PROVIDERS)[number];
+
+export function isProvider(value: string): value is Provider {
+  return PROVIDERS.includes(value as Provider);
+}

package/src/providers/utils.ts

@@ -0,0 +1,27 @@
+import type { HookInput } from "../core/types";
+import { maybeString } from "../core/utils";
+
+export function sessionIdFor(input: HookInput): string | undefined {
+  return (
+    maybeString(input.session_id) ??
+    maybeString(input.conversation_id) ??
+    maybeString(input.generation_id)
+  );
+}
+
+export function normalizeModelId(model?: string): string | undefined {
+  if (!model) return undefined;
+  if (model.includes("/")) return model;
+  const prefixes: Record<string, string> = {
+    "claude-": "anthropic",
+    "gpt-": "openai",
+    o1: "openai",
+    o3: "openai",
+    o4: "openai",
+    "gemini-": "google",
+  };
+  for (const [prefix, provider] of Object.entries(prefixes)) {
+    if (model.startsWith(prefix)) return `${provider}/${model}`;
+  }
+  return model;
+}