macro-agent 0.1.3 → 0.1.5

package/src/map/trajectory-reporter.ts

@@ -2,8 +2,10 @@
  * Trajectory Reporter — builds and reports trajectory checkpoints to the MAP hub.
  *
  * Sends checkpoints via the `trajectory/checkpoint` JSON-RPC extension.
- * Also handles inbound `trajectory/content.request` notifications by serving
- * session transcript data.
+ * Handles inbound `trajectory/content.request` notifications by serving
+ * session transcripts via sessionlog's SessionStore and CheckpointStore.
+ * Supports all agent types (Claude Code, Codex, Gemini, etc.) through
+ * sessionlog's adapter system.
  *
  * @module map/trajectory-reporter
  */
@@ -34,37 +36,173 @@ export interface TrajectoryConnection {
   get isConnected(): boolean;
 }
 
+/**
+ * Resolve transcript content for a checkpoint ID using sessionlog.
+ *
+ * Two-source strategy (matching cc-swarm):
+ * 1. Live session — use sessionlog's SessionStore to find a session
+ *    matching the checkpoint ID, then read its transcript from disk.
+ * 2. Committed checkpoint — use sessionlog's CheckpointStore to read
+ *    content from the git history.
+ *
+ * Returns null if no content is found or sessionlog is unavailable.
+ */
+async function resolveContent(
+  checkpointId: string,
+  sessionDirs: string[],
+): Promise<{
+  transcript: string;
+  metadata: Record<string, unknown>;
+  prompts: string;
+  context: string;
+} | null> {
+  let sessionlog: typeof import("sessionlog") | null = null;
+  try {
+    sessionlog = await import("sessionlog");
+  } catch {
+    return null; // sessionlog not available
+  }
+
+  const { readFileSync, existsSync } = await import("node:fs");
+
+  // Derive the session ID from checkpoint ID (e.g., "sess-abc-step3" → "sess-abc")
+  const sessionId = checkpointId.replace(/-step\d+$/, "");
+
+  // ── 1. Live session lookup via SessionStore ────────────────────────────
+  for (const sessionsDir of sessionDirs) {
+    if (!existsSync(sessionsDir)) continue;
+
+    try {
+      const store = sessionlog.createSessionStore(undefined, sessionsDir);
+      // Try loading by derived session ID first, then by raw checkpoint ID
+      let state = await store.load(sessionId);
+      if (!state) state = await store.load(checkpointId);
+
+      // If not found by ID, scan all sessions for checkpoint match
+      if (!state) {
+        const allSessions = await store.list();
+        state = allSessions.find((s) =>
+          s.lastCheckpointID === checkpointId ||
+          (s.turnCheckpointIDs || []).includes(checkpointId),
+        ) ?? null;
+      }
+
+      if (!state?.transcriptPath || !existsSync(state.transcriptPath)) continue;
+
+      const transcript = readFileSync(state.transcriptPath, "utf-8");
+
+      // Use sessionlog's prompt extraction if the agent has a TranscriptAnalyzer,
+      // otherwise fall back to the prompts stored in state
+      let prompts = "";
+      if (state.firstPrompt) {
+        // Collect from promptAttributions if available, otherwise use firstPrompt
+        const attrs = state.promptAttributions;
+        if (attrs && attrs.length > 0) {
+          prompts = attrs.map((a) => a.prompt).join("\n---\n");
+        } else {
+          prompts = state.firstPrompt;
+        }
+      }
+
+      return {
+        transcript,
+        prompts,
+        metadata: {
+          sessionID: state.sessionID,
+          phase: state.phase,
+          agentType: state.agentType,
+          stepCount: state.stepCount || 0,
+          filesTouched: state.filesTouched || [],
+          tokenUsage: state.tokenUsage || {},
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+          source: "live",
+        },
+        context: `Session ${state.sessionID} (${state.phase})`,
+      };
+    } catch {
+      continue;
+    }
+  }
+
+  // ── 2. Committed checkpoint via CheckpointStore ────────────────────────
+  try {
+    if (sessionlog.createCheckpointStore) {
+      const store = sessionlog.createCheckpointStore();
+      const content = await store.readSessionContent(checkpointId, 0);
+      if (content) {
+        return {
+          transcript: content.transcript,
+          prompts: content.prompts,
+          metadata: { ...content.metadata, source: "committed" },
+          context: content.context,
+        };
+      }
+    }
+  } catch {
+    // Checkpoint not found or store unavailable
+  }
+
+  return null;
+}
+
 /**
  * Create a trajectory reporter that sends checkpoints to the MAP hub
- * and serves content on demand.
+ * and serves session transcript content on demand via sessionlog.
  */
 export function createTrajectoryReporter(
   connection: TrajectoryConnection,
-  config: Pick<MAPSidecarConfig, "trajectorySyncLevel">,
+  config: Pick<MAPSidecarConfig, "trajectorySyncLevel"> & {
+    /** Additional session directories to search for transcripts */
+    sessionDirs?: string[];
+  },
 ): TrajectoryReporter {
   // Cache the resource_id from the first checkpoint response
   // so subsequent calls reuse it (avoids creating duplicate session resources)
   let cachedResourceId: string | undefined;
 
+  // Build session directory search list
+  const defaultDirs: string[] = [];
+  try {
+    const cwd = process.cwd();
+    defaultDirs.push(
+      `${cwd}/.git/sessionlog-sessions`,
+      `${cwd}/.swarm/sessionlog/sessions`,
+    );
+  } catch {
+    // Can't resolve paths — will use config dirs only
+  }
+  const sessionDirs = [...(config.sessionDirs ?? []), ...defaultDirs];
+
   // Handler for inbound content requests
   const contentHandler = async (params: unknown): Promise<void> => {
     const req = params as TrajectoryContentRequest;
     if (!req?.request_id) return;
 
     try {
-      // Respond with what we have — macro-agent doesn't store full transcripts
-      // like sessionlog does, so we send a minimal response.
-      // Future: integrate with ACP session history for richer content.
-      await connection.sendNotification("trajectory/content.response", {
-        request_id: req.request_id,
-        transcript: null,
-        metadata: {
-          source: "macro-agent",
-          note: "Full transcript serving not yet implemented",
-        },
-      });
+      const content = await resolveContent(
+        req.checkpoint_id,
+        sessionDirs,
+      );
+
+      if (content) {
+        await connection.sendNotification("trajectory/content.response", {
+          request_id: req.request_id,
+          transcript: content.transcript,
+          metadata: content.metadata,
+          prompts: content.prompts,
+          context: content.context,
+        });
+      } else {
+        await connection.sendNotification("trajectory/content.response", {
+          request_id: req.request_id,
+          transcript: "",
+          metadata: { source: "macro-agent" },
+          prompts: "",
+          context: "",
+        });
+      }
     } catch {
-      // Best effort
       try {
         await connection.sendNotification("trajectory/content.response", {
           request_id: req.request_id,

package/src/map/types.ts

@@ -145,46 +145,8 @@ export interface TrajectoryContentRequest {
 // Coordination Wire Format
 // =============================================================================
 
-/** Inbound task assignment from hub */
-export interface CoordinationTaskAssign {
-  title: string;
-  description?: string;
-  assigned_to?: string;
-  assigned_by: string;
-  priority?: string;
-  context?: Record<string, unknown>;
-  deadline?: string;
-}
-
-/** Inbound task status update from hub */
-export interface CoordinationTaskStatus {
-  task_id: string;
-  status: string;
-  progress?: number;
-  result?: unknown;
-  error?: string;
-}
-
-/** Inbound context share from hub */
-export interface CoordinationContextShare {
-  hive_id?: string;
-  source_swarm_id: string;
-  context_type: string;
-  data: unknown;
-  target_swarm_ids?: string[];
-  ttl_seconds?: number;
-}
-
-/** Inbound message from hub */
-export interface CoordinationMessage {
-  hive_id?: string;
-  from_swarm_id: string;
-  to_swarm_id: string;
-  content_type: string;
-  content: unknown;
-  reply_to?: string;
-  metadata?: Record<string, unknown>;
-}
+// Coordination uses generic MAP scope messages — see coordination-handler.ts.
+// Wire format types are inlined there; no custom types needed here.
 
 // =============================================================================
 // Internal Bridge Types