codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,285 @@
+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 sensor_bridge_service_exports = {};
+__export(sensor_bridge_service_exports, {
+  checkAllDocsAndBridge: () => checkAllDocsAndBridge,
+  checkDocFreshnessForFile: () => checkDocFreshnessForFile,
+  initSensorBridge: () => initSensorBridge,
+  onDeviationDetected: () => onDeviationDetected,
+  onStuckDetected: () => onStuckDetected,
+  postCriterionNotice: () => postCriterionNotice,
+  resetSensorBridge: () => resetSensorBridge,
+  resolveCriterionNotices: () => resolveCriterionNotices
+});
+module.exports = __toCommonJS(sensor_bridge_service_exports);
+var _lazy___system_docs_service = __toESM(require("./system-docs-service"));
+var import_channel_event_service = require("./channel-event-service");
+var import_channel_event_file_service = require("./channel-event-file-service");
+var import_plan_service = require("./plan-service");
+var import_plan_file_service = require("./plan-file-service");
+var import_project_config_service = require("./project-config-service");
+var import_channel_dispatcher_service = require("./channel-dispatcher-service");
+let broadcastFn = null;
+function initSensorBridge(broadcast) {
+  broadcastFn = broadcast;
+}
+function postSensorEvent(input) {
+  try {
+    const event = (0, import_channel_event_service.postChannelEvent)({
+      ...input,
+      author: "codetrellis",
+      authorType: "sensor"
+    });
+    try {
+      const plan = (0, import_plan_service.getPlan)(event.planUid);
+      if (plan) {
+        const linkedDir = (0, import_plan_file_service.getLinkedPlanDir)(event.planUid, plan.projectPath);
+        if (linkedDir) {
+          (0, import_channel_event_file_service.exportChannelEvent)(event, plan.projectPath);
+        }
+      }
+    } catch {
+    }
+    if (broadcastFn) {
+      broadcastFn("channel-event-posted", {
+        uid: event.uid,
+        planUid: event.planUid,
+        itemUid: event.itemUid,
+        eventType: event.eventType,
+        respondsTo: event.respondsTo,
+        source: "sensor"
+      });
+    }
+    (0, import_channel_dispatcher_service.dispatchChannelEvent)(event).catch(
+      (err) => console.warn("[SensorBridge] dispatch failed:", err)
+    );
+    return event;
+  } catch (err) {
+    console.warn("[SensorBridge] Failed to post sensor event:", err);
+    return null;
+  }
+}
+function postCriterionNotice(opts) {
+  return postSensorEvent({
+    planUid: opts.planUid,
+    itemUid: opts.itemUid,
+    eventType: "need-decision",
+    payload: { message: opts.message, criterionUid: opts.criterionUid, reason: opts.reason }
+  });
+}
+function resolveCriterionNotices(planUid, criterionUid) {
+  let resolved = 0;
+  try {
+    const open = (0, import_channel_event_service.listChannelEvents)(planUid, { eventTypes: ["need-decision"], status: "open", limit: 500 });
+    for (const e of open) {
+      if (e.payload?.criterionUid !== criterionUid) continue;
+      const updated = (0, import_channel_event_service.setChannelEventStatus)(e.uid, "resolved");
+      resolved++;
+      try {
+        const plan = (0, import_plan_service.getPlan)(updated.planUid);
+        if (plan && (0, import_plan_file_service.getLinkedPlanDir)(updated.planUid, plan.projectPath)) (0, import_channel_event_file_service.exportChannelEvent)(updated, plan.projectPath);
+      } catch {
+      }
+      broadcastFn?.("channel-event-status-changed", { uid: updated.uid, planUid: updated.planUid, status: updated.status });
+    }
+  } catch (err) {
+    console.warn("[SensorBridge] Could not resolve criterion notices:", err);
+  }
+  return resolved;
+}
+const driftBatches = /* @__PURE__ */ new Map();
+function onDeviationDetected(deviation, projectRoot) {
+  try {
+    const cfg = (0, import_project_config_service.getEffectiveSensorConfig)(projectRoot);
+    if (!cfg.drift.enabled || !cfg.drift.channelEvents) return;
+    const key = deviation.planUid;
+    let batch = driftBatches.get(key);
+    if (!batch) {
+      batch = {
+        planUid: deviation.planUid,
+        projectRoot,
+        deviations: [],
+        timer: setTimeout(() => flushDriftBatch(key), cfg.drift.debounceMs)
+      };
+      if (typeof batch.timer.unref === "function") batch.timer.unref();
+      driftBatches.set(key, batch);
+    }
+    batch.deviations.push({
+      type: deviation.deviationType,
+      file: deviation.filePath,
+      description: deviation.description
+    });
+  } catch (err) {
+    console.warn("[SensorBridge] onDeviationDetected error:", err);
+  }
+}
+function flushDriftBatch(planUid) {
+  const batch = driftBatches.get(planUid);
+  if (!batch || batch.deviations.length === 0) {
+    driftBatches.delete(planUid);
+    return;
+  }
+  driftBatches.delete(planUid);
+  const count = batch.deviations.length;
+  const fileList = batch.deviations.filter((d) => d.file).map((d) => d.file).slice(0, 10);
+  const messageParts = [
+    `Drift sensor detected ${count} new deviation${count > 1 ? "s" : ""}.`
+  ];
+  if (fileList.length > 0) {
+    messageParts.push(`Files: ${fileList.join(", ")}${count > 10 ? ` (+${count - 10} more)` : ""}.`);
+  }
+  messageParts.push("Run `get_drift_report` to review.");
+  postSensorEvent({
+    planUid: batch.planUid,
+    eventType: "need-decision",
+    payload: {
+      message: messageParts.join(" "),
+      source: "drift-sensor",
+      deviations: batch.deviations
+    }
+  });
+}
+const firedDocStale = /* @__PURE__ */ new Set();
+function checkDocFreshnessForFile(relativePath, projectRoot) {
+  try {
+    const cfg = (0, import_project_config_service.getEffectiveSensorConfig)(projectRoot);
+    if (!cfg.docs.enabled || !cfg.docs.channelEvents) return;
+    const { findDocsByReferencedFile, getFreshness } = _lazy___system_docs_service;
+    const matchingDocs = findDocsByReferencedFile(projectRoot, relativePath);
+    if (matchingDocs.length === 0) return;
+    for (const doc of matchingDocs) {
+      const report = getFreshness(doc.uid);
+      if (!report || report.status !== "stale") continue;
+      const planUid = doc.plans[0];
+      if (!planUid) continue;
+      const key = `${doc.uid}:${planUid}`;
+      if (firedDocStale.has(key)) continue;
+      firedDocStale.add(key);
+      postDocStaleEvent({
+        docUid: doc.uid,
+        slug: doc.slug,
+        title: doc.title,
+        changedFiles: report.changedReferencedFiles,
+        planUid,
+        projectRoot
+      });
+    }
+  } catch (err) {
+    console.warn("[SensorBridge] checkDocFreshnessForFile error:", err);
+  }
+}
+function checkAllDocsAndBridge(projectRoot) {
+  try {
+    const cfg = (0, import_project_config_service.getEffectiveSensorConfig)(projectRoot);
+    if (!cfg.docs.enabled || !cfg.docs.channelEvents) return { staleCount: 0, eventsSurfaced: 0 };
+    const { checkAllDocsFreshness, getSystemDoc } = _lazy___system_docs_service;
+    const staleReports = checkAllDocsFreshness(projectRoot);
+    let eventsSurfaced = 0;
+    for (const report of staleReports) {
+      const doc = getSystemDoc(report.uid);
+      if (!doc) continue;
+      const planUid = doc.references?.plans?.[0];
+      if (!planUid) continue;
+      const key = `${doc.uid}:${planUid}`;
+      if (firedDocStale.has(key)) {
+        eventsSurfaced++;
+        continue;
+      }
+      firedDocStale.add(key);
+      const posted = postDocStaleEvent({
+        docUid: doc.uid,
+        slug: doc.slug,
+        title: doc.title,
+        changedFiles: report.changedReferencedFiles,
+        planUid,
+        projectRoot
+      });
+      if (posted) eventsSurfaced++;
+    }
+    return { staleCount: staleReports.length, eventsSurfaced };
+  } catch (err) {
+    console.warn("[SensorBridge] checkAllDocsAndBridge error:", err);
+    return { staleCount: 0, eventsSurfaced: 0 };
+  }
+}
+function postDocStaleEvent(opts) {
+  const fileList = opts.changedFiles.slice(0, 5);
+  const message = [
+    `Doc "${opts.title}" (${opts.slug}) is stale \u2014 referenced files changed since last verification.`,
+    `Changed: ${fileList.join(", ")}${opts.changedFiles.length > 5 ? ` (+${opts.changedFiles.length - 5} more)` : ""}.`,
+    "Verify the doc is still accurate, then run `verify_system_doc` to re-stamp it, or update the doc body to match current code."
+  ].join(" ");
+  return !!postSensorEvent({
+    planUid: opts.planUid,
+    eventType: "need-decision",
+    payload: {
+      message,
+      source: "doc-sensor",
+      docUid: opts.docUid,
+      docSlug: opts.slug,
+      changedFiles: opts.changedFiles
+    }
+  });
+}
+function onStuckDetected(opts) {
+  try {
+    const cfg = (0, import_project_config_service.getEffectiveSensorConfig)(opts.projectRoot);
+    if (!cfg.stuck.enabled) return;
+    postSensorEvent({
+      planUid: opts.planUid,
+      eventType: "stuck",
+      payload: {
+        message: opts.description,
+        source: "stuck-sensor",
+        heuristic: opts.heuristic,
+        sessionId: opts.sessionId
+      }
+    });
+  } catch (err) {
+    console.warn("[SensorBridge] onStuckDetected error:", err);
+  }
+}
+function resetSensorBridge() {
+  for (const batch of driftBatches.values()) {
+    clearTimeout(batch.timer);
+  }
+  driftBatches.clear();
+  firedDocStale.clear();
+  broadcastFn = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkAllDocsAndBridge,
+  checkDocFreshnessForFile,
+  initSensorBridge,
+  onDeviationDetected,
+  onStuckDetected,
+  postCriterionNotice,
+  resetSensorBridge,
+  resolveCriterionNotices
+});

package/src/backend/services/session-service.js

@@ -0,0 +1,192 @@
+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 session_service_exports = {};
+__export(session_service_exports, {
+  bindBrief: () => bindBrief,
+  bindSession: () => bindSession,
+  cleanStaleSessions: () => cleanStaleSessions,
+  disconnectSession: () => disconnectSession,
+  getActiveSessions: () => getActiveSessions,
+  getHostTerminalId: () => getHostTerminalId,
+  getSessionCapabilities: () => getSessionCapabilities,
+  heartbeat: () => heartbeat,
+  registerSession: () => registerSession,
+  retypeSession: () => retypeSession,
+  setActivePlan: () => setActivePlan,
+  startSessionSweep: () => startSessionSweep,
+  stopSessionSweep: () => stopSessionSweep,
+  updateCapabilities: () => updateCapabilities
+});
+module.exports = __toCommonJS(session_service_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_intent_service = require("./intent-service");
+var import_agent_event_log = require("./agent-event-log");
+function registerSession(sessionId, agentType, model, capabilities, hostTerminalId) {
+  const now = Date.now();
+  (0, import_database.getDb)().run(
+    `INSERT INTO agent_sessions (session_id, agent_type, model, capabilities, host_terminal_id, connected_at, last_seen, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 'active')
+     ON CONFLICT(session_id) DO UPDATE SET
+       agent_type = excluded.agent_type,
+       model = COALESCE(excluded.model, agent_sessions.model),
+       capabilities = CASE WHEN ? THEN excluded.capabilities ELSE agent_sessions.capabilities END,
+       host_terminal_id = COALESCE(excluded.host_terminal_id, agent_sessions.host_terminal_id),
+       last_seen = excluded.last_seen,
+       status = 'active'`,
+    [sessionId, agentType, model || null, JSON.stringify(capabilities ?? []), hostTerminalId || null, now, now, capabilities ? 1 : 0]
+  );
+  (0, import_persistence.markDirty)();
+}
+function getHostTerminalId(sessionId) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT host_terminal_id FROM agent_sessions WHERE session_id = ?`,
+    [sessionId]
+  );
+  if (!result[0]?.values[0]) return null;
+  return result[0].values[0][0] ?? null;
+}
+function updateCapabilities(sessionId, capabilities) {
+  (0, import_database.getDb)().run(
+    `UPDATE agent_sessions SET capabilities = ?, last_seen = ? WHERE session_id = ?`,
+    [JSON.stringify(capabilities), Date.now(), sessionId]
+  );
+  (0, import_persistence.markDirty)();
+}
+function getSessionCapabilities(sessionId) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT capabilities FROM agent_sessions WHERE session_id = ?`,
+    [sessionId]
+  );
+  if (!result[0]?.values[0]) return [];
+  try {
+    return JSON.parse(result[0].values[0][0] ?? "[]");
+  } catch {
+    return [];
+  }
+}
+function setActivePlan(sessionId, planUid) {
+  (0, import_database.getDb)().run(
+    `UPDATE agent_sessions SET active_plan_uid = ?, last_seen = ? WHERE session_id = ?`,
+    [planUid, Date.now(), sessionId]
+  );
+  (0, import_persistence.markDirty)();
+}
+function heartbeat(sessionId) {
+  (0, import_database.getDb)().run(`UPDATE agent_sessions SET last_seen = ? WHERE session_id = ?`, [Date.now(), sessionId]);
+}
+function getActiveSessions() {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT session_id, agent_type, model, active_plan_uid, connected_at, last_seen, status, capabilities,
+            workstream_root, host_terminal_id, brief_item_uid
+     FROM agent_sessions WHERE status = 'active' ORDER BY connected_at DESC`
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => ({
+    sessionId: r[0],
+    agentType: r[1],
+    model: r[2],
+    activePlanUid: r[3],
+    connectedAt: r[4],
+    lastSeen: r[5],
+    status: r[6],
+    capabilities: (() => {
+      try {
+        return JSON.parse(r[7] ?? "[]");
+      } catch {
+        return [];
+      }
+    })(),
+    workstreamRoot: r[8] ?? null,
+    hostTerminalId: r[9] ?? null,
+    briefItemUid: r[10] ?? null
+  }));
+}
+function bindBrief(sessionId, itemUid, now = Date.now()) {
+  (0, import_database.getDb)().run(
+    "UPDATE agent_sessions SET brief_item_uid = ?, brief_bound_at = ? WHERE session_id = ?",
+    [itemUid, now, sessionId]
+  );
+  (0, import_persistence.markDirty)();
+}
+function bindSession(sessionId, workstreamRoot, hostTerminalId) {
+  (0, import_database.getDb)().run(
+    `UPDATE agent_sessions SET workstream_root = ?, host_terminal_id = COALESCE(?, host_terminal_id) WHERE session_id = ?`,
+    [workstreamRoot, hostTerminalId ?? null, sessionId]
+  );
+  if (workstreamRoot) (0, import_agent_event_log.adoptSessionEvents)(sessionId, workstreamRoot);
+  (0, import_persistence.markDirty)();
+}
+function disconnectSession(sessionId) {
+  (0, import_intent_service.clearIntent)(sessionId);
+  (0, import_database.getDb)().run(`UPDATE agent_sessions SET status = 'inactive', last_seen = ? WHERE session_id = ?`, [Date.now(), sessionId]);
+  (0, import_persistence.markDirty)();
+}
+function cleanStaleSessions(timeoutMs = 6e4) {
+  const cutoff = Date.now() - timeoutMs;
+  (0, import_database.getDb)().run(`UPDATE agent_sessions SET status = 'inactive' WHERE status = 'active' AND last_seen < ?`, [cutoff]);
+}
+let sweepTimer = null;
+function startSessionSweep(intervalMs = 3e4, timeoutMs = 6e4) {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    try {
+      cleanStaleSessions(timeoutMs);
+    } catch (err) {
+      console.warn("[Session] periodic sweep failed:", err);
+    }
+  }, intervalMs);
+  if (typeof sweepTimer.unref === "function") sweepTimer.unref();
+}
+function stopSessionSweep() {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}
+function retypeSession(sessionId, fromType, toType) {
+  const before = (0, import_database.getDb)().exec(
+    `SELECT agent_type FROM agent_sessions WHERE session_id = ?`,
+    [sessionId]
+  );
+  const current = before[0]?.values?.[0]?.[0];
+  if (current !== fromType) return false;
+  (0, import_database.getDb)().run(
+    `UPDATE agent_sessions SET agent_type = ? WHERE session_id = ? AND agent_type = ?`,
+    [toType, sessionId, fromType]
+  );
+  (0, import_persistence.markDirty)();
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindBrief,
+  bindSession,
+  cleanStaleSessions,
+  disconnectSession,
+  getActiveSessions,
+  getHostTerminalId,
+  getSessionCapabilities,
+  heartbeat,
+  registerSession,
+  retypeSession,
+  setActivePlan,
+  startSessionSweep,
+  stopSessionSweep,
+  updateCapabilities
+});