pi-obsidian-memory 0.0.1 → 0.1.1

package/src/pi/memory-init/memory-init.ts

@@ -0,0 +1,63 @@
+import type { MemoryCommand, MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import { describeRegistered, describeRegistrationFailure } from "#src/pi/registration-report"
+import {
+  checkProjectName,
+  type InitPreparation,
+  initProjectMemory,
+  prepareProjectInit,
+  type RegistrationContext,
+} from "#src/usecases"
+import {
+  INIT_CANCELLED,
+  INIT_DONE,
+  INIT_NAME_TITLE,
+  INIT_REPOINT_VAULT_TITLE,
+  INIT_SETUP_HINT,
+  INIT_VAULT_PLACEHOLDER,
+  INIT_VAULT_TITLE,
+  MEMORY_INIT_DESCRIPTION,
+} from "./constants.ts"
+
+export function memoryInitCommand(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryCommand {
+  return {
+    description: MEMORY_INIT_DESCRIPTION,
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) return
+      const { registration } = sessions.registrationFlow(ctx, paths)
+      await runMemoryInit(ctx, registration)
+    },
+  }
+}
+
+async function runMemoryInit(ctx: MemoryPiContext, registration: RegistrationContext): Promise<void> {
+  const preparation = await prepareProjectInit(registration)
+  if (!preparation.succeeded) {
+    const lines = [...preparation.problems]
+    if (preparation.reason !== "unreadable") lines.push(INIT_SETUP_HINT)
+    return ctx.ui.notify(lines.join("\n"), "error")
+  }
+  const name = await askName(ctx, preparation.output)
+  if (typeof name !== "string") return ctx.ui.notify(INIT_CANCELLED, "info")
+  const vault = await askVault(ctx, preparation.output)
+  if (typeof vault !== "string") return ctx.ui.notify(INIT_CANCELLED, "info")
+  const result = await initProjectMemory({ name, vault, expectedHash: preparation.output.expectedHash }, registration)
+  if (!result.succeeded) return ctx.ui.notify(describeRegistrationFailure(result), "error")
+  ctx.ui.notify(describeRegistered(`${INIT_DONE} ${name}`, result.output), "info")
+}
+
+async function askName(ctx: MemoryPiContext, preparation: InitPreparation): Promise<string | null> {
+  if (preparation.existing) return preparation.existing.name
+  for (;;) {
+    const answer = await ctx.ui.input(INIT_NAME_TITLE, preparation.defaultName)
+    if (typeof answer !== "string") return null
+    const checked = checkProjectName(preparation, answer)
+    if (checked.succeeded) return checked.output
+    ctx.ui.notify(checked.problems.join("\n"), "error")
+  }
+}
+
+function askVault(ctx: MemoryPiContext, preparation: InitPreparation): Promise<string | undefined> {
+  if (preparation.existing) return ctx.ui.input(INIT_REPOINT_VAULT_TITLE, INIT_VAULT_PLACEHOLDER)
+  return ctx.ui.input(INIT_VAULT_TITLE, INIT_VAULT_PLACEHOLDER)
+}

package/src/pi/memory-search/constants.ts

@@ -0,0 +1,16 @@
+export const MEMORY_SEARCH_TOOL_NAME = "memory_search"
+
+export const MEMORY_SEARCH_TOOL_LABEL = "Memory search"
+
+export const MEMORY_SEARCH_TOOL_DESCRIPTION =
+  "Search long-term memory by words. Archived notes and notes without valid frontmatter are not searched."
+
+export const NO_PROJECT_VAULT = "No project vault is registered for this folder."
+
+export const READ_HINT = 'Try other words or walk folders with memory_get (path "" is the vault root).'
+
+export const SEARCH_FIELD_SEPARATOR = " · "
+
+export const DONT_FORGET_MARK = "don't forget"
+
+export const NEEDS_FIXING_MARK = "needs fixing"

package/src/pi/memory-search/index.ts

@@ -0,0 +1,5 @@
+export * from "./constants.ts"
+export * from "./memory-search.ts"
+export * from "./respond.ts"
+export * from "./schemas.ts"
+export * from "./types.ts"

package/src/pi/memory-search/memory-search.ts

@@ -0,0 +1,22 @@
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { searchMemory } from "#src/usecases"
+import { MEMORY_SEARCH_TOOL_DESCRIPTION, MEMORY_SEARCH_TOOL_LABEL, MEMORY_SEARCH_TOOL_NAME } from "./constants.ts"
+import { respondToSearch } from "./respond.ts"
+import { MemorySearchParamsSchema } from "./schemas.ts"
+import type { MemorySearchTool } from "./types.ts"
+
+export function memorySearchTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemorySearchTool {
+  return {
+    name: MEMORY_SEARCH_TOOL_NAME,
+    label: MEMORY_SEARCH_TOOL_LABEL,
+    description: MEMORY_SEARCH_TOOL_DESCRIPTION,
+    parameters: MemorySearchParamsSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const request = { query: params.query, vault: params.vault }
+      const result = await sessions.readFresh(ctx.cwd, paths, signal, (context) => searchMemory(request, context))
+      if (!result) return noSessionResponse()
+      return respondToSearch(result)
+    },
+  }
+}

package/src/pi/memory-search/respond.ts

@@ -0,0 +1,62 @@
+import { SETUP_GUIDANCE } from "#src/pi/memory-add"
+import type { SearchedMemory, SearchMemoryResult, VaultSearchFailure, VaultSearchHits } from "#src/usecases"
+import {
+  DONT_FORGET_MARK,
+  NEEDS_FIXING_MARK,
+  NO_PROJECT_VAULT,
+  READ_HINT,
+  SEARCH_FIELD_SEPARATOR,
+} from "./constants.ts"
+import type { MemorySearchResponse } from "./types.ts"
+
+export function respondToSearch(result: SearchMemoryResult): MemorySearchResponse {
+  if (result.succeeded) return describeSearched(result.output)
+  switch (result.reason) {
+    case "not-configured":
+    case "invalid-config":
+      return reply([...result.problems, SETUP_GUIDANCE], true)
+    default:
+      return reply(result.problems, true)
+  }
+}
+
+function describeSearched(searched: SearchedMemory): MemorySearchResponse {
+  const lines: string[] = []
+  const failures = searched.vaults.filter(isFailure)
+  const answered = searched.vaults.filter(isHits)
+  for (const entry of answered) {
+    for (const hit of entry.hits) lines.push(describeHit(entry.vault, hit))
+  }
+  if (answered.length > 0 && lines.length === 0) {
+    const names = answered.map((entry) => entry.vault).join(", ")
+    lines.push(`No notes found in ${names}. ${READ_HINT}`)
+  }
+  for (const entry of failures) {
+    for (const problem of entry.problems) lines.push(`Could not search ${entry.vault}: ${problem}`)
+  }
+  for (const entry of answered) {
+    for (const warning of entry.warnings) lines.push(`Warning: ${warning}`)
+  }
+  lines.push(...searched.semantic.problems)
+  if (searched.projectMissing) lines.push(NO_PROJECT_VAULT)
+  return reply(lines, answered.length === 0)
+}
+
+function describeHit(vault: string, hit: VaultSearchHits["hits"][number]): string {
+  const fields = [vault, hit.path, hit.type]
+  if (hit.dontForget) fields.push(DONT_FORGET_MARK)
+  if (hit.needsFixing) fields.push(NEEDS_FIXING_MARK)
+  return fields.join(SEARCH_FIELD_SEPARATOR)
+}
+
+function isFailure(entry: VaultSearchHits | VaultSearchFailure): entry is VaultSearchFailure {
+  return "problems" in entry
+}
+
+function isHits(entry: VaultSearchHits | VaultSearchFailure): entry is VaultSearchHits {
+  return "hits" in entry
+}
+
+function reply(lines: string[], isError: boolean): MemorySearchResponse {
+  return { content: [{ type: "text", text: lines.join("\n") }], details: undefined, isError }
+}

package/src/pi/memory-search/schemas.ts

@@ -0,0 +1,11 @@
+import Type from "typebox"
+
+export const MemorySearchParamsSchema = Type.Object(
+  {
+    query: Type.String({ minLength: 1, description: "Words to look for, in English." }),
+    vault: Type.Union([Type.Literal("global"), Type.Literal("project"), Type.Literal("both")], {
+      description: "global: about the user. project: about this project. both: search the two, each on its own.",
+    }),
+  },
+  { additionalProperties: false },
+)

package/src/pi/memory-search/types.ts

@@ -0,0 +1,10 @@
+import type { AgentToolResult, ToolDefinition } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemorySearchParamsSchema } from "./schemas.ts"
+
+export type MemorySearchParams = Static<typeof MemorySearchParamsSchema>
+
+export type MemorySearchTool = ToolDefinition<typeof MemorySearchParamsSchema, undefined>
+
+export type MemorySearchResponse = AgentToolResult<undefined>

package/src/pi/memory-session/constants.ts

@@ -0,0 +1,7 @@
+export const NO_SESSION_NOTICE = "Memory is not ready in this session; try again after the session has started."
+
+export const STALE_SESSION_REASON = "stale-session"
+
+export const CAPTURE_BRANCH = "capture"
+
+export const RETRIEVAL_BRANCH = "retrieval"

package/src/pi/memory-session/index.ts

@@ -0,0 +1,4 @@
+export * from "./constants.ts"
+export * from "./keeper.ts"
+export * from "./respond.ts"
+export * from "./types.ts"

package/src/pi/memory-session/keeper.ts

@@ -0,0 +1,101 @@
+import type { MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import { hostPathPlatform } from "#src/pi/paths"
+import type { SemanticRuntime } from "#src/pi/semantic"
+import { createMemorySession, LoadedMemory, type MemoryOperationContext, type MemorySession } from "#src/usecases"
+import { CAPTURE_BRANCH, RETRIEVAL_BRANCH, STALE_SESSION_REASON } from "./constants.ts"
+import type { ReadOutcome, ReadRun, RegistrationFlow } from "./types.ts"
+
+export class MemorySessionKeeper {
+  #session: MemorySession | null = null
+  #semantic: SemanticRuntime | null = null
+  #loaded = new LoadedMemory()
+
+  constructor(semantic?: SemanticRuntime) {
+    if (semantic) this.#semantic = semantic
+  }
+
+  start(ctx: MemoryPiContext): MemorySession {
+    if (this.#session) this.#session.abortPending()
+    const session = createMemorySession({ sessionId: ctx.sessionManager.getSessionId(), branchId: null })
+    if (this.#semantic) this.#semantic.attach(ctx)
+    this.#session = session
+    this.#loaded = new LoadedMemory()
+    return session
+  }
+
+  shutdown(): void {
+    if (this.#session) this.#session.abortPending()
+    this.#session = null
+  }
+
+  operationContext(
+    session: MemorySession,
+    workingFolder: string,
+    paths: MemoryPaths,
+    callerSignal: AbortSignal | undefined,
+  ): MemoryOperationContext {
+    const stamp = session.stamp()
+    let signal = session.signal(stamp)
+    if (callerSignal) signal = AbortSignal.any([signal, callerSignal])
+    const context: MemoryOperationContext = {
+      configPath: paths.configPath,
+      indexPath: paths.indexPath,
+      workingFolder,
+      platform: hostPathPlatform(process.platform),
+      session,
+      stamp,
+      signal,
+    }
+    if (this.#semantic) context.semantic = this.#semantic.source
+    return context
+  }
+
+  currentOperation(
+    workingFolder: string,
+    paths: MemoryPaths,
+    callerSignal: AbortSignal | undefined,
+  ): MemoryOperationContext | null {
+    if (!this.#session) return null
+    return this.operationContext(this.#session, workingFolder, paths, callerSignal)
+  }
+
+  loaded(): LoadedMemory {
+    return this.#loaded
+  }
+
+  captureOperation(workingFolder: string, paths: MemoryPaths): MemoryOperationContext | null {
+    return this.#siblingOperation(CAPTURE_BRANCH, workingFolder, paths)
+  }
+
+  retrievalOperation(workingFolder: string, paths: MemoryPaths): MemoryOperationContext | null {
+    return this.#siblingOperation(RETRIEVAL_BRANCH, workingFolder, paths)
+  }
+
+  #siblingOperation(branchId: string, workingFolder: string, paths: MemoryPaths): MemoryOperationContext | null {
+    const main = this.#session
+    if (!main) return null
+    const sibling = main.sibling({ sessionId: main.stamp().sessionId, branchId })
+    return this.operationContext(sibling, workingFolder, paths, main.signal(main.stamp()))
+  }
+
+  async readFresh<Outcome extends ReadOutcome>(
+    workingFolder: string,
+    paths: MemoryPaths,
+    callerSignal: AbortSignal | undefined,
+    run: ReadRun<Outcome>,
+  ): Promise<Outcome | null> {
+    const first = this.currentOperation(workingFolder, paths, callerSignal)
+    if (!first) return null
+    const result = await run(first)
+    if (result.succeeded || result.reason !== STALE_SESSION_REASON) return result
+    const second = this.currentOperation(workingFolder, paths, callerSignal)
+    if (!second) return result
+    return run(second)
+  }
+
+  registrationFlow(ctx: MemoryPiContext, paths: MemoryPaths): RegistrationFlow {
+    let session = this.#session
+    if (!session) session = this.start(ctx)
+    return { session, registration: this.operationContext(session, ctx.cwd, paths, undefined) }
+  }
+}

package/src/pi/memory-session/respond.ts

@@ -0,0 +1,6 @@
+import { NO_SESSION_NOTICE } from "./constants.ts"
+import type { NoSessionResponse } from "./types.ts"
+
+export function noSessionResponse(): NoSessionResponse {
+  return { content: [{ type: "text", text: NO_SESSION_NOTICE }], details: undefined, isError: true }
+}

package/src/pi/memory-session/types.ts

@@ -0,0 +1,23 @@
+import type { AgentToolResult, SessionShutdownEvent } from "@earendil-works/pi-coding-agent"
+
+import type { MemoryPiContext } from "#src/pi/context"
+import type { Done } from "#src/shared"
+import type { MemoryOperationContext, MemorySession, RegistrationContext } from "#src/usecases"
+
+export interface RegistrationFlow {
+  session: MemorySession
+  registration: RegistrationContext
+}
+
+export type SessionShutdownHandler = (event: SessionShutdownEvent, ctx: MemoryPiContext) => Promise<void>
+
+export type NoSessionResponse = AgentToolResult<undefined>
+
+export interface ReadRefusal {
+  succeeded: false
+  reason: string
+}
+
+export type ReadOutcome = Done | ReadRefusal
+
+export type ReadRun<Outcome extends ReadOutcome> = (context: MemoryOperationContext) => Promise<Outcome>

package/src/pi/memory-settings/constants.ts

@@ -0,0 +1,69 @@
+import type { EmbeddingChoice } from "./types.ts"
+
+export const CURRENT_MARK = "(current)"
+
+export const IN_USE_MARK = "(in use)"
+
+export const PRICE_SEPARATOR = " · "
+
+export const PRICE_DECIMALS = 4
+
+export const DISCLOSURE_TITLE = "Before setup: what leaves this machine"
+
+export const CHAT_MODELS_DISCLOSURE =
+  "Capture and the memory agent send conversation and note content to the chat model you chose."
+
+export const JEV_DISCLOSURE = "TypeSafe (Jev) receives your messages and candidate notes."
+
+export const REMOTE_EMBEDDINGS_DISCLOSURE =
+  "The remote embeddings provider receives note content, secrets included, and search queries."
+
+export const SETTINGS_TITLE = "Memory settings (Done or Escape leaves)"
+
+export const DONE_LABEL = "Done"
+
+export const SAVED = "Saved:"
+
+export const RELOAD_NOTE =
+  "The Don't forget notes already loaded into this conversation's memory block update at the next session or /reload."
+
+export const CAPTURE_MODEL_TITLE =
+  "Chat model for automatic capture (a cheap model is usually enough; Escape keeps the current one)"
+
+export const AGENT_MODEL_TITLE =
+  "Chat model for the memory agent (it searches memory for each message; Escape keeps the current one)"
+
+export const DECISION_TITLE = "Decision model (Escape keeps the current one)"
+
+export const JEV_OPTION = "Jev (TypeSafe, by API)"
+
+export const LAYA_OPTION = "Laya (local)"
+
+export const LAYA_ENDPOINT_TITLE = "Laya endpoint (empty keeps the current one)"
+
+export const LAYA_DEFAULT_ENDPOINT = "http://127.0.0.1:8000/v1/systemone"
+
+export const EMBEDDINGS_TITLE = "Embeddings provider (Escape keeps the current one)"
+
+export const NONE_WORD = "none"
+
+export const NO_PROJECTS_NOTICE = "No project is registered. Run /memory-init in a project folder to register one."
+
+export const PROJECT_TITLE = "Project (Escape goes back)"
+
+export const PROJECT_ACTION_TITLE = "What to do with this project? (Escape goes back)"
+
+export const PROJECT_CHANGE_VAULT = "Change its vault"
+
+export const PROJECT_REMOVE = "Remove it from the memory"
+
+export const PROJECT_VAULT_TITLE = "Project vault (an existing folder; empty keeps the current one)"
+
+export const EMBEDDING_CHOICES: EmbeddingChoice[] = [
+  {
+    value: { provider: "local", model: "Xenova/multilingual-e5-small" },
+    label: "local (Xenova/multilingual-e5-small)",
+  },
+  { value: { provider: "openai", model: "text-embedding-3-small" }, label: "openai (text-embedding-3-small)" },
+  { value: { provider: "google", model: "gemini-embedding-001" }, label: "google (gemini-embedding-001)" },
+]

package/src/pi/memory-settings/edits.ts

@@ -0,0 +1,46 @@
+import { parseSettingNumber } from "#src/usecases"
+import { NONE_WORD } from "./constants.ts"
+import { chooseModel } from "./models.ts"
+import { saveChange } from "./save.ts"
+import type { LineEdit, ModelEditSpec, NumberEditSpec, SwitchEditSpec } from "./types.ts"
+
+export function modelEdit(spec: ModelEditSpec): LineEdit {
+  return async (env) => {
+    const chosen = await chooseModel(env.ctx, spec.title, spec.current, {})
+    if (!chosen) return
+    if (chosen.provider === spec.current.provider && chosen.id === spec.current.id) return
+    await saveChange(env, {
+      change: { kind: spec.kind, model: chosen },
+      what: `${spec.what} is now ${chosen.provider}/${chosen.id}`,
+      reload: false,
+    })
+  }
+}
+
+export function switchEdit(spec: SwitchEditSpec): LineEdit {
+  return async (env) => {
+    const value = !spec.current
+    let state = "off"
+    if (value) state = "on"
+    await saveChange(env, {
+      change: { kind: "captureSwitch", name: spec.name, value },
+      what: `${spec.what} is now ${state}`,
+      reload: false,
+    })
+  }
+}
+
+export function numberEdit(spec: NumberEditSpec): LineEdit {
+  return async (env) => {
+    const answer = await env.ctx.ui.input(spec.title, spec.current)
+    if (typeof answer !== "string" || answer.trim() === "") return
+    const typed = answer.trim()
+    if (spec.clear && typed.toLowerCase() === NONE_WORD) {
+      await saveChange(env, { change: spec.clear, what: `${spec.what} is now not set`, reload: false })
+      return
+    }
+    const parsed = parseSettingNumber(typed, spec.kind)
+    if (!parsed.succeeded) return env.ctx.ui.notify(`${spec.what}: ${parsed.problems.join("; ")}`, "error")
+    await saveChange(env, { change: spec.change(parsed.output), what: `${spec.what} is now ${typed}`, reload: false })
+  }
+}

package/src/pi/memory-settings/index.ts

@@ -0,0 +1,9 @@
+export * from "./constants.ts"
+export * from "./edits.ts"
+export * from "./lines.ts"
+export * from "./models.ts"
+export * from "./projects.ts"
+export * from "./providers.ts"
+export * from "./save.ts"
+export * from "./screen.ts"
+export * from "./types.ts"

package/src/pi/memory-settings/lines.ts

@@ -0,0 +1,119 @@
+import type { CutoffValue, MemoryConfig } from "#src/usecases"
+import { resolveCutoffs } from "#src/usecases"
+import { AGENT_MODEL_TITLE, CAPTURE_MODEL_TITLE } from "./constants.ts"
+import { modelEdit, numberEdit, switchEdit } from "./edits.ts"
+import { projectsEdit } from "./projects.ts"
+import { decisionEdit, embeddingsEdit } from "./providers.ts"
+import type { CaptureCountName, CaptureSwitchName, NumberChange, SettingLine } from "./types.ts"
+
+function cutoffText(cutoff: CutoffValue): string {
+  if (typeof cutoff.value !== "number") return "not set"
+  if (cutoff.source === "config") return `${cutoff.value} (set)`
+  return `${cutoff.value} (TypeSafe starting value)`
+}
+
+function decisionText(config: MemoryConfig): string {
+  const { decisionModel } = config
+  if (decisionModel.provider === "laya") return `Laya (${decisionModel.endpoint})`
+  return "Jev (TypeSafe)"
+}
+
+function captureSwitchLine(label: string, name: CaptureSwitchName, config: MemoryConfig): SettingLine {
+  const current = config.capture[name]
+  let state = "off"
+  if (current) state = "on"
+  return { label: `${label}: ${state}`, edit: switchEdit({ name, what: label.toLowerCase(), current }) }
+}
+
+function cutoffLine(label: string, which: "gate" | "relevance", config: MemoryConfig): SettingLine {
+  const cutoff = resolveCutoffs(config.decisionModel)[which]
+  const title = `${label}, 0 to 1 (currently ${cutoffText(cutoff)}; type none to clear it; empty keeps it)`
+  const kind = `${which}Threshold` as const
+  return {
+    label: `${label}: ${cutoffText(cutoff)}`,
+    edit: numberEdit({
+      title,
+      what: label.toLowerCase(),
+      kind: "threshold",
+      current: cutoffText(cutoff),
+      change: (value) => ({ kind, value }),
+      clear: { kind, value: null },
+    }),
+  }
+}
+
+function countLine(label: string, unit: string, current: number, change: NumberChange): SettingLine {
+  return {
+    label: `${label}: ${current}${unit}`,
+    edit: numberEdit({
+      title: `${label} (a whole number of 1 or more; currently ${current}; empty keeps it)`,
+      what: label.toLowerCase(),
+      kind: "count",
+      current: String(current),
+      change,
+      clear: null,
+    }),
+  }
+}
+
+function captureCountLine(label: string, unit: string, name: CaptureCountName, config: MemoryConfig): SettingLine {
+  return countLine(label, unit, config.capture[name], (value) => ({ kind: "captureCount", name, value }))
+}
+
+function captureLines(config: MemoryConfig): SettingLine[] {
+  return [
+    {
+      label: `Capture model: ${config.capture.model.provider}/${config.capture.model.id}`,
+      edit: modelEdit({
+        title: CAPTURE_MODEL_TITLE,
+        what: "capture model",
+        kind: "captureModel",
+        current: config.capture.model,
+      }),
+    },
+    captureSwitchLine("Review during the session", "reviewEnabled", config),
+    captureCountLine("Review every", " turns", "nudgeInterval", config),
+    captureCountLine("Review after tool calls", "", "nudgeToolCalls", config),
+    captureSwitchLine("Flush at compaction", "flushOnCompact", config),
+    captureSwitchLine("Flush at session end", "flushOnShutdown", config),
+    captureCountLine("Flush minimum user messages", "", "flushMinTurns", config),
+  ]
+}
+
+export function settingLines(config: MemoryConfig): SettingLine[] {
+  const { limits } = config
+  return [
+    ...captureLines(config),
+    {
+      label: `Memory agent model: ${config.memoryAgent.model.provider}/${config.memoryAgent.model.id}`,
+      edit: modelEdit({
+        title: AGENT_MODEL_TITLE,
+        what: "memory agent model",
+        kind: "agentModel",
+        current: config.memoryAgent.model,
+      }),
+    },
+    { label: `Decision model: ${decisionText(config)}`, edit: decisionEdit },
+    cutoffLine("Gate cutoff", "gate", config),
+    cutoffLine("Relevance cutoff", "relevance", config),
+    { label: `Embeddings: ${config.embeddings.provider} (${config.embeddings.model})`, edit: embeddingsEdit },
+    countLine("Context budget", " characters", config.context.budgetChars, (value) => ({ kind: "budgetChars", value })),
+    countLine("Max note body", " characters", limits.maxBodyChars, (value) => ({
+      kind: "limit",
+      name: "maxBodyChars",
+      value,
+    })),
+    countLine("Max statement", " characters", limits.maxStatementChars, (value) => ({
+      kind: "limit",
+      name: "maxStatementChars",
+      value,
+    })),
+    countLine("Max notes per folder", "", limits.maxNotesPerFolder, (value) => ({
+      kind: "limit",
+      name: "maxNotesPerFolder",
+      value,
+    })),
+    { label: `Global vault: ${config.global.vault}`, edit: (env) => env.deps.changeGlobalVault(env.context) },
+    { label: `Projects: ${config.projects.length}`, edit: projectsEdit },
+  ]
+}

package/src/pi/memory-settings/models.ts

@@ -0,0 +1,81 @@
+import type { ChatModelSource, MemoryPiContext } from "#src/pi/context"
+import type { ChatModelReference } from "#src/usecases"
+import { CURRENT_MARK, IN_USE_MARK, PRICE_DECIMALS, PRICE_SEPARATOR } from "./constants.ts"
+import type { CurrentModel, ModelChoice } from "./types.ts"
+
+function priceText(value: number): string {
+  return `$${Number(value.toFixed(PRICE_DECIMALS))}`
+}
+
+export function modelLabel(model: ChatModelSource, mark: string | null): string {
+  let label = `${model.provider}/${model.id}`
+  if (mark) label = `${label} ${mark}`
+  if (!model.cost) return label
+  const prices = `${priceText(model.cost.input)} in / ${priceText(model.cost.output)} out per 1M tokens`
+  return `${label}${PRICE_SEPARATOR}${prices}`
+}
+
+function sameModel(model: ChatModelSource, current: CurrentModel): boolean {
+  return model.provider === current.provider && model.id === current.id
+}
+
+function inputPrice(model: ChatModelSource): number {
+  if (model.cost) return model.cost.input
+  return Number.POSITIVE_INFINITY
+}
+
+function byPrice(left: ChatModelSource, right: ChatModelSource): number {
+  const leftPrice = inputPrice(left)
+  const rightPrice = inputPrice(right)
+  if (leftPrice === rightPrice) return 0
+  if (leftPrice < rightPrice) return -1
+  return 1
+}
+
+function firstChoice(available: ChatModelSource[], current: CurrentModel, inUse: CurrentModel): ModelChoice | null {
+  let first = current
+  let mark = CURRENT_MARK
+  if (typeof current.provider !== "string" || typeof current.id !== "string") {
+    first = inUse
+    mark = IN_USE_MARK
+  }
+  if (typeof first.provider !== "string" || typeof first.id !== "string") return null
+  const reference = { provider: first.provider, id: first.id }
+  let shown: ChatModelSource = reference
+  const known = available.find((model) => sameModel(model, first))
+  if (known) shown = known
+  return { label: modelLabel(shown, mark), reference, current: true }
+}
+
+export function modelChoices(available: ChatModelSource[], current: CurrentModel, inUse: CurrentModel): ModelChoice[] {
+  const first = firstChoice(available, current, inUse)
+  const others = available
+    .filter((model) => !first || !sameModel(model, first.reference))
+    .sort(byPrice)
+    .map((model) => ({
+      label: modelLabel(model, null),
+      reference: { provider: model.provider, id: model.id },
+      current: false,
+    }))
+  if (!first) return others
+  return [first, ...others]
+}
+
+export async function chooseModel(
+  ctx: MemoryPiContext,
+  title: string,
+  current: CurrentModel,
+  inUse: CurrentModel,
+): Promise<ChatModelReference | null> {
+  const choices = modelChoices(ctx.modelRegistry.getAvailable(), current, inUse)
+  const answer = await ctx.ui.select(
+    title,
+    choices.map((choice) => choice.label),
+  )
+  const chosen = choices.find((choice) => choice.label === answer)
+  if (chosen) return chosen.reference
+  if (typeof answer === "string" && answer !== "") return null
+  const kept = choices.find((choice) => choice.current)
+  if (kept) return kept.reference
+  return null
+}