oh-my-knowledge 0.48.0 → 0.49.0

package/dist/observability/trace-session-index.d.ts

@@ -0,0 +1,19 @@
+import type { TraceSession } from './trace-ir.js';
+export interface TraceSessionRef {
+    traceId?: string;
+    traceSessionId?: string;
+    sessionId: string;
+    sourceTrace?: string;
+}
+export interface TraceSessionIndex {
+    resolve(ref: TraceSessionRef): TraceSession | undefined;
+}
+export declare function traceSessionRefIdentity(ref: TraceSessionRef): string;
+/**
+ * Resolve projected segments back to their physical evidence stream.
+ *
+ * `sourcePath` is not an identity: one Markdown log can contain many sessions.
+ * Prefer the globally unique traceId, then source + concrete run id. Single-key
+ * fallbacks are only retained when unambiguous.
+ */
+export declare function createTraceSessionIndex(sessions: TraceSession[]): TraceSessionIndex;

package/dist/observability/trace-session-index.js

@@ -0,0 +1,68 @@
+export function traceSessionRefIdentity(ref) {
+    return ref.traceId
+        ?? `${ref.sourceTrace ?? ''}\u0000${ref.traceSessionId ?? ref.sessionId}`;
+}
+/**
+ * Resolve projected segments back to their physical evidence stream.
+ *
+ * `sourcePath` is not an identity: one Markdown log can contain many sessions.
+ * Prefer the globally unique traceId, then source + concrete run id. Single-key
+ * fallbacks are only retained when unambiguous.
+ */
+export function createTraceSessionIndex(sessions) {
+    const byTraceId = uniqueIndex(sessions, (session) => session.traceId);
+    const bySourceAndRun = uniqueIndex(sessions, (session) => `${session.sourcePath}\u0000${session.runId}`);
+    const byRunId = uniqueIndex(sessions, (session) => session.runId);
+    const bySourcePath = uniqueIndex(sessions, (session) => session.sourcePath);
+    const byRootRunId = uniqueIndex(sessions, (session) => session.rootRunId);
+    return {
+        resolve(ref) {
+            if (ref.traceId) {
+                return matchingSession(byTraceId.get(ref.traceId), ref);
+            }
+            if (ref.sourceTrace && ref.traceSessionId) {
+                return matchingSession(bySourceAndRun.get(`${ref.sourceTrace}\u0000${ref.traceSessionId}`), ref);
+            }
+            if (ref.traceSessionId) {
+                const concrete = byRunId.get(ref.traceSessionId);
+                if (concrete)
+                    return matchingSession(concrete, ref);
+            }
+            if (ref.sourceTrace) {
+                const source = bySourcePath.get(ref.sourceTrace);
+                if (source)
+                    return matchingSession(source, ref);
+            }
+            return matchingSession(byRootRunId.get(ref.sessionId) ?? byRunId.get(ref.sessionId), ref);
+        },
+    };
+}
+function matchingSession(session, ref) {
+    if (!session)
+        return undefined;
+    if (ref.traceId && session.traceId !== ref.traceId)
+        return undefined;
+    if (ref.sourceTrace && session.sourcePath !== ref.sourceTrace)
+        return undefined;
+    if (ref.traceSessionId && session.runId !== ref.traceSessionId)
+        return undefined;
+    if (session.rootRunId !== ref.sessionId)
+        return undefined;
+    return session;
+}
+function uniqueIndex(sessions, keyFor) {
+    const index = new Map();
+    const ambiguous = new Set();
+    for (const session of sessions) {
+        const key = keyFor(session);
+        if (ambiguous.has(key))
+            continue;
+        if (index.has(key)) {
+            index.delete(key);
+            ambiguous.add(key);
+            continue;
+        }
+        index.set(key, session);
+    }
+    return index;
+}

package/dist/observability/trace-source.d.ts

@@ -1,5 +1,6 @@
-/** Trace source loading and parsing for Claude JSONL / OpenClaw JSONL / generic markdown logs. */
+/** Trace source loading and parsing for Claude / Codex / OpenClaw JSONL and generic markdown logs. */
 import type { TraceSourceMetadata } from '../types/index.js';
+import type { TraceCorpus, TraceSession, TraceSourceKind } from './trace-ir.js';
 export interface CcAssistantContent {
     type: 'thinking' | 'text' | 'tool_use';
     thinking?: string;
@@ -58,10 +59,12 @@ export type CcRecord = CcAssistantRecord | CcUserRecord | {
     [k: string]: unknown;
 };
 export type { TraceSourceMetadata } from '../types/index.js';
+/** @deprecated Compatibility shape for callers that still construct Claude-style fixtures. */
 export interface CcSession {
     sessionId: string;
     /**
-     * Logical parent session. For a directory shaped as:
+     * Logical root session used to aggregate a main trace and all descendants.
+     * For a directory shaped as:
      *   A/main.jsonl
      *   A/subagents/x1.jsonl
      *   A/subagents/x2.jsonl
@@ -74,7 +77,7 @@ export interface CcSession {
     traceRole?: 'standalone' | 'main' | 'subagent';
     traceLabel?: string;
     sourcePath: string;
-    sourceKind?: 'claude' | 'openclaw' | 'markdown_log' | 'unknown';
+    sourceKind?: TraceSourceKind;
     records: unknown[];
     cwd?: string;
     gitBranch?: string;
@@ -83,9 +86,14 @@ export interface CcSession {
     startTimestamp?: string;
     endTimestamp?: string;
 }
+export type { TraceEvent, TraceSession } from './trace-ir.js';
 /**
  * 加载一个目录(或单个 JSONL/agent markdown log 文件)下的所有 session。
  * 递归扫描目录,覆盖 Claude Code 主 session 旁边的 subagents/*.jsonl,
  * 也支持 agent workspace/logs/*.log 里的 Markdown 对话记录。
  */
-export declare function loadCcSessions(path: string): CcSession[];
+export declare function loadTraceSessions(path: string): TraceSession[];
+export declare function loadTraceCorpus(path: string): TraceCorpus;
+/** @deprecated Use `loadTraceSessions`. */
+export declare const loadCcSessions: typeof loadTraceSessions;
+export declare function legacyCcSessionToTraceSession(session: CcSession): TraceSession;