@heretek-ai/epistemic-swarm 0.7.25 → 1.0.2

package/src/rpc.ts

@@ -0,0 +1,331 @@
+// Server side of the human-only channel. Each mutating method needs a token
+// from a preview made in the last two minutes over the same subject, so the
+// human confirms exactly what the dialog showed (no swap between preview and
+// confirm).
+import { randomBytes } from "node:crypto"
+import {
+  type ApprovalStage,
+  approvalSubject,
+  capabilityLoss,
+  commandSetHash,
+  factoryLayout,
+  factorySummary,
+  type HookEngine,
+  hashJson,
+  installServer,
+  isTrusted,
+  loadGatesConfig,
+  readIdeas,
+  readPlan,
+  readResult,
+  readScores,
+  recordApproval,
+  recordConsent,
+  trustProject,
+  verifyControl,
+  writeJson,
+} from "@heretek-ai/es-core"
+import type { Runtime } from "./runtime.ts"
+import { pendingApprovals } from "./tools.ts"
+
+interface Ticket {
+  readonly kind: string
+  readonly subject: string
+  readonly expires: number
+}
+
+const TTL_MS = 120_000
+
+export function createRpcHandlers(runtime: Runtime, notify: () => Promise<void>, hooks?: HookEngine) {
+  const tickets = new Map<string, Ticket>()
+  const issue = (kind: string, subject: unknown) => {
+    const token = randomBytes(12).toString("hex")
+    tickets.set(token, { kind, subject: hashJson(subject), expires: Date.now() + TTL_MS })
+    return token
+  }
+  const redeem = (token: string, kind: string, subject: unknown) => {
+    const ticket = tickets.get(token)
+    tickets.delete(token)
+    if (!ticket || ticket.kind !== kind || ticket.expires < Date.now())
+      throw new Error("The confirmation expired or does not match; preview again.")
+    if (ticket.subject !== hashJson(subject))
+      throw new Error("What you confirmed changed since the preview; preview again.")
+  }
+  const refused = (context: any, error: unknown) =>
+    context.error("refused", error instanceof Error ? error.message : String(error), {
+      reason: error instanceof Error ? error.message : String(error),
+    })
+
+  /** Everything a trust approval covers: gate commands and project hooks. */
+  const trustSubject = async () => {
+    const { config } = await loadGatesConfig(runtime.root)
+    const gates = await commandSetHash(runtime.root, config.commands)
+    await hooks?.reload()
+    const hookStatus = hooks?.status()
+    const hookHash = hookStatus?.projectHash ?? ""
+    return {
+      gates,
+      hooks: { hash: hookHash, lines: hookStatus?.projectLines ?? [] },
+      lines: [...gates.lines, ...(hookStatus?.projectLines ?? [])],
+      key: { gates: gates.hash, hooks: hookHash },
+    }
+  }
+
+  return {
+    status: async () => {
+      const state = await runtime.factory.read()
+      return {
+        summary: factorySummary(state),
+        stage: state?.stage ?? "NONE",
+        pending: (await pendingApprovals(runtime.root)).map((item) => item.stage),
+      }
+    },
+    factoryState: async () => {
+      const state = await runtime.factory.read()
+      return {
+        stage: state?.stage ?? "NONE",
+        ...(state?.runId ? { runId: state.runId } : {}),
+        ...(state?.halt ? { halt: state.halt.reason } : {}),
+        ...(state?.release?.prUrl ? { release: state.release.prUrl } : {}),
+        ...(state?.activePhase ? { activePhase: state.activePhase } : {}),
+        spend: {
+          usd: state?.spend.usd ?? 0,
+          estimated: state?.spend.estimated ?? false,
+          ...(state?.spendCeilingUSD ? { ceilingUSD: state.spendCeilingUSD } : {}),
+        },
+        phases: (state?.phases ?? []).map((phase) => ({
+          id: phase.id,
+          title: phase.title,
+          status: phase.status,
+          failures: phase.failures,
+          qa: Object.fromEntries(Object.entries(phase.qa).filter(([, verdict]) => verdict !== undefined)),
+        })),
+        pending: (await pendingApprovals(runtime.root)).map((item) => item.stage),
+      }
+    },
+    lspState: async () => {
+      const status = await runtime.lsp.status()
+      const settings = await runtime.lsp.settings()
+      const servers = []
+      for (const server of settings.servers) {
+        const command = await runtime.lsp.command(server, runtime.root)
+        servers.push({
+          id: server.id,
+          extensions: server.extensions,
+          available: Array.isArray(command),
+          command: Array.isArray(command) ? command.join(" ") : String((command as any)?.unavailable ?? "unavailable"),
+          running: status.running.filter((item) => item.id === server.id).length,
+        })
+      }
+      return { enabled: status.enabled, servers, diagnostics: status.diagnostics }
+    },
+    hooksState: async () => {
+      await hooks?.reload()
+      const status = hooks?.status()
+      return {
+        handlers: status?.handlers ?? 0,
+        projectHandlers: status?.projectHandlers ?? 0,
+        trusted: status?.trusted ?? true,
+        projectLines: status?.projectLines ?? [],
+        diagnostics: status?.diagnostics ?? [],
+        recent: hooks?.recent.slice(-10) ?? [],
+        loss: capabilityLoss(hooks?.list() ?? [], "opencode").map((item) => ({
+          source: item.source,
+          event: item.event,
+          handler: item.handler,
+          support: item.support,
+          reason: item.reason,
+        })),
+      }
+    },
+    brainstormState: async () => {
+      const plan = await readPlan(runtime.root).catch(() => undefined)
+      if (!plan) return { active: false }
+      const ideas = await readIdeas(runtime.root).catch(() => [])
+      const scores = await readScores(runtime.root).catch(() => [])
+      const result = await readResult(runtime.root).catch(() => undefined)
+      const survivors = ideas.filter((idea) => !idea.duplicateOf)
+      return {
+        active: true,
+        brief: plan.brief.idea,
+        lenses: plan.lenses,
+        ideas: survivors.length,
+        duplicates: ideas.length - survivors.length,
+        scored: scores.length,
+        coverage: Object.fromEntries(
+          plan.lenses.map((lens) => [lens, survivors.filter((idea) => idea.lens === lens).length]),
+        ),
+        shortlist: (result?.shortlist ?? []).map((entry) => ({
+          id: entry.id,
+          total: entry.total,
+          outlier: entry.outlier,
+          title: result?.ideas.find((idea) => idea.id === entry.id)?.title ?? entry.id,
+        })),
+        gaps: result?.gaps ?? [],
+        complete: Boolean(result),
+      }
+    },
+    previewApproval: async (input: unknown) => {
+      const { stage } = input as { stage: ApprovalStage }
+      try {
+        const subject = await approvalSubject(runtime.root, stage)
+        return {
+          ok: true,
+          title: `Approve ${stage}?`,
+          lines: [
+            ...subject.summary,
+            "",
+            ...subject.subject.map((item) => `${item.sha256.slice(0, 12)}  ${item.path}`),
+          ],
+          problems: [],
+          token: issue(`approve:${stage}`, subject.subject),
+        }
+      } catch (error) {
+        return {
+          ok: false,
+          title: `Cannot approve ${stage}`,
+          lines: [],
+          problems: [error instanceof Error ? error.message : String(error)],
+        }
+      }
+    },
+    approve: async (input: unknown, context: any) => {
+      const { stage, user, token } = input as { stage: ApprovalStage; user: string; token: string }
+      try {
+        redeem(token, `approve:${stage}`, (await approvalSubject(runtime.root, stage)).subject)
+        const record = await recordApproval(runtime.root, {
+          stage,
+          channel: "tui",
+          approvedBy: user,
+          stateDir: runtime.stateDir,
+        })
+        await writeJson(
+          factoryLayout(runtime.root).pending,
+          (await pendingApprovals(runtime.root)).filter((item) => item.stage !== stage),
+        )
+        if (stage === "frontier") {
+          const state = await runtime.factory.read()
+          if (!state) await runtime.factory.begin(`human:${user}`)
+          if ((await runtime.factory.read())?.stage === "GRILL") await runtime.factory.beginResearch(`human:${user}`)
+        }
+        await notify()
+        return { message: `Approved ${stage} as ${record.approvedBy}.` }
+      } catch (error) {
+        return refused(context, error)
+      }
+    },
+    previewTrust: async () => {
+      const subject = await trustSubject()
+      const trusted =
+        (await isTrusted(runtime.root, subject.gates.hash, runtime.stateDir)) &&
+        (!subject.hooks.hash || (await isTrusted(runtime.root, subject.hooks.hash, runtime.stateDir, "hooks")))
+      return {
+        ok: subject.lines.length > 0,
+        title: trusted ? "Gate commands and hooks (already trusted)" : "Trust these gate commands and project hooks?",
+        lines: subject.lines.length ? subject.lines : ["No gate commands or project hooks detected."],
+        problems: [],
+        token: issue("trust", subject.key),
+      }
+    },
+    trust: async (input: unknown, context: any) => {
+      const { user, token } = input as { user: string; token: string }
+      try {
+        const subject = await trustSubject()
+        redeem(token, "trust", subject.key)
+        await trustProject(runtime.root, subject.gates.hash, subject.gates.lines, {
+          approvedBy: user,
+          stateDir: runtime.stateDir,
+        })
+        if (subject.hooks.hash)
+          await trustProject(runtime.root, subject.hooks.hash, subject.hooks.lines, {
+            approvedBy: user,
+            stateDir: runtime.stateDir,
+            kind: "hooks",
+          })
+        await hooks?.refresh()
+        return { message: `Trusted ${subject.lines.length} command/hook line(s).` }
+      } catch (error) {
+        return refused(context, error)
+      }
+    },
+    previewLspInstall: async (input: unknown) => {
+      const { id } = input as { id: string }
+      const server = (await runtime.lsp.settings()).servers.find((item) => item.id === id)
+      if (!server?.install)
+        return {
+          ok: false,
+          title: `Cannot install ${id}`,
+          lines: [],
+          problems: [server ? `${id} has no pinned install` : `unknown server ${id}`],
+        }
+      return {
+        ok: true,
+        title: `Install ${id}?`,
+        lines: [
+          ...server.install.packages.map((pkg) => `${pkg.name}@${pkg.version}  ${pkg.integrity.slice(0, 32)}…`),
+          "Downloaded from npm, verified against the pinned sha512, installed with scripts disabled into your state dir.",
+        ],
+        problems: [],
+        token: issue(`lsp:${id}`, server.install),
+      }
+    },
+    lspInstall: async (input: unknown, context: any) => {
+      const { id, user, token } = input as { id: string; user: string; token: string }
+      try {
+        const server = (await runtime.lsp.settings()).servers.find((item) => item.id === id)
+        if (!server?.install) throw new Error(`${id} has no pinned install`)
+        redeem(token, `lsp:${id}`, server.install)
+        await recordConsent(id, true, runtime.stateDir)
+        const bin = await installServer(server, { stateDir: runtime.stateDir })
+        return { message: `Installed ${id} (${bin}) for ${user}.` }
+      } catch (error) {
+        return refused(context, error)
+      }
+    },
+    previewResume: async () => {
+      const state = await runtime.factory.read()
+      if (state?.stage !== "HALTED")
+        return {
+          ok: false,
+          title: "Nothing to resume",
+          lines: [factorySummary(state)],
+          problems: ["The factory is not halted."],
+        }
+      const control = await verifyControl(runtime.root)
+      return {
+        ok: true,
+        title: "Resume the factory?",
+        lines: [
+          `Halted: ${state.halt?.reason}`,
+          `Spend: $${state.spend.usd.toFixed(2)} of $${state.spendCeilingUSD ?? "?"}`,
+          ...(control.clean
+            ? []
+            : ["Control-file drift (accepting it re-baselines):", ...control.violations.map((item) => `  ${item}`)]),
+        ],
+        problems: [],
+        token: issue("resume", state.halt),
+      }
+    },
+    resume: async (input: unknown, context: any) => {
+      const { user, token, acceptControlDrift, raiseCeilingUSD, extendRuntime } = input as {
+        user: string
+        token: string
+        acceptControlDrift?: boolean
+        raiseCeilingUSD?: number
+        extendRuntime?: boolean
+      }
+      try {
+        redeem(token, "resume", (await runtime.factory.read())?.halt)
+        const state = await runtime.factory.resume(user, {
+          ...(acceptControlDrift ? { acceptControlDrift } : {}),
+          ...(raiseCeilingUSD ? { raiseCeilingUSD } : {}),
+          ...(extendRuntime ? { extendRuntime } : {}),
+        })
+        await notify()
+        return { message: `Resumed at ${state.stage}.` }
+      } catch (error) {
+        return refused(context, error)
+      }
+    },
+  }
+}

package/src/runtime.ts

@@ -0,0 +1,112 @@
+// Per-location runtime shared by the plugin's hooks, tools, commands and RPC.
+// Options are layered: the canonical config (global file → project file) with
+// plugin options as the most specific override.
+import {
+  stateDir as defaultStateDir,
+  type EsConfig,
+  Factory,
+  gateRunner,
+  LspManager,
+  loadEsConfig,
+  type PolicyContext,
+} from "@heretek-ai/es-core"
+import { ghPrOpener } from "./pr.ts"
+
+/** Raw plugin options from opencode.json; every field is optional. */
+export interface RawPluginOptions {
+  /** Override the user-global state dir (signing key, trust store). Tests only. */
+  readonly stateDir?: string
+  /** Model per tier, "provider/model". */
+  readonly models?: {
+    readonly fast?: string
+    readonly balanced?: string
+    readonly deep?: string
+    readonly agents?: Readonly<Record<string, string>>
+  }
+  readonly afterEdit?: "fast" | "off"
+  readonly estimate?: { readonly inputPerM?: number; readonly outputPerM?: number }
+  readonly pr?: "gh" | "off"
+  readonly lspAfterEdit?: boolean
+  readonly searchProvider?: "brave" | "firecrawl" | "searxng"
+}
+
+/** Resolved options: config defaults applied; consumers read this shape. */
+export interface PluginOptions {
+  readonly stateDir?: string
+  readonly models?: EsConfig["models"]
+  readonly afterEdit: "fast" | "off"
+  readonly estimate?: { readonly inputPerM: number; readonly outputPerM: number }
+  readonly pr: "gh" | "off"
+  readonly lspAfterEdit: boolean
+  readonly searchProvider?: "brave" | "firecrawl" | "searxng"
+}
+
+export interface Runtime {
+  readonly root: string
+  readonly options: PluginOptions
+  readonly config: EsConfig
+  /** Config files that contributed values, in layer order. */
+  readonly configSources: readonly string[]
+  readonly stateDir: string
+  readonly factory: Factory
+  readonly lsp: LspManager
+  policy(): Promise<PolicyContext>
+}
+
+export async function createRuntime(root: string, raw: RawPluginOptions): Promise<Runtime> {
+  // stateDir is runtime-only; everything else can come from config files.
+  const { stateDir: rawStateDir, ...overrides } = raw
+  const loaded = await loadEsConfig(root, { overrides })
+  const config = loaded.config
+  const options: PluginOptions = {
+    ...(rawStateDir ? { stateDir: rawStateDir } : {}),
+    ...(config.models ? { models: config.models } : {}),
+    afterEdit: config.afterEdit,
+    ...(config.estimate ? { estimate: config.estimate } : {}),
+    pr: config.pr,
+    lspAfterEdit: config.lspAfterEdit,
+    ...(config.searchProvider ? { searchProvider: config.searchProvider } : {}),
+  }
+  const stateDir = options.stateDir ?? defaultStateDir()
+  const lsp = new LspManager({ root, stateDir })
+  const factory = new Factory(root, {
+    gates: gateRunner({ stateDir }),
+    ...(options.pr === "off" ? {} : { pr: ghPrOpener }),
+    stateDir,
+  })
+  return {
+    root,
+    options,
+    config,
+    configSources: loaded.sources,
+    stateDir,
+    factory,
+    lsp,
+    async policy() {
+      const worktree = await factory.activeWorktree().catch(() => undefined)
+      return { root, stateDir, ...(worktree ? { worktree } : {}) }
+    },
+  }
+}
+
+/** Keep only the keys the user actually set, so config files are not clobbered. */
+export function parseOptions(raw: Record<string, unknown> | undefined): RawPluginOptions {
+  const options = raw ?? {}
+  const models =
+    typeof options.models === "object" && options.models ? (options.models as RawPluginOptions["models"]) : undefined
+  const estimate =
+    typeof options.estimate === "object" && options.estimate
+      ? (options.estimate as RawPluginOptions["estimate"])
+      : undefined
+  return {
+    ...(typeof options.stateDir === "string" ? { stateDir: options.stateDir } : {}),
+    ...(models ? { models } : {}),
+    ...(options.afterEdit === "fast" || options.afterEdit === "off" ? { afterEdit: options.afterEdit } : {}),
+    ...(estimate ? { estimate } : {}),
+    ...(options.pr === "gh" || options.pr === "off" ? { pr: options.pr } : {}),
+    ...(typeof options.lspAfterEdit === "boolean" ? { lspAfterEdit: options.lspAfterEdit } : {}),
+    ...(typeof options.searchProvider === "string"
+      ? { searchProvider: options.searchProvider as RawPluginOptions["searchProvider"] }
+      : {}),
+  }
+}