@nothumanwork/nn 0.1.0

package/src/ir/event-id.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+
+import type { NormalizedEvent } from "./types.ts";
+
+export function contentHash(text: string): string {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+export function eventIdFor(
+  event: Pick<NormalizedEvent, "source" | "sourceSessionId" | "lineKey">,
+): string {
+  const material = `${event.source}|${event.sourceSessionId}|${event.lineKey}`;
+  return `evt:v1:${contentHash(material)}`;
+}
+
+export function projectIdFor(canonicalPath: string): string {
+  return `proj:v1:${contentHash(canonicalPath)}`;
+}
+
+export function sessionIdFor(
+  projectId: string,
+  source: string,
+  sourceSessionId: string,
+): string {
+  return `sess:v1:${contentHash(`${projectId}|${source}|${sourceSessionId}`)}`;
+}

package/src/ir/types.ts

@@ -0,0 +1,84 @@
+export const PROVIDERS = [
+  "cursor",
+  "claude",
+  "codex",
+  "copilot",
+  "antigravity",
+  "pi",
+  "grok",
+] as const;
+
+export type ProviderId = (typeof PROVIDERS)[number];
+
+export const EVENT_BOUNDARIES = [
+  "session_start",
+  "session_end",
+  "user_turn",
+  "assistant_turn",
+  "tool_call",
+  "tool_result",
+  "compaction",
+  "unknown_raw_event",
+] as const;
+
+export type EventBoundary = (typeof EVENT_BOUNDARIES)[number];
+
+export function defaultRole(boundary: EventBoundary): string {
+  switch (boundary) {
+    case "session_start":
+    case "session_end":
+    case "compaction":
+    case "unknown_raw_event":
+      return "system";
+    case "user_turn":
+      return "user";
+    case "assistant_turn":
+    case "tool_call":
+      return "assistant";
+    case "tool_result":
+      return "tool";
+  }
+}
+
+export interface NormalizedEvent {
+  source: ProviderId;
+  sourceSessionId: string;
+  sourceEventId?: string;
+  lineKey: string;
+  boundary: EventBoundary;
+  role: string;
+  timestamp: string;
+  contentText: string;
+  toolName?: string;
+  toolCallId?: string;
+  toolInputJson?: string;
+  toolOutputJson?: string;
+  parserVersion: string;
+  rawLocalRef: string;
+  rawJson: string;
+}
+
+export interface SourceSessionRef {
+  source: ProviderId;
+  sessionId: string;
+  path: string;
+  workspaceRoot?: string;
+  title?: string;
+  model?: string;
+}
+
+export interface SourceImportBatch {
+  source: ProviderId;
+  parserVersion: string;
+  session: SourceSessionRef;
+  events: NormalizedEvent[];
+  cursorKey: string;
+  consumedBytes: number;
+  emittedLines: number;
+  warnings: string[];
+}
+
+export interface ExportWarning {
+  code: string;
+  message: string;
+}

package/src/providers/antigravity/index.ts

@@ -0,0 +1,175 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { homeDir, projectDir } from "../../config/paths.ts";
+import { lineKeyFor, parseCompleteJsonlLines } from "../../ingest/jsonl.ts";
+import type {
+  EventBoundary,
+  NormalizedEvent,
+  SourceImportBatch,
+  SourceSessionRef,
+} from "../../ir/types.ts";
+import { defaultRole } from "../../ir/types.ts";
+import type { ProviderAdapter } from "../types.ts";
+import { stringField, truncate } from "../types.ts";
+
+export const PARSER_VERSION = "antigravity-step-jsonl-v1";
+
+function antigravityRoot(): string {
+  return join(homeDir(), ".gemini", "antigravity-cli", "brain");
+}
+
+function discoverAntigravitySessions(): SourceSessionRef[] {
+  if (!existsSync(antigravityRoot())) {
+    return [];
+  }
+  const sessions: SourceSessionRef[] = [];
+  for (const brainEntry of readdirSync(antigravityRoot(), {
+    withFileTypes: true,
+  })) {
+    if (!brainEntry.isDirectory()) {
+      continue;
+    }
+    const transcriptPath = join(
+      antigravityRoot(),
+      brainEntry.name,
+      ".system_generated",
+      "logs",
+      "transcript.jsonl",
+    );
+    if (!existsSync(transcriptPath)) {
+      continue;
+    }
+    sessions.push({
+      source: "antigravity",
+      sessionId: brainEntry.name,
+      path: transcriptPath,
+      workspaceRoot: projectDir(),
+    });
+  }
+  return sessions;
+}
+
+function boundaryForStep(source: string, stepType: string): EventBoundary {
+  if (source === "USER_EXPLICIT" || stepType === "USER_INPUT") {
+    return "user_turn";
+  }
+  if (stepType === "PLANNER_RESPONSE") {
+    return "assistant_turn";
+  }
+  if (
+    stepType.includes("SEARCH") ||
+    stepType.includes("VIEW") ||
+    stepType.includes("LIST")
+  ) {
+    return "tool_call";
+  }
+  return "unknown_raw_event";
+}
+
+function parseAntigravityFile(
+  sourcePath: string,
+  sessionId: string,
+  offset: number,
+): SourceImportBatch {
+  const buffer = readFileSync(sourcePath);
+  const slice = buffer.subarray(offset);
+  const { lines, consumedBytes, partialTail } = parseCompleteJsonlLines(
+    slice,
+    0,
+  );
+  const events: NormalizedEvent[] = [];
+  const warnings: string[] = [];
+  let emittedLines = 0;
+
+  for (const line of lines) {
+    emittedLines = line.lineIndex;
+    const absoluteStart = offset + line.lineStart;
+    const lineKey = lineKeyFor(sourcePath, absoluteStart);
+    let value: Record<string, unknown>;
+    try {
+      value = JSON.parse(line.raw) as Record<string, unknown>;
+    } catch (error) {
+      warnings.push(
+        `${sourcePath}:${line.lineIndex} malformed row: ${String(error)}`,
+      );
+      continue;
+    }
+
+    const source = stringField(value, "source") ?? "SYSTEM";
+    const stepType = stringField(value, "type") ?? "unknown";
+    const timestamp =
+      stringField(value, "created_at") ?? new Date().toISOString();
+    const content = stringField(value, "content") ?? "";
+    const boundary = boundaryForStep(source, stepType);
+    const toolCalls = Array.isArray(value.tool_calls) ? value.tool_calls : [];
+
+    events.push({
+      source: "antigravity",
+      sourceSessionId: sessionId,
+      sourceEventId: `step:${String(value.step_index ?? line.lineIndex)}`,
+      lineKey,
+      boundary,
+      role:
+        boundary === "user_turn" ? "user"
+        : boundary === "assistant_turn" ? "assistant"
+        : defaultRole(boundary),
+      timestamp,
+      contentText: truncate(content || stepType),
+      parserVersion: PARSER_VERSION,
+      rawLocalRef: `${sourcePath}:${line.lineIndex}`,
+      rawJson: line.raw,
+    });
+
+    for (const [index, call] of toolCalls.entries()) {
+      const item = call as Record<string, unknown>;
+      events.push({
+        source: "antigravity",
+        sourceSessionId: sessionId,
+        sourceEventId: `step:${String(value.step_index ?? line.lineIndex)}:tool:${index}`,
+        lineKey: `${lineKey}:tool:${index}`,
+        boundary: "tool_call",
+        role: "assistant",
+        timestamp,
+        contentText: truncate(
+          `${stringField(item, "name") ?? "tool"} ${JSON.stringify(item.args ?? {})}`,
+        ),
+        toolName: stringField(item, "name") ?? undefined,
+        toolInputJson: JSON.stringify(item.args ?? {}),
+        parserVersion: PARSER_VERSION,
+        rawLocalRef: `${sourcePath}:${line.lineIndex}`,
+        rawJson: JSON.stringify(item),
+      });
+    }
+  }
+
+  const absoluteConsumed =
+    partialTail ?
+      offset + (lines.at(-1)?.lineEnd ?? 0)
+    : offset + consumedBytes;
+
+  return {
+    source: "antigravity",
+    parserVersion: PARSER_VERSION,
+    session: {
+      source: "antigravity",
+      sessionId,
+      path: sourcePath,
+      workspaceRoot: projectDir(),
+    },
+    events,
+    cursorKey: sourcePath,
+    consumedBytes: absoluteConsumed,
+    emittedLines,
+    warnings,
+  };
+}
+
+export const antigravityProvider: ProviderAdapter = {
+  name: "antigravity",
+  parserVersion: PARSER_VERSION,
+  discover: discoverAntigravitySessions,
+  parseIncremental: parseAntigravityFile,
+  parseFull: (sourcePath, sessionId) =>
+    parseAntigravityFile(sourcePath, sessionId, 0),
+};

package/src/providers/claude/index.ts

@@ -0,0 +1,228 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+import { homeDir, encodeProjectSlug, projectDir } from "../../config/paths.ts";
+import { lineKeyFor, parseCompleteJsonlLines } from "../../ingest/jsonl.ts";
+import type {
+  EventBoundary,
+  NormalizedEvent,
+  SourceImportBatch,
+  SourceSessionRef,
+} from "../../ir/types.ts";
+import { defaultRole } from "../../ir/types.ts";
+import type { ProviderAdapter } from "../types.ts";
+import { stringField, textFromUnknown, truncate } from "../types.ts";
+
+export const PARSER_VERSION = "claude-code-jsonl-v1";
+
+function claudeRoot(): string {
+  return join(homeDir(), ".claude", "projects");
+}
+
+function discoverClaudeSessions(): SourceSessionRef[] {
+  if (!existsSync(claudeRoot())) {
+    return [];
+  }
+  const slug = encodeProjectSlug(projectDir());
+  const sessions: SourceSessionRef[] = [];
+  for (const projectEntry of readdirSync(claudeRoot(), {
+    withFileTypes: true,
+  })) {
+    if (!projectEntry.isDirectory() || projectEntry.name !== slug) {
+      continue;
+    }
+    const projectPath = join(claudeRoot(), projectEntry.name);
+    for (const entry of readdirSync(projectPath, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      const path = join(projectPath, entry.name);
+      sessions.push({
+        source: "claude",
+        sessionId: basename(entry.name, ".jsonl"),
+        path,
+        workspaceRoot: projectDir(),
+      });
+    }
+  }
+  return sessions;
+}
+
+function claudeBoundaryForBlock(
+  blockType: string,
+  rowType: string,
+): EventBoundary {
+  if (rowType === "system") {
+    return "session_start";
+  }
+  if (blockType === "tool_use") {
+    return "tool_call";
+  }
+  if (blockType === "tool_result") {
+    return "tool_result";
+  }
+  if (blockType === "thinking") {
+    return "compaction";
+  }
+  if (rowType === "user") {
+    return "user_turn";
+  }
+  if (rowType === "assistant") {
+    return "assistant_turn";
+  }
+  return "unknown_raw_event";
+}
+
+function parseClaudeFile(
+  sourcePath: string,
+  sessionId: string,
+  offset: number,
+): SourceImportBatch {
+  const buffer = readFileSync(sourcePath);
+  const slice = buffer.subarray(offset);
+  const { lines, consumedBytes, partialTail } = parseCompleteJsonlLines(
+    slice,
+    0,
+  );
+  const events: NormalizedEvent[] = [];
+  const warnings: string[] = [];
+  let currentSessionId = sessionId;
+  let emittedLines = 0;
+
+  for (const line of lines) {
+    emittedLines = line.lineIndex;
+    const absoluteStart = offset + line.lineStart;
+    const lineKey = lineKeyFor(sourcePath, absoluteStart);
+    let value: Record<string, unknown>;
+    try {
+      value = JSON.parse(line.raw) as Record<string, unknown>;
+    } catch (error) {
+      warnings.push(
+        `${sourcePath}:${line.lineIndex} malformed row: ${String(error)}`,
+      );
+      continue;
+    }
+
+    const rowType = stringField(value, "type") ?? "unknown";
+    if (
+      ["file-history-snapshot", "attachment", "permission-mode"].includes(
+        rowType,
+      )
+    ) {
+      continue;
+    }
+
+    currentSessionId = stringField(value, "sessionId") ?? currentSessionId;
+    const timestamp =
+      stringField(value, "timestamp") ?? new Date().toISOString();
+    const rowEventId = stringField(value, "uuid") ?? `line:${line.lineIndex}`;
+    const message = value.message;
+    const content =
+      typeof message === "object" && message !== null ?
+        (message as Record<string, unknown>).content
+      : undefined;
+
+    if (typeof content === "string") {
+      events.push({
+        source: "claude",
+        sourceSessionId: currentSessionId,
+        sourceEventId: rowEventId,
+        lineKey,
+        boundary:
+          rowType === "user" ? "user_turn"
+          : rowType === "assistant" ? "assistant_turn"
+          : "unknown_raw_event",
+        role: rowType,
+        timestamp,
+        contentText: content,
+        parserVersion: PARSER_VERSION,
+        rawLocalRef: `${sourcePath}:${line.lineIndex}`,
+        rawJson: line.raw,
+      });
+      continue;
+    }
+
+    if (Array.isArray(content)) {
+      for (const [index, block] of content.entries()) {
+        const item = block as Record<string, unknown>;
+        const blockType = stringField(item, "type") ?? "text";
+        const text = textFromUnknown(item) ?? "";
+        if (!text.trim() && blockType === "text") {
+          continue;
+        }
+        const boundary = claudeBoundaryForBlock(blockType, rowType);
+        events.push({
+          source: "claude",
+          sourceSessionId: currentSessionId,
+          sourceEventId: `${rowEventId}:block:${index}`,
+          lineKey: `${lineKey}:block:${index}`,
+          boundary,
+          role: boundary === "tool_result" ? "tool" : rowType,
+          timestamp,
+          contentText: truncate(text || JSON.stringify(item)),
+          toolName: stringField(item, "name"),
+          toolCallId:
+            stringField(item, "id") ?? stringField(item, "tool_use_id"),
+          toolInputJson:
+            blockType === "tool_use" ?
+              JSON.stringify(item.input ?? {})
+            : undefined,
+          toolOutputJson:
+            blockType === "tool_result" ?
+              JSON.stringify(item.content ?? item)
+            : undefined,
+          parserVersion: PARSER_VERSION,
+          rawLocalRef: `${sourcePath}:${line.lineIndex}`,
+          rawJson: line.raw,
+        });
+      }
+      continue;
+    }
+
+    const fallback =
+      textFromUnknown(message) ?? truncate(JSON.stringify(value));
+    events.push({
+      source: "claude",
+      sourceSessionId: currentSessionId,
+      sourceEventId: rowEventId,
+      lineKey,
+      boundary: "unknown_raw_event",
+      role: defaultRole("unknown_raw_event"),
+      timestamp,
+      contentText: fallback,
+      parserVersion: PARSER_VERSION,
+      rawLocalRef: `${sourcePath}:${line.lineIndex}`,
+      rawJson: line.raw,
+    });
+  }
+
+  const absoluteConsumed =
+    partialTail ?
+      offset + (lines.at(-1)?.lineEnd ?? 0)
+    : offset + consumedBytes;
+
+  return {
+    source: "claude",
+    parserVersion: PARSER_VERSION,
+    session: {
+      source: "claude",
+      sessionId: currentSessionId,
+      path: sourcePath,
+      workspaceRoot: projectDir(),
+    },
+    events,
+    cursorKey: sourcePath,
+    consumedBytes: absoluteConsumed,
+    emittedLines,
+    warnings,
+  };
+}
+
+export const claudeProvider: ProviderAdapter = {
+  name: "claude",
+  parserVersion: PARSER_VERSION,
+  discover: discoverClaudeSessions,
+  parseIncremental: parseClaudeFile,
+  parseFull: (sourcePath, sessionId) =>
+    parseClaudeFile(sourcePath, sessionId, 0),
+};