@seqyuan/annodex 0.1.10 → 0.1.12

package/lib/session-runtime.ts

@@ -0,0 +1,105 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+export interface StoredSessionRuntime {
+  sessionId: string;
+  cwd?: string;
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+  updatedAt: string;
+}
+
+interface RuntimeStoreFile {
+  version: 1;
+  sessions: Record<string, StoredSessionRuntime>;
+}
+
+function getAnnodexConfigDir(): string {
+  return process.env.ANNODEX_CONFIG_DIR
+    ?? process.env.ANNOVIBE_CONFIG_DIR
+    ?? join(homedir(), ".config", "annodex");
+}
+
+function getRuntimeStorePath(): string {
+  return join(getAnnodexConfigDir(), "session-runtime.json");
+}
+
+function emptyStore(): RuntimeStoreFile {
+  return { version: 1, sessions: {} };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeRuntime(value: unknown): StoredSessionRuntime | null {
+  if (!isRecord(value) || typeof value.sessionId !== "string") return null;
+  const sessionId = value.sessionId.trim();
+  if (!sessionId) return null;
+  return {
+    sessionId,
+    cwd: typeof value.cwd === "string" && value.cwd.trim() ? value.cwd : undefined,
+    provider: typeof value.provider === "string" && value.provider.trim() ? value.provider : undefined,
+    modelId: typeof value.modelId === "string" && value.modelId.trim() ? value.modelId : undefined,
+    thinkingLevel: typeof value.thinkingLevel === "string" && value.thinkingLevel.trim() ? value.thinkingLevel : undefined,
+    updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : new Date(0).toISOString(),
+  };
+}
+
+function readStore(): RuntimeStoreFile {
+  const path = getRuntimeStorePath();
+  if (!existsSync(path)) return emptyStore();
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+    if (!isRecord(parsed) || !isRecord(parsed.sessions)) return emptyStore();
+    const sessions: Record<string, StoredSessionRuntime> = {};
+    for (const [id, entry] of Object.entries(parsed.sessions)) {
+      const normalized = normalizeRuntime(entry);
+      if (normalized && normalized.sessionId === id) sessions[id] = normalized;
+    }
+    return { version: 1, sessions };
+  } catch {
+    return emptyStore();
+  }
+}
+
+function writeStore(store: RuntimeStoreFile): void {
+  const path = getRuntimeStorePath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(store, null, 2), "utf-8");
+}
+
+export function readSessionRuntime(sessionId: string): StoredSessionRuntime | null {
+  if (!sessionId) return null;
+  return readStore().sessions[sessionId] ?? null;
+}
+
+export function upsertSessionRuntime(
+  sessionId: string,
+  patch: Partial<Omit<StoredSessionRuntime, "sessionId" | "updatedAt">>,
+): StoredSessionRuntime {
+  const store = readStore();
+  const previous = store.sessions[sessionId] ?? { sessionId, updatedAt: new Date(0).toISOString() };
+  const next: StoredSessionRuntime = {
+    ...previous,
+    sessionId,
+    updatedAt: new Date().toISOString(),
+  };
+  if (patch.cwd !== undefined) next.cwd = patch.cwd;
+  if (patch.provider !== undefined) next.provider = patch.provider;
+  if (patch.modelId !== undefined) next.modelId = patch.modelId;
+  if (patch.thinkingLevel !== undefined) next.thinkingLevel = patch.thinkingLevel;
+  store.sessions[sessionId] = next;
+  writeStore(store);
+  return next;
+}
+
+export function deleteSessionRuntime(sessionId: string): void {
+  const store = readStore();
+  if (!store.sessions[sessionId]) return;
+  delete store.sessions[sessionId];
+  writeStore(store);
+}

package/lib/subagent-progress.ts

@@ -0,0 +1,279 @@
+import type { SubagentRun, SubagentRunStatus } from "./types";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function numberTimestamp(value: unknown): number | undefined {
+  if (typeof value !== "string" || !value) return undefined;
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : undefined;
+}
+
+function limitText(value: string, maxLength = 1200): string {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+
+function stableJson(value: unknown): string | undefined {
+  if (typeof value === "string") return limitText(value);
+  if (value === null || value === undefined) return undefined;
+  try {
+    return limitText(JSON.stringify(value));
+  } catch {
+    return limitText(String(value));
+  }
+}
+
+export function normalizeSubagentStatus(value: unknown): SubagentRunStatus {
+  if (isRecord(value)) {
+    if ("completed" in value) return "completed";
+    if ("failed" in value || "error" in value) return "failed";
+    if ("paused" in value || "blocked" in value) return "paused";
+    if ("not_found" in value) return "not_found";
+    if ("running" in value || "in_progress" in value || "pending" in value) return "running";
+  }
+
+  const raw = typeof value === "string" ? value.toLowerCase().trim() : "";
+  if (raw === "completed" || raw === "complete" || raw === "done" || raw === "success" || raw === "succeeded") return "completed";
+  if (raw === "failed" || raw === "failure" || raw === "error" || raw === "cancelled" || raw === "canceled") return "failed";
+  if (raw === "paused" || raw === "blocked" || raw === "interrupted") return "paused";
+  if (raw === "not_found" || raw === "not-found" || raw === "missing") return "not_found";
+  if (raw === "pending" || raw === "pending_init" || raw === "starting" || raw === "started" || raw === "in_progress" || raw === "running") return "running";
+  return "running";
+}
+
+function summaryFromStatus(status: unknown): string | undefined {
+  if (isRecord(status)) {
+    const candidate = status.completed ?? status.failed ?? status.error ?? status.blocked ?? status.paused ?? status.running ?? status.pending;
+    return stableJson(candidate);
+  }
+  return undefined;
+}
+
+function toolLabel(tool: unknown): string | undefined {
+  if (typeof tool === "string" && tool.trim()) return tool;
+  if (!isRecord(tool)) return undefined;
+  return stringValue(tool.name)
+    ?? stringValue(tool.agent)
+    ?? stringValue(tool.agent_nickname)
+    ?? stringValue(tool.agentNickname)
+    ?? stringValue(tool.nickname);
+}
+
+function runFromRecord(record: Record<string, unknown>, fallback: Partial<SubagentRun>): SubagentRun {
+  const threadId = stringValue(record.thread_id) ?? stringValue(record.threadId) ?? stringValue(record.id) ?? fallback.threadId;
+  const agent = stringValue(record.agent_nickname)
+    ?? stringValue(record.agentNickname)
+    ?? stringValue(record.nickname)
+    ?? stringValue(record.agent)
+    ?? fallback.agent
+    ?? "agent";
+  const statusSource = record.status ?? record.state ?? fallback.status;
+  return {
+    id: stringValue(record.call_id) ?? stringValue(record.callId) ?? threadId ?? fallback.id ?? agent,
+    agent,
+    status: normalizeSubagentStatus(statusSource),
+    role: stringValue(record.agent_role) ?? stringValue(record.agentRole) ?? stringValue(record.role) ?? fallback.role,
+    task: stringValue(record.prompt) ?? stringValue(record.task) ?? fallback.task,
+    summary: summaryFromStatus(statusSource) ?? stringValue(record.summary) ?? fallback.summary,
+    threadId,
+    parentThreadId: stringValue(record.parent_thread_id) ?? stringValue(record.parentThreadId) ?? fallback.parentThreadId,
+    model: stringValue(record.model) ?? fallback.model,
+    reasoningEffort: stringValue(record.reasoning_effort) ?? stringValue(record.reasoningEffort) ?? fallback.reasoningEffort,
+    timestamp: numberTimestamp(record.timestamp) ?? fallback.timestamp,
+  };
+}
+
+function runsFromAgentStates(states: unknown, fallback: Partial<SubagentRun>): SubagentRun[] {
+  if (Array.isArray(states)) {
+    return states
+      .filter(isRecord)
+      .map((state, index) => runFromRecord(state, { ...fallback, id: `${fallback.id ?? "agent"}:${index}` }));
+  }
+  if (!isRecord(states)) return [];
+
+  const agentStatuses = states.agent_statuses ?? states.agentStatuses;
+  if (Array.isArray(agentStatuses)) {
+    return agentStatuses
+      .filter(isRecord)
+      .map((state, index) => runFromRecord(state, { ...fallback, id: `${fallback.id ?? "agent"}:${index}` }));
+  }
+
+  const statuses = states.statuses;
+  if (isRecord(statuses)) return runsFromStatusMap(statuses, fallback);
+
+  return Object.entries(states).map(([threadId, state]) => {
+    if (isRecord(state)) return runFromRecord(state, { ...fallback, id: threadId, threadId });
+    return {
+      id: threadId,
+      agent: fallback.agent ?? "agent",
+      status: normalizeSubagentStatus(state),
+      role: fallback.role,
+      task: fallback.task,
+      summary: summaryFromStatus(state),
+      threadId,
+      parentThreadId: fallback.parentThreadId,
+      model: fallback.model,
+      reasoningEffort: fallback.reasoningEffort,
+      timestamp: fallback.timestamp,
+    };
+  });
+}
+
+function runsFromStatusMap(statuses: Record<string, unknown>, fallback: Partial<SubagentRun>): SubagentRun[] {
+  return Object.entries(statuses).map(([threadId, status]) => {
+    if (isRecord(status)) return runFromRecord({ ...status, thread_id: threadId }, { ...fallback, id: threadId, threadId });
+    return {
+      id: threadId,
+      agent: fallback.agent ?? "agent",
+      status: normalizeSubagentStatus(status),
+      role: fallback.role,
+      task: fallback.task,
+      summary: summaryFromStatus(status),
+      threadId,
+      parentThreadId: fallback.parentThreadId,
+      model: fallback.model,
+      reasoningEffort: fallback.reasoningEffort,
+      timestamp: fallback.timestamp,
+    };
+  });
+}
+
+export function subagentRunsFromCollabItem(item: unknown, timestamp?: number): SubagentRun[] {
+  if (!isRecord(item) || item.type !== "collabAgentToolCall") return [];
+
+  const fallback: Partial<SubagentRun> = {
+    id: stringValue(item.id),
+    agent: (() => {
+      const label = toolLabel(item.tool);
+      if (!label) return "agent";
+      return label.toLowerCase().endsWith("agent") ? "agent" : label;
+    })(),
+    status: normalizeSubagentStatus(item.status),
+    task: stringValue(item.prompt),
+    parentThreadId: stringValue(item.senderThreadId) ?? stringValue(item.sender_thread_id),
+    model: stringValue(item.model),
+    reasoningEffort: stableJson(item.reasoningEffort ?? item.reasoning_effort),
+    timestamp,
+  };
+
+  const fromStates = runsFromAgentStates(item.agentsStates ?? item.agents_states, fallback);
+  if (fromStates.length > 0) return fromStates;
+
+  const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+    ? item.receiverThreadIds.filter((id): id is string => typeof id === "string" && !!id)
+    : [];
+  if (receiverThreadIds.length > 0) {
+    return receiverThreadIds.map((threadId, index) => ({
+      id: `${stringValue(item.id) ?? "agents"}:${threadId}`,
+      agent: fallback.agent ?? `agent ${index + 1}`,
+      status: fallback.status ?? "running",
+      task: fallback.task,
+      threadId,
+      parentThreadId: fallback.parentThreadId,
+      model: fallback.model,
+      reasoningEffort: fallback.reasoningEffort,
+      timestamp,
+    }));
+  }
+
+  return [{
+    id: stringValue(item.id) ?? `agents:${timestamp ?? Date.now()}`,
+    agent: fallback.agent ?? "agents",
+    status: fallback.status ?? "running",
+    task: fallback.task,
+    parentThreadId: fallback.parentThreadId,
+    model: fallback.model,
+    reasoningEffort: fallback.reasoningEffort,
+    timestamp,
+  }];
+}
+
+export function subagentRunsFromCollabEvent(payload: unknown, timestamp?: number): SubagentRun[] {
+  if (!isRecord(payload)) return [];
+  const type = stringValue(payload.type);
+  if (!type?.startsWith("collab_")) return [];
+
+  const base: Partial<SubagentRun> = {
+    id: stringValue(payload.call_id) ?? stringValue(payload.callId),
+    parentThreadId: stringValue(payload.sender_thread_id) ?? stringValue(payload.senderThreadId),
+    task: stringValue(payload.prompt),
+    model: stringValue(payload.model),
+    reasoningEffort: stringValue(payload.reasoning_effort) ?? stringValue(payload.reasoningEffort),
+    timestamp,
+  };
+
+  const agentStatuses = payload.agent_statuses ?? payload.agentStatuses;
+  if (Array.isArray(agentStatuses)) {
+    return agentStatuses
+      .filter(isRecord)
+      .map((status, index) => runFromRecord(status, { ...base, id: `${base.id ?? "agent"}:${index}` }));
+  }
+  if (isRecord(payload.statuses)) return runsFromStatusMap(payload.statuses, base);
+
+  if (type === "collab_agent_spawn_end") {
+    return [runFromRecord({
+      call_id: payload.call_id,
+      thread_id: payload.new_thread_id,
+      agent_nickname: payload.new_agent_nickname,
+      agent_role: payload.new_agent_role,
+      prompt: payload.prompt,
+      model: payload.model,
+      reasoning_effort: payload.reasoning_effort,
+      status: payload.status,
+    }, base)];
+  }
+
+  if (type === "collab_close_end" || type === "collab_agent_interaction_end") {
+    return [runFromRecord({
+      call_id: payload.call_id,
+      thread_id: payload.receiver_thread_id,
+      agent_nickname: payload.receiver_agent_nickname,
+      agent_role: payload.receiver_agent_role,
+      prompt: payload.prompt,
+      status: payload.status,
+    }, base)];
+  }
+
+  return [];
+}
+
+export function coerceSubagentRuns(value: unknown): SubagentRun[] {
+  const rawRuns = Array.isArray(value) ? value : (isRecord(value) ? [value] : []);
+  return rawRuns.filter(isRecord).map((run, index) => ({
+    id: stringValue(run.id) ?? stringValue(run.threadId) ?? stringValue(run.thread_id) ?? `agent:${index}`,
+    agent: stringValue(run.agent) ?? stringValue(run.agent_nickname) ?? "agent",
+    status: normalizeSubagentStatus(run.status),
+    role: stringValue(run.role) ?? stringValue(run.agent_role),
+    task: stringValue(run.task) ?? stringValue(run.prompt),
+    summary: stringValue(run.summary),
+    threadId: stringValue(run.threadId) ?? stringValue(run.thread_id),
+    parentThreadId: stringValue(run.parentThreadId) ?? stringValue(run.parent_thread_id),
+    model: stringValue(run.model),
+    reasoningEffort: stringValue(run.reasoningEffort) ?? stringValue(run.reasoning_effort),
+    timestamp: typeof run.timestamp === "number" ? run.timestamp : numberTimestamp(run.timestamp),
+  }));
+}
+
+export function mergeSubagentRuns(...groups: Array<SubagentRun[] | undefined>): SubagentRun[] {
+  const merged = new Map<string, SubagentRun>();
+  for (const group of groups) {
+    for (const run of group ?? []) {
+      const previous = merged.get(run.id);
+      merged.set(run.id, {
+        ...previous,
+        ...run,
+        timestamp: Math.max(previous?.timestamp ?? 0, run.timestamp ?? 0) || previous?.timestamp || run.timestamp,
+        summary: run.summary ?? previous?.summary,
+        task: run.task ?? previous?.task,
+        role: run.role ?? previous?.role,
+        threadId: run.threadId ?? previous?.threadId,
+      });
+    }
+  }
+  return [...merged.values()].sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+}

package/lib/types.ts

@@ -0,0 +1,241 @@
+// Types for annodex session format
+
+export interface SessionHeader {
+  type: "session";
+  version?: number;
+  id: string;
+  timestamp: string;
+  cwd: string;
+  parentSession?: string;
+}
+
+export interface SessionEntryBase {
+  type: string;
+  id: string;
+  parentId: string | null;
+  timestamp: string;
+}
+
+export interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export interface ImageContent {
+  type: "image";
+  source?: {
+    type: "base64" | "url";
+    media_type?: string;
+    data?: string;
+    url?: string;
+  };
+  data?: string;
+  mimeType?: string;
+}
+
+export interface ThinkingContent {
+  type: "thinking";
+  thinking: string;
+}
+
+export interface ToolCallContent {
+  type: "toolCall";
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+}
+
+export type AssistantContentBlock = TextContent | ImageContent | ThinkingContent | ToolCallContent;
+
+export interface UserMessage {
+  role: "user";
+  content: string | (TextContent | ImageContent)[];
+  timestamp?: number;
+}
+
+export interface AssistantMessage {
+  role: "assistant";
+  content: AssistantContentBlock[];
+  model: string;
+  provider: string;
+  stopReason?: string;
+  errorMessage?: string;
+  timestamp?: number;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      total: number;
+    };
+  };
+}
+
+export interface ToolResultMessage {
+  role: "toolResult";
+  toolCallId: string;
+  toolName?: string;
+  content: (TextContent | ImageContent)[];
+  isError?: boolean;
+  timestamp?: number;
+}
+
+export interface CustomMessage {
+  role: "custom";
+  customType: string;
+  content: string | (TextContent | ImageContent)[];
+  display: boolean;
+  details?: unknown;
+  timestamp?: number;
+}
+
+export type AgentMessage = UserMessage | AssistantMessage | ToolResultMessage | CustomMessage;
+
+export type SubagentRunStatus = "pending" | "running" | "completed" | "failed" | "paused" | "not_found";
+
+export interface SubagentRun {
+  id: string;
+  agent: string;
+  status: SubagentRunStatus;
+  role?: string;
+  task?: string;
+  summary?: string;
+  threadId?: string;
+  parentThreadId?: string;
+  model?: string;
+  reasoningEffort?: string;
+  timestamp?: number;
+}
+
+export interface SessionMessageEntry extends SessionEntryBase {
+  type: "message";
+  message: AgentMessage;
+}
+
+export interface ThinkingLevelChangeEntry extends SessionEntryBase {
+  type: "thinking_level_change";
+  thinkingLevel: string;
+}
+
+export interface ModelChangeEntry extends SessionEntryBase {
+  type: "model_change";
+  provider: string;
+  modelId: string;
+}
+
+export interface CompactionEntry extends SessionEntryBase {
+  type: "compaction";
+  summary: string;
+  firstKeptEntryId: string;
+  tokensBefore: number;
+  details?: unknown;
+  fromHook?: boolean;
+}
+
+export interface BranchSummaryEntry extends SessionEntryBase {
+  type: "branch_summary";
+  fromId: string;
+  summary: string;
+  details?: unknown;
+  fromHook?: boolean;
+}
+
+export interface CustomEntry extends SessionEntryBase {
+  type: "custom";
+  customType: string;
+  data?: unknown;
+}
+
+export interface CustomMessageEntry extends SessionEntryBase {
+  type: "custom_message";
+  customType: string;
+  content: string | (TextContent | ImageContent)[];
+  details?: unknown;
+  display: boolean;
+}
+
+export interface LabelEntry extends SessionEntryBase {
+  type: "label";
+  targetId: string;
+  label: string | undefined;
+}
+
+export interface SessionInfoEntry extends SessionEntryBase {
+  type: "session_info";
+  name?: string;
+}
+
+export type SessionEntry =
+  | SessionMessageEntry
+  | ThinkingLevelChangeEntry
+  | ModelChangeEntry
+  | CompactionEntry
+  | BranchSummaryEntry
+  | CustomEntry
+  | CustomMessageEntry
+  | LabelEntry
+  | SessionInfoEntry;
+
+export type FileEntry = SessionHeader | SessionEntry;
+
+export interface SessionTreeNode {
+  entry: SessionEntry;
+  children: SessionTreeNode[];
+  label?: string;
+}
+
+export interface SessionInfo {
+  path: string;
+  id: string;
+  cwd: string;
+  cwdExists?: boolean;
+  name?: string;
+  created: string;
+  modified: string;
+  messageCount: number;
+  firstMessage: string;
+  parentSessionId?: string; // set if this session was forked from another
+}
+
+export interface ProjectInfo {
+  cwd: string;
+  name?: string;
+  displayName: string;
+  chatCount: number;
+  lastAccessed: string | null;
+  created: string | null;
+  hidden?: boolean;
+  exists: boolean;
+  source: "session" | "manual" | "both";
+}
+
+export interface SessionContext {
+  messages: AgentMessage[];
+  entryIds: string[]; // parallel to messages — the session entry id for each message
+  thinkingLevel: string;
+  model: { provider: string; modelId: string } | null;
+  subagentRuns?: SubagentRun[];
+  sessionStats?: {
+    tokens: { input: number; output: number; cacheRead: number; cacheWrite: number };
+    cost?: number;
+  } | null;
+  contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null;
+}
+
+// RPC types
+export interface RpcSessionState {
+  model?: { provider: string; id: string; contextWindow?: number };
+  thinkingLevel: string;
+  isStreaming: boolean;
+  isCompacting: boolean;
+  sessionFile?: string;
+  sessionId: string;
+  sessionName?: string;
+  messageCount: number;
+  contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null;
+}