@100xprompt/brain 0.1.3 → 0.1.5

package/src/settings/apply.ts

@@ -0,0 +1,306 @@
+// The only code that changes a setting. `brain settings`, `brain sync` and (later) the background agent and the local page
+// all call it, so a change looks the same whichever way it was made: it is checked against the catalog, recorded with who
+// made it and what it replaced, applied under the brain lock, read back from the files, and the result kept, so every way
+// in can say whether it worked. brain's other commands (gateway connect, mcp install, ...) make their changes themselves,
+// as before, and record them here (recordChanges, recordConnected) in the same hold of the lock, so they show up the same way.
+import type { Env, GatewaySettings } from "../gateway/common.ts"
+import { connectionState } from "../gateway/connect.ts"
+import { withBrainLock } from "../lock.ts"
+import { type Actual, cleanText, type Ctx, type Family, FAMILIES, HEADER_TOOLS, modelAlias, parseId, parseValue, resolve, settingsHere, type SettingRef } from "./catalog.ts"
+import { type Applied, type Change, type Effective, type Entry, type Level, LEVELS, readSettingsFile, recordChange, same, type SettingsDoc, SettingsUnwritable, settingsFile, type Source, updateDoc, type Value } from "./store.ts"
+
+export type State = "applied" | "default" | "as found" | "waiting" | "failed" | "not on this computer" | "changed outside brain" | "can't read" | "used when connected" | "locked"
+
+export interface Row {
+  id: string
+  family: Family
+  tool?: string
+  /** The value that applies here, and where it comes from. */
+  value?: Value
+  from: Effective["from"]
+  entry?: Entry
+  actual: Actual
+  state: State
+  error?: string
+  notes: string[]
+}
+
+export interface Outcome {
+  ok: boolean
+  /** Why nothing was saved (an unknown setting, a value of the wrong type, a level it cannot be set at). */
+  refused?: string
+  row?: Row
+  change?: Change
+  /** What the person should know beyond the row (the value comes from another level, say). */
+  notes: string[]
+}
+
+const now = () => new Date().toISOString()
+const readDoc = (home: string) => readSettingsFile(home).doc
+const ctxOf = (home: string, env: Env, doc: SettingsDoc = readDoc(home)): Ctx => ({ home, env, doc })
+
+/** A settings file written by a newer brain is read, never acted on: applying what it says could undo what that brain did. */
+function refuseNewer(home: string) {
+  if (readSettingsFile(home).problem === "newer") throw new SettingsUnwritable(`${settingsFile(home)} was written by a newer brain; update brain (bun add -g @100xprompt/brain) to change or apply settings here`)
+}
+
+/** One setting as it stands: what applies, from where, what this computer actually has, and whether that is applied. */
+export async function rowOf(ctx: Ctx, ref: SettingRef): Promise<Row> {
+  const { id, family, tool } = ref
+  const eff = resolve(ctx.doc, ref)
+  let actual: Actual
+  try {
+    actual = await family.read(ctx, tool)
+  } catch (e) {
+    actual = { value: null, note: `could not read it (${cleanText((e as Error).message, ctx.home).slice(0, 160)})` }
+  }
+  const ap: Applied | undefined = ctx.doc.applied[id]
+  // What a tool's files say can hold this computer's paths: cleaned before it is shown, kept or sent.
+  const notes = [...(actual.note ? [cleanText(actual.note, ctx.home)] : []), ...(ap?.ok && ap.notes ? ap.notes : [])]
+  const held = ctx.doc.sync.held.find((h) => h.id === id)
+  const base = { id, family, ...(tool ? { tool } : {}), ...(eff.value !== undefined ? { value: eff.value } : {}), from: eff.from, ...(eff.entry ? { entry: eff.entry } : {}), actual }
+  let state: State
+  let error: string | undefined
+  if (family.apply && tool && eff.from !== "none" && !family.present(ctx, tool)) state = "not on this computer"
+  else if (held) {
+    // A value from the account this computer did not take (memory turned on from afar on a team-memory computer).
+    state = "failed"
+    error = held.why
+  } else if (!family.apply) state = eff.from === "lock" ? "locked" : eff.from === "default" ? "default" : "applied"
+  else if (eff.from === "none") state = actual.value === null && !actual.idle ? "can't read" : "as found"
+  else if (ap && !ap.ok && same(ap.want, eff.value)) {
+    state = ap.missing ? "not on this computer" : "failed"
+    error = ap.error
+  } else if (!ap || !same(ap.want, eff.value)) state = "waiting"
+  else if (actual.value === null) state = actual.idle ? "used when connected" : "can't read"
+  else if (!same(actual.value, eff.value)) state = "changed outside brain"
+  else state = eff.from === "lock" ? "locked" : "applied"
+  return { ...base, state, ...(error ? { error } : {}), notes: [...new Set(notes)] }
+}
+
+/** The settings that have a value at some level (or a lock), as catalog references; ids this brain does not know are left out. */
+function refsSet(doc: SettingsDoc): SettingRef[] {
+  const ids = new Set([...Object.keys(doc.locks), ...LEVELS.flatMap((l) => Object.keys(doc.levels[l]))])
+  return [...ids].map((id) => parseId(id)).filter((r): r is SettingRef => !("error" in r))
+}
+
+/** Every setting on this computer, plus any set at some level for a tool that is not here (it shows as not on this computer). */
+export async function listSettings(home: string, env: Env = process.env): Promise<Row[]> {
+  const ctx = ctxOf(home, env)
+  const refs = settingsHere(ctx)
+  const seen = new Set(refs.map((r) => r.id))
+  for (const r of refsSet(ctx.doc)) if (!seen.has(r.id)) refs.push(r)
+  return Promise.all(refs.map((r) => rowOf(ctx, r)))
+}
+
+const upload = (f: Family) => f.remote === "yes"
+
+/** Marks a tool's model and context editing applied when what they ask for is what the tool was just connected with. */
+function markConnected(d: SettingsDoc, tool: string, s: GatewaySettings, at: string) {
+  const asked: Array<[string, Value]> = [
+    [`tools.${tool}.model`, modelAlias(s.model)!],
+    ...(HEADER_TOOLS.includes(tool) ? [[`tools.${tool}.contextEdit`, s.contextEdit] as [string, Value]] : []),
+  ]
+  for (const [id, has] of asked) {
+    const ref = parseId(id)
+    if ("error" in ref) continue
+    const v = resolve(d, ref).value
+    if (v !== undefined && same(v, has)) d.applied[id] = { want: v, ok: true, at }
+  }
+}
+
+/** Applies what now applies for `ref` (inside the lock), and keeps the result. Settings brain reads where it uses them have nothing to apply. */
+async function applyNow(home: string, env: Env, ref: SettingRef): Promise<void> {
+  const doc = readDoc(home)
+  const eff = resolve(doc, ref)
+  if (!ref.family.apply) return
+  if (eff.value === undefined) {
+    // Nobody sets it any more: brain stops managing it and leaves it as it is.
+    updateDoc(home, (d) => {
+      delete d.applied[ref.id]
+    })
+    return
+  }
+  let r
+  try {
+    r = await ref.family.apply(ctxOf(home, env, doc), eff.value, ref.tool)
+  } catch (e) {
+    r = { ok: false, error: cleanText((e as Error).message, home) }
+  }
+  const at = now()
+  const record: Applied = { want: eff.value, ok: r.ok, at, ...(r.error ? { error: r.error } : {}), ...(r.notes?.length ? { notes: r.notes } : {}), ...(r.missing ? { missing: true } : {}) }
+  const connected = r.ok && ref.tool && ref.family.key !== "tools.*.mcp" && ref.family.key !== "tools.*.hooks" ? connectionState(home, ref.tool, env) : undefined
+  updateDoc(home, (d) => {
+    d.applied[ref.id] = record
+    // Connecting a tool (or changing its model) also applies its model and context editing when those are what it got.
+    if (connected?.state === "connected" && connected.settings) markConnected(d, ref.tool!, connected.settings, at)
+  })
+}
+
+const LEVEL_WORD: Record<"computer" | "person", string> = { computer: "this computer", person: "all your computers" }
+
+/**
+ * `brain settings set <id> <value> [--for computer|me]`: saves the value at the level, then applies what applies here. A
+ * value that cannot be applied stays saved (it is what the person wants), marked failed with the reason; `brain sync`
+ * tries it again. A value for all the person's computers, for a tool that is not on this one, is saved and not applied here.
+ */
+export async function setSetting(home: string, id: string, given: string, o: { level?: "computer" | "person"; source?: Source; env?: Env } = {}): Promise<Outcome> {
+  const env = o.env ?? process.env
+  const level = o.level ?? "computer"
+  const ref = parseId(id)
+  if ("error" in ref) return { ok: false, refused: ref.error, notes: [] }
+  const parsed = parseValue(ref.family.type, given)
+  if ("error" in parsed) return { ok: false, refused: `${ref.id}: ${parsed.error}`, notes: [] }
+  if (!ref.family.levels.includes(level)) return { ok: false, refused: `${ref.id} can only be set on this computer`, notes: [] }
+  const here = !ref.tool || ref.family.present(ctxOf(home, env), ref.tool)
+  if (level === "computer" && !here) return { ok: false, refused: `${ref.id}: this tool has not run on this computer; nothing was saved`, notes: [] }
+  return withBrainLock(
+    home,
+    async () => {
+      let change: Change | undefined
+      updateDoc(home, (d) => {
+        change = recordChange(d, { id: ref.id, level, value: parsed.value, source: o.source ?? "settings", at: now() }, { upload: upload(ref.family) })
+      })
+      const notes: string[] = []
+      if (here) await applyNow(home, env, ref)
+      else notes.push(`${ref.tool} is not on this computer: nothing to apply here`)
+      const doc = readDoc(home)
+      const eff = resolve(doc, ref)
+      if (eff.from === "lock") notes.push(`your team admin has locked ${ref.id}: that value applies here`)
+      else if (eff.from !== level) notes.push(`this computer keeps its own value for ${ref.id}; \`brain settings unset ${ref.id}\` uses the one for all your computers`)
+      if (level === "person") notes.push("saved for all your computers: it reaches the others once settings sync with your 100xprompt account")
+      const row = await rowOf(ctxOf(home, env, doc), ref)
+      const ok = !here || (row.state !== "failed" && row.state !== "not on this computer")
+      return { ok, row, ...(change ? { change } : {}), notes }
+    },
+    { what: `changing ${ref.id}` },
+  )
+}
+
+/** `brain settings unset <id>`: clears the value at the level; what is set at the level above applies, or brain stops managing it. */
+export async function unsetSetting(home: string, id: string, o: { level?: "computer" | "person"; env?: Env } = {}): Promise<Outcome> {
+  const env = o.env ?? process.env
+  const level = o.level ?? "computer"
+  const ref = parseId(id)
+  if ("error" in ref) return { ok: false, refused: ref.error, notes: [] }
+  return withBrainLock(
+    home,
+    async () => {
+      let change: Change | undefined
+      updateDoc(home, (d) => {
+        change = recordChange(d, { id: ref.id, level, value: null, source: "settings", at: now() }, { upload: upload(ref.family) })
+      })
+      if (!change) return { ok: true, notes: [`nothing was set for ${ref.id} on ${LEVEL_WORD[level]}`] }
+      const here = !ref.tool || ref.family.present(ctxOf(home, env), ref.tool)
+      if (here) await applyNow(home, env, ref)
+      const doc = readDoc(home)
+      const eff = resolve(doc, ref)
+      const notes = eff.from === "none" ? ["brain no longer manages it: it stays as it is now"] : []
+      const row = await rowOf(ctxOf(home, env, doc), ref)
+      return { ok: row.state !== "failed", row, change, notes }
+    },
+    { what: `clearing ${ref.id}` },
+  )
+}
+
+/**
+ * Applies every setting whose value changed since brain last applied it (and, with `retryFailed`, those that failed and
+ * brain entries that broke). A setting brain applied that someone changed by hand since is NOT put back: that would fight
+ * the person; it shows as "changed outside brain" until it is set again. A tool that is not on this computer is skipped.
+ * Tools first, so a connect carries the tool's model and context editing. Never acts on a newer brain's settings file.
+ */
+export async function reconcile(home: string, o: { env?: Env; retryFailed?: boolean } = {}): Promise<{ applied: Row[]; unknown: string[]; elsewhere: string[] }> {
+  const env = o.env ?? process.env
+  refuseNewer(home)
+  return withBrainLock(
+    home,
+    async () => {
+      refuseNewer(home)
+      const doc = readDoc(home)
+      const ids = new Set([...Object.keys(doc.locks), ...LEVELS.flatMap((l) => Object.keys(doc.levels[l]))])
+      const unknown: string[] = []
+      const refs: SettingRef[] = []
+      for (const id of ids) {
+        const r = parseId(id)
+        if ("error" in r) unknown.push(id)
+        else if (r.family.apply) refs.push(r)
+      }
+      const order = (r: SettingRef) => FAMILIES.indexOf(r.family)
+      refs.sort((a, b) => order(a) - order(b))
+      const done: SettingRef[] = []
+      const elsewhere: string[] = []
+      for (const r of refs) {
+        const cur = readDoc(home)
+        const ctx = ctxOf(home, env, cur)
+        const eff = resolve(cur, r)
+        const ap = cur.applied[r.id]
+        if (eff.value === undefined) continue
+        if (r.tool && !r.family.present(ctx, r.tool)) {
+          elsewhere.push(r.id)
+          continue
+        }
+        const changed = !ap || !same(ap.want, eff.value)
+        const retry = !!o.retryFailed && ((ap && !ap.ok) || (eff.value === true && !!r.family.repair?.(ctx, r.tool)))
+        if (!changed && !retry) continue
+        await applyNow(home, env, r)
+        done.push(r)
+      }
+      const ctx = ctxOf(home, env)
+      return { applied: await Promise.all(done.map((r) => rowOf(ctx, r))), unknown, elsewhere }
+    },
+    { what: "applying settings" },
+  )
+}
+
+/**
+ * What one of brain's other commands just did, recorded at this computer's level as that command's change (`brain mcp
+ * install` records tools.<tool>.mcp on); null clears this computer's value. The command already made the change, so it is
+ * marked applied. Call it inside the command's own hold of the brain lock. Never fails the command.
+ */
+export function recordChanges(home: string, changes: Array<{ id: string; value: Value | null }>, command: string): Change[] {
+  const out: Change[] = []
+  try {
+    updateDoc(home, (d) => {
+      const at = now()
+      for (const c of changes) {
+        const ref = parseId(c.id)
+        if ("error" in ref) continue
+        const ch = recordChange(d, { id: ref.id, level: "computer", value: c.value, source: "command", command, at }, { upload: upload(ref.family) })
+        if (ch) out.push(ch)
+        if (c.value !== null && ref.family.apply) d.applied[ref.id] = { want: c.value, ok: true, at }
+      }
+    })
+  } catch {}
+  return out
+}
+
+/**
+ * `brain gateway connect` (s: the settings it connected with) or `disconnect` (s undefined), recorded inside the same hold
+ * of the lock: the tool on or off, and for a connect the model it got (cleared when it is a model brain has no short name
+ * for) and its context editing. A value already in force is not recorded again, so a choice made with `brain settings`
+ * keeps its source; what is asked for and now in force is marked applied (a model that failed earlier, say).
+ */
+export function recordConnected(home: string, tool: string, s: GatewaySettings | undefined): void {
+  const command = s ? "brain gateway connect" : "brain gateway disconnect"
+  try {
+    updateDoc(home, (d) => {
+      const at = now()
+      const put = (id: string, value: Value | null) => {
+        const ref = parseId(id)
+        if ("error" in ref) return
+        const cur = resolve(d, ref).value
+        if (value === null ? d.levels.computer[ref.id] === undefined : cur !== undefined && same(cur, value)) return
+        recordChange(d, { id: ref.id, level: "computer", value, source: "command", command, at }, { upload: upload(ref.family) })
+      }
+      put(`tools.${tool}.gateway`, !!s)
+      if (s) {
+        const alias = modelAlias(s.model)
+        put(`tools.${tool}.model`, alias && alias !== "other" ? alias : null)
+        if (HEADER_TOOLS.includes(tool)) put(`tools.${tool}.contextEdit`, s.contextEdit)
+      }
+      const g = parseId(`tools.${tool}.gateway`)
+      if (!("error" in g)) d.applied[g.id] = { want: !!s, ok: true, at }
+      if (s) markConnected(d, tool, s, at)
+    })
+  } catch {}
+}