pi-obsidian-memory 0.0.1 → 0.1.1

package/src/domain/vault-catalog/export-entries.ts

@@ -0,0 +1,10 @@
+import type { VaultExportEntry, VaultExportFile } from "./types.ts"
+
+export function exportEntries(
+  global: readonly VaultExportFile[],
+  project: readonly VaultExportFile[] | null,
+): VaultExportEntry[] {
+  const entries = global.map((file) => ({ path: `global/${file.path}`, bytes: file.bytes }))
+  if (!project) return entries
+  return [...entries, ...project.map((file) => ({ path: `project/${file.path}`, bytes: file.bytes }))]
+}

package/src/domain/vault-catalog/index.ts

@@ -0,0 +1,5 @@
+export * from "./analyze.ts"
+export * from "./classify.ts"
+export * from "./dont-forget.ts"
+export * from "./export-entries.ts"
+export * from "./types.ts"

package/src/domain/vault-catalog/types.ts

@@ -0,0 +1,114 @@
+import type { NoteFrontmatter, NoteLimits, ParsedNote } from "#src/domain/note"
+import type { Failed, Succeeded } from "#src/shared"
+
+export type VaultEntryKind = "note" | "folder" | "index" | "template" | "dashboard" | "temporary" | "other"
+
+export interface VaultFileStat {
+  size: number
+  mtimeMs: number
+  ctimeMs: number
+  device: number
+  inode: number
+}
+
+export interface VaultCatalogEntry {
+  path: string
+  kind: VaultEntryKind
+  archived: boolean
+  stat: VaultFileStat
+}
+
+export interface VaultCatalogFailure extends Failed {
+  path: string
+  scope: "file" | "directory" | "entry"
+  reason:
+    | "invalid-path"
+    | "outside-vault"
+    | "not-found"
+    | "not-directory"
+    | "not-file"
+    | "unreadable"
+    | "not-writable"
+    | "cycle"
+    | "excluded"
+    | "changed"
+    | "io-error"
+}
+
+export interface VaultAlias {
+  path: string
+  target: string
+}
+
+export interface VaultEnumeration {
+  entries: VaultCatalogEntry[]
+  observedPaths: string[]
+  completeDirectories: string[]
+  failures: VaultCatalogFailure[]
+  aliases: VaultAlias[]
+}
+
+export type VaultEnumerationResult = Succeeded<VaultEnumeration> | VaultCatalogFailure
+
+export interface AnalyzeVaultNoteRequest {
+  statement: string
+  text: string
+  archived: boolean
+  limits: NoteLimits
+}
+
+export interface VaultNoteProblems {
+  frontmatterProblems: string[]
+  nameProblems: string[]
+  bodyProblems: string[]
+}
+
+export interface ParsedVaultNote extends VaultNoteProblems {
+  status: "parsed"
+  parsed: ParsedNote
+  frontmatter: NoteFrontmatter | null
+  searchable: boolean
+  needsFixing: boolean
+}
+
+export interface UnclosedVaultNote extends VaultNoteProblems {
+  status: "unclosed"
+  searchable: false
+  needsFixing: true
+}
+
+export type VaultNoteAnalysis = ParsedVaultNote | UnclosedVaultNote
+
+export interface VaultFileRequest {
+  path: string
+}
+
+export interface InspectedVaultFile {
+  path: string
+  canonicalPath: string
+  text: string
+  rawHash: string
+  stat: VaultFileStat
+  archived: boolean
+  analysis: VaultNoteAnalysis
+}
+
+export type VaultInspectionResult = Succeeded<InspectedVaultFile> | VaultCatalogFailure
+
+export interface VaultExportFile {
+  path: string
+  bytes: Uint8Array
+  rawHash: string
+  stat: VaultFileStat
+}
+
+export interface VaultExportEntry {
+  path: string
+  bytes: Uint8Array
+}
+
+export interface VaultExportFailure extends Failed {
+  failures: VaultCatalogFailure[]
+}
+
+export type VaultExportResult = Succeeded<VaultExportFile[]> | VaultExportFailure

package/src/domain/vault-diagnosis/diagnose.ts

@@ -0,0 +1,79 @@
+import { catalogFolder } from "#src/domain/search-catalog"
+import { isRootArchive, type VaultCatalogEntry } from "#src/domain/vault-catalog"
+import type {
+  CrowdedFolder,
+  DuplicateNoteId,
+  InvalidVaultNote,
+  VaultDiagnosis,
+  VaultDiagnosisRequest,
+} from "./types.ts"
+
+export function diagnoseVault(request: VaultDiagnosisRequest): VaultDiagnosis {
+  return {
+    invalid: invalidNotes(request),
+    blank: request.inspected
+      .filter((file) => file.analysis.status === "unclosed")
+      .map((file) => file.path)
+      .sort(compareText),
+    duplicateIds: duplicateIds(request),
+    temporaries: request.entries
+      .filter((entry) => entry.kind === "temporary")
+      .map((entry) => entry.path)
+      .sort(compareText),
+    crowdedFolders: crowdedFolders(request),
+  }
+}
+
+function invalidNotes(request: VaultDiagnosisRequest): InvalidVaultNote[] {
+  const invalid: InvalidVaultNote[] = []
+  for (const file of request.inspected) {
+    const { analysis } = file
+    if (analysis.status === "parsed" && analysis.needsFixing) {
+      invalid.push({
+        path: file.path,
+        problems: [...analysis.frontmatterProblems, ...analysis.nameProblems, ...analysis.bodyProblems],
+      })
+    }
+  }
+  return invalid.sort((left, right) => compareText(left.path, right.path))
+}
+
+function duplicateIds(request: VaultDiagnosisRequest): DuplicateNoteId[] {
+  const groups = new Map<string, string[]>()
+  for (const file of request.inspected) {
+    const { analysis } = file
+    if (analysis.status !== "parsed" || !analysis.frontmatter) continue
+    const group = groups.get(analysis.frontmatter.id)
+    if (group) group.push(file.path)
+    else groups.set(analysis.frontmatter.id, [file.path])
+  }
+  return [...groups]
+    .filter(([, paths]) => paths.length > 1)
+    .map(([id, paths]) => ({ id, paths: paths.sort(compareText) }))
+    .sort((left, right) => compareText(left.id, right.id))
+}
+
+function crowdedFolders(request: VaultDiagnosisRequest): CrowdedFolder[] {
+  const counts = new Map<string, number>()
+  for (const entry of request.entries) {
+    if (!isLiveNote(entry)) continue
+    const folder = catalogFolder(entry.path)
+    const count = counts.get(folder)
+    if (count) counts.set(folder, count + 1)
+    else counts.set(folder, 1)
+  }
+  return [...counts]
+    .filter(([, count]) => count > request.limits.maxNotesPerFolder)
+    .map(([folder, count]) => ({ folder, count }))
+    .sort((left, right) => compareText(left.folder, right.folder))
+}
+
+function isLiveNote(entry: VaultCatalogEntry): boolean {
+  return entry.kind === "note" && !entry.archived && !isRootArchive(entry.path)
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1
+  if (left > right) return 1
+  return 0
+}

package/src/domain/vault-diagnosis/index.ts

@@ -0,0 +1,2 @@
+export * from "./diagnose.ts"
+export * from "./types.ts"

package/src/domain/vault-diagnosis/types.ts

@@ -0,0 +1,31 @@
+import type { MemoryConfig } from "#src/domain/config"
+import type { InspectedVaultFile, VaultCatalogEntry } from "#src/domain/vault-catalog"
+
+export interface VaultDiagnosisRequest {
+  entries: readonly VaultCatalogEntry[]
+  inspected: readonly InspectedVaultFile[]
+  limits: MemoryConfig["limits"]
+}
+
+export interface InvalidVaultNote {
+  path: string
+  problems: string[]
+}
+
+export interface DuplicateNoteId {
+  id: string
+  paths: string[]
+}
+
+export interface CrowdedFolder {
+  folder: string
+  count: number
+}
+
+export interface VaultDiagnosis {
+  invalid: InvalidVaultNote[]
+  blank: string[]
+  duplicateIds: DuplicateNoteId[]
+  temporaries: string[]
+  crowdedFolders: CrowdedFolder[]
+}

package/src/domain/vault-path/constants.ts

@@ -0,0 +1,13 @@
+export const FOLDER_INDEX_NAME = "index"
+
+export const ARCHIVE_FOLDER = "archive"
+
+export const TEMPLATES_FOLDER = "_templates"
+
+export const RESERVED_ROOT_FOLDERS = [ARCHIVE_FOLDER, TEMPLATES_FOLDER]
+
+export const VAULT_PATH_SEPARATOR = "/"
+
+export const DRIVE_LETTER = /^[A-Za-z]:/
+
+export const HIDDEN_NAME_PREFIX = "."

package/src/domain/vault-path/index.ts

@@ -0,0 +1,2 @@
+export * from "./constants.ts"
+export * from "./vault-path.ts"

package/src/domain/vault-path/vault-path.ts

@@ -0,0 +1,65 @@
+import { checkEdges, checkFileSystemName, checkLinkCharacters, RELATIVE_NAMES } from "#src/domain/names"
+import { DRIVE_LETTER, HIDDEN_NAME_PREFIX, RESERVED_ROOT_FOLDERS, VAULT_PATH_SEPARATOR } from "./constants.ts"
+
+export function joinVaultPath(...parts: string[]): string {
+  return parts.filter((part) => part.length > 0).join(VAULT_PATH_SEPARATOR)
+}
+
+export function ancestorFolders(folder: string): string[] {
+  const parts = folder.split(VAULT_PATH_SEPARATOR).filter((part) => part.length > 0)
+  const nested = parts.map((_part, depth) => parts.slice(0, parts.length - depth).join(VAULT_PATH_SEPARATOR))
+
+  return [...nested, ""]
+}
+
+export function checkVaultPath(folder: string): string[] {
+  if (folder.includes("\\")) {
+    return ['folder: use "/" between folders']
+  }
+
+  if (folder.startsWith(VAULT_PATH_SEPARATOR) || DRIVE_LETTER.test(folder)) {
+    return ["folder: must be relative to the vault"]
+  }
+
+  if (folder.length === 0) {
+    return []
+  }
+
+  const problems = folder.split(VAULT_PATH_SEPARATOR).flatMap(checkFolderPart)
+  return [...new Set(problems)]
+}
+
+export function checkMemoryFolder(folder: string): string[] {
+  const problems = checkVaultPath(folder)
+  if (problems.length > 0 || folder.length === 0) {
+    return problems
+  }
+
+  return folder.split(VAULT_PATH_SEPARATOR).flatMap(checkMemoryFolderPart)
+}
+
+function checkFolderPart(part: string): string[] {
+  if (part.length === 0) {
+    return ["folder: has an empty part"]
+  }
+
+  if (RELATIVE_NAMES.includes(part)) {
+    return [`folder: "${part}" is not allowed`]
+  }
+
+  const label = `folder "${part}"`
+  return [...checkFileSystemName(label, part), ...checkLinkCharacters(label, part), ...checkEdges(label, part)]
+}
+
+function checkMemoryFolderPart(part: string, depth: number): string[] {
+  const isReservedRoot = depth === 0 && RESERVED_ROOT_FOLDERS.includes(part.toLowerCase())
+  if (isReservedRoot) {
+    return [`folder "${part}": is reserved for the vault`]
+  }
+
+  if (part.startsWith(HIDDEN_NAME_PREFIX)) {
+    return [`folder "${part}": is hidden (starts with ".")`]
+  }
+
+  return []
+}

package/src/pi/capture/cadence.ts

@@ -0,0 +1,49 @@
+import type { MemoryPiContext } from "#src/pi/context"
+import {
+  type CaptureCadenceSettings,
+  type CaptureTally,
+  captureSettings,
+  EMPTY_TALLY,
+  type FlushMoment,
+  shouldFlush,
+  tallyTurn,
+  tallyUserMessage,
+} from "#src/usecases"
+import type { CaptureRuntime } from "./runtime.ts"
+import type { CaptureDeps } from "./types.ts"
+
+export class CaptureCadence {
+  #runtime: CaptureRuntime
+  #deps: Pick<CaptureDeps, "paths" | "sessions">
+  #tally: CaptureTally = EMPTY_TALLY
+
+  constructor(runtime: CaptureRuntime, deps: Pick<CaptureDeps, "paths" | "sessions">) {
+    this.#runtime = runtime
+    this.#deps = deps
+  }
+
+  userMessageEnded(): void {
+    this.#tally = tallyUserMessage(this.#tally)
+  }
+
+  async turnEnded(toolCalls: number, ctx: MemoryPiContext): Promise<void> {
+    const settings = await this.#settings(ctx)
+    const outcome = tallyTurn(this.#tally, { toolCalls, reviewActive: this.#runtime.reviewActive }, settings)
+    this.#tally = outcome.tally
+    if (outcome.review) void this.#runtime.request({ ctx, kind: "review" })
+  }
+
+  async flush(moment: FlushMoment, ctx: MemoryPiContext): Promise<void> {
+    const settings = await this.#settings(ctx)
+    if (!settings || !shouldFlush(this.#tally, settings, moment)) return
+    await this.#runtime.request({ ctx, kind: "flush" })
+  }
+
+  async #settings(ctx: MemoryPiContext): Promise<CaptureCadenceSettings | null> {
+    const operation = this.#deps.sessions.captureOperation(ctx.cwd, this.#deps.paths)
+    if (!operation) return null
+    const result = await captureSettings(operation)
+    if (!result.succeeded) return null
+    return result.output
+  }
+}

package/src/pi/capture/completion.ts

@@ -0,0 +1,26 @@
+import type { MemoryPiContext } from "#src/pi/context"
+import type { CompletionPort } from "#src/usecases"
+import type { TextPart } from "./types.ts"
+
+export function registryCompletion(ctx: MemoryPiContext): CompletionPort {
+  return async (request) => {
+    const model = ctx.modelRegistry.find(request.model.provider, request.model.id)
+    if (!model) return { status: "unsupported" }
+    const message = await ctx.modelRegistry.complete(
+      model,
+      { systemPrompt: request.system, messages: [{ role: "user", content: request.data, timestamp: Date.now() }] },
+      { signal: request.signal, maxTokens: model.maxTokens },
+    )
+    if (message.stopReason === "aborted") return { status: "aborted" }
+    if (message.stopReason === "error") {
+      if (message.errorMessage) return { status: "error", error: message.errorMessage }
+      return { status: "error" }
+    }
+    const text = message.content.flatMap((part: TextPart) => {
+      if (part.type === "text" && typeof part.text === "string") return [part.text]
+      return []
+    })
+    if (text.length === 0) return { status: "empty" }
+    return { status: "completed", text: text.join("") }
+  }
+}

package/src/pi/capture/constants.ts

@@ -0,0 +1,5 @@
+export const CURSOR_TYPE = "obsidian-memory-capture"
+
+export const CAPTURE_FAILED = "Memory capture did not finish:"
+
+export const CAPTURE_SAVED = "Memory capture applied"

package/src/pi/capture/handlers.ts

@@ -0,0 +1,30 @@
+import type { SessionShutdownHandler } from "#src/pi/memory-session"
+import type { CaptureCadence } from "./cadence.ts"
+import type { CaptureRuntime } from "./runtime.ts"
+import { toolCallCount } from "./tool-calls.ts"
+import type { BeforeCompactHandler, MessageEndHandler, TurnEndHandler } from "./types.ts"
+
+export function messageEndHandler(cadence: CaptureCadence): MessageEndHandler {
+  return async (event) => {
+    if (event.message.role === "user") cadence.userMessageEnded()
+  }
+}
+
+export function turnEndHandler(cadence: CaptureCadence): TurnEndHandler {
+  return async (event, ctx) => {
+    await cadence.turnEnded(toolCallCount(event.message), ctx)
+  }
+}
+
+export function beforeCompactHandler(cadence: CaptureCadence): BeforeCompactHandler {
+  return async (_event, ctx) => {
+    await cadence.flush("compact", ctx)
+  }
+}
+
+export function flushOnShutdownHandler(cadence: CaptureCadence, runtime: CaptureRuntime): SessionShutdownHandler {
+  return async (event, ctx) => {
+    await runtime.stopReview()
+    if (event.reason !== "reload") await cadence.flush("shutdown", ctx)
+  }
+}

package/src/pi/capture/index.ts

@@ -0,0 +1,8 @@
+export * from "./cadence.ts"
+export * from "./completion.ts"
+export * from "./constants.ts"
+export * from "./handlers.ts"
+export * from "./runtime.ts"
+export * from "./schemas.ts"
+export * from "./transcript.ts"
+export * from "./types.ts"

package/src/pi/capture/runtime.ts

@@ -0,0 +1,83 @@
+import { type MemoryPiContext, STATUS_CAPTURING, withMemoryStatus } from "#src/pi/context"
+import { captureMemory } from "#src/usecases"
+import { CAPTURE_FAILED, CAPTURE_SAVED } from "./constants.ts"
+import { reviewableSince } from "./transcript.ts"
+import type { CaptureDeps, PendingCapture } from "./types.ts"
+
+export class CaptureRuntime {
+  #deps: CaptureDeps
+  #running: Promise<void> | null = null
+  #current: PendingCapture | null = null
+  #pending: PendingCapture[] = []
+  #abort = new AbortController()
+
+  constructor(deps: CaptureDeps) {
+    this.#deps = deps
+  }
+
+  get reviewActive(): boolean {
+    return [this.#current, ...this.#pending].some((capture) => capture?.kind === "review")
+  }
+
+  async stopReview(): Promise<void> {
+    this.#pending = this.#pending.filter((capture) => capture.kind === "flush")
+    if (this.#current?.kind === "review") this.#abort.abort()
+    await this.#running
+  }
+
+  request(request: PendingCapture): Promise<void> {
+    if (this.#running) {
+      this.#pending.push(request)
+      return this.#running
+    }
+    const running = this.#drain(request).finally(() => {
+      this.#running = null
+    })
+    this.#running = running
+    return running
+  }
+
+  async #drain(first: PendingCapture): Promise<void> {
+    let next: PendingCapture | undefined = first
+    while (next) {
+      this.#current = next
+      this.#abort = new AbortController()
+      await this.#run(next)
+      next = this.#pending.shift()
+    }
+    this.#current = null
+  }
+
+  async #run(request: PendingCapture): Promise<void> {
+    try {
+      await this.#review(request)
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      notifyFailure(request.ctx, "unexpected", [error.message])
+    }
+  }
+
+  async #review({ ctx }: PendingCapture): Promise<void> {
+    const captureOperation = this.#deps.sessions.captureOperation(ctx.cwd, this.#deps.paths)
+    if (!captureOperation) return
+    const { signal } = this.#abort
+    const operation = { ...captureOperation, signal: AbortSignal.any([captureOperation.signal, signal]) }
+    const transcript = reviewableSince(ctx.sessionManager.getBranch())
+    if (transcript.messages.length === 0) return
+    const run = { messages: transcript.messages, explicitSaves: transcript.explicitSaves }
+    const result = await withMemoryStatus(ctx, STATUS_CAPTURING, () =>
+      captureMemory(run, operation, this.#deps.completionOf(ctx)),
+    )
+    if (!result.succeeded) return notifyFailure(ctx, result.reason, result.problems)
+    if (result.output.reviewed && transcript.lastEntryId)
+      this.#deps.writeCursor({ lastEntryId: transcript.lastEntryId })
+    if (ctx.hasUI && result.output.applied.length > 0) {
+      ctx.ui.notify(`${CAPTURE_SAVED} ${result.output.applied.length} change(s).`, "info")
+    }
+  }
+}
+
+function notifyFailure(ctx: MemoryPiContext, reason: string, problems: string[]): void {
+  if (!ctx.hasUI || reason === "not-configured" || reason === "interrupted") return
+  ctx.ui.notify(`${CAPTURE_FAILED} ${problems.join("; ")}`, "warning")
+}

package/src/pi/capture/schemas.ts

@@ -0,0 +1,8 @@
+import Type from "typebox"
+
+export const AddedDetailsSchema = Type.Object({
+  vault: Type.Enum(["global", "project"]),
+  path: Type.String({ minLength: 1 }),
+})
+
+export const CursorSchema = Type.Object({ lastEntryId: Type.String({ minLength: 1 }) })

package/src/pi/capture/tool-calls.ts

@@ -0,0 +1,6 @@
+import type { TurnEndEvent } from "@earendil-works/pi-coding-agent"
+
+export function toolCallCount(message: TurnEndEvent["message"]): number {
+  if (message.role !== "assistant") return 0
+  return message.content.filter((block) => block.type === "toolCall").length
+}

package/src/pi/capture/transcript.ts

@@ -0,0 +1,55 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent"
+import { Value } from "typebox/value"
+
+import { MEMORY_ADD_TOOL_NAME } from "#src/pi/memory-add"
+import type { ExplicitSave, TranscriptMessage } from "#src/usecases"
+import { CURSOR_TYPE } from "./constants.ts"
+import { AddedDetailsSchema, CursorSchema } from "./schemas.ts"
+import type { ReviewableTranscript, TextPart } from "./types.ts"
+
+export function reviewableSince(entries: SessionEntry[]): ReviewableTranscript {
+  const messages: TranscriptMessage[] = []
+  const explicitSaves: ExplicitSave[] = []
+  for (const entry of afterCursor(entries)) {
+    if (entry.type !== "message") continue
+    const { message } = entry
+    if (message.role === "user") addText(messages, "user", message.content)
+    else if (message.role === "assistant") addText(messages, "assistant", message.content)
+    else if (message.role === "toolResult" && message.toolName === MEMORY_ADD_TOOL_NAME) {
+      if (Value.Check(AddedDetailsSchema, message.details)) explicitSaves.push(message.details)
+    }
+  }
+  const last = entries.at(-1)
+  let lastEntryId: string | null = null
+  if (last) lastEntryId = last.id
+  return { messages, explicitSaves, lastEntryId }
+}
+
+function afterCursor(entries: SessionEntry[]): SessionEntry[] {
+  const cursor = entries.findLast((entry) => entry.type === "custom" && entry.customType === CURSOR_TYPE)
+  if (cursor?.type !== "custom") return entries
+  const { data } = cursor
+  if (!Value.Check(CursorSchema, data)) return entries
+  const index = entries.findIndex((entry) => entry.id === data.lastEntryId)
+  if (index === -1) return entries
+  return entries.slice(index + 1)
+}
+
+function addText(
+  messages: TranscriptMessage[],
+  role: "user" | "assistant",
+  content: string | readonly TextPart[],
+): void {
+  const text = textOf(content)
+  if (text.trim() !== "") messages.push({ role, text })
+}
+
+function textOf(content: string | readonly TextPart[]): string {
+  if (typeof content === "string") return content
+  return content
+    .flatMap((part) => {
+      if (part.type === "text" && typeof part.text === "string") return [part.text]
+      return []
+    })
+    .join("\n")
+}

package/src/pi/capture/types.ts

@@ -0,0 +1,46 @@
+import type { MessageEndEvent, SessionBeforeCompactEvent, TurnEndEvent } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import type { CompletionPort, ExplicitSave, TranscriptMessage } from "#src/usecases"
+import type { CursorSchema } from "./schemas.ts"
+
+export type CursorData = Static<typeof CursorSchema>
+
+export interface ReviewableTranscript {
+  messages: TranscriptMessage[]
+  explicitSaves: ExplicitSave[]
+  lastEntryId: string | null
+}
+
+export type CompletionFactory = (ctx: MemoryPiContext) => CompletionPort
+
+export type CursorWriter = (data: CursorData) => void
+
+export interface CaptureDeps {
+  paths: MemoryPaths
+  sessions: MemorySessionKeeper
+  completionOf: CompletionFactory
+  writeCursor: CursorWriter
+}
+
+export type CaptureKind = "review" | "flush"
+
+export interface PendingCapture {
+  ctx: MemoryPiContext
+  kind: CaptureKind
+}
+
+export interface TextPart {
+  type: string
+  text?: string
+}
+
+export type MessageEndHandler = (event: MessageEndEvent, ctx: MemoryPiContext) => Promise<void>
+
+export type TurnEndHandler = (event: TurnEndEvent, ctx: MemoryPiContext) => Promise<void>
+
+export type CompactTrigger = Pick<SessionBeforeCompactEvent, "type" | "reason">
+
+export type BeforeCompactHandler = (event: CompactTrigger, ctx: MemoryPiContext) => Promise<void>

package/src/pi/change-report/constants.ts

@@ -0,0 +1,15 @@
+export const NOT_READ_GUIDANCE = "was not read with memory_get in this session. Read it, then call again."
+
+export const CONFLICT_GUIDANCE =
+  "changed on disk since it was read; the user's edit was kept. Read it again with memory_get."
+
+export const STALE_SESSION_GUIDANCE =
+  "Not changed: the memory configuration changed during this session. Read the note again with memory_get, then call again."
+
+export const PARTIAL_GUIDANCE = "Do not call again; ask the user to check the vault."
+
+export const INVALID_HEADING = "Not changed. Fix and call again:"
+
+export const NOT_CHANGED_PREFIX = "Not changed:"
+
+export const MAINTENANCE_WARNING_PREFIX = "Maintenance warning:"

package/src/pi/change-report/index.ts

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