pi-obsidian-memory 0.0.0 → 0.1.0

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
+}

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

@@ -0,0 +1,46 @@
+import type { ProjectEntry } from "#src/usecases"
+import {
+  NO_PROJECTS_NOTICE,
+  PROJECT_ACTION_TITLE,
+  PROJECT_CHANGE_VAULT,
+  PROJECT_REMOVE,
+  PROJECT_TITLE,
+  PROJECT_VAULT_TITLE,
+} from "./constants.ts"
+import { saveChange } from "./save.ts"
+import type { SettingsEnv } from "./types.ts"
+
+export function projectLabel(project: ProjectEntry): string {
+  return `${project.name} — ${project.folder} → ${project.vault}`
+}
+
+async function repoint(env: SettingsEnv, project: ProjectEntry): Promise<void> {
+  const answer = await env.ctx.ui.input(PROJECT_VAULT_TITLE, project.vault)
+  if (typeof answer !== "string" || answer.trim() === "") return
+  await saveChange(env, {
+    change: { kind: "projectVault", name: project.name, vault: answer.trim() },
+    what: `project ${project.name} now uses ${answer.trim()}`,
+    reload: true,
+  })
+}
+
+async function remove(env: SettingsEnv, project: ProjectEntry): Promise<void> {
+  await saveChange(env, {
+    change: { kind: "removeProject", name: project.name },
+    what: `project ${project.name} was removed from the memory`,
+    reload: true,
+  })
+}
+
+export async function projectsEdit(env: SettingsEnv): Promise<void> {
+  const { projects } = env.state.config
+  if (projects.length === 0) return env.ctx.ui.notify(NO_PROJECTS_NOTICE, "info")
+  const labels = projects.map(projectLabel)
+  const answer = await env.ctx.ui.select(PROJECT_TITLE, labels)
+  const project = projects.find((_entry, index) => labels[index] === answer)
+  if (!project) return
+  const actions = [PROJECT_CHANGE_VAULT, PROJECT_REMOVE]
+  const action = await env.ctx.ui.select(PROJECT_ACTION_TITLE, actions)
+  if (action === PROJECT_CHANGE_VAULT) return repoint(env, project)
+  if (action === PROJECT_REMOVE) return remove(env, project)
+}

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

@@ -0,0 +1,77 @@
+import {
+  CURRENT_MARK,
+  DECISION_TITLE,
+  EMBEDDING_CHOICES,
+  EMBEDDINGS_TITLE,
+  JEV_DISCLOSURE,
+  JEV_OPTION,
+  LAYA_DEFAULT_ENDPOINT,
+  LAYA_ENDPOINT_TITLE,
+  LAYA_OPTION,
+  REMOTE_EMBEDDINGS_DISCLOSURE,
+} from "./constants.ts"
+import { saveChange } from "./save.ts"
+import type { SettingsEnv } from "./types.ts"
+
+async function askEndpoint(env: SettingsEnv): Promise<string | null> {
+  let placeholder = LAYA_DEFAULT_ENDPOINT
+  const { decisionModel } = env.state.config
+  if (decisionModel.provider === "laya") placeholder = decisionModel.endpoint
+  const answer = await env.ctx.ui.input(LAYA_ENDPOINT_TITLE, placeholder)
+  if (typeof answer !== "string") return null
+  const typed = answer.trim()
+  if (typed !== "") return typed
+  if (decisionModel.provider === "laya") return decisionModel.endpoint
+  return null
+}
+
+async function useLaya(env: SettingsEnv): Promise<void> {
+  const endpoint = await askEndpoint(env)
+  if (typeof endpoint !== "string") return
+  await saveChange(env, {
+    change: { kind: "decision", provider: "laya", endpoint },
+    what: "decision model is now Laya (local). It ships no cutoffs: set the gate and relevance cutoffs here, or per-message memory stays off",
+    reload: false,
+  })
+}
+
+async function useJev(env: SettingsEnv): Promise<void> {
+  env.ctx.ui.notify(JEV_DISCLOSURE, "warning")
+  await saveChange(env, {
+    change: { kind: "decision", provider: "typesafe" },
+    what: "decision model is now Jev. The cutoffs start from TypeSafe's values (0.5 and 0.5)",
+    reload: false,
+  })
+}
+
+export async function decisionEdit(env: SettingsEnv): Promise<void> {
+  const jevCurrent = env.state.config.decisionModel.provider === "typesafe"
+  let options = [`${JEV_OPTION} ${CURRENT_MARK}`, LAYA_OPTION]
+  if (!jevCurrent) options = [`${LAYA_OPTION} ${CURRENT_MARK}`, JEV_OPTION]
+  const answer = await env.ctx.ui.select(DECISION_TITLE, options)
+  if (typeof answer !== "string" || !options.includes(answer)) return
+  if (answer.startsWith(JEV_OPTION)) {
+    if (!jevCurrent) await useJev(env)
+    return
+  }
+  await useLaya(env)
+}
+
+export async function embeddingsEdit(env: SettingsEnv): Promise<void> {
+  const current = env.state.config.embeddings
+  const same = (provider: string) => provider === current.provider
+  const labels = EMBEDDING_CHOICES.filter((choice) => same(choice.value.provider)).map(
+    (choice) => `${choice.label} ${CURRENT_MARK}`,
+  )
+  const others = EMBEDDING_CHOICES.filter((choice) => !same(choice.value.provider))
+  const options = [...labels, ...others.map((choice) => choice.label)]
+  const answer = await env.ctx.ui.select(EMBEDDINGS_TITLE, options)
+  const picked = others.find((choice) => choice.label === answer)
+  if (!picked) return
+  if (picked.value.provider !== "local") env.ctx.ui.notify(REMOTE_EMBEDDINGS_DISCLOSURE, "warning")
+  await saveChange(env, {
+    change: { kind: "embeddings", embeddings: picked.value },
+    what: `embeddings are now ${picked.label}`,
+    reload: false,
+  })
+}

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

@@ -0,0 +1,16 @@
+import { changeMemorySettings } from "#src/usecases"
+import { RELOAD_NOTE, SAVED } from "./constants.ts"
+import type { Saving, SettingsEnv } from "./types.ts"
+
+export async function saveChange(env: SettingsEnv, saving: Saving): Promise<boolean> {
+  const result = await changeMemorySettings({ change: saving.change, expectedHash: env.state.hash }, env.context)
+  if (!result.succeeded) {
+    if (result.reason !== "cancelled") env.ctx.ui.notify(result.problems.join("\n"), "error")
+    return false
+  }
+  const lines = [`${SAVED} ${saving.what}.`]
+  if (saving.reload) lines.push(RELOAD_NOTE)
+  lines.push(...result.output.warnings.map((warning) => `- ${warning}`))
+  env.ctx.ui.notify(lines.join("\n"), "info")
+  return true
+}

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

@@ -0,0 +1,27 @@
+import type { MemoryPiContext } from "#src/pi/context"
+import { prepareMemorySettings, type RegistrationContext } from "#src/usecases"
+import { DONE_LABEL, SETTINGS_TITLE } from "./constants.ts"
+import { settingLines } from "./lines.ts"
+import type { SettingsDeps } from "./types.ts"
+
+function freshContext(base: RegistrationContext): RegistrationContext {
+  const stamp = base.session.stamp()
+  return { ...base, stamp, signal: base.session.signal(stamp) }
+}
+
+export async function runSettingsScreen(ctx: MemoryPiContext, deps: SettingsDeps): Promise<void> {
+  while (true) {
+    const context = freshContext(deps.registration)
+    const prepared = await prepareMemorySettings(context)
+    if (!prepared.succeeded) {
+      if (!context.signal.aborted) ctx.ui.notify(prepared.problems.join("\n"), "error")
+      return
+    }
+    const lines = settingLines(prepared.output.config)
+    const labels = [...lines.map((line) => line.label), DONE_LABEL]
+    const answer = await ctx.ui.select(SETTINGS_TITLE, labels)
+    const line = lines.find((_entry, index) => labels[index] === answer)
+    if (!line) return
+    await line.edit({ ctx, deps, context, state: prepared.output })
+  }
+}

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

@@ -0,0 +1,87 @@
+import type { MemoryPiContext } from "#src/pi/context"
+import type {
+  ChatModelReference,
+  MemoryConfig,
+  RegistrationContext,
+  SettingChange,
+  SettingsPreparation,
+} from "#src/usecases"
+
+export interface CurrentModel {
+  provider?: string
+  id?: string
+}
+
+export interface ModelChoice {
+  label: string
+  reference: ChatModelReference
+  current: boolean
+}
+
+export type VaultChanger = (context: RegistrationContext) => Promise<void>
+
+export interface SettingsDeps {
+  registration: RegistrationContext
+  changeGlobalVault: VaultChanger
+}
+
+export interface SettingsEnv {
+  ctx: MemoryPiContext
+  deps: SettingsDeps
+  context: RegistrationContext
+  state: SettingsPreparation
+}
+
+export type LineEdit = (env: SettingsEnv) => Promise<void>
+
+export interface SettingLine {
+  label: string
+  edit: LineEdit
+}
+
+export interface Saving {
+  change: SettingChange
+  what: string
+  reload: boolean
+}
+
+export interface SwitchDiscriminant {
+  kind: "captureSwitch"
+}
+
+export interface CountDiscriminant {
+  kind: "captureCount"
+}
+
+export type CaptureCountName = Extract<SettingChange, CountDiscriminant>["name"]
+
+export type CaptureSwitchName = Extract<SettingChange, SwitchDiscriminant>["name"]
+
+export interface SwitchEditSpec {
+  name: CaptureSwitchName
+  what: string
+  current: boolean
+}
+
+export interface EmbeddingChoice {
+  value: MemoryConfig["embeddings"]
+  label: string
+}
+
+export interface ModelEditSpec {
+  title: string
+  what: string
+  kind: "captureModel" | "agentModel"
+  current: CurrentModel
+}
+
+export type NumberChange = (value: number) => SettingChange
+
+export interface NumberEditSpec {
+  title: string
+  what: string
+  kind: "threshold" | "count"
+  current: string
+  change: NumberChange
+  clear: SettingChange | null
+}

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

@@ -0,0 +1,33 @@
+export const MEMORY_SETUP_COMMAND = "memory-setup"
+
+export const MEMORY_SETUP_DESCRIPTION = "Choose or attach the global memory vault and write the memory config"
+
+export const SETUP_CREATE_OPTION = "Create a new vault"
+
+export const SETUP_ATTACH_OPTION = "Attach an existing folder"
+
+export const SETUP_MODE_TITLE = "Global memory vault"
+
+export const SETUP_VAULT_TITLE = "Vault folder (absolute path)"
+
+export const SETUP_KEEP_VAULT_TITLE = "Vault folder (leave empty to keep the current one)"
+
+export const SETUP_VAULT_PLACEHOLDER = "Absolute folder path"
+
+export const SETUP_CAPTURE_MODEL_TITLE =
+  "Chat model for automatic capture (the model in use is the default and Escape keeps the one marked)"
+
+export const SETUP_AGENT_MODEL_TITLE =
+  "Chat model for the memory agent (a small model, it searches memory for each message; sorted by price; Escape keeps the current one)"
+
+export const SETUP_NO_MODEL = "No chat model is available. Connect a model in pi, then run /memory-setup again."
+
+export const SETUP_CANCELLED = "Setup cancelled: nothing changed."
+
+export const SETUP_DONE = "Memory is set up. Global vault:"
+
+export const REPAIR_TITLE = "The memory config needs changes"
+
+export const REPAIR_CONFIRM_LINE = "Continue and rewrite it with every key?"
+
+export const REPLACE_LINE = "The file is not valid JSON and will be replaced."

package/src/pi/memory-setup/disclosure.ts

@@ -0,0 +1,22 @@
+import {
+  CHAT_MODELS_DISCLOSURE,
+  DISCLOSURE_TITLE,
+  JEV_DISCLOSURE,
+  REMOTE_EMBEDDINGS_DISCLOSURE,
+} from "#src/pi/memory-settings"
+import type { SetupDisclosure } from "#src/usecases"
+
+export function disclosureText(disclosures: SetupDisclosure[]): string {
+  return [DISCLOSURE_TITLE, ...disclosures.map(disclosureLine)].join("\n")
+}
+
+function disclosureLine(disclosure: SetupDisclosure): string {
+  switch (disclosure) {
+    case "chat-models":
+      return CHAT_MODELS_DISCLOSURE
+    case "jev":
+      return JEV_DISCLOSURE
+    case "remote-embeddings":
+      return REMOTE_EMBEDDINGS_DISCLOSURE
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from "./constants.ts"
+export * from "./disclosure.ts"
+export * from "./memory-setup.ts"
+export * from "./types.ts"