pi-obsidian-memory 0.0.1 → 0.1.1

package/src/pi/memory-block/render.ts

@@ -0,0 +1,54 @@
+import type { DontForgetVault, LoadDontForgetResult, LoadedDontForgetNote } from "#src/usecases"
+import {
+  BLOCK_FIELD_SEPARATOR,
+  BLOCK_INTRO,
+  BLOCK_NEEDS_FIXING_HEADING,
+  BLOCK_SEPARATOR,
+  DONT_FORGET_HEADING,
+  LOAD_ERROR_PREFIX,
+  LOAD_FAILURE_PREFIX,
+  LOAD_FAILURE_SUFFIX,
+  NO_DONT_FORGET,
+  NOTE_HEADING_PREFIX,
+} from "./constants.ts"
+
+export function renderMemoryBlock(result: LoadDontForgetResult): string | null {
+  if (!result.succeeded) {
+    if (result.reason === "not-configured") return null
+    return renderLoadFailure(result.problems.join("; "))
+  }
+  const notes = result.output.vaults.flatMap((vault) => vault.notes)
+  const parts = [BLOCK_INTRO]
+  if (notes.length === 0) parts.push(NO_DONT_FORGET)
+  else parts.push(DONT_FORGET_HEADING, ...notes.map(renderNote))
+  for (const vault of result.output.vaults) parts.push(...renderFailure(vault))
+  return parts.join(BLOCK_SEPARATOR)
+}
+
+function renderNote(note: LoadedDontForgetNote): string {
+  const heading = `${NOTE_HEADING_PREFIX}${[note.vault, note.path, note.type].join(BLOCK_FIELD_SEPARATOR)}`
+  const lines = [heading, note.body]
+  if (note.problems.length > 0)
+    lines.push(BLOCK_NEEDS_FIXING_HEADING, ...note.problems.map((problem) => `- ${problem}`))
+  return lines.join("\n")
+}
+
+function renderFailure(vault: DontForgetVault): string[] {
+  return vault.problems.map((problem) => `${LOAD_FAILURE_PREFIX} ${vault.vault} ${LOAD_FAILURE_SUFFIX} ${problem}`)
+}
+
+export function loadNotices(result: LoadDontForgetResult): string[] {
+  if (!result.succeeded) {
+    if (result.reason === "not-configured") return []
+    return [renderLoadNotice(result.problems.join("; "))]
+  }
+  return result.output.vaults.flatMap(renderFailure)
+}
+
+export function renderLoadNotice(message: string): string {
+  return `${LOAD_ERROR_PREFIX} ${message}`
+}
+
+export function renderLoadFailure(message: string): string {
+  return [BLOCK_INTRO, renderLoadNotice(message)].join(BLOCK_SEPARATOR)
+}

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

@@ -0,0 +1,24 @@
+import type { BeforeAgentStartEvent, BeforeAgentStartEventResult } from "@earendil-works/pi-coding-agent"
+
+import type { MemoryPiContext } from "#src/pi/context"
+import type { LoadDontForgetResult, LoadedMemory, MemoryOperationContext } from "#src/usecases"
+
+export type BeforeAgentStartHandler = (
+  event: BeforeAgentStartEvent,
+  ctx: MemoryPiContext,
+) => Promise<BeforeAgentStartEventResult | undefined>
+
+export type RelevantLoader = () => Promise<string | null>
+
+export type BlockNotifier = (messages: string[]) => void
+
+export interface BlockStart {
+  ctx: MemoryPiContext
+  context: MemoryOperationContext
+  configured: boolean
+  loaded: LoadedMemory
+  relevant: RelevantLoader
+  notify: BlockNotifier
+}
+
+export type DontForgetLoader = (context: MemoryOperationContext) => Promise<LoadDontForgetResult>

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

@@ -0,0 +1,43 @@
+export const MEMORY_DOCTOR_COMMAND = "memory-doctor"
+
+export const MEMORY_DOCTOR_DESCRIPTION = "Check the memory for problems and offer to complete blank notes"
+
+export const DOCTOR_TITLE = "Memory doctor"
+
+export const DOCTOR_SETUP_HINT = "Run /memory-setup to create or repair the config."
+
+export const NO_PROBLEMS = "no problems found."
+
+export const COULD_NOT_CHECK = "could not be checked."
+
+export const DOCTOR_NO_PROJECT_VAULT = "No project vault is registered for this folder."
+
+export const DOCTOR_INVALID_HEADING = "Invalid notes:"
+
+export const DUPLICATES_HEADING = "Copied ids:"
+
+export const BLANK_HEADING = "Blank notes (no frontmatter):"
+
+export const TEMPORARIES_HEADING = "Leftover temporary files:"
+
+export const UNREADABLE_HEADING = "Files that could not be read:"
+
+export const CUTOFF_SOURCES = new Map<string, string>([
+  ["config", "config"],
+  ["typesafe", "TypeSafe starting value"],
+  ["missing", "missing"],
+])
+
+export const CUTOFFS_HINT = "set both cutoffs in /memory-setup, see docs/decision-thresholds.md"
+
+export const MODELS_HEADING = "Models:"
+
+export const COMPLETE_TYPE_TITLE = "Complete this blank note: which type is it?"
+
+export const COMPLETE_BODY_TITLE = "Body of the new note (written in English)"
+
+export const COMPLETE_CONFIRM_MESSAGE = "A new id and dates are added and the file is rewritten as a note."
+
+export const COMPLETED = "Completed"
+
+export const COMPLETE_SKIPPED = "Left unchanged:"

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

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

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

@@ -0,0 +1,135 @@
+import type { MemoryCommand, MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import {
+  BLANK_NOTE_TYPES,
+  type BlankFile,
+  completeBlankMemory,
+  type DecisionProbe,
+  type DiagnosedMemory,
+  diagnoseMemory,
+  type EmbeddingProbe,
+  type MemoryOperationContext,
+  type VaultReport,
+} from "#src/usecases"
+import {
+  COMPLETE_BODY_TITLE,
+  COMPLETE_CONFIRM_MESSAGE,
+  COMPLETE_SKIPPED,
+  COMPLETE_TYPE_TITLE,
+  COMPLETED,
+  DOCTOR_SETUP_HINT,
+  MEMORY_DOCTOR_DESCRIPTION,
+} from "./constants.ts"
+import { renderDoctorReport } from "./report.ts"
+import type { BlankTarget, DoctorModelPort } from "./types.ts"
+
+export function memoryDoctorCommand(
+  paths: MemoryPaths,
+  sessions: MemorySessionKeeper,
+  modelCachePath: string,
+): MemoryCommand {
+  return {
+    description: MEMORY_DOCTOR_DESCRIPTION,
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) return
+      const { registration } = sessions.registrationFlow(ctx, paths)
+      await runMemoryDoctor(ctx, registration, modelCachePath)
+    },
+  }
+}
+
+async function runMemoryDoctor(
+  ctx: MemoryPiContext,
+  context: MemoryOperationContext,
+  modelCachePath: string,
+): Promise<void> {
+  const port: DoctorModelPort = {
+    find: (provider, id) => ctx.modelRegistry.find(provider, id),
+    configured: (model) => ctx.modelRegistry.hasConfiguredAuth(model),
+    auth: (model) => ctx.modelRegistry.getApiKeyAndHeaders(model),
+  }
+  const diagnosed = await diagnoseMemory(
+    { port, embeddings: embeddingProbeOf(ctx, modelCachePath), decision: decisionProbeOf(ctx) },
+    context,
+  )
+  if (!diagnosed.succeeded) {
+    return ctx.ui.notify([...diagnosed.problems, DOCTOR_SETUP_HINT].join("\n"), "error")
+  }
+  ctx.ui.notify(renderDoctorReport(diagnosed.output), levelOf(diagnosed.output))
+  for (const target of blankTargets(diagnosed.output)) await offerCompletion(ctx, context, target)
+}
+
+function levelOf(diagnosed: DiagnosedMemory): "info" | "warning" {
+  for (const report of diagnosed.vaults) {
+    if ("problems" in report) return "warning"
+    const { diagnosis } = report
+    const found = [
+      diagnosis.invalid,
+      diagnosis.duplicateIds,
+      diagnosis.blank,
+      diagnosis.temporaries,
+      diagnosis.crowdedFolders,
+    ]
+    if (found.some((items) => items.length > 0) || report.unreadable.length > 0) return "warning"
+  }
+  if (diagnosed.models.some((report) => report.check.status !== "ok")) return "warning"
+  if (diagnosed.embeddings.status !== "ready") return "warning"
+  if ("problem" in diagnosed.decision) return "warning"
+  if (diagnosed.cutoffs.gate.source === "missing" || diagnosed.cutoffs.relevance.source === "missing") return "warning"
+  return "info"
+}
+
+function blankTargets(diagnosed: DiagnosedMemory): BlankTarget[] {
+  const reports = diagnosed.vaults.filter((report): report is VaultReport => "blanks" in report)
+  return reports.flatMap((report) => report.blanks.map((blank: BlankFile) => ({ vault: report.vault, blank })))
+}
+
+async function offerCompletion(
+  ctx: MemoryPiContext,
+  context: MemoryOperationContext,
+  target: BlankTarget,
+): Promise<void> {
+  const { vault, blank } = target
+  const label = `${vault}/${blank.path}`
+  const type = await ctx.ui.select(`${COMPLETE_TYPE_TITLE} (${label})`, [...BLANK_NOTE_TYPES])
+  if (!isNoteType(type)) return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+  let body = ""
+  if (blank.empty) {
+    const typed = await ctx.ui.input(`${COMPLETE_BODY_TITLE} (${label})`)
+    if (typeof typed !== "string" || typed.trim() === "") return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+    body = typed
+  }
+  const confirmed = await ctx.ui.confirm(`Complete ${label} as a ${type} note?`, COMPLETE_CONFIRM_MESSAGE)
+  if (!confirmed) return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+  const result = await completeBlankMemory(
+    { vault, path: blank.path, expectedHash: blank.rawHash, type, body },
+    context,
+  )
+  if (!result.succeeded) return ctx.ui.notify(result.problems.join("\n"), "error")
+  const warnings = result.output.maintenanceProblems.map((problem) => `\nMaintenance warning: ${problem}`)
+  ctx.ui.notify(`${COMPLETED} ${label} as a ${type} note.${warnings.join("")}`, "info")
+}
+
+function isNoteType(value: string | undefined): value is (typeof BLANK_NOTE_TYPES)[number] {
+  return typeof value === "string" && BLANK_NOTE_TYPES.some((type) => type === value)
+}
+
+function embeddingProbeOf(ctx: MemoryPiContext, modelCachePath: string): EmbeddingProbe {
+  return {
+    modelCachePath,
+    async hasCredentials(provider) {
+      const key = await ctx.modelRegistry.getApiKeyForProvider(provider)
+      return typeof key === "string" && key !== ""
+    },
+  }
+}
+
+function decisionProbeOf(ctx: MemoryPiContext): DecisionProbe {
+  return {
+    hasClassifier: (provider, model) => typeof ctx.modelRegistry.findOfType("classifier", provider, model) === "object",
+    async hasCredentials(provider) {
+      const key = await ctx.modelRegistry.getApiKeyForProvider(provider)
+      return typeof key === "string" && key !== ""
+    },
+  }
+}

package/src/pi/memory-doctor/report.ts

@@ -0,0 +1,101 @@
+import type {
+  CutoffReport,
+  CutoffValue,
+  DecisionReport,
+  DiagnosedMemory,
+  EmbeddingReport,
+  ModelReport,
+  VaultReport,
+  VaultReportFailure,
+} from "#src/usecases"
+import {
+  BLANK_HEADING,
+  COULD_NOT_CHECK,
+  CUTOFF_SOURCES,
+  CUTOFFS_HINT,
+  DOCTOR_INVALID_HEADING,
+  DOCTOR_NO_PROJECT_VAULT,
+  DOCTOR_TITLE,
+  DUPLICATES_HEADING,
+  MODELS_HEADING,
+  NO_PROBLEMS,
+  TEMPORARIES_HEADING,
+  UNREADABLE_HEADING,
+} from "./constants.ts"
+
+export function renderDoctorReport(diagnosed: DiagnosedMemory): string {
+  const sections = diagnosed.vaults.map((report) => renderVault(report, diagnosed.maxNotesPerFolder))
+  const lines = [DOCTOR_TITLE, "", ...sections.flatMap((section) => [...section, ""])]
+  if (diagnosed.projectMissing) lines.push(DOCTOR_NO_PROJECT_VAULT, "")
+  lines.push(MODELS_HEADING, ...diagnosed.models.map(renderModel), renderEmbeddings(diagnosed.embeddings))
+  lines.push(renderDecision(diagnosed.decision), renderCutoffs(diagnosed.cutoffs))
+  return lines.join("\n")
+}
+
+function renderVault(report: VaultReport | VaultReportFailure, limit: number): string[] {
+  const title = vaultTitle(report.vault)
+  if ("problems" in report) return [`${title}: ${COULD_NOT_CHECK}`, ...report.problems.map((problem) => `- ${problem}`)]
+  const { diagnosis } = report
+  const groups: string[][] = []
+  addGroup(
+    groups,
+    DOCTOR_INVALID_HEADING,
+    diagnosis.invalid.map((note) => `${note.path}: ${note.problems.join("; ")}`),
+  )
+  addGroup(
+    groups,
+    DUPLICATES_HEADING,
+    diagnosis.duplicateIds.map((copy) => `${copy.id}: ${copy.paths.join(", ")}`),
+  )
+  addGroup(groups, BLANK_HEADING, diagnosis.blank)
+  addGroup(groups, TEMPORARIES_HEADING, diagnosis.temporaries)
+  addGroup(
+    groups,
+    `Folders above ${limit} notes (consider splitting them):`,
+    diagnosis.crowdedFolders.map((folder) => `${folder.folder}: ${folder.count} notes`),
+  )
+  addGroup(groups, UNREADABLE_HEADING, report.unreadable)
+  if (groups.length === 0) return [`${title}: ${NO_PROBLEMS}`]
+  return [`${title}:`, ...groups.flat()]
+}
+
+function addGroup(groups: string[][], heading: string, items: string[]): void {
+  if (items.length === 0) return
+  groups.push([heading, ...items.map((item) => `- ${item}`)])
+}
+
+function vaultTitle(scope: string): string {
+  if (scope === "global") return "Global vault"
+  return "Project vault"
+}
+
+function renderEmbeddings(report: EmbeddingReport): string {
+  const name = `embeddings ${report.provider}/${report.model}`
+  if (report.status === "ready") return `- ${name}: ready`
+  return `- ${name}: ${report.problem}`
+}
+
+function renderDecision(report: DecisionReport): string {
+  const name = `decision model ${report.provider}/${report.model}`
+  if ("problem" in report) return `- ${name}: ${report.problem}`
+  return `- ${name}: ready (${report.detail})`
+}
+
+function cutoffText(name: string, value: CutoffValue): string {
+  const source = CUTOFF_SOURCES.get(value.source)
+  if (typeof value.value !== "number") return `${name} ${source}`
+  return `${name} ${value.value} (${source})`
+}
+
+function renderCutoffs(cutoffs: CutoffReport): string {
+  const line = `- decision cutoffs: ${cutoffText("gate", cutoffs.gate)}, ${cutoffText("relevance", cutoffs.relevance)}`
+  if (cutoffs.gate.source === "missing" || cutoffs.relevance.source === "missing") return `${line}; ${CUTOFFS_HINT}`
+  return line
+}
+
+function renderModel(report: ModelReport): string {
+  const { check } = report
+  const name = `${report.role} ${check.model.provider}/${check.model.id}`
+  if (check.status === "ok") return `- ${name}: ok`
+  return `- ${name}: ${check.problem}`
+}

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

@@ -0,0 +1,13 @@
+import type { ChatModelSource, ModelAuthResult } from "#src/pi/context"
+import type { BlankFile, VaultReport } from "#src/usecases"
+
+export interface BlankTarget {
+  vault: VaultReport["vault"]
+  blank: BlankFile
+}
+
+export interface DoctorModelPort {
+  find(provider: string, id: string): ChatModelSource | undefined
+  configured(model: ChatModelSource): boolean
+  auth(model: ChatModelSource): Promise<ModelAuthResult>
+}

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

@@ -0,0 +1,15 @@
+export const MEMORY_EXPORT_COMMAND = "memory-export"
+
+export const MEMORY_EXPORT_DESCRIPTION = "Export the global and project memory as one .zip file"
+
+export const EXPORT_FOLDER_TITLE = "Save the export in which folder? (empty: the working folder)"
+
+export const EXPORT_NAME_TITLE = "File name (empty: the suggested one)"
+
+export const EXPORT_CANCELLED = "Export cancelled: nothing was written."
+
+export const EXPORT_DONE = "Exported"
+
+export const EXPORT_SETUP_HINT = "Run /memory-setup first."
+
+export const EXPORT_NAME_TAKEN = "already exists and was kept; choose another name."

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

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

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

@@ -0,0 +1,57 @@
+import type { MemoryCommand, MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import { hostPathPlatform } from "#src/pi/paths"
+import { type ExportedMemory, exportMemory, type MemoryOperationContext } from "#src/usecases"
+import {
+  EXPORT_CANCELLED,
+  EXPORT_DONE,
+  EXPORT_FOLDER_TITLE,
+  EXPORT_NAME_TAKEN,
+  EXPORT_NAME_TITLE,
+  EXPORT_SETUP_HINT,
+  MEMORY_EXPORT_DESCRIPTION,
+} from "./constants.ts"
+import { defaultExportName } from "./name.ts"
+import type { ExportFailure } from "./types.ts"
+
+export function memoryExportCommand(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryCommand {
+  return {
+    description: MEMORY_EXPORT_DESCRIPTION,
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) return
+      const { registration } = sessions.registrationFlow(ctx, paths)
+      await runMemoryExport(ctx, registration)
+    },
+  }
+}
+
+async function runMemoryExport(ctx: MemoryPiContext, context: MemoryOperationContext): Promise<void> {
+  const folder = await askOrDefault(ctx, EXPORT_FOLDER_TITLE, ctx.cwd)
+  if (typeof folder !== "string") return ctx.ui.notify(EXPORT_CANCELLED, "info")
+  const suggested = defaultExportName(new Date())
+  for (;;) {
+    const fileName = await askOrDefault(ctx, EXPORT_NAME_TITLE, suggested)
+    if (typeof fileName !== "string") return ctx.ui.notify(EXPORT_CANCELLED, "info")
+    const result = await exportMemory({ folder, fileName, platform: hostPathPlatform(process.platform) }, context)
+    if (result.succeeded) return ctx.ui.notify(describeExported(result.output), "info")
+    if (result.reason !== "exists") return ctx.ui.notify(describeRefusal(result), "error")
+    ctx.ui.notify(`${fileName} ${EXPORT_NAME_TAKEN}`, "error")
+  }
+}
+
+async function askOrDefault(ctx: MemoryPiContext, title: string, fallback: string): Promise<string | null> {
+  const answer = await ctx.ui.input(title, fallback)
+  if (typeof answer !== "string") return null
+  if (answer.trim() === "") return fallback
+  return answer.trim()
+}
+
+function describeRefusal(result: ExportFailure): string {
+  const lines = [...result.problems]
+  if (result.reason === "not-configured" || result.reason === "invalid-config") lines.push(EXPORT_SETUP_HINT)
+  return lines.join("\n")
+}
+
+function describeExported(output: ExportedMemory): string {
+  return `${EXPORT_DONE} ${output.files} files from ${output.vaults.join(" and ")} to ${output.path}`
+}

package/src/pi/memory-export/name.ts

@@ -0,0 +1,9 @@
+export function defaultExportName(now: Date): string {
+  const date = [now.getFullYear(), pad(now.getMonth() + 1), pad(now.getDate())].join("-")
+  const time = [pad(now.getHours()), pad(now.getMinutes()), pad(now.getSeconds())].join("")
+  return `memory-export-${date}-${time}.zip`
+}
+
+function pad(value: number): string {
+  return String(value).padStart(2, "0")
+}

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

@@ -0,0 +1,4 @@
+import type { Done } from "#src/shared"
+import type { ExportMemoryResult } from "#src/usecases"
+
+export type ExportFailure = Exclude<ExportMemoryResult, Done>

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

@@ -0,0 +1,12 @@
+export const MEMORY_GET_TOOL_NAME = "memory_get"
+
+export const MEMORY_GET_TOOL_LABEL = "Memory get"
+
+export const MEMORY_GET_TOOL_DESCRIPTION =
+  'Read a note in full, or a folder\'s index (path "" = root); archive/ paths can be read.'
+
+export const GET_FIELD_SEPARATOR = " · "
+
+export const GET_NEEDS_FIXING_HEADING = "Needs fixing:"
+
+export const UNCLOSED_NOTICE = "This file cannot be read as a note: it has no closed frontmatter block."

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

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

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

@@ -0,0 +1,23 @@
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { getMemory } from "#src/usecases"
+import { MEMORY_GET_TOOL_DESCRIPTION, MEMORY_GET_TOOL_LABEL, MEMORY_GET_TOOL_NAME } from "./constants.ts"
+import { respondToGet } from "./respond.ts"
+import { MemoryGetParamsSchema } from "./schemas.ts"
+import type { MemoryGetTool } from "./types.ts"
+
+export function memoryGetTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryGetTool {
+  return {
+    name: MEMORY_GET_TOOL_NAME,
+    label: MEMORY_GET_TOOL_LABEL,
+    description: MEMORY_GET_TOOL_DESCRIPTION,
+    parameters: MemoryGetParamsSchema,
+    async execute(toolCallId, params, signal, _onUpdate, ctx) {
+      const request = { vault: params.vault, path: params.path }
+      const read = { ...request, sourceCallId: toolCallId }
+      const result = await sessions.readFresh(ctx.cwd, paths, signal, (context) => getMemory(read, context))
+      if (!result) return noSessionResponse()
+      return respondToGet(request, result)
+    },
+  }
+}

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

@@ -0,0 +1,38 @@
+import { SETUP_GUIDANCE } from "#src/pi/memory-add"
+import type { GetMemoryRequest, GetMemoryResult } from "#src/usecases"
+import { GET_FIELD_SEPARATOR, GET_NEEDS_FIXING_HEADING, UNCLOSED_NOTICE } from "./constants.ts"
+import type { MemoryGetResponse } from "./types.ts"
+
+export function respondToGet(
+  request: Pick<GetMemoryRequest, "vault" | "path">,
+  result: GetMemoryResult,
+): MemoryGetResponse {
+  if (result.succeeded) {
+    if (result.output.kind === "folder") return reply([result.output.text], false)
+    const { file } = result.output
+    const problems = [
+      ...file.analysis.frontmatterProblems,
+      ...file.analysis.nameProblems,
+      ...file.analysis.bodyProblems,
+    ]
+    const lines = [[request.vault, request.path].join(GET_FIELD_SEPARATOR), file.text]
+    if (problems.length > 0) lines.push(GET_NEEDS_FIXING_HEADING, ...problems.map((problem) => `- ${problem}`))
+    return reply(lines, false)
+  }
+  switch (result.reason) {
+    case "unclosed-frontmatter":
+      return reply(
+        [UNCLOSED_NOTICE, GET_NEEDS_FIXING_HEADING, ...result.problems.map((problem) => `- ${problem}`)],
+        true,
+      )
+    case "not-configured":
+    case "invalid-config":
+      return reply([...result.problems, SETUP_GUIDANCE], true)
+    default:
+      return reply(result.problems, true)
+  }
+}
+
+function reply(lines: string[], isError: boolean): MemoryGetResponse {
+  return { content: [{ type: "text", text: lines.join("\n") }], details: undefined, isError }
+}

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

@@ -0,0 +1,13 @@
+import Type from "typebox"
+
+export const MemoryGetParamsSchema = Type.Object(
+  {
+    vault: Type.Union([Type.Literal("global"), Type.Literal("project")], {
+      description: "global: about the user. project: about this project.",
+    }),
+    path: Type.String({
+      description: 'Path inside the vault, as memory_search shows it: a note, a folder, or "" for the vault root.',
+    }),
+  },
+  { additionalProperties: false },
+)

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

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

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

@@ -0,0 +1,17 @@
+export const MEMORY_INIT_COMMAND = "memory-init"
+
+export const MEMORY_INIT_DESCRIPTION = "Register this folder as a project with its own memory vault"
+
+export const INIT_NAME_TITLE = "Project name (empty keeps the suggested one)"
+
+export const INIT_VAULT_TITLE = "Project vault folder (absolute path; created if missing)"
+
+export const INIT_REPOINT_VAULT_TITLE = "New vault folder for this project (absolute path; created if missing)"
+
+export const INIT_VAULT_PLACEHOLDER = "Absolute folder path"
+
+export const INIT_SETUP_HINT = "Run /memory-setup first."
+
+export const INIT_CANCELLED = "Init cancelled: nothing changed."
+
+export const INIT_DONE = "Project registered:"

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

@@ -0,0 +1,2 @@
+export * from "./constants.ts"
+export * from "./memory-init.ts"