om-memory-system 3.5.0 → 3.6.0-next.38

package/dist/importer/claude-conversation.js

@@ -0,0 +1,216 @@
+/**
+ * Entry types seen in real transcripts. A line with any other type is skipped
+ * and counted, so a new Claude Code version shows up in the import report.
+ */
+const KNOWN_ENTRY_TYPES = new Set([
+    "user",
+    "assistant",
+    "system",
+    "attachment",
+    "summary",
+    "file-history-snapshot",
+    "file-history-delta",
+    "last-prompt",
+    "mode",
+    "permission-mode",
+    "ai-title",
+    "custom-title",
+    "pr-link",
+    "queue-operation",
+    "cost-state",
+    "agent-name",
+    "atis-latch",
+]);
+/**
+ * User entries that Claude Code writes itself: local command output, bash
+ * mode, and background task notices. They end the current turn but never
+ * start one.
+ */
+const NOISE_PREFIXES = [
+    "<local-command-stdout>",
+    "<local-command-stderr>",
+    "<local-command-caveat>",
+    "<bash-input>",
+    "<bash-stdout>",
+    "<bash-stderr>",
+    "<task-notification>",
+];
+const MAX_TOOL_INPUT_LENGTH = 100;
+/** Parse one transcript line. A JSON value without a string `type` is unreadable. */
+export function parseClaudeTranscriptLine(line) {
+    if (!line.trim())
+        return { status: "blank" };
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return { status: "unreadable" };
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return { status: "unreadable" };
+    const type = value.type;
+    if (typeof type !== "string")
+        return { status: "unreadable" };
+    if (!KNOWN_ENTRY_TYPES.has(type))
+        return { status: "unknown-type" };
+    return { status: "entry", entry: value };
+}
+/** Parse a whole transcript, counting the lines that were skipped. */
+export function parseClaudeTranscript(text) {
+    const result = { entries: [], unreadableLines: 0, unknownTypes: 0 };
+    for (const line of text.split("\n")) {
+        const parsed = parseClaudeTranscriptLine(line);
+        if (parsed.status === "entry")
+            result.entries.push(parsed.entry);
+        else if (parsed.status === "unreadable")
+            result.unreadableLines++;
+        else if (parsed.status === "unknown-type")
+            result.unknownTypes++;
+    }
+    return result;
+}
+function blocksOf(entry) {
+    const content = entry.message?.content;
+    return Array.isArray(content)
+        ? content.filter((block) => block && typeof block === "object")
+        : [];
+}
+function promptText(entry) {
+    const content = entry.message?.content;
+    if (typeof content === "string")
+        return content.trim();
+    return blocksOf(entry)
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+}
+/**
+ * A user entry that ends the current turn: in the main chain, not written by
+ * Claude Code as context (`isMeta`), and not a tool result.
+ */
+function isTurnBoundary(entry) {
+    if (entry.type !== "user" || entry.isMeta === true || entry.isSidechain === true)
+        return false;
+    return !blocksOf(entry).some((block) => block.type === "tool_result");
+}
+/** Show a slash command as the user typed it: `/name args`. */
+function slashCommandText(text) {
+    const name = /<command-name>([^<]*)<\/command-name>/.exec(text)?.[1]?.trim();
+    if (!name)
+        return null;
+    const args = /<command-args>([^<]*)<\/command-args>/.exec(text)?.[1]?.trim();
+    return args ? `${name} ${args}` : name;
+}
+/** The prompt a boundary entry starts, or null for Claude Code's own noise. */
+function turnPrompt(entry) {
+    const text = promptText(entry);
+    if (!text)
+        return null;
+    if (NOISE_PREFIXES.some((prefix) => text.startsWith(prefix)))
+        return null;
+    return slashCommandText(text) ?? text;
+}
+function formatToolInput(input) {
+    if (input === undefined || input === null)
+        return "";
+    if (typeof input !== "object" || Array.isArray(input))
+        return JSON.stringify(input);
+    return Object.entries(input)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(", ");
+}
+function boundToolInput(input) {
+    if (input.length > MAX_TOOL_INPUT_LENGTH) {
+        return input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
+    }
+    return input;
+}
+function closeWindow(open) {
+    if (open.textResponses.length === 0 && open.toolCalls.length === 0)
+        return null;
+    const timestamp = Date.parse(open.entry.timestamp ?? "");
+    return {
+        userEntryId: open.entry.uuid,
+        userPrompt: open.userPrompt,
+        textResponses: open.textResponses,
+        toolCalls: open.toolCalls,
+        sourceEntryIds: open.sourceEntryIds,
+        cwd: typeof open.entry.cwd === "string" ? open.entry.cwd : null,
+        ...(Number.isNaN(timestamp) ? {} : { userTimestamp: timestamp, sourceTimestamp: timestamp }),
+    };
+}
+function addAssistantWork(open, entry) {
+    if (typeof entry.uuid === "string")
+        open.sourceEntryIds.push(entry.uuid);
+    const blocks = blocksOf(entry);
+    const text = blocks
+        .filter((block) => block.type === "text" && typeof block.text === "string" && block.text.trim())
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+    if (text)
+        open.textResponses.push(text);
+    for (const block of blocks.filter((item) => item.type === "tool_use")) {
+        open.toolCalls.push({
+            name: typeof block.name === "string" ? block.name : "unknown",
+            input: boundToolInput(formatToolInput(block.input)),
+        });
+    }
+}
+function windowsWithIndex(entries) {
+    const result = [];
+    let open = null;
+    const flush = () => {
+        const window = open ? closeWindow(open) : null;
+        if (open && window)
+            result.push({ entryIndex: open.entryIndex, window });
+        open = null;
+    };
+    entries.forEach((entry, entryIndex) => {
+        if (isTurnBoundary(entry)) {
+            flush();
+            const userPrompt = turnPrompt(entry);
+            if (userPrompt && typeof entry.uuid === "string") {
+                open = {
+                    entryIndex,
+                    entry,
+                    userPrompt,
+                    textResponses: [],
+                    toolCalls: [],
+                    sourceEntryIds: [entry.uuid],
+                };
+            }
+            return;
+        }
+        if (open && entry.type === "assistant" && entry.isSidechain !== true) {
+            addAssistantWork(open, entry);
+        }
+    });
+    flush();
+    return result;
+}
+/**
+ * All capture windows in a transcript, oldest first: one per user prompt that
+ * produced assistant text or tool work. Sidechain (subagent) entries, meta
+ * entries, and tool results are skipped; tool results and meta entries do not
+ * end a turn. Thinking blocks are never included. Tool inputs are bounded by
+ * the same truncation policy as the other hosts.
+ */
+export function extractClaudeConversationWindows(entries) {
+    return windowsWithIndex(entries).map((item) => item.window);
+}
+/**
+ * Windows for live capture: every window whose prompt comes after the cursor
+ * entry. Without a cursor, or when the cursor is no longer in the transcript,
+ * only the last window is returned, so a lost cursor never re-captures a
+ * whole session.
+ */
+export function extractClaudeWindowsAfter(entries, cursorUserUuid) {
+    const windows = windowsWithIndex(entries);
+    const cursorIndex = cursorUserUuid === null ? -1 : entries.findIndex((entry) => entry.uuid === cursorUserUuid);
+    if (cursorIndex === -1)
+        return windows.slice(-1).map((item) => item.window);
+    return windows.filter((item) => item.entryIndex > cursorIndex).map((item) => item.window);
+}

package/dist/importer/claude-hook-api.d.ts

@@ -0,0 +1,50 @@
+import type { CaptureSummaryProvider } from "../core/host.js";
+import type { ModelPort } from "../core/profile-analysis.js";
+import { type ClaudeConversationWindow, type ClaudeTranscriptEntry } from "./claude-conversation.js";
+export interface ClaudeHookDeps {
+    /** The capture model. Defaults to the external API. */
+    captureProvider?: () => CaptureSummaryProvider;
+    /** The profile learning model. Defaults to the external API. */
+    profileModel?: () => ModelPort;
+    /** Starts the Claude Code backfill after the start-up delay; the web app passes its controls. */
+    startBackfill?: () => Promise<unknown>;
+    sleep?: (ms: number) => Promise<void>;
+}
+/** A hook request the handler cannot use. `status` is the HTTP status. */
+export declare class ClaudeHookRequestError extends Error {
+    readonly status = 400;
+    constructor(message: string);
+}
+/**
+ * `POST /api/claude/retrieve`: recent project memories for a fresh session,
+ * the session's own memories after compaction or resume, or the retrieval
+ * section for a prompt. Every text is wrapped in the retrieval tag; an empty
+ * string means nothing to add.
+ */
+export declare function handleClaudeRetrieve(body: unknown, deps?: ClaudeHookDeps): Promise<{
+    additionalContext: string;
+}>;
+/**
+ * `POST /api/claude/capture`: check the request, queue the turn on the
+ * one-worker queue, and answer at once. Throws `ClaudeHookRequestError` for a
+ * request that cannot be used.
+ */
+export declare function handleClaudeCapture(body: unknown, deps?: ClaudeHookDeps): {
+    queued: true;
+};
+/** Resolves when every queued capture has finished. */
+export declare function whenClaudeCaptureIdle(): Promise<void>;
+/**
+ * The windows after the cursor. The transcript file can lag the hook, so the
+ * hook's final text is added as a last assistant reply when the transcript
+ * does not already end with it. It carries no entry id, so `sourceEntryIds`
+ * stay the reader's ids.
+ */
+export declare function claudeWindowsToCapture(entries: ClaudeTranscriptEntry[], cursor: string | null, finalText: string | undefined): ClaudeConversationWindow[];
+/**
+ * Register the Claude Code retry drain in this web app and start one retry
+ * pass. The drain uses the external API. When capture is off, the first
+ * capture request logs the missing settings, so a web app that never serves
+ * Claude Code does not log them.
+ */
+export declare function startClaudeCodeWorker(): void;