codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/state-sync-service.js

@@ -0,0 +1,384 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_sync_service_exports = {};
+__export(state_sync_service_exports, {
+  collectSnapshot: () => collectSnapshot,
+  getAllRemoteStates: () => getAllRemoteStates,
+  getRemoteState: () => getRemoteState,
+  isStateSyncRunning: () => isStateSyncRunning,
+  onRemoteStateChange: () => onRemoteStateChange,
+  startStateSync: () => startStateSync,
+  stopStateSync: () => stopStateSync
+});
+module.exports = __toCommonJS(state_sync_service_exports);
+var _lazy___audio_buffer_service = __toESM(require("./audio-buffer-service"));
+var import_fast_json_patch = require("fast-json-patch");
+var import_types = require("../../shared/types");
+var import_webrtc_service = require("./webrtc-service");
+var sessionService = __toESM(require("./session-service"));
+var planItemService = __toESM(require("./plan-item-service"));
+var planService = __toESM(require("./plan-service"));
+var channelEventService = __toESM(require("./channel-event-service"));
+var presenceService = __toESM(require("./presence-service"));
+var recentProjectsService = __toESM(require("./recent-projects-service"));
+var terminalService = __toESM(require("./terminal-service"));
+var import_terminal_history_service = require("./terminal-history-service");
+var deviationService = __toESM(require("./deviation-service"));
+var remoteInteractionService = __toESM(require("./remote-interaction-service"));
+var import_breakpoint_service = require("./breakpoint-service");
+var import_awareness_service = require("./awareness-service");
+var import_pairing_server = require("./pairing-server");
+var import_power_service = require("./power-service");
+var import_server = require("../server");
+let running = false;
+let instanceId = "";
+const lastSent = /* @__PURE__ */ new Map();
+let patchTimer = null;
+let unsubMessage = null;
+let unsubConnection = null;
+const remoteStates = /* @__PURE__ */ new Map();
+const remoteStateListeners = /* @__PURE__ */ new Set();
+const PATCH_DEBOUNCE_MS = 100;
+const MAX_CHANNEL_EVENTS = 50;
+function startStateSync(myInstanceId) {
+  if (running) return;
+  running = true;
+  instanceId = myInstanceId;
+  unsubMessage = (0, import_webrtc_service.onChannelMessage)(import_types.DATA_CHANNELS.UI, handleUiMessage);
+  unsubConnection = (0, import_webrtc_service.onConnectionStateChange)(handleConnectionChange);
+  patchTimer = setInterval(broadcastPatchIfChanged, PATCH_DEBOUNCE_MS);
+  console.log("[StateSync] Started");
+}
+function stopStateSync() {
+  if (!running) return;
+  running = false;
+  if (unsubMessage) {
+    unsubMessage();
+    unsubMessage = null;
+  }
+  if (unsubConnection) {
+    unsubConnection();
+    unsubConnection = null;
+  }
+  if (patchTimer) {
+    clearInterval(patchTimer);
+    patchTimer = null;
+  }
+  lastSent.clear();
+  remoteStates.clear();
+  console.log("[StateSync] Stopped");
+}
+function getRemoteState(fingerprint) {
+  return remoteStates.get(fingerprint) ?? null;
+}
+function getAllRemoteStates() {
+  return new Map(remoteStates);
+}
+function onRemoteStateChange(cb) {
+  remoteStateListeners.add(cb);
+  return () => {
+    remoteStateListeners.delete(cb);
+  };
+}
+function isStateSyncRunning() {
+  return running;
+}
+function collectSnapshot() {
+  const plans = planService.listPlans().map((p) => {
+    const items = planItemService.listAllItems(p.uid);
+    return {
+      uid: p.uid,
+      name: p.title,
+      status: p.status,
+      projectPath: p.projectPath,
+      itemCount: items.length,
+      doneCount: items.filter((i) => i.status === "done").length,
+      inProgressCount: items.filter((i) => i.status === "in_progress" || i.status === "assigned").length,
+      updatedAt: p.updatedAt ?? null
+    };
+  });
+  const channelEvents = [];
+  for (const plan of planService.listPlans()) {
+    const events = channelEventService.listChannelEvents(plan.uid, {
+      limit: MAX_CHANNEL_EVENTS
+    });
+    for (const e of events) {
+      channelEvents.push({
+        uid: e.uid,
+        planUid: e.planUid,
+        eventType: e.eventType,
+        message: e.payload?.message ?? "",
+        author: e.author,
+        authorType: e.authorType,
+        status: e.status,
+        createdAt: e.createdAt
+      });
+    }
+  }
+  channelEvents.sort((a, b) => b.createdAt - a.createdAt);
+  channelEvents.splice(MAX_CHANNEL_EVENTS);
+  const agents = sessionService.getActiveSessions().map((s) => ({
+    sessionId: s.sessionId,
+    agentType: s.agentType,
+    model: s.model ?? "",
+    activePlanUid: s.activePlanUid ?? null,
+    lastSeen: s.lastSeen
+  }));
+  const presence = presenceService.getCards().map((c) => ({
+    id: c.id,
+    text: c.text,
+    tone: c.tone,
+    createdAt: c.createdAt,
+    agentId: c.agentId ?? null,
+    linkTo: c.linkTo ?? null
+  }));
+  let audio = { capturing: false, bufferedSeconds: 0 };
+  try {
+    const instance = _lazy___audio_buffer_service.audioBuffer;
+    if (instance && typeof instance.getStatus === "function") {
+      const status = instance.getStatus();
+      audio = {
+        capturing: status.capturing,
+        bufferedSeconds: status.bufferedSeconds
+      };
+    }
+  } catch {
+  }
+  let activeProject = null;
+  try {
+    const activePath = (0, import_server.getActiveProjectPath)();
+    if (activePath) {
+      const proj = recentProjectsService.getRecentProject(activePath);
+      activeProject = {
+        path: activePath,
+        displayName: proj?.displayName ?? activePath.split("/").pop() ?? activePath,
+        branch: proj?.branch ?? null
+      };
+    }
+  } catch {
+  }
+  let recentProjects = [];
+  try {
+    recentProjects = recentProjectsService.listRecentProjects().map((p) => ({
+      path: p.path,
+      displayName: p.displayName,
+      branch: p.branch,
+      pinned: p.pinned,
+      lastOpenedAt: p.lastOpenedAt
+    }));
+  } catch {
+  }
+  let terminals = [];
+  try {
+    terminals = terminalService.listTerminals().map((t) => ({
+      id: t.id,
+      title: t.title,
+      cwd: t.cwd,
+      alive: t.alive,
+      createdAt: t.createdAt,
+      bytesOnDisk: (() => {
+        try {
+          return (0, import_terminal_history_service.getHistorySize)(t.id);
+        } catch {
+          return 0;
+        }
+      })()
+    }));
+  } catch {
+  }
+  let pendingInputRequests = [];
+  try {
+    pendingInputRequests = remoteInteractionService.getPendingInputRequests().map((r) => ({
+      requestId: r.requestId,
+      prompt: r.prompt,
+      options: r.options,
+      planUid: r.planUid,
+      receivedAt: r.receivedAt
+    }));
+  } catch {
+  }
+  const walkthroughActive = presence.length > 0;
+  let deviationCounts = { pending: 0, byPlan: [] };
+  try {
+    let totalPending = 0;
+    const byPlan = [];
+    for (const plan of planService.listPlans()) {
+      const devs = deviationService.getDeviations(plan.uid);
+      const pendingCount = devs.filter((d) => d.resolution === "pending").length;
+      if (pendingCount > 0) {
+        byPlan.push({ planUid: plan.uid, planName: plan.title, count: pendingCount });
+        totalPending += pendingCount;
+      }
+    }
+    deviationCounts = { pending: totalPending, byPlan };
+  } catch {
+  }
+  let waitingBreakpoints = 0;
+  try {
+    waitingBreakpoints = (0, import_breakpoint_service.countWaitingHits)();
+  } catch {
+  }
+  let openSignals = 0;
+  try {
+    const root = (0, import_server.getActiveProjectPath)();
+    if (root) openSignals = (0, import_awareness_service.countNeedsYou)(root);
+  } catch {
+  }
+  const powerStatus = (0, import_power_service.getCurrentPowerStatus)();
+  return {
+    v: 2,
+    ts: Date.now(),
+    plans,
+    channelEvents,
+    agents,
+    presence,
+    audio,
+    activeProject,
+    recentProjects,
+    terminals,
+    pendingInputRequests,
+    walkthroughActive,
+    deviationCounts,
+    waitingBreakpoints,
+    openSignals,
+    deviceAddresses: safeAddresses(),
+    powerStatus
+  };
+}
+function safeAddresses() {
+  try {
+    return (0, import_pairing_server.getAllAddresses)();
+  } catch {
+    return [];
+  }
+}
+function broadcastPatchIfChanged() {
+  if (!running || lastSent.size === 0) return;
+  const current = collectSnapshot();
+  for (const [fingerprint, base] of lastSent) {
+    if ((0, import_fast_json_patch.compare)({ ...base, ts: 0 }, { ...current, ts: 0 }).length === 0) continue;
+    const msg = {
+      type: "patch",
+      patch: (0, import_fast_json_patch.compare)(base, current),
+      ts: Date.now(),
+      sourceInstanceId: instanceId
+    };
+    if ((0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.UI, JSON.stringify(msg))) {
+      lastSent.set(fingerprint, current);
+    } else {
+      lastSent.delete(fingerprint);
+    }
+  }
+}
+function sendFullSnapshot(fingerprint) {
+  const snapshot = collectSnapshot();
+  const msg = {
+    type: "snapshot",
+    snapshot,
+    ts: Date.now(),
+    sourceInstanceId: instanceId
+  };
+  const payload = JSON.stringify(msg);
+  console.log(`[StateSync] Sending full snapshot to ${fingerprint.slice(0, 12)}\u2026 (${payload.length} bytes, plans=${snapshot.plans?.length ?? 0})`);
+  const sent = (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.UI, payload);
+  console.log(`[StateSync] sendToPeer returned ${sent}`);
+  if (sent) lastSent.set(fingerprint, snapshot);
+}
+function handleUiMessage(fingerprint, data) {
+  try {
+    const text = typeof data === "string" ? data : data.toString("utf-8");
+    const msg = JSON.parse(text);
+    if (msg.sourceInstanceId === instanceId) return;
+    if (msg.type === "resync-request") {
+      console.log(`[StateSync] Resync requested by ${fingerprint.slice(0, 12)}\u2026`);
+      sendFullSnapshot(fingerprint);
+      return;
+    }
+    if (msg.type === "snapshot" && msg.snapshot) {
+      remoteStates.set(fingerprint, msg.snapshot);
+      emitRemoteStateChange(fingerprint, msg.snapshot);
+    } else if (msg.type === "patch" && msg.patch) {
+      const existing = remoteStates.get(fingerprint);
+      if (existing) {
+        try {
+          const patched = (0, import_fast_json_patch.applyPatch)(
+            JSON.parse(JSON.stringify(existing)),
+            msg.patch
+          );
+          const newState = patched.newDocument;
+          remoteStates.set(fingerprint, newState);
+          emitRemoteStateChange(fingerprint, newState);
+        } catch (err) {
+          console.warn(`[StateSync] Patch from ${fingerprint.slice(0, 12)}\u2026 failed, requesting resync:`, err);
+          requestResync(fingerprint);
+        }
+      } else {
+        requestResync(fingerprint);
+      }
+    }
+  } catch (err) {
+    console.warn("[StateSync] Invalid message on ui channel:", err);
+  }
+}
+function handleConnectionChange(fingerprint, state) {
+  console.log(`[StateSync] handleConnectionChange: ${fingerprint.slice(0, 12)}\u2026 \u2192 ${state} (running=${running})`);
+  if (state === "connected") {
+    sendFullSnapshot(fingerprint);
+    setTimeout(() => sendFullSnapshot(fingerprint), 1e3);
+    setTimeout(() => sendFullSnapshot(fingerprint), 3e3);
+  } else if (state === "disconnected" || state === "failed") {
+    remoteStates.delete(fingerprint);
+    lastSent.delete(fingerprint);
+  }
+}
+function requestResync(fingerprint) {
+  const msg = JSON.stringify({
+    type: "resync-request",
+    ts: Date.now(),
+    sourceInstanceId: instanceId
+  });
+  (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.UI, msg);
+}
+function emitRemoteStateChange(fingerprint, state) {
+  for (const cb of remoteStateListeners) {
+    try {
+      cb(fingerprint, state);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectSnapshot,
+  getAllRemoteStates,
+  getRemoteState,
+  isStateSyncRunning,
+  onRemoteStateChange,
+  startStateSync,
+  stopStateSync
+});

package/src/backend/services/stuck-sensor-service.js

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stuck_sensor_service_exports = {};
+__export(stuck_sensor_service_exports, {
+  clearSession: () => clearSession,
+  recordFileActivity: () => recordFileActivity,
+  recordToolCall: () => recordToolCall,
+  registerSessionProject: () => registerSessionProject,
+  resetStuckSensor: () => resetStuckSensor
+});
+module.exports = __toCommonJS(stuck_sensor_service_exports);
+var import_project_config_service = require("./project-config-service");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+const windows = /* @__PURE__ */ new Map();
+const WINDOW_SIZE = 20;
+const COOLDOWN_MS = 10 * 6e4;
+const sessionProjectRoots = /* @__PURE__ */ new Map();
+function registerSessionProject(sessionId, projectRoot) {
+  if (!sessionProjectRoots.has(sessionId)) {
+    sessionProjectRoots.set(sessionId, projectRoot);
+  }
+}
+function recordToolCall(event) {
+  if (!event.sessionId) return;
+  const sessionId = event.sessionId;
+  let win = windows.get(sessionId);
+  if (!win) {
+    win = {
+      calls: [],
+      lastFileActivity: Date.now(),
+      cooldowns: /* @__PURE__ */ new Map()
+    };
+    windows.set(sessionId, win);
+  }
+  const call = {
+    tool: event.tool,
+    args: event.args,
+    phase: event.phase,
+    timestamp: Date.now(),
+    sessionId,
+    error: event.error
+  };
+  win.calls.push(call);
+  if (win.calls.length > WINDOW_SIZE) {
+    win.calls.shift();
+  }
+  tryExtractProjectRoot(sessionId, event.args);
+  const projectRoot = sessionProjectRoots.get(sessionId);
+  if (!projectRoot) return;
+  const cfg = (0, import_project_config_service.getEffectiveSensorConfig)(projectRoot);
+  if (!cfg.stuck.enabled) return;
+  checkRepetition(win, cfg.stuck.repetitionThreshold, sessionId, projectRoot);
+  checkErrorLoop(win, cfg.stuck.errorLoopThreshold, sessionId, projectRoot);
+  checkIdleStall(win, cfg.stuck.idleMinutes, sessionId, projectRoot);
+}
+function recordFileActivity(projectRoot) {
+  const now = Date.now();
+  for (const [sessionId, root] of sessionProjectRoots.entries()) {
+    if (root === projectRoot) {
+      const win = windows.get(sessionId);
+      if (win) win.lastFileActivity = now;
+    }
+  }
+}
+function clearSession(sessionId) {
+  windows.delete(sessionId);
+  sessionProjectRoots.delete(sessionId);
+}
+function resetStuckSensor() {
+  windows.clear();
+  sessionProjectRoots.clear();
+}
+function checkRepetition(win, threshold, sessionId, projectRoot) {
+  if (win.calls.length < threshold) return;
+  if (isOnCooldown(win, "repetition")) return;
+  const tail = win.calls.slice(-threshold);
+  const toolName = tail[0].tool;
+  if (!tail.every((c) => c.tool === toolName)) return;
+  let highSimilarityCount = 0;
+  for (let i = 1; i < tail.length; i++) {
+    if (jaccardSimilarity(tokenize(tail[i - 1].args), tokenize(tail[i].args)) > 0.7) {
+      highSimilarityCount++;
+    }
+  }
+  const similarityRatio = highSimilarityCount / (tail.length - 1);
+  if (similarityRatio < 0.7) return;
+  setCooldown(win, "repetition");
+  const planUid = inferPlanUid(win);
+  if (!planUid) return;
+  (0, import_sensor_bridge_service.onStuckDetected)({
+    planUid,
+    sessionId,
+    heuristic: "repetition",
+    description: `Agent called \`${toolName}\` ${threshold}+ times consecutively with similar arguments. This may indicate the agent is retrying without learning from the result.`,
+    projectRoot
+  });
+}
+function checkErrorLoop(win, threshold, sessionId, projectRoot) {
+  if (win.calls.length < threshold) return;
+  if (isOnCooldown(win, "error-loop")) return;
+  const recent = win.calls.slice(-10);
+  const errors = recent.filter((c) => c.phase === "error");
+  if (errors.length < threshold) return;
+  const toolCounts = /* @__PURE__ */ new Map();
+  for (const e of errors) {
+    toolCounts.set(e.tool, (toolCounts.get(e.tool) ?? 0) + 1);
+  }
+  const [topTool, topCount] = [...toolCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+  if (topCount < threshold) return;
+  setCooldown(win, "error-loop");
+  const planUid = inferPlanUid(win);
+  if (!planUid) return;
+  (0, import_sensor_bridge_service.onStuckDetected)({
+    planUid,
+    sessionId,
+    heuristic: "error-loop",
+    description: `Agent's last 10 tool calls include ${topCount} errors on \`${topTool}\`. The agent may be stuck in an error-retry loop.`,
+    projectRoot
+  });
+}
+function checkIdleStall(win, idleMinutes, sessionId, projectRoot) {
+  if (win.calls.length < 3) return;
+  if (isOnCooldown(win, "idle-stall")) return;
+  const now = Date.now();
+  const idleMs = idleMinutes * 6e4;
+  const timeSinceFile = now - win.lastFileActivity;
+  if (timeSinceFile < idleMs) return;
+  const recentCalls = win.calls.filter((c) => c.timestamp > now - idleMs);
+  if (recentCalls.length < 3) return;
+  setCooldown(win, "idle-stall");
+  const planUid = inferPlanUid(win);
+  if (!planUid) return;
+  (0, import_sensor_bridge_service.onStuckDetected)({
+    planUid,
+    sessionId,
+    heuristic: "idle-stall",
+    description: `Agent has been calling tools for ${idleMinutes}+ minutes without producing any file changes. This may indicate the agent is reading or reasoning but not making progress.`,
+    projectRoot
+  });
+}
+function isOnCooldown(win, heuristic) {
+  const lastFire = win.cooldowns.get(heuristic);
+  if (!lastFire) return false;
+  return Date.now() - lastFire < COOLDOWN_MS;
+}
+function setCooldown(win, heuristic) {
+  win.cooldowns.set(heuristic, Date.now());
+}
+function inferPlanUid(win) {
+  for (let i = win.calls.length - 1; i >= 0; i--) {
+    const match = win.calls[i].args.match(/"plan_uid"\s*:\s*"([^"]+)"/);
+    if (match) return match[1];
+    const match2 = win.calls[i].args.match(/"planUid"\s*:\s*"([^"]+)"/);
+    if (match2) return match2[1];
+  }
+  return null;
+}
+function tryExtractProjectRoot(sessionId, args) {
+  if (sessionProjectRoots.has(sessionId)) return;
+  const match = args.match(/"project_(?:root|path)"\s*:\s*"([^"]+)"/);
+  if (match) {
+    sessionProjectRoots.set(sessionId, match[1]);
+  }
+}
+function tokenize(s) {
+  const tokens = s.toLowerCase().split(/[\s,{}[\]":]+/).filter(Boolean);
+  return new Set(tokens);
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 1 : intersection / union;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearSession,
+  recordFileActivity,
+  recordToolCall,
+  registerSessionProject,
+  resetStuckSensor
+});