work-ally 0.2.0-alpha.1

package/bridge/src/session-store-meta.ts

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendNdjson, ensureDir, nowIso, readJsonFile, writeJsonFile } from './utils.ts';
+import type { ConversationRef, SessionMeta } from './types.ts';
+
+export interface SessionMetaStoreDeps {
+  sessionsDir: string;
+  resolveSessionKey(ref: ConversationRef): string;
+  resolveSessionDir(ref: ConversationRef): string;
+  metaFile(ref: ConversationRef): string;
+  eventsFile(ref: ConversationRef): string;
+}
+
+export function ensureSessionDirs(deps: SessionMetaStoreDeps, ref: ConversationRef): string {
+  const sessionDir = deps.resolveSessionDir(ref);
+  ensureDir(sessionDir);
+  ensureDir(path.join(sessionDir, 'turns'));
+  ensureDir(path.join(sessionDir, 'turn-ledger'));
+  ensureDir(path.join(sessionDir, 'inbound-ledger'));
+  ensureDir(path.join(sessionDir, 'approvals'));
+  ensureDir(path.join(sessionDir, 'receipts'));
+  ensureDir(path.join(sessionDir, 'user-inputs'));
+  ensureDir(path.join(sessionDir, 'seen-inbounds'));
+  ensureDir(path.join(sessionDir, 'outbound-delivery'));
+  return sessionDir;
+}
+
+export function normalizeSessionMeta(
+  deps: SessionMetaStoreDeps,
+  ref: ConversationRef,
+  current: SessionMeta | null,
+  now = nowIso(),
+): SessionMeta {
+  const meta: SessionMeta = current || {
+    conversationRef: ref,
+    sessionKey: deps.resolveSessionKey(ref),
+    createdAt: now,
+    updatedAt: now,
+    threadId: null,
+    activeTurnId: null,
+    lastTurnId: null,
+    lastMessageId: null,
+    lastPromptPreview: null,
+    lastReplyPreview: null,
+    pendingApprovalIds: [],
+    pendingUserInputRequestId: null,
+  };
+
+  meta.conversationRef = ref;
+  if (!('activeTurnId' in meta)) meta.activeTurnId = null;
+  if (!('lastTurnId' in meta)) meta.lastTurnId = null;
+  if (!('lastMessageId' in meta)) meta.lastMessageId = null;
+  if (!('lastPromptPreview' in meta)) meta.lastPromptPreview = null;
+  if (!('lastReplyPreview' in meta)) meta.lastReplyPreview = null;
+  if (!('pendingApprovalIds' in meta) || !Array.isArray(meta.pendingApprovalIds)) meta.pendingApprovalIds = [];
+  if (!('pendingUserInputRequestId' in meta)) meta.pendingUserInputRequestId = null;
+  meta.updatedAt = now;
+  return meta;
+}
+
+export function ensureSession(deps: SessionMetaStoreDeps, ref: ConversationRef): SessionMeta {
+  ensureSessionDirs(deps, ref);
+  const metaFile = deps.metaFile(ref);
+  const meta = normalizeSessionMeta(deps, ref, readJsonFile(metaFile) as SessionMeta | null);
+  writeJsonFile(metaFile, meta);
+  return meta;
+}
+
+export function bindThread(
+  deps: SessionMetaStoreDeps,
+  ref: ConversationRef,
+  threadId: string | null,
+): SessionMeta {
+  const meta = ensureSession(deps, ref);
+  meta.threadId = threadId;
+  if (threadId === null) {
+    meta.activeTurnId = null;
+    meta.pendingApprovalIds = [];
+    meta.pendingUserInputRequestId = null;
+  }
+  meta.updatedAt = nowIso();
+  writeJsonFile(deps.metaFile(ref), meta);
+  writeJsonFile(path.join(deps.resolveSessionDir(ref), 'current-thread.json'), {
+    threadId,
+    updatedAt: meta.updatedAt,
+  });
+  return meta;
+}
+
+export function noteLatestInbound(
+  deps: SessionMetaStoreDeps,
+  ref: ConversationRef,
+  details: { messageId?: string | null; promptPreview?: string | null },
+): SessionMeta {
+  const meta = ensureSession(deps, ref);
+  if ('messageId' in details) {
+    meta.lastMessageId = details.messageId || meta.lastMessageId;
+  }
+  if ('promptPreview' in details) {
+    meta.lastPromptPreview = details.promptPreview || meta.lastPromptPreview;
+  }
+  meta.updatedAt = nowIso();
+  writeJsonFile(deps.metaFile(ref), meta);
+  appendNdjson(deps.eventsFile(ref), {
+    type: 'latest_inbound_noted',
+    at: meta.updatedAt,
+    messageId: details.messageId || null,
+  });
+  return meta;
+}
+
+export function clearActiveTurn(deps: SessionMetaStoreDeps, ref: ConversationRef): SessionMeta {
+  const meta = ensureSession(deps, ref);
+  meta.activeTurnId = null;
+  meta.updatedAt = nowIso();
+  writeJsonFile(deps.metaFile(ref), meta);
+  appendNdjson(deps.eventsFile(ref), {
+    type: 'active_turn_cleared',
+    at: meta.updatedAt,
+  });
+  return meta;
+}
+
+export function listSessions(deps: SessionMetaStoreDeps): SessionMeta[] {
+  const entries = fs.readdirSync(deps.sessionsDir, { withFileTypes: true });
+  const sessions: SessionMeta[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const meta = readJsonFile(path.join(deps.sessionsDir, entry.name, 'meta.json')) as SessionMeta | null;
+    if (!meta?.conversationRef) continue;
+    sessions.push(normalizeSessionMeta(deps, meta.conversationRef, meta, meta.updatedAt || nowIso()));
+  }
+  return sessions;
+}

package/bridge/src/session-store-turn-ledger.ts

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendNdjson, nowIso, readJsonFile, writeJsonFile } from './utils.ts';
+import type {
+  ConversationRef,
+  InboundAcceptanceRecord,
+  SessionMeta,
+  TurnDeliveryStatus,
+  TurnExecutionStatus,
+  TurnLedgerRecord,
+  TurnRecord,
+} from './types.ts';
+
+export interface TurnLedgerStoreDeps {
+  ensureSessionDirs(ref: ConversationRef): string;
+  ensureSession(ref: ConversationRef): SessionMeta;
+  getSession(ref: ConversationRef): SessionMeta | null;
+  resolveSessionDir(ref: ConversationRef): string;
+  metaFile(ref: ConversationRef): string;
+  eventsFile(ref: ConversationRef): string;
+  turnLedgerFile(ref: ConversationRef, turnId: string): string;
+  updateInboundAcceptance(
+    ref: ConversationRef,
+    messageId: string,
+    seed?: Partial<InboundAcceptanceRecord>,
+    mutate?: (record: InboundAcceptanceRecord, now: string) => void,
+  ): InboundAcceptanceRecord;
+}
+
+function turnExecutionStatusFromRuntimeStatus(status: string): TurnExecutionStatus {
+  if (status === 'completed') {
+    return 'completed';
+  }
+  if (status === 'interrupted') {
+    return 'interrupted';
+  }
+  if (status === 'failed') {
+    return 'failed';
+  }
+  return 'failed';
+}
+
+function syncInboundAcceptanceFromTurn(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  ledger: TurnLedgerRecord,
+  now: string,
+): void {
+  if (!ledger.messageId) {
+    return;
+  }
+  deps.updateInboundAcceptance(ref, ledger.messageId, {
+    threadId: ledger.threadId || null,
+    turnId: ledger.turnId,
+    executionStatus: ledger.executionStatus,
+  }, (record) => {
+    record.threadId = ledger.threadId || record.threadId || null;
+    record.turnId = ledger.turnId;
+    record.executionStatus = ledger.executionStatus;
+    if (!record.acceptedAt) {
+      record.acceptedAt = now;
+    }
+  });
+}
+
+function normalizeTurnLedger(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  current: TurnLedgerRecord | null,
+  seed: Partial<TurnLedgerRecord> = {},
+  now = nowIso(),
+): TurnLedgerRecord {
+  const session = deps.getSession(ref);
+  return {
+    turnId,
+    threadId: current?.threadId || seed.threadId || session?.threadId || '',
+    messageId: current?.messageId ?? seed.messageId ?? null,
+    promptPreview: current?.promptPreview ?? seed.promptPreview ?? null,
+    createdAt: current?.createdAt || now,
+    updatedAt: now,
+    executionStatus: current?.executionStatus || (seed.executionStatus as TurnExecutionStatus | undefined) || 'running',
+    replyPreview: current?.replyPreview ?? seed.replyPreview ?? null,
+    error: current?.error ?? seed.error ?? null,
+    deliveryStatus: current?.deliveryStatus || (seed.deliveryStatus as TurnDeliveryStatus | undefined) || 'not_ready',
+    deliveredAt: current?.deliveredAt ?? seed.deliveredAt ?? null,
+    suppressedByMessageId: current?.suppressedByMessageId ?? seed.suppressedByMessageId ?? null,
+    suppressedByTurnId: current?.suppressedByTurnId ?? seed.suppressedByTurnId ?? null,
+    suppressionReason: current?.suppressionReason ?? seed.suppressionReason ?? null,
+  };
+}
+
+function updateTurnLedger(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  seed: Partial<TurnLedgerRecord> = {},
+  mutate?: (ledger: TurnLedgerRecord, now: string) => void,
+): TurnLedgerRecord {
+  deps.ensureSessionDirs(ref);
+  const file = deps.turnLedgerFile(ref, turnId);
+  const current = readJsonFile(file) as TurnLedgerRecord | null;
+  const now = nowIso();
+  const ledger = normalizeTurnLedger(deps, ref, turnId, current, seed, now);
+  mutate?.(ledger, now);
+  ledger.updatedAt = now;
+  writeJsonFile(file, ledger);
+  syncInboundAcceptanceFromTurn(deps, ref, ledger, now);
+  appendNdjson(deps.eventsFile(ref), {
+    type: 'turn_ledger_updated',
+    at: now,
+    turn: ledger,
+  });
+  return ledger;
+}
+
+export function markActiveTurn(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  details?: { messageId?: string | null; promptPreview?: string | null },
+): SessionMeta {
+  const meta = deps.ensureSession(ref);
+  meta.activeTurnId = turnId;
+  meta.pendingUserInputRequestId = null;
+  if (details && 'messageId' in details) {
+    meta.lastMessageId = details.messageId || null;
+  }
+  if (details && 'promptPreview' in details) {
+    meta.lastPromptPreview = details.promptPreview || null;
+  }
+  meta.updatedAt = nowIso();
+  writeJsonFile(deps.metaFile(ref), meta);
+  appendNdjson(deps.eventsFile(ref), {
+    type: 'turn_started',
+    at: meta.updatedAt,
+    turnId,
+  });
+  updateTurnLedger(deps, ref, turnId, {
+    threadId: meta.threadId || '',
+    messageId: details?.messageId || null,
+    promptPreview: details?.promptPreview || null,
+  }, (ledger) => {
+    ledger.executionStatus = 'running';
+    ledger.error = null;
+    ledger.replyPreview = null;
+    ledger.deliveryStatus = 'not_ready';
+    ledger.deliveredAt = null;
+    ledger.suppressedByMessageId = null;
+    ledger.suppressedByTurnId = null;
+    ledger.suppressionReason = null;
+  });
+  return meta;
+}
+
+export function markTurnRunning(deps: TurnLedgerStoreDeps, ref: ConversationRef, turnId: string): TurnLedgerRecord {
+  return updateTurnLedger(deps, ref, turnId, {}, (ledger) => {
+    if (ledger.deliveryStatus === 'suppressed') {
+      return;
+    }
+    ledger.executionStatus = 'running';
+  });
+}
+
+export function noteTurnTerminalState(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  details: { threadId: string; status: string; reply?: string | null; error?: string | null },
+): TurnLedgerRecord {
+  return updateTurnLedger(deps, ref, turnId, {
+    threadId: details.threadId,
+  }, (ledger, now) => {
+    ledger.threadId = details.threadId;
+    ledger.executionStatus = turnExecutionStatusFromRuntimeStatus(details.status || 'failed');
+    ledger.replyPreview = (details.reply || '').trim().slice(0, 160) || null;
+    ledger.error = details.error || null;
+    if (ledger.deliveryStatus !== 'suppressed') {
+      ledger.deliveryStatus = 'pending';
+    }
+  });
+}
+
+export function markTurnSuppressed(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  details: { threadId?: string | null; suppressedByMessageId?: string | null; suppressedByTurnId?: string | null; reason: string },
+): TurnLedgerRecord {
+  return updateTurnLedger(deps, ref, turnId, {
+    threadId: details.threadId || undefined,
+  }, (ledger) => {
+    ledger.deliveryStatus = 'suppressed';
+    ledger.suppressedByMessageId = details.suppressedByMessageId || null;
+    ledger.suppressedByTurnId = details.suppressedByTurnId || null;
+    ledger.suppressionReason = details.reason;
+  });
+}
+
+export function markTurnDelivery(
+  deps: TurnLedgerStoreDeps,
+  ref: ConversationRef,
+  turnId: string,
+  status: 'delivered' | 'delivery_unavailable',
+): TurnLedgerRecord {
+  return updateTurnLedger(deps, ref, turnId, {}, (ledger, now) => {
+    if (ledger.deliveryStatus === 'suppressed') {
+      return;
+    }
+    ledger.deliveryStatus = status;
+    if (status === 'delivered') {
+      ledger.deliveredAt = now;
+    }
+  });
+}
+
+export function findLatestDeliveryIssue(deps: TurnLedgerStoreDeps, ref: ConversationRef): TurnLedgerRecord | null {
+  const dir = path.join(deps.resolveSessionDir(ref), 'turn-ledger');
+  if (!fs.existsSync(dir)) {
+    return null;
+  }
+  return fs.readdirSync(dir)
+    .filter((entry) => entry.endsWith('.json'))
+    .map((entry) => readJsonFile(path.join(dir, entry)) as TurnLedgerRecord | null)
+    .filter((ledger): ledger is TurnLedgerRecord => Boolean(ledger))
+    .filter((ledger) => ledger.deliveryStatus === 'delivery_unavailable')
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))[0] || null;
+}
+
+export function getTurnLedger(deps: TurnLedgerStoreDeps, ref: ConversationRef, turnId: string): TurnLedgerRecord | null {
+  return readJsonFile(deps.turnLedgerFile(ref, turnId)) as TurnLedgerRecord | null;
+}
+
+export function getTurnRecord(deps: TurnLedgerStoreDeps, ref: ConversationRef, turnId: string): TurnRecord | null {
+  const dir = path.join(deps.resolveSessionDir(ref), 'turns');
+  if (!fs.existsSync(dir)) {
+    return null;
+  }
+  const suffix = `-${turnId}.json`;
+  const match = fs.readdirSync(dir)
+    .filter((entry) => entry.endsWith(suffix))
+    .sort((left, right) => right.localeCompare(left))[0];
+  if (!match) {
+    return null;
+  }
+  return readJsonFile(path.join(dir, match)) as TurnRecord | null;
+}
+
+export function recordTurn(deps: TurnLedgerStoreDeps, ref: ConversationRef, turn: TurnRecord): void {
+  const sessionDir = deps.resolveSessionDir(ref);
+  deps.ensureSessionDirs(ref);
+  const meta = deps.ensureSession(ref);
+  meta.activeTurnId = null;
+  meta.lastTurnId = turn.turnId;
+  meta.lastReplyPreview = (turn.reply || '').trim().slice(0, 160) || null;
+  meta.pendingApprovalIds = [];
+  meta.pendingUserInputRequestId = null;
+  meta.updatedAt = nowIso();
+  writeJsonFile(deps.metaFile(ref), meta);
+  writeJsonFile(path.join(sessionDir, 'turns', `${turn.startedAt.replace(/[:.]/g, '-')}-${turn.turnId}.json`), turn);
+  appendNdjson(deps.eventsFile(ref), {
+    type: 'turn',
+    at: nowIso(),
+    turn,
+  });
+  noteTurnTerminalState(deps, ref, turn.turnId, {
+    threadId: turn.threadId,
+    status: turn.status || 'failed',
+    reply: turn.reply,
+    error: turn.error || null,
+  });
+}