@mrc2204/opencode-bridge 0.1.1 → 0.1.3

package/dist/src/chunk-OVQ5X54C.js

@@ -0,0 +1,289 @@
+// src/observability.ts
+function parseSseFramesFromBuffer(input) {
+  const normalized = input.replace(/\r\n/g, "\n");
+  const parts = normalized.split("\n\n");
+  const remainder = parts.pop() ?? "";
+  const frames = [];
+  for (const rawFrame of parts) {
+    const lines = rawFrame.split("\n");
+    let event;
+    let id;
+    let retry;
+    const dataLines = [];
+    for (const line of lines) {
+      if (!line || line.startsWith(":")) continue;
+      const idx = line.indexOf(":");
+      const field = idx >= 0 ? line.slice(0, idx).trim() : line.trim();
+      const value = idx >= 0 ? line.slice(idx + 1).replace(/^\s/, "") : "";
+      if (field === "event") event = value;
+      else if (field === "id") id = value;
+      else if (field === "retry") {
+        const n = Number(value);
+        if (Number.isFinite(n)) retry = n;
+      } else if (field === "data") dataLines.push(value);
+    }
+    if (dataLines.length <= 0) continue;
+    frames.push({
+      event,
+      id,
+      retry,
+      data: dataLines.join("\n"),
+      raw: rawFrame
+    });
+  }
+  return { frames, remainder };
+}
+function parseSseData(data) {
+  const trimmed = data.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return { raw: trimmed };
+  }
+}
+function unwrapGlobalPayload(raw) {
+  let current = raw;
+  const wrappers = [];
+  for (let i = 0; i < 3; i += 1) {
+    if (!current || typeof current !== "object") break;
+    if ("payload" in current && current.payload !== void 0) {
+      wrappers.push("payload");
+      current = current.payload;
+      continue;
+    }
+    if ("data" in current && current.data !== void 0 && Object.keys(current).length <= 4) {
+      wrappers.push("data");
+      current = current.data;
+      continue;
+    }
+    break;
+  }
+  return { payload: current, wrappers };
+}
+function pickFirstString(obj, keys) {
+  if (!obj || typeof obj !== "object") return void 0;
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))];
+}
+function inferLifecycleState(raw) {
+  const text = JSON.stringify(raw || {}).toLowerCase();
+  if (text.includes("permission") || text.includes("question.asked")) return "awaiting_permission";
+  if (text.includes("blocked") || text.includes("missing config") || text.includes("missing token") || text.includes("missing api_key")) return "blocked";
+  if (text.includes("error") || text.includes("failed")) return "failed";
+  if (text.includes("stalled")) return "stalled";
+  if (text.includes("compile") || text.includes("pytest") || text.includes("test") || text.includes("verify")) return "verifying";
+  if (text.includes("apply_patch") || text.includes("diff") || text.includes("edit") || text.includes("write")) return "coding";
+  if (text.includes("plan") || text.includes("discovery") || text.includes("ground") || text.includes("calibrate")) return "planning";
+  if (text.includes("complete") || text.includes("completed") || text.includes("done")) return "completed";
+  return "running";
+}
+function extractFilesChanged(raw) {
+  const files = [];
+  const root = asObject(raw) || {};
+  const payload = asObject(root.payload) || root;
+  const state = asObject(root.state) || asObject(payload.state) || {};
+  const metadata = asObject(state.metadata) || asObject(payload.metadata) || {};
+  for (const file of asArray(metadata.files)) {
+    const obj = asObject(file);
+    if (!obj) continue;
+    if (typeof obj.relativePath === "string") files.push(obj.relativePath);
+    else if (typeof obj.filePath === "string") files.push(obj.filePath);
+  }
+  for (const file of asArray(root.files)) {
+    if (typeof file === "string") files.push(file);
+  }
+  return uniqueStrings(files);
+}
+function extractVerifySummary(raw) {
+  const root = asObject(raw) || {};
+  const payload = asObject(root.payload) || root;
+  const state = asObject(root.state) || asObject(payload.state);
+  const input = asObject(state?.input);
+  const metadata = asObject(state?.metadata);
+  const command = typeof input?.command === "string" ? input.command : void 0;
+  const exit = typeof metadata?.exit === "number" ? metadata.exit : null;
+  const output = typeof state?.output === "string" ? state.output : typeof metadata?.output === "string" ? metadata.output : null;
+  if (!command && output == null) return null;
+  return {
+    command,
+    exit,
+    output_preview: typeof output === "string" ? output.slice(0, 500) : null
+  };
+}
+function extractBlockers(raw) {
+  const text = JSON.stringify(raw || {}).toLowerCase();
+  const blockers = [];
+  if (text.includes("no module named pytest")) blockers.push("pytest_missing");
+  if (text.includes("missing token") || text.includes("missing api_key") || text.includes("pow service not configured")) blockers.push("runtime_config_missing");
+  if (text.includes("permission") || text.includes("question.asked")) blockers.push("awaiting_permission");
+  return uniqueStrings(blockers);
+}
+function extractCompletionSummary(raw) {
+  const root = asObject(raw) || {};
+  const text = typeof root.text === "string" ? root.text : typeof root.summary === "string" ? root.summary : null;
+  return text ? text.slice(0, 2e3) : null;
+}
+function normalizeOpenCodeEvent(raw) {
+  const text = JSON.stringify(raw || {}).toLowerCase();
+  let kind = null;
+  let summary;
+  if (text.includes("permission") || text.includes("question.asked")) {
+    kind = "permission.requested";
+    summary = "OpenCode \u0111ang ch\u1EDD permission/user input";
+  } else if (text.includes("error") || text.includes("failed")) {
+    kind = "task.failed";
+    summary = "OpenCode task failed";
+  } else if (text.includes("stalled")) {
+    kind = "task.stalled";
+    summary = "OpenCode task stalled";
+  } else if (text.includes("complete") || text.includes("completed") || text.includes("done")) {
+    kind = "task.completed";
+    summary = "OpenCode task completed";
+  } else if (text.includes("progress") || text.includes("delta") || text.includes("assistant")) {
+    kind = "task.progress";
+    summary = "OpenCode task made progress";
+  } else if (text.includes("start") || text.includes("created") || text.includes("connected")) {
+    kind = "task.started";
+    summary = "OpenCode task/server started";
+  }
+  return {
+    kind,
+    summary,
+    raw,
+    lifecycleState: inferLifecycleState(raw),
+    filesChanged: extractFilesChanged(raw),
+    verifySummary: extractVerifySummary(raw),
+    blockers: extractBlockers(raw),
+    completionSummary: extractCompletionSummary(raw)
+  };
+}
+function normalizeTypedEventV1(frame, scope) {
+  const parsed = parseSseData(frame.data);
+  const unwrapped = unwrapGlobalPayload(parsed);
+  const normalized = normalizeOpenCodeEvent(unwrapped.payload);
+  return {
+    schema: "opencode.event.v1",
+    scope,
+    eventName: frame.event,
+    eventId: frame.id,
+    kind: normalized.kind,
+    summary: normalized.summary,
+    lifecycleState: normalized.lifecycleState,
+    filesChanged: normalized.filesChanged,
+    verifySummary: normalized.verifySummary,
+    blockers: normalized.blockers,
+    completionSummary: normalized.completionSummary,
+    runId: pickFirstString(unwrapped.payload, ["run_id", "runId"]),
+    taskId: pickFirstString(unwrapped.payload, ["task_id", "taskId"]),
+    sessionId: pickFirstString(unwrapped.payload, ["session_id", "sessionId", "session"]),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    wrappers: unwrapped.wrappers,
+    payload: unwrapped.payload
+  };
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function scoreSessionCandidate(candidate, ctx) {
+  const id = asString(candidate?.id) || "";
+  const candidateText = JSON.stringify(candidate || {}).toLowerCase();
+  const runId = ctx.runId?.toLowerCase();
+  const taskId = ctx.taskId?.toLowerCase();
+  const sessionKey = ctx.sessionKey?.toLowerCase();
+  const artifactSessionId = ctx.artifactSessionId;
+  let score = 0;
+  if (artifactSessionId && id === artifactSessionId) score += 1e3;
+  if (runId && candidateText.includes(runId)) score += 120;
+  if (taskId && candidateText.includes(taskId)) score += 70;
+  if (sessionKey && candidateText.includes(sessionKey)) score += 60;
+  if (runId && id.toLowerCase().includes(runId)) score += 30;
+  if (taskId && id.toLowerCase().includes(taskId)) score += 20;
+  score += Math.max(0, 20 - ctx.recencyRank);
+  return score;
+}
+function summarizeLifecycle(events = []) {
+  let currentState = null;
+  let last_event_kind = null;
+  let last_event_at = null;
+  const files_changed = /* @__PURE__ */ new Set();
+  const verify_summary = [];
+  const blockers = /* @__PURE__ */ new Set();
+  let completion_summary = null;
+  for (const item of events) {
+    if (item.lifecycleState) currentState = item.lifecycleState;
+    if (item.kind) last_event_kind = item.kind;
+    if (item.timestamp) last_event_at = item.timestamp;
+    for (const file of item.filesChanged || []) files_changed.add(file);
+    if (item.verifySummary) verify_summary.push(item.verifySummary);
+    for (const blocker of item.blockers || []) blockers.add(blocker);
+    if (item.completionSummary) completion_summary = item.completionSummary;
+  }
+  return {
+    currentState,
+    current_state: currentState,
+    last_event_kind,
+    last_event_at,
+    files_changed: [...files_changed],
+    verify_summary,
+    blockers: [...blockers],
+    completion_summary
+  };
+}
+function resolveSessionId(input) {
+  if (input.explicitSessionId) {
+    return { sessionId: input.explicitSessionId, strategy: "explicit", score: 9999 };
+  }
+  const list = Array.isArray(input.sessionList) ? input.sessionList : [];
+  const withRecency = [...list].map((item, idx) => {
+    const updated = Number(item?.time?.updated || 0);
+    return { item, idx, updated };
+  }).sort((a, b) => b.updated - a.updated).map((x, rank) => ({ ...x, rank }));
+  if (input.artifactSessionId) {
+    const direct = withRecency.find((x) => asString(x.item?.id) === input.artifactSessionId);
+    if (direct) {
+      return { sessionId: input.artifactSessionId, strategy: "artifact", score: 1e3 };
+    }
+  }
+  let best = { score: -1 };
+  for (const candidate of withRecency) {
+    const id = asString(candidate.item?.id);
+    if (!id) continue;
+    const score = scoreSessionCandidate(candidate.item, {
+      runId: input.runId,
+      taskId: input.taskId,
+      sessionKey: input.sessionKey,
+      artifactSessionId: input.artifactSessionId,
+      recencyRank: candidate.rank
+    });
+    if (score > best.score) best = { id, score };
+  }
+  if (best.id && best.score > 0) {
+    return { sessionId: best.id, strategy: "scored_fallback", score: best.score };
+  }
+  const latest = withRecency.find((x) => asString(x.item?.id));
+  if (latest) return { sessionId: asString(latest.item?.id), strategy: "latest", score: 0 };
+  return { strategy: "none", score: -1 };
+}
+
+export {
+  parseSseFramesFromBuffer,
+  parseSseData,
+  unwrapGlobalPayload,
+  normalizeOpenCodeEvent,
+  normalizeTypedEventV1,
+  summarizeLifecycle,
+  resolveSessionId
+};

package/dist/src/chunk-TDVN5AFB.js

@@ -0,0 +1,36 @@
+// src/shared-contracts.ts
+function buildTaggedSessionTitle(fields) {
+  return [
+    `${fields.taskId}`,
+    `runId=${fields.runId}`,
+    `taskId=${fields.taskId}`,
+    `requested=${fields.requested}`,
+    `resolved=${fields.resolved}`,
+    `callbackSession=${fields.callbackSession}`,
+    ...fields.callbackSessionId ? [`callbackSessionId=${fields.callbackSessionId}`] : [],
+    ...fields.projectId ? [`projectId=${fields.projectId}`] : [],
+    ...fields.repoRoot ? [`repoRoot=${fields.repoRoot}`] : []
+  ].join(" ");
+}
+function parseTaggedSessionTitle(title) {
+  if (!title || !title.trim()) return null;
+  const tags = {};
+  for (const token of title.split(/\s+/)) {
+    const idx = token.indexOf("=");
+    if (idx <= 0) continue;
+    const key = token.slice(0, idx).trim();
+    const raw = token.slice(idx + 1).trim();
+    if (!key || !raw) continue;
+    tags[key] = raw;
+  }
+  return Object.keys(tags).length > 0 ? tags : null;
+}
+function buildPluginCallbackDedupeKey(input) {
+  return `${input.sessionId || "no-session"}|${input.runId || "no-run"}`;
+}
+
+export {
+  buildTaggedSessionTitle,
+  parseTaggedSessionTitle,
+  buildPluginCallbackDedupeKey
+};