@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/pi.ts

@@ -0,0 +1,357 @@
+// Gateway connector for Pi (badlogic's pi coding agent, npm @earendil-works/pi-coding-agent; checked against 1.5.0, the copy
+// installed in ~/.cache/brain-wire/pi, whose docs and dist/ are cited below).
+//
+// Pi takes an OpenAI-compatible endpoint as a custom provider in <agent-dir>/models.json, and its startup model from
+// <agent-dir>/settings.json; the agent dir is ~/.pi/agent, or $PI_CODING_AGENT_DIR (dist/config.js:494-516,
+// docs/configuration.md "Agent directory").
+//   - models.json `providers.<id>`: name, baseUrl, api ("openai-completions", ...), apiKey, headers, compat, models[{id, name,
+//     input}] (docs/models-configuration.md "Providers", "Models"). The file may hold `//` comments and trailing commas
+//     (dist/core/model-config.js:139 parses it with stripJsonComments, dist/utils/json.js).
+//   - apiKey and header values are a literal, "$VAR", or "!command" whose stdout is used, run at request time
+//     (dist/core/resolve-config-value.js:66-68, 123-129; docs/models.md "Configure a compatible endpoint"). So the key is
+//     read at run time from brain's key file with `!cat '<key file>'`; it is never copied into Pi's files.
+//   - headers carry `x-100x-context-edit: on` (provider `headers`, "Values resolve like apiKey").
+//   - settings.json `defaultProvider` + `defaultModel` pick the startup model (docs/settings.md "Model and thinking";
+//     dist/core/sdk.js:107-108 findInitialModel). settings.json is plain JSON (dist/core/settings-manager.js:269) that Pi itself
+//     writes with JSON.stringify(_, null, 2) and no final newline (:471), so both files go through the text-keeping editor
+//     below, which changes only the keys brain owns and gives the exact bytes back on disconnect.
+// The request is OpenAI Chat Completions on <route>/v1 with Authorization: Bearer (pi-ai dist/api/openai-completions.js:516-547,
+// the OpenAI client's apiKey). compat pins the request to the shape OpenCode already sends the gateway (system role, no
+// `store`, max_tokens), instead of Pi guessing from an unknown URL (openai-completions.js:1217-1300 would send the developer
+// role and `store`).
+import { join } from "node:path"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+
+// ---- a JSON / JSON-with-comments editor that keeps every byte it does not change --------------------------------------
+//
+// Keys are paths with "/" (providers/brain-gateway). A segment `list[field=value]` is the element of the array `list` whose
+// `field` is `value`, so a whole list entry can be one key (customProviders[name=100xprompt gateway]). A value that is set
+// replaces only the old value's text; a key that is added goes last in its object (or list), in the file's own indentation;
+// a key that is removed takes back exactly what adding it put in. Objects a removal leaves empty are dropped, as the core's
+// JSON handling does (never the root, never a list).
+
+interface Member {
+  key?: string
+  /** Where the member starts (its key, or the element's value) and where its value ends. */
+  start: number
+  end: number
+  /** The comma after it, or -1. */
+  comma: number
+  node: Node
+}
+type Node = { kind: "object" | "array"; start: number; end: number; members: Member[] } | { kind: "scalar"; start: number; end: number; value: unknown }
+type Hop = { key: string } | { field: string; equals: string }
+
+class JsonSyntax extends Error {}
+
+/** The syntax tree of a JSON text (with `//` and `/* *\/` comments and trailing commas when `jsonc`). Throws on bad input. */
+function parseTree(text: string, jsonc: boolean): Node {
+  let i = text.charCodeAt(0) === 0xfeff ? 1 : 0
+  const fail = (): never => {
+    throw new JsonSyntax(`unexpected input at ${i}`)
+  }
+  const skip = () => {
+    for (;;) {
+      while (i < text.length && " \t\r\n".includes(text[i]!)) i++
+      if (jsonc && text.startsWith("//", i)) {
+        const n = text.indexOf("\n", i)
+        i = n < 0 ? text.length : n
+      } else if (jsonc && text.startsWith("/*", i)) {
+        const n = text.indexOf("*/", i + 2)
+        if (n < 0) fail()
+        i = n + 2
+      } else return
+    }
+  }
+  const STR = /"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/y
+  const LIT = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null/y
+  const token = (re: RegExp) => {
+    re.lastIndex = i
+    const m = re.exec(text)
+    if (!m) fail()
+    i += m![0].length
+    return JSON.parse(m![0]) as unknown
+  }
+  const value = (): Node => {
+    skip()
+    const start = i
+    const c = text[i]
+    if (c === "{" || c === "[") {
+      const close = c === "{" ? "}" : "]"
+      const members: Member[] = []
+      i++
+      for (;;) {
+        skip()
+        const last = members[members.length - 1]
+        if (text[i] === close) {
+          if (last && last.comma >= 0 && !jsonc) fail()
+          i++
+          break
+        }
+        if (last && last.comma < 0) fail()
+        const mStart = i
+        let key: string | undefined
+        if (c === "{") {
+          if (text[i] !== '"') fail()
+          key = token(STR) as string
+          skip()
+          if (text[i] !== ":") fail()
+          i++
+        }
+        const node = value()
+        const m: Member = { start: mStart, end: node.end, comma: -1, node, ...(key !== undefined ? { key } : {}) }
+        skip()
+        if (text[i] === ",") m.comma = i++
+        members.push(m)
+      }
+      return { kind: c === "{" ? "object" : "array", start, end: i, members }
+    }
+    return { kind: "scalar", start, value: token(c === '"' ? STR : LIT), end: i }
+  }
+  const root = value()
+  skip()
+  if (i !== text.length) fail()
+  return root
+}
+
+function valueOf(n: Node): unknown {
+  if (n.kind === "scalar") return n.value
+  if (n.kind === "array") return n.members.map((m) => valueOf(m.node))
+  return Object.fromEntries(n.members.map((m) => [m.key!, valueOf(m.node)]))
+}
+
+const ENTRY = /^(.*)\[([^=\]]+)=(.*)\]$/
+function hops(key: string): Hop[] {
+  return key.split("/").flatMap((s): Hop[] => {
+    const m = ENTRY.exec(s)
+    return m ? [{ key: m[1]! }, { field: m[2]!, equals: m[3]! }] : [{ key: s }]
+  })
+}
+
+const isObj = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v)
+
+/** The member of `n` that `h` names (the last one, as JSON.parse keeps the last of a repeated key), or -1. */
+function memberIndex(n: Node, h: Hop): number {
+  if ("key" in h) {
+    if (n.kind !== "object") return -1
+    for (let k = n.members.length - 1; k >= 0; k--) if (n.members[k]!.key === h.key) return k
+    return -1
+  }
+  if (n.kind !== "array") return -1
+  return n.members.findIndex((m) => m.node.kind === "object" && (valueOf(m.node) as Json)[h.field] === h.equals)
+}
+
+/** The value a missing hop's member gets so that the remaining hops lead to `value`. */
+function memberValue(hop: Hop, after: Hop[], value: unknown): unknown {
+  let v = value
+  if (after.length) {
+    const [next, ...more] = after
+    const inner = memberValue(next!, more, value)
+    v = "key" in next! ? { [next.key]: inner } : [inner]
+  }
+  return "key" in hop || !after.length ? v : { [hop.field]: hop.equals, ...(v as Json) }
+}
+
+const lineStart = (t: string, at: number) => t.lastIndexOf("\n", at - 1) + 1
+const lineIndent = (t: string, at: number) => /^[ \t]*/.exec(t.slice(lineStart(t, at)))![0]
+const startsLine = (t: string, at: number) => !t.slice(lineStart(t, at), at).trim()
+const blank = (t: string, a: number, b: number) => !t.slice(a, b).trim()
+/** The file's indentation step: the first indented member's, else two spaces (as the core's JSON handling). */
+const unitOf = (t: string) => /\n([ \t]+)"/.exec(t)?.[1] ?? "  "
+const render = (v: unknown, indent: string, unit: string) => JSON.stringify(v, null, unit).replace(/\n/g, `\n${indent}`)
+const oneLine = (t: string, n: Node) => !t.slice(n.start, n.end).includes("\n")
+
+function insertMember(t: string, c: Node & { members: Member[] }, hop: Hop, v: unknown): string {
+  const label = "key" in hop ? `${JSON.stringify(hop.key)}: ` : ""
+  const open = c.start + 1
+  const close = c.end - 1
+  const last = c.members[c.members.length - 1]
+  if (last && oneLine(t, c)) {
+    const body = `${label}${JSON.stringify(v)}`
+    return last.comma >= 0 ? `${t.slice(0, last.comma + 1)} ${body},${t.slice(last.comma + 1)}` : `${t.slice(0, last.end)}, ${body}${t.slice(last.end)}`
+  }
+  const unit = unitOf(t)
+  const outer = lineIndent(t, c.start)
+  if (!last) {
+    const inner = `${outer}${unit}`
+    const body = `${label}${render(v, inner, unit)}`
+    if (blank(t, open, close)) return `${t.slice(0, open)}\n${inner}${body}\n${outer}${t.slice(close)}`
+    // Only comments inside: the new member goes on its own line before the closing bracket's line.
+    const ls = lineStart(t, close)
+    if (ls > open && startsLine(t, close)) return `${t.slice(0, ls)}${inner}${body}\n${t.slice(ls)}`
+    return `${t.slice(0, close)}\n${inner}${body}\n${outer}${t.slice(close)}`
+  }
+  const inner = startsLine(t, last.start) ? lineIndent(t, last.start) : `${outer}${unit}`
+  const body = `${label}${render(v, inner, unit)}`
+  // A trailing comma stays a trailing comma (JSONC); otherwise the comma goes right after the last value. A `// comment` at
+  // the end of the last member's line stays on that line: the new member goes on the next one.
+  const after = last.comma >= 0 ? last.comma + 1 : last.end
+  const nl = t.indexOf("\n", after)
+  const eol = nl < 0 ? t.length : nl
+  const tail = t.slice(after, eol).trim()
+  const at = tail.startsWith("//") || (tail.startsWith("/*") && tail.endsWith("*/")) ? eol : after
+  if (last.comma >= 0) return `${t.slice(0, at)}\n${inner}${body},${t.slice(at)}`
+  return `${t.slice(0, last.end)},${t.slice(last.end, at)}\n${inner}${body}${t.slice(at)}`
+}
+
+/** Removes [a, b), and the whole line when nothing else is left on it. */
+function dropSpan(t: string, a: number, b: number): string {
+  const ls = lineStart(t, a)
+  const nl = t.indexOf("\n", b)
+  const le = nl < 0 ? t.length : nl
+  if (blank(t, ls, a) && blank(t, b, le)) return t.slice(0, ls) + t.slice(Math.min(le + 1, t.length))
+  return t.slice(0, a) + t.slice(b)
+}
+
+/** Removes member `idx`: exactly what insertMember added when it was added there, otherwise its text and one comma. */
+function removeMember(t: string, c: Node & { members: Member[] }, idx: number): string {
+  const m = c.members[idx]!
+  const prev = c.members[idx - 1]
+  const next = c.members[idx + 1]
+  const open = c.start + 1
+  const close = c.end - 1
+  const own = m.comma >= 0 ? m.comma + 1 : m.end
+  if (c.members.length === 1) return blank(t, open, m.start) && blank(t, own, close) ? t.slice(0, open) + t.slice(close) : dropSpan(t, m.start, own)
+  if (next || m.comma >= 0) {
+    const s = prev ? prev.comma + 1 : open
+    return blank(t, s, m.start) && blank(t, m.end, m.comma) ? t.slice(0, s) + t.slice(m.comma + 1) : dropSpan(t, m.start, m.comma + 1)
+  }
+  // The last member, after `prev` (whose comma separates them).
+  const p = prev!
+  if (blank(t, p.end, p.comma) && blank(t, p.comma + 1, m.start)) return t.slice(0, p.comma) + t.slice(m.end)
+  const dropped = dropSpan(t, m.start, m.end)
+  return dropped.slice(0, p.comma) + dropped.slice(p.comma + 1)
+}
+
+/** The containers along `path` from the root: [container, index of the member in it] for each hop, while they exist. */
+function walk(root: Node, path: Hop[]): Array<{ c: Node & { members: Member[] }; idx: number }> {
+  const out: Array<{ c: Node & { members: Member[] }; idx: number }> = []
+  let n = root
+  for (const h of path) {
+    if (n.kind === "scalar") break
+    const idx = memberIndex(n, h)
+    if (idx < 0) break
+    out.push({ c: n, idx })
+    n = n.members[idx]!.node
+  }
+  return out
+}
+
+/**
+ * A Codec for a JSON file that keeps comments, formatting and key order. `jsonc`: the file may hold comments and trailing
+ * commas (refused otherwise, as the tool would refuse them). `mustExist`: the reason to give when the file is missing or
+ * empty, for a tool whose own first run writes it (brain then waits for that rather than writing it first). `shape`: the
+ * containers the keys go through ("providers": "object"), so a file where one is something else is refused up front.
+ */
+export function jsonText(o: { jsonc: boolean; mustExist?: string; shape?: Record<string, "object" | "array"> }): Codec {
+  const tree = (text: string) => parseTree(text, o.jsonc)
+  return {
+    check(text) {
+      if (!text.trim()) return o.mustExist
+      let root: Node
+      try {
+        root = tree(text)
+      } catch {
+        return o.jsonc ? "it is not valid JSON (comments and trailing commas allowed); left as it is" : "it is not plain JSON (comments?); left as it is"
+      }
+      if (root.kind !== "object") return "it is not a JSON object; left as it is"
+      const v = valueOf(root) as Json
+      for (const [path, kind] of Object.entries(o.shape ?? {})) {
+        let x: unknown = v
+        for (const p of path.split("/")) x = isObj(x) ? x[p] : undefined
+        if (x !== undefined && (kind === "array" ? !Array.isArray(x) || x.some((e) => !isObj(e)) : !isObj(x))) return `its ${path.replace(/\//g, ".")} is not ${kind === "array" ? "a list of objects" : "an object"}; left as it is`
+      }
+      return undefined
+    },
+    get(text, key) {
+      if (!text.trim()) return undefined
+      let v: unknown = valueOf(tree(text))
+      for (const h of hops(key)) {
+        if ("key" in h) v = isObj(v) && Object.hasOwn(v, h.key) ? v[h.key] : undefined
+        else v = Array.isArray(v) ? v.find((x) => isObj(x) && x[h.field] === h.equals) : undefined
+        if (v === undefined) return undefined
+      }
+      return v
+    },
+    set(text, key, value) {
+      const fresh = !text.trim()
+      let t = fresh ? "{}" : text
+      const path = hops(key)
+      const chain = walk(tree(t), path)
+      if (chain.length < path.length) {
+        if (value === undefined) return text
+        // Missing from hop k on: add one member there that holds the rest of the path.
+        const k = chain.length
+        const holder = (k ? chain[k - 1]!.c.members[chain[k - 1]!.idx]!.node : tree(t)) as Node & { members: Member[] }
+        if (holder.kind === "scalar" || ("key" in path[k]! ? holder.kind !== "object" : holder.kind !== "array")) throw new Error(`${key}: the file has a different shape there`)
+        t = insertMember(t, holder, path[k]!, memberValue(path[k]!, path.slice(k + 1), value))
+        return fresh ? `${t}\n` : t
+      }
+      const { c, idx } = chain[chain.length - 1]!
+      if (value !== undefined) {
+        const n = c.members[idx]!.node
+        t = t.slice(0, n.start) + (oneLine(t, c) ? JSON.stringify(value) : render(value, lineIndent(t, c.members[idx]!.start), unitOf(t))) + t.slice(n.end)
+        return fresh ? `${t}\n` : t
+      }
+      t = removeMember(t, c, idx)
+      // Objects the removal left empty go too (a key hop's object only; never the root or a list entry).
+      for (let d = path.length - 1; d >= 1; d--) {
+        if (!("key" in path[d - 1]!)) break
+        const up = walk(tree(t), path.slice(0, d))
+        if (up.length < d) break
+        const { c: pc, idx: pi } = up[d - 1]!
+        const n = pc.members[pi]!.node
+        if (n.kind !== "object" || n.members.length || !blank(t, n.start + 1, n.end - 1)) break
+        t = removeMember(t, pc, pi)
+      }
+      return t
+    },
+  }
+}
+
+// ---- Pi -----------------------------------------------------------------------------------------------------------------
+
+export const PROVIDER_ID = "brain-gateway"
+export const PROVIDER_NAME = "100xprompt gateway"
+
+/**
+ * The OpenAI Chat Completions request shape the gateway is known to take from OpenCode: system role (not developer), no
+ * `store`, max_tokens. Pi and Oh My Pi share these compat names (Pi docs/models-configuration.md "openai-completions").
+ */
+export const CHAT_COMPAT = { supportsDeveloperRole: false, supportsStore: false, maxTokensField: "max_tokens" }
+
+/** The command Pi and Oh My Pi run to read the key at request time ("!command" values). */
+export const keyCommand = (home: string) => `!cat ${shellQuote(keyPath(home))}`
+
+const agentDir = (home: string, env: Env) => dirFromEnv(env, "PI_CODING_AGENT_DIR", join(home, ".pi", "agent"))
+
+export function piProvider(home: string, s: GatewaySettings): Json {
+  return {
+    name: PROVIDER_NAME,
+    baseUrl: `${routeUrl(s)}/v1`,
+    api: "openai-completions",
+    apiKey: keyCommand(home),
+    ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+    compat: CHAT_COMPAT,
+    models: [{ id: s.model, name: modelName(s.model), input: ["text", "image"] }],
+  }
+}
+
+const pi: Connector = {
+  id: "pi",
+  label: "Pi",
+  file: (home, env) => join(agentDir(home, env), "models.json"),
+  // The agent dir (the main file's folder) is what Pi's first run creates; nothing else to look for.
+  probe: [],
+  authHeader: "authorization",
+  edits: (home, s, env) => [
+    { path: join(agentDir(home, env), "models.json"), format: "custom", codec: jsonText({ jsonc: true, shape: { providers: "object" } }), values: { [`providers/${PROVIDER_ID}`]: piProvider(home, s) } },
+    { path: join(agentDir(home, env), "settings.json"), format: "custom", codec: jsonText({ jsonc: false }), values: { defaultProvider: PROVIDER_ID, defaultModel: s.model } },
+  ],
+  notes: [
+    `Pi now starts on the "${PROVIDER_NAME}" provider in models.json and reads the key from the brain's key file at each request (apiKey "!cat <key file>").`,
+    "A --provider/--model flag, a resumed session's own model, or an enabledModels list in settings.json that leaves this model out still take precedence.",
+  ],
+}
+
+export const connectors: Connector[] = [pi]

package/src/gateway/connectors/qoder-cli.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Qoder CLI: not built. It has OpenAI-compatible custom models, but only through the /model wizard of a
+// signed-in account on an eligible plan, and Qoder says not to write them into settings.json by hand; it makes no model
+// request before a Qoder sign-in (https://docs.qoder.com/cli/custom-models; wire/drivers/b.ts:20).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []