@nothumanwork/nn 0.1.0

package/src/hooks/ingest.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env bun
+
+import { stdin } from "bun";
+
+import type { ProviderId } from "../ir/types.ts";
+import { ingestIncremental } from "../ingest/pipeline.ts";
+import {
+  flushSync,
+  pullSync,
+  scheduleIncrementalSync,
+} from "../sync/coordinator.ts";
+import { syncConfig } from "../config/sync.ts";
+import { ensureProjectDir } from "../config/paths.ts";
+import { resolveHookInvocation } from "./resolvers/index.ts";
+import type { HookEventKind, HookPayload } from "./types.ts";
+import { HOOK_EVENTS } from "./types.ts";
+import { stringField } from "./resolvers/common.ts";
+
+export { resolveHookInvocation };
+
+function parseArgs(argv: string[]): {
+  provider?: ProviderId;
+  hookEvent?: HookEventKind;
+} {
+  let provider: ProviderId | undefined;
+  let hookEvent: HookEventKind | undefined;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    if (argv[index] === "--provider") {
+      provider = argv[index + 1] as ProviderId;
+    }
+    if (argv[index] === "--event") {
+      hookEvent = argv[index + 1] as HookEventKind;
+    }
+  }
+
+  return { provider, hookEvent };
+}
+
+export async function handleHookInvocation(
+  provider: ProviderId,
+  hookEvent: HookEventKind,
+  payload: HookPayload,
+): Promise<void> {
+  ensureProjectDir(stringField(payload, "cwd"));
+
+  if (hookEvent === "sessionStart") {
+    if (syncConfig().pullOnSession) {
+      await pullSync();
+    }
+    return;
+  }
+
+  const invocation = resolveHookInvocation(provider, hookEvent, payload);
+  if (!invocation) {
+    return;
+  }
+
+  const report = await ingestIncremental(
+    invocation.provider,
+    invocation.sourcePath,
+    invocation.sessionId,
+  );
+
+  if (!syncConfig().enabled) {
+    return;
+  }
+
+  if (hookEvent === "postToolUse" && report.eventsInserted > 0) {
+    scheduleIncrementalSync();
+    return;
+  }
+
+  if (hookEvent === "turnEnd" && report.eventsInserted > 0) {
+    await flushSync();
+    return;
+  }
+
+  if (hookEvent === "stop") {
+    await flushSync();
+  }
+}
+
+async function main(): Promise<number> {
+  try {
+    const { provider, hookEvent } = parseArgs(process.argv.slice(2));
+    if (!provider || !hookEvent || !HOOK_EVENTS.includes(hookEvent)) {
+      console.error("usage: ingest.ts --provider <id> --event <kind>");
+      return 0;
+    }
+
+    const raw = await stdin.text();
+    const payload = raw.trim() ? (JSON.parse(raw) as HookPayload) : {};
+    await handleHookInvocation(provider, hookEvent, payload);
+    console.log(JSON.stringify({}));
+    return 0;
+  } catch (error) {
+    console.error("[nn-ingest] failed", error);
+    console.log(JSON.stringify({}));
+    return 0;
+  }
+}
+
+if (import.meta.main) {
+  await main();
+  process.exit(0);
+}

package/src/hooks/resolvers/antigravity.ts

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+
+import { homeDir } from "../../config/paths.ts";
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+function antigravityTranscriptPath(sessionId: string): string {
+  return join(
+    homeDir(),
+    ".gemini",
+    "antigravity-cli",
+    "brain",
+    sessionId,
+    ".system_generated",
+    "logs",
+    "transcript.jsonl",
+  );
+}
+
+export function resolveAntigravityHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const sessionId =
+    stringField(payload, "session_id") ??
+    stringField(payload, "sessionId") ??
+    "";
+
+  const transcriptPath = firstExistingPath(
+    stringField(payload, "transcript_path"),
+    sessionId ? antigravityTranscriptPath(sessionId) : undefined,
+  );
+  if (!transcriptPath || !sessionId) {
+    return null;
+  }
+
+  return {
+    provider: "antigravity",
+    hookEvent,
+    sessionId,
+    sourcePath: transcriptPath,
+    cwd: stringField(payload, "cwd"),
+  };
+}

package/src/hooks/resolvers/claude.ts

@@ -0,0 +1,27 @@
+import { basename } from "node:path";
+
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+export function resolveClaudeHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const transcriptPath = firstExistingPath(stringField(payload, "transcript_path"));
+  if (!transcriptPath) {
+    return null;
+  }
+
+  const sessionId =
+    stringField(payload, "session_id") ??
+    stringField(payload, "sessionId") ??
+    basename(transcriptPath, ".jsonl");
+
+  return {
+    provider: "claude",
+    hookEvent,
+    sessionId,
+    sourcePath: transcriptPath,
+    cwd: stringField(payload, "cwd"),
+  };
+}

package/src/hooks/resolvers/codex.ts

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+
+import { homeDir } from "../../config/paths.ts";
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+function codexRoot(): string {
+  return join(homeDir(), ".codex", "sessions");
+}
+
+function findCodexRollout(sessionId: string): string | null {
+  if (!existsSync(codexRoot())) {
+    return null;
+  }
+
+  const targetName = `rollout-${sessionId}.jsonl`;
+  const walk = (dir: string): string | null => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const found = walk(path);
+        if (found) {
+          return found;
+        }
+        continue;
+      }
+      if (entry.isFile() && entry.name === targetName) {
+        return path;
+      }
+    }
+    return null;
+  };
+
+  return walk(codexRoot());
+}
+
+export function resolveCodexHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const sessionId =
+    stringField(payload, "session_id") ??
+    stringField(payload, "sessionId") ??
+    "";
+
+  const transcriptPath = firstExistingPath(
+    stringField(payload, "transcript_path"),
+    sessionId ? findCodexRollout(sessionId) ?? undefined : undefined,
+  );
+  if (!transcriptPath) {
+    return null;
+  }
+
+  const resolvedSessionId =
+    sessionId || basename(transcriptPath, ".jsonl").replace(/^rollout-/, "");
+
+  return {
+    provider: "codex",
+    hookEvent,
+    sessionId: resolvedSessionId,
+    sourcePath: transcriptPath,
+    cwd: stringField(payload, "cwd"),
+  };
+}

package/src/hooks/resolvers/common.ts

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+
+export function stringField(
+  value: unknown,
+  key: string,
+): string | undefined {
+  if (!value || typeof value !== "object") {
+    return undefined;
+  }
+  const raw = (value as Record<string, unknown>)[key];
+  return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+
+export function firstExistingPath(...paths: Array<string | undefined>): string | null {
+  for (const path of paths) {
+    if (path && existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}

package/src/hooks/resolvers/cursor.ts

@@ -0,0 +1,31 @@
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import {
+  cursorSessionIdFromPath,
+  isTranscriptFile,
+} from "../../providers/cursor/index.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+export function resolveCursorHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const transcriptPath = firstExistingPath(
+    stringField(payload, "transcript_path"),
+    process.env.CURSOR_TRANSCRIPT_PATH?.trim(),
+  );
+  if (!transcriptPath || !isTranscriptFile(transcriptPath)) {
+    return null;
+  }
+
+  const sessionId =
+    stringField(payload, "conversation_id") ??
+    cursorSessionIdFromPath(transcriptPath);
+
+  return {
+    provider: "cursor",
+    hookEvent,
+    sessionId,
+    sourcePath: transcriptPath,
+    cwd: stringField(payload, "cwd"),
+  };
+}

package/src/hooks/resolvers/grok.ts

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { encodeProjectSlug, homeDir } from "../../config/paths.ts";
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+function grokRoot(): string {
+  return join(homeDir(), ".grok", "sessions");
+}
+
+function findGrokUpdates(sessionId: string, cwd?: string): string | null {
+  if (!existsSync(grokRoot())) {
+    return null;
+  }
+
+  const candidates: string[] = [];
+  if (cwd) {
+    candidates.push(join(grokRoot(), encodeProjectSlug(cwd), sessionId, "updates.jsonl"));
+  }
+
+  for (const cwdEntry of readdirSync(grokRoot(), { withFileTypes: true })) {
+    if (!cwdEntry.isDirectory()) {
+      continue;
+    }
+    candidates.push(
+      join(grokRoot(), cwdEntry.name, sessionId, "updates.jsonl"),
+    );
+  }
+
+  return firstExistingPath(...candidates);
+}
+
+export function resolveGrokHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const sessionId =
+    stringField(payload, "session_id") ??
+    stringField(payload, "sessionId") ??
+    "";
+  const cwd = stringField(payload, "cwd");
+
+  const transcriptPath = firstExistingPath(
+    stringField(payload, "transcript_path"),
+    sessionId ? findGrokUpdates(sessionId, cwd) ?? undefined : undefined,
+  );
+  if (!transcriptPath || !sessionId) {
+    return null;
+  }
+
+  return {
+    provider: "grok",
+    hookEvent,
+    sessionId,
+    sourcePath: transcriptPath,
+    cwd,
+  };
+}

package/src/hooks/resolvers/index.ts

@@ -0,0 +1,35 @@
+import type { ProviderId } from "../../ir/types.ts";
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { resolveAntigravityHook } from "./antigravity.ts";
+import { resolveClaudeHook } from "./claude.ts";
+import { resolveCodexHook } from "./codex.ts";
+import { resolveCursorHook } from "./cursor.ts";
+import { resolveGrokHook } from "./grok.ts";
+import { resolvePiHook } from "./pi.ts";
+
+type Resolver = (
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+) => HookInvocation | null;
+
+const resolvers: Record<ProviderId, Resolver | undefined> = {
+  cursor: resolveCursorHook,
+  claude: resolveClaudeHook,
+  codex: resolveCodexHook,
+  pi: resolvePiHook,
+  grok: resolveGrokHook,
+  antigravity: resolveAntigravityHook,
+  copilot: undefined,
+};
+
+export function resolveHookInvocation(
+  provider: ProviderId,
+  hookEvent: HookEventKind,
+  payload: HookPayload,
+): HookInvocation | null {
+  const resolver = resolvers[provider];
+  if (!resolver) {
+    return null;
+  }
+  return resolver(payload, hookEvent);
+}

package/src/hooks/resolvers/pi.ts

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+
+import { homeDir } from "../../config/paths.ts";
+import type { HookEventKind, HookInvocation, HookPayload } from "../types.ts";
+import { firstExistingPath, stringField } from "./common.ts";
+
+function piRoot(): string {
+  return join(homeDir(), ".pi", "agent", "sessions");
+}
+
+function findPiSessionFile(sessionId: string): string | null {
+  if (!existsSync(piRoot())) {
+    return null;
+  }
+
+  const walk = (dir: string): string | null => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const found = walk(path);
+        if (found) {
+          return found;
+        }
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      const fileSessionId =
+        entry.name.replace(".jsonl", "").split("_").at(-1) ??
+        basename(entry.name, ".jsonl");
+      if (fileSessionId === sessionId) {
+        return path;
+      }
+    }
+    return null;
+  };
+
+  return walk(piRoot());
+}
+
+export function resolvePiHook(
+  payload: HookPayload,
+  hookEvent: HookEventKind,
+): HookInvocation | null {
+  const sessionId =
+    stringField(payload, "session_id") ??
+    stringField(payload, "sessionId") ??
+    "";
+
+  const transcriptPath = firstExistingPath(
+    stringField(payload, "transcript_path"),
+    sessionId ? findPiSessionFile(sessionId) ?? undefined : undefined,
+  );
+  if (!transcriptPath) {
+    return null;
+  }
+
+  const resolvedSessionId =
+    sessionId ||
+    basename(transcriptPath, ".jsonl").split("_").at(-1) ||
+    basename(transcriptPath, ".jsonl");
+
+  return {
+    provider: "pi",
+    hookEvent,
+    sessionId: resolvedSessionId,
+    sourcePath: transcriptPath,
+    cwd: stringField(payload, "cwd"),
+  };
+}

package/src/hooks/types.ts

@@ -0,0 +1,20 @@
+import type { ProviderId } from "../ir/types.ts";
+
+export const HOOK_EVENTS = [
+  "postToolUse",
+  "turnEnd",
+  "stop",
+  "sessionStart",
+] as const;
+
+export type HookEventKind = (typeof HOOK_EVENTS)[number];
+
+export interface HookInvocation {
+  provider: ProviderId;
+  hookEvent: HookEventKind;
+  sessionId: string;
+  sourcePath: string;
+  cwd?: string;
+}
+
+export type HookPayload = Record<string, unknown>;