@bybrawe/opencode-loop 0.5.28 → 0.5.29

package/src/source/opencode2/runtime-adapter.js

@@ -0,0 +1,56 @@
+import { inspectOpenCode2Context } from "./capabilities.js"
+import { createOpenCode2HostContract } from "./host-contract.js"
+
+function promptRequest(request) {
+  const value = {
+    sessionID: request.sessionID,
+  }
+  if (request.noReply === true) {
+    value.noReply = true
+    value.parts = [{ type: "text", text: request.text }]
+  } else {
+    value.text = request.text
+  }
+  if (request.agent !== undefined) value.agent = request.agent
+  if (request.model !== undefined) value.model = request.model
+  return value
+}
+
+function commandRequest(request) {
+  const value = {
+    sessionID: request.sessionID,
+    command: request.command,
+  }
+  if (request.arguments !== undefined) value.arguments = request.arguments
+  if (request.agent !== undefined) value.agent = request.agent
+  if (request.model !== undefined) value.model = request.model
+  if (request.delivery !== undefined) value.delivery = request.delivery
+  if (request.resume !== undefined) value.resume = request.resume
+  return value
+}
+
+export function createOpenCode2RuntimeAdapter(ctx, options = {}) {
+  const capabilities = inspectOpenCode2Context(ctx)
+  if (!capabilities.eventSubscribe) throw new Error("OpenCode 2 event.subscribe capability is unavailable")
+  if (!capabilities.sessionPrompt) throw new Error("OpenCode 2 session.prompt capability is unavailable")
+
+  const host = createOpenCode2HostContract({
+    directory: options.directory,
+    subscribe: ctx.event.subscribe.bind(ctx.event),
+    sendPrompt: (request) => ctx.session.prompt(promptRequest(request)),
+    sendCommand: capabilities.sessionCommand ? (request) => ctx.session.command(commandRequest(request)) : undefined,
+    onEvent: options.onEvent,
+    onError: options.onError,
+  })
+
+  return Object.freeze({
+    start: () => host.start(),
+    prompt: (request) => host.prompt(request),
+    command: (request) => host.command(request),
+    dispose: (reason = "runtime-adapter-disposed") => host.dispose(reason),
+    runtimeManager: host.runtimeManager,
+    isStarted: host.isStarted,
+    isDisposed: host.isDisposed,
+    isHostDisposed: host.isHostDisposed,
+  })
+}

package/src/source/opencode2/status.js

@@ -0,0 +1,40 @@
+import { durationToText } from "../core/args.js"
+import { goalStatusText, isGoalJob, jobLabel } from "../core/jobs.js"
+
+function dueAt(job, current) {
+  if (Number(job?.runNowRequestedAt || 0) > 0) return current
+  const intervalMs = Math.max(0, Number(job?.intervalMs || 0))
+  const lastRunAt = Number(job?.lastRunAt || 0)
+  if (intervalMs === 0) return current
+  if (lastRunAt > 0) return lastRunAt + intervalMs
+  if (job?.immediate === false) {
+    const createdAt = Date.parse(job?.createdAt || "")
+    return (Number.isFinite(createdAt) ? createdAt : current) + intervalMs
+  }
+  return current
+}
+
+export function formatOpenCode2LoopStatus(state, current = Date.now()) {
+  const jobs = Array.isArray(state?.jobs) ? state.jobs : []
+  const lines = jobs.length
+    ? jobs.map((job, index) => {
+        const dueIn = Math.max(0, dueAt(job, current) - current)
+        const flags = [
+          isGoalJob(job) ? `goal:${goalStatusText(job)}` : undefined,
+          job.paused ? "paused" : "active",
+          Number(job.runNowRequestedAt || 0) > 0 ? "run-now" : undefined,
+          job.safe ? "safe" : undefined,
+          job.askNever ? "ask-never" : undefined,
+          job.noOverlap ? "no-overlap" : undefined,
+          job.checkpointOnly ? "checkpoint-only" : undefined,
+          job.gitCheckpoint ? "git-checkpoint" : undefined,
+        ].filter(Boolean).join(",")
+        return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${jobLabel(job)} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | due in ${durationToText(dueIn)} | ${flags}`
+      })
+    : ["No active loop jobs."]
+
+  return Object.freeze({
+    jobs,
+    text: `OpenCode loop status:\n${lines.join("\n")}`,
+  })
+}

package/src/source/runtime/compaction.js

@@ -0,0 +1,122 @@
+import { now as defaultNow } from "../core/args.js"
+import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
+import { compactSession as defaultCompactSession, log as defaultLog } from "../opencode/host.js"
+import { sdkErrorMessage as defaultErrorMessage } from "../opencode/sdk.js"
+
+export function createCompactionRuntime(options = {}) {
+  const activeRuns = options.activeRuns
+  if (!(activeRuns instanceof Map)) throw new TypeError("createCompactionRuntime requires activeRuns Map")
+  if (typeof options.finalizeActiveRun !== "function") throw new TypeError("createCompactionRuntime requires finalizeActiveRun")
+
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const compactSession = typeof options.compactSession === "function" ? options.compactSession : defaultCompactSession
+  const log = typeof options.log === "function" ? options.log : defaultLog
+  const errorMessage = typeof options.errorMessage === "function" ? options.errorMessage : defaultErrorMessage
+  const finalizeActiveRun = options.finalizeActiveRun
+  const requests = new Map()
+
+  function begin(sessionID, jobId, resumeAfter = false) {
+    if (typeof sessionID !== "string" || typeof jobId !== "string") return undefined
+    const request = {
+      jobId,
+      resumeAfter: Boolean(resumeAfter),
+      requestedAt: now(),
+      startedAt: 0,
+      completedAt: 0,
+    }
+    requests.set(sessionID, request)
+    return request
+  }
+
+  function getPending(sessionID) {
+    return requests.get(sessionID)
+  }
+
+  function clear(sessionID) {
+    return requests.delete(sessionID)
+  }
+
+  function clearForActiveRun(sessionID, active) {
+    const pending = requests.get(sessionID)
+    if (!pending || !active || pending.jobId === active.jobId) requests.delete(sessionID)
+  }
+
+  function isCompleted(sessionID, jobId) {
+    const pending = requests.get(sessionID)
+    return Boolean(pending && pending.jobId === jobId && pending.completedAt)
+  }
+
+  async function start(directory, client, sessionID, jobId, model, resumeAfter = false) {
+    begin(sessionID, jobId, resumeAfter)
+    const ok = await compactSession(directory, client, sessionID, model)
+    if (!ok) clear(sessionID)
+    return ok
+  }
+
+  async function maybeCompact(directory, client, sessionID, job) {
+    const dueRuns = job.compactEveryRuns > 0 && (job.runCount || 0) > 0 && (job.runCount || 0) % job.compactEveryRuns === 0 && job.lastCompactRunCount !== job.runCount
+    const dueTime = job.compactEveryMs > 0 && (!job.lastCompactAt || now() - job.lastCompactAt >= job.compactEveryMs)
+    if (!dueRuns && !dueTime) return { job, started: false }
+
+    if (await start(directory, client, sessionID, job.id, job.model, true)) {
+      job.lastCompactAt = now()
+      job.lastCompactRunCount = job.runCount || 0
+      return { job, started: true }
+    }
+    return { job, started: false }
+  }
+
+  async function noteStarted(directory, sessionID) {
+    const pending = requests.get(sessionID)
+    if (!pending) return false
+    if (!pending.startedAt) {
+      pending.startedAt = now()
+      requests.set(sessionID, pending)
+      await appendLoopLog(directory, "compact-started", {
+        sessionID,
+        job: pending.jobId,
+        resumeAfter: pending.resumeAfter,
+      })
+    }
+    return true
+  }
+
+  async function finalize(directory, client, sessionID) {
+    const pending = requests.get(sessionID)
+    const active = activeRuns.get(sessionID)
+    if (!pending || !active || pending.jobId !== active.jobId) return false
+    return await finalizeActiveRun(directory, client, sessionID)
+  }
+
+  async function noteCompleted(directory, client, sessionID) {
+    const pending = requests.get(sessionID)
+    if (!pending) return false
+    pending.completedAt = now()
+    requests.set(sessionID, pending)
+    await appendLoopLog(directory, "compact-event", {
+      sessionID,
+      job: pending.jobId,
+      resumeAfter: pending.resumeAfter,
+    })
+    const timer = setTimeout(() => {
+      finalize(directory, client, sessionID)
+        .catch((error) => log(client, "error", "compaction finalization failed", { error: errorMessage(error) }))
+    }, 0)
+    timer.unref?.()
+    return true
+  }
+
+  return {
+    begin,
+    getPending,
+    clear,
+    clearForActiveRun,
+    isCompleted,
+    start,
+    maybeCompact,
+    noteStarted,
+    finalize,
+    noteCompleted,
+  }
+}