pi-obsidian-memory 0.0.1 → 0.1.1

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"

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

@@ -0,0 +1,153 @@
+import type { MemoryCommand, MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import { type CurrentModel, chooseModel, RELOAD_NOTE, runSettingsScreen } from "#src/pi/memory-settings"
+import { describeRegistered, describeRegistrationFailure } from "#src/pi/registration-report"
+import {
+  type ConfigRepairDraft,
+  prepareMemorySettings,
+  prepareMemorySetup,
+  proposeMemorySetup,
+  type RegistrationContext,
+  type SetupPreparation,
+  type SetupVaultMode,
+  setupMemory,
+} from "#src/usecases"
+import {
+  MEMORY_SETUP_DESCRIPTION,
+  REPAIR_CONFIRM_LINE,
+  REPAIR_TITLE,
+  REPLACE_LINE,
+  SETUP_AGENT_MODEL_TITLE,
+  SETUP_ATTACH_OPTION,
+  SETUP_CANCELLED,
+  SETUP_CAPTURE_MODEL_TITLE,
+  SETUP_CREATE_OPTION,
+  SETUP_DONE,
+  SETUP_KEEP_VAULT_TITLE,
+  SETUP_MODE_TITLE,
+  SETUP_NO_MODEL,
+  SETUP_VAULT_PLACEHOLDER,
+  SETUP_VAULT_TITLE,
+} from "./constants.ts"
+import { disclosureText } from "./disclosure.ts"
+import type { VaultStep } from "./types.ts"
+
+export function memorySetupCommand(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryCommand {
+  return {
+    description: MEMORY_SETUP_DESCRIPTION,
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) return
+      const { registration } = sessions.registrationFlow(ctx, paths)
+      await runMemorySetup(ctx, registration)
+    },
+  }
+}
+
+async function runMemorySetup(ctx: MemoryPiContext, registration: RegistrationContext): Promise<void> {
+  const settings = await prepareMemorySettings(registration)
+  if (settings.succeeded) {
+    await runSettingsScreen(ctx, { registration, changeGlobalVault: (context) => changeVault(ctx, context) })
+    return
+  }
+  await runFirstSetup(ctx, registration)
+}
+
+async function runFirstSetup(ctx: MemoryPiContext, registration: RegistrationContext): Promise<void> {
+  const preparation = await prepareSetup(ctx, registration)
+  if (!preparation) return
+  if (!(await confirmRepair(ctx, preparation.draft))) return cancelled(ctx)
+  if (noModelToChoose(ctx, preparation.draft)) return
+  const draft = await chooseModels(ctx, preparation.draft)
+  if (!draft) return cancelled(ctx)
+  await commitVault(ctx, registration, { snapshot: preparation.snapshot, draft })
+}
+
+async function changeVault(ctx: MemoryPiContext, registration: RegistrationContext): Promise<void> {
+  const preparation = await prepareSetup(ctx, registration)
+  if (!preparation) return
+  await commitVault(ctx, registration, preparation)
+}
+
+async function commitVault(
+  ctx: MemoryPiContext,
+  registration: RegistrationContext,
+  preparation: VaultStep,
+): Promise<void> {
+  const { snapshot, draft } = preparation
+  const mode = await askMode(ctx, draft)
+  if (!mode) return cancelled(ctx)
+  const vault = await askVault(ctx, draft)
+  if (typeof vault !== "string") return cancelled(ctx)
+  const proposal = await proposeMemorySetup({ draft, vault, mode }, registration)
+  if (!proposal.succeeded) return ctx.ui.notify(proposal.problems.join("\n"), "error")
+  ctx.ui.notify(disclosureText(proposal.output.disclosures), "warning")
+  const result = await setupMemory(
+    {
+      config: proposal.output.config,
+      expectedHash: snapshot.hash,
+      replacementConfirmed: draft.replacementRequired,
+    },
+    registration,
+  )
+  if (!result.succeeded) return ctx.ui.notify(describeRegistrationFailure(result), "error")
+  const saved = describeRegistered(`${SETUP_DONE} ${proposal.output.config.global.vault}`, result.output)
+  ctx.ui.notify(`${saved}\n${RELOAD_NOTE}`, "info")
+}
+
+function cancelled(ctx: MemoryPiContext): void {
+  ctx.ui.notify(SETUP_CANCELLED, "info")
+}
+
+async function prepareSetup(ctx: MemoryPiContext, registration: RegistrationContext): Promise<SetupPreparation | null> {
+  const preparation = await prepareMemorySetup({ selectedModel: null }, registration)
+  if (!preparation.succeeded) {
+    ctx.ui.notify(preparation.problems.join("\n"), "error")
+    return null
+  }
+  return preparation.output
+}
+
+function modelResolved(model: ConfigRepairDraft["capture"]["model"]): boolean {
+  return typeof model.provider === "string" && typeof model.id === "string"
+}
+
+function noModelToChoose(ctx: MemoryPiContext, draft: ConfigRepairDraft): boolean {
+  if (ctx.modelRegistry.getAvailable().length > 0) return false
+  if (modelResolved(draft.capture.model) && modelResolved(draft.memoryAgent.model)) return false
+  ctx.ui.notify(SETUP_NO_MODEL, "error")
+  return true
+}
+
+function inUseOf(ctx: MemoryPiContext): CurrentModel {
+  if (!ctx.model) return {}
+  return { provider: ctx.model.provider, id: ctx.model.id }
+}
+
+async function chooseModels(ctx: MemoryPiContext, draft: ConfigRepairDraft): Promise<ConfigRepairDraft | null> {
+  const capture = await chooseModel(ctx, SETUP_CAPTURE_MODEL_TITLE, draft.capture.model, inUseOf(ctx))
+  if (!capture) return null
+  const agent = await chooseModel(ctx, SETUP_AGENT_MODEL_TITLE, draft.memoryAgent.model, {})
+  if (!agent) return null
+  return { ...draft, capture: { ...draft.capture, model: capture }, memoryAgent: { model: agent } }
+}
+
+async function confirmRepair(ctx: MemoryPiContext, draft: ConfigRepairDraft): Promise<boolean> {
+  if (draft.problems.length === 0 && !draft.replacementRequired) return true
+  const lines = draft.problems.map((problem) => `- ${problem}`)
+  if (draft.replacementRequired) lines.push(REPLACE_LINE)
+  return ctx.ui.confirm(REPAIR_TITLE, [...lines, REPAIR_CONFIRM_LINE].join("\n"))
+}
+
+async function askMode(ctx: MemoryPiContext, draft: ConfigRepairDraft): Promise<SetupVaultMode | null> {
+  let options = [SETUP_CREATE_OPTION, SETUP_ATTACH_OPTION]
+  if (draft.global.vault) options = [SETUP_ATTACH_OPTION, SETUP_CREATE_OPTION]
+  const answer = await ctx.ui.select(SETUP_MODE_TITLE, options)
+  if (answer === SETUP_CREATE_OPTION) return "create"
+  if (answer === SETUP_ATTACH_OPTION) return "attach"
+  return null
+}
+
+function askVault(ctx: MemoryPiContext, draft: ConfigRepairDraft): Promise<string | undefined> {
+  if (draft.global.vault) return ctx.ui.input(SETUP_KEEP_VAULT_TITLE, draft.global.vault)
+  return ctx.ui.input(SETUP_VAULT_TITLE, SETUP_VAULT_PLACEHOLDER)
+}

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

@@ -0,0 +1,6 @@
+import type { ConfigRepairDraft, SetupPreparation } from "#src/usecases"
+
+export interface VaultStep {
+  snapshot: SetupPreparation["snapshot"]
+  draft: ConfigRepairDraft
+}

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

@@ -0,0 +1,10 @@
+export const MEMORY_SUCCEED_TOOL_NAME = "memory_succeed"
+
+export const MEMORY_SUCCEED_TOOL_LABEL = "Memory succeed"
+
+export const MEMORY_SUCCEED_TOOL_DESCRIPTION =
+  "Use only when the user explicitly asks to replace a memory that stopped being true or was resolved. Read it with memory_get first."
+
+export const REPLACED_PREFIX = "Replaced in"
+
+export const NEW_NOTE_LABEL = "new note:"

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

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

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

@@ -0,0 +1,34 @@
+import { type ChangeResponse, reportFailure, reportSuccess } from "#src/pi/change-report"
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { succeedMemory } from "#src/usecases"
+import {
+  MEMORY_SUCCEED_TOOL_DESCRIPTION,
+  MEMORY_SUCCEED_TOOL_LABEL,
+  MEMORY_SUCCEED_TOOL_NAME,
+  NEW_NOTE_LABEL,
+  REPLACED_PREFIX,
+} from "./constants.ts"
+import { MemorySucceedParamsSchema } from "./schemas.ts"
+import type { MemorySucceedTool } from "./types.ts"
+
+export function memorySucceedTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemorySucceedTool {
+  return {
+    name: MEMORY_SUCCEED_TOOL_NAME,
+    label: MEMORY_SUCCEED_TOOL_LABEL,
+    description: MEMORY_SUCCEED_TOOL_DESCRIPTION,
+    parameters: MemorySucceedParamsSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx): Promise<ChangeResponse> {
+      const context = sessions.currentOperation(ctx.cwd, paths, signal)
+      if (!context) return noSessionResponse()
+      const { vault, path, folder, statement, type, body, dontForget } = params
+      const result = await succeedMemory({ vault, path, folder, draft: { statement, type, body, dontForget } }, context)
+      if (!result.succeeded) return reportFailure(result, path)
+      const { archivedPath, successorPath, maintenanceProblems } = result.output
+      return reportSuccess(
+        `${REPLACED_PREFIX} ${result.output.vault}: ${archivedPath}; ${NEW_NOTE_LABEL} ${successorPath}`,
+        maintenanceProblems,
+      )
+    },
+  }
+}

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

@@ -0,0 +1,30 @@
+import Type from "typebox"
+
+import { SucceedMemoryRequestSchema } from "#src/usecases"
+
+export const MemorySucceedParamsSchema = Type.Object(
+  {
+    vault: Type.With(SucceedMemoryRequestSchema.properties.vault, {
+      description: "global: about the user. project: about this project. The vault the old note was read from.",
+    }),
+    path: Type.With(SucceedMemoryRequestSchema.properties.path, {
+      description: "The old note's path, exactly as read with memory_get.",
+    }),
+    folder: Type.With(SucceedMemoryRequestSchema.properties.folder, {
+      description: "Subject folder of the new note, in English, from general to specific. Reuse a folder that exists.",
+    }),
+    statement: Type.With(SucceedMemoryRequestSchema.properties.draft.properties.statement, {
+      description: "The new note's name, in English: one short statement saying what is true now.",
+    }),
+    type: Type.With(SucceedMemoryRequestSchema.properties.draft.properties.type, {
+      description: "The kind of memory of the new note.",
+    }),
+    body: Type.With(SucceedMemoryRequestSchema.properties.draft.properties.body, {
+      description: "The full detail of the new note, in English. Never empty.",
+    }),
+    dontForget: Type.With(SucceedMemoryRequestSchema.properties.draft.properties.dontForget, {
+      description: "true only when the new note must be loaded in every session.",
+    }),
+  },
+  { additionalProperties: false },
+)

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

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemorySucceedParamsSchema } from "./schemas.ts"
+
+export type MemorySucceedParams = Static<typeof MemorySucceedParamsSchema>
+
+export type MemorySucceedTool = ToolDefinition<typeof MemorySucceedParamsSchema, undefined>

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

@@ -0,0 +1,8 @@
+export const MEMORY_UPDATE_TOOL_NAME = "memory_update"
+
+export const MEMORY_UPDATE_TOOL_LABEL = "Memory update"
+
+export const MEMORY_UPDATE_TOOL_DESCRIPTION =
+  "Use only when the user explicitly asks to change a memory. Read it with memory_get first."
+
+export const UPDATED_PREFIX = "Updated in"

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

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

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

@@ -0,0 +1,29 @@
+import { type ChangeResponse, reportFailure, reportSuccess } from "#src/pi/change-report"
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { updateMemory } from "#src/usecases"
+import {
+  MEMORY_UPDATE_TOOL_DESCRIPTION,
+  MEMORY_UPDATE_TOOL_LABEL,
+  MEMORY_UPDATE_TOOL_NAME,
+  UPDATED_PREFIX,
+} from "./constants.ts"
+import { MemoryUpdateParamsSchema } from "./schemas.ts"
+import type { MemoryUpdateTool } from "./types.ts"
+
+export function memoryUpdateTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryUpdateTool {
+  return {
+    name: MEMORY_UPDATE_TOOL_NAME,
+    label: MEMORY_UPDATE_TOOL_LABEL,
+    description: MEMORY_UPDATE_TOOL_DESCRIPTION,
+    parameters: MemoryUpdateParamsSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx): Promise<ChangeResponse> {
+      const context = sessions.currentOperation(ctx.cwd, paths, signal)
+      if (!context) return noSessionResponse()
+      const result = await updateMemory(params, context)
+      if (!result.succeeded) return reportFailure(result, params.path)
+      const { vault, path, maintenanceProblems } = result.output
+      return reportSuccess(`${UPDATED_PREFIX} ${vault}: ${path}`, maintenanceProblems)
+    },
+  }
+}

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

@@ -0,0 +1,24 @@
+import Type from "typebox"
+
+import { UpdateMemoryRequestSchema } from "#src/usecases"
+
+export const MemoryUpdateParamsSchema = Type.Object(
+  {
+    vault: Type.With(UpdateMemoryRequestSchema.properties.vault, {
+      description: "global: about the user. project: about this project. The vault the note was read from.",
+    }),
+    path: Type.With(UpdateMemoryRequestSchema.properties.path, {
+      description: "The note's path, exactly as read with memory_get. A new name needs a new note, not an update.",
+    }),
+    body: Type.With(UpdateMemoryRequestSchema.properties.body, {
+      description: "The full new body, in English. Never empty.",
+    }),
+    type: Type.With(UpdateMemoryRequestSchema.properties.type, {
+      description: "Only when the kind of memory changes; leave out to keep it.",
+    }),
+    dontForget: Type.With(UpdateMemoryRequestSchema.properties.dontForget, {
+      description: "true to load it in every session, false to stop; leave out to keep it.",
+    }),
+  },
+  { additionalProperties: false },
+)

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

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemoryUpdateParamsSchema } from "./schemas.ts"
+
+export type MemoryUpdateParams = Static<typeof MemoryUpdateParamsSchema>
+
+export type MemoryUpdateTool = ToolDefinition<typeof MemoryUpdateParamsSchema, undefined>

package/src/pi/paths/constants.ts

@@ -0,0 +1,7 @@
+export const MEMORY_FOLDER_NAME = "pi-obsidian-memory"
+
+export const CONFIG_FILE_NAME = "config.json"
+
+export const INDEX_FOLDER_NAME = "index"
+
+export const MODEL_FOLDER_NAME = "models"

package/src/pi/paths/index.ts

@@ -0,0 +1,2 @@
+export * from "./paths.ts"
+export * from "./platform.ts"