@bububuger/spanory 0.1.15 → 0.1.18

package/dist/runtime/openclaw/adapter.js

@@ -1,8 +1,9 @@
 // @ts-nocheck
-import { readFile, stat } from 'node:fs/promises';
+import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { RUNTIME_CAPABILITIES } from '../shared/capabilities.js';
 import { normalizeTranscriptMessages, parseProjectIdFromTranscriptPath, pickUsage } from '../shared/normalize.js';
+const INFER_WINDOW_EPSILON_MS = 1200;
 function parseTimestamp(entry) {
     const raw = entry?.timestamp ?? entry?.created_at ?? entry?.createdAt;
     const date = raw ? new Date(raw) : new Date();
@@ -140,6 +141,139 @@ function normalizeAgentId(entry) {
         ?? entry?.payload?.agentId
         ?? entry?.payload?.agent_id);
 }
+function extractToolUses(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_use');
+}
+function extractToolResults(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isToolResultOnlyContent(content) {
+    return Array.isArray(content)
+        && content.length > 0
+        && content.every((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isPromptUserMessage(message) {
+    if (!message || message.role !== 'user' || message.isMeta)
+        return false;
+    const { content } = message;
+    if (typeof content === 'string')
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    if (isToolResultOnlyContent(content))
+        return false;
+    return content.length > 0;
+}
+function findChildSessionHints(messages) {
+    const hasSidechainSignal = messages.some((m) => m?.isSidechain === true || String(m?.agentId ?? '').trim().length > 0);
+    if (!hasSidechainSignal)
+        return null;
+    const hasParentLink = messages.some((m) => String(m?.parentSessionId ?? m?.parent_session_id ?? '').trim().length > 0
+        || String(m?.parentTurnId ?? m?.parent_turn_id ?? '').trim().length > 0
+        || String(m?.parentToolCallId ?? m?.parent_tool_call_id ?? '').trim().length > 0);
+    if (hasParentLink)
+        return null;
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const childStartedAt = sorted[0]?.timestamp;
+    if (!childStartedAt)
+        return null;
+    return { childStartedAt };
+}
+function extractTaskWindows(messages, sessionId) {
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const windows = [];
+    const byCallId = new Map();
+    let turnIndex = 0;
+    let currentTurnId = 'turn-1';
+    for (const msg of sorted) {
+        if (isPromptUserMessage(msg)) {
+            turnIndex += 1;
+            currentTurnId = `turn-${turnIndex}`;
+        }
+        if (msg.role === 'assistant') {
+            for (const tu of extractToolUses(msg.content)) {
+                const toolName = String(tu.name ?? '').trim();
+                if (toolName !== 'Task')
+                    continue;
+                const callId = String(tu.id ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = {
+                    parentSessionId: sessionId,
+                    parentTurnId: currentTurnId,
+                    parentToolCallId: callId,
+                    startedAtMs: msg.timestamp.getTime(),
+                    endedAtMs: msg.timestamp.getTime(),
+                };
+                windows.push(window);
+                byCallId.set(callId, window);
+            }
+        }
+        if (msg.role === 'user') {
+            for (const tr of extractToolResults(msg.content)) {
+                const callId = String(tr.tool_use_id ?? tr.toolUseId ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = byCallId.get(callId);
+                if (window) {
+                    window.endedAtMs = Math.max(window.endedAtMs, msg.timestamp.getTime());
+                }
+            }
+        }
+    }
+    return windows;
+}
+async function inferParentLinkFromSiblingSessions({ transcriptPath, messages }) {
+    const hints = findChildSessionHints(messages);
+    if (!hints)
+        return messages;
+    const currentSessionId = path.basename(transcriptPath, '.jsonl');
+    const dir = path.dirname(transcriptPath);
+    let entries = [];
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return messages;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const siblingSessionId = entry.name.slice(0, -'.jsonl'.length);
+        if (siblingSessionId === currentSessionId)
+            continue;
+        const siblingPath = path.join(dir, entry.name);
+        const siblingMessages = await readOpenclawTranscript(siblingPath);
+        const windows = extractTaskWindows(siblingMessages, siblingSessionId);
+        for (const window of windows) {
+            const childAtMs = hints.childStartedAt.getTime();
+            const lower = window.startedAtMs - INFER_WINDOW_EPSILON_MS;
+            const upper = window.endedAtMs + INFER_WINDOW_EPSILON_MS;
+            if (childAtMs < lower || childAtMs > upper)
+                continue;
+            candidates.push({
+                ...window,
+                score: Math.abs(childAtMs - window.startedAtMs),
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return messages;
+    candidates.sort((a, b) => a.score - b.score);
+    const best = candidates[0];
+    return messages.map((msg) => ({
+        ...msg,
+        parentSessionId: best.parentSessionId,
+        parentTurnId: best.parentTurnId,
+        parentToolCallId: best.parentToolCallId,
+        parentLinkConfidence: 'inferred',
+    }));
+}
 async function readOpenclawTranscript(transcriptPath) {
     const raw = await readFile(transcriptPath, 'utf-8');
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
@@ -165,6 +299,9 @@ async function readOpenclawTranscript(transcriptPath) {
                 isMeta: entry?.isMeta ?? entry?.is_meta ?? false,
                 isSidechain: normalizeIsSidechain(entry),
                 agentId: normalizeAgentId(entry),
+                parentSessionId: entry?.parentSessionId ?? entry?.parent_session_id,
+                parentTurnId: entry?.parentTurnId ?? entry?.parent_turn_id,
+                parentToolCallId: entry?.parentToolCallId ?? entry?.parent_tool_call_id,
                 content: normalizeContent(entry),
                 model: normalizeModel(entry),
                 usage: normalizeUsage(entry),
@@ -231,7 +368,8 @@ export const openclawAdapter = {
     },
     async collectEvents(context) {
         const transcriptPath = await resolveTranscriptPath(context);
-        const messages = await readOpenclawTranscript(transcriptPath);
+        const loaded = await readOpenclawTranscript(transcriptPath);
+        const messages = await inferParentLinkFromSiblingSessions({ transcriptPath, messages: loaded });
         return normalizeTranscriptMessages({
             runtime: 'openclaw',
             projectId: context.projectId,

package/dist/runtime/shared/file-settle.d.ts

@@ -0,0 +1,19 @@
+type FileStat = {
+    mtimeMs: number;
+};
+type WaitForFileSettleOptions = {
+    filePath: string;
+    stableWindowMs?: number;
+    timeoutMs?: number;
+    pollMs?: number;
+    statFn?: (filePath: string) => Promise<FileStat>;
+    sleepFn?: (ms: number) => Promise<void>;
+    nowFn?: () => number;
+};
+type WaitForFileSettleResult = {
+    settled: boolean;
+    lastMtimeMs?: number;
+    waitedMs: number;
+};
+export declare function waitForFileMtimeToSettle(options: WaitForFileSettleOptions): Promise<WaitForFileSettleResult>;
+export {};

package/dist/runtime/shared/file-settle.js

@@ -0,0 +1,44 @@
+import { stat } from 'node:fs/promises';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function waitForFileMtimeToSettle(options) {
+    const stableWindowMs = options.stableWindowMs ?? 400;
+    const timeoutMs = options.timeoutMs ?? 2500;
+    const pollMs = options.pollMs ?? 100;
+    const statFn = options.statFn ?? (async (filePath) => stat(filePath));
+    const sleepFn = options.sleepFn ?? sleep;
+    const nowFn = options.nowFn ?? Date.now;
+    const startedAt = nowFn();
+    const deadline = startedAt + timeoutMs;
+    let lastMtimeMs;
+    let unchangedSinceMs;
+    while (nowFn() <= deadline) {
+        const current = await statFn(options.filePath);
+        const mtimeMs = Number(current.mtimeMs);
+        if (lastMtimeMs === mtimeMs) {
+            if (unchangedSinceMs === undefined)
+                unchangedSinceMs = nowFn();
+            if (nowFn() - unchangedSinceMs >= stableWindowMs) {
+                return {
+                    settled: true,
+                    lastMtimeMs: mtimeMs,
+                    waitedMs: nowFn() - startedAt,
+                };
+            }
+        }
+        else {
+            lastMtimeMs = mtimeMs;
+            unchangedSinceMs = undefined;
+        }
+        const remainingMs = deadline - nowFn();
+        if (remainingMs <= 0)
+            break;
+        await sleepFn(Math.min(pollMs, remainingMs));
+    }
+    return {
+        settled: false,
+        lastMtimeMs,
+        waitedMs: nowFn() - startedAt,
+    };
+}