pi-obsidian-memory 0.0.0 → 0.1.0

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"

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

@@ -0,0 +1,54 @@
+import { SETUP_GUIDANCE } from "#src/pi/memory-add"
+import {
+  CONFLICT_GUIDANCE,
+  INVALID_HEADING,
+  MAINTENANCE_WARNING_PREFIX,
+  NOT_CHANGED_PREFIX,
+  NOT_READ_GUIDANCE,
+  PARTIAL_GUIDANCE,
+  STALE_SESSION_GUIDANCE,
+} from "./constants.ts"
+import type { ChangeFailure, ChangeResponse } from "./types.ts"
+
+export function reportSuccess(line: string, maintenanceProblems: string[]): ChangeResponse {
+  const warnings = maintenanceProblems.map((problem) => `${MAINTENANCE_WARNING_PREFIX} ${problem}`)
+  return reply([line, ...warnings].join("\n"), false)
+}
+
+export function reportFailure(failure: ChangeFailure, path: string): ChangeResponse {
+  return reply(describeFailure(failure, path), true)
+}
+
+function describeFailure(failure: ChangeFailure, path: string): string {
+  switch (failure.reason) {
+    case "not-read":
+      return `${NOT_CHANGED_PREFIX} ${path} ${NOT_READ_GUIDANCE}`
+    case "conflict":
+      return `${NOT_CHANGED_PREFIX} ${path} ${CONFLICT_GUIDANCE}`
+    case "stale-session":
+      return STALE_SESSION_GUIDANCE
+    case "partial":
+      return [
+        `Partly done: ${failure.problems.join("; ")}.`,
+        `Published: ${failure.published.join(", ")}.`,
+        `Original: ${failure.originalState}.`,
+        PARTIAL_GUIDANCE,
+      ].join(" ")
+    case "invalid":
+      return [INVALID_HEADING, ...failure.problems.map((problem) => `- ${problem}`)].join("\n")
+    case "exists":
+    case "needs-fixing":
+    case "archived":
+    case "stale-vault":
+      return [NOT_CHANGED_PREFIX, ...failure.problems].join(" ")
+    case "not-configured":
+    case "invalid-config":
+      return [...failure.problems, SETUP_GUIDANCE].join("\n")
+    default:
+      return failure.problems.join("\n")
+  }
+}
+
+function reply(text: string, isError: boolean): ChangeResponse {
+  return { content: [{ type: "text", text }], details: undefined, isError }
+}

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

@@ -0,0 +1,8 @@
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent"
+
+import type { Done } from "#src/shared"
+import type { ArchiveMemoryResult, SucceedMemoryResult, UpdateMemoryResult } from "#src/usecases"
+
+export type ChangeResponse = AgentToolResult<undefined>
+
+export type ChangeFailure = Exclude<UpdateMemoryResult | ArchiveMemoryResult | SucceedMemoryResult, Done>

package/src/pi/context/constants.ts

@@ -0,0 +1,5 @@
+export const STATUS_LOADING = { key: "obsidian-memory-loading", text: "memory: loading" }
+
+export const STATUS_SEARCHING = { key: "obsidian-memory-searching", text: "memory: searching" }
+
+export const STATUS_CAPTURING = { key: "obsidian-memory-capturing", text: "memory: capturing" }

package/src/pi/context/index.ts

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

package/src/pi/context/status.ts

@@ -0,0 +1,15 @@
+import type { MemoryPiContext, MemoryStatus, StatusWork } from "./types.ts"
+
+export async function withMemoryStatus<Result>(
+  ctx: MemoryPiContext,
+  status: MemoryStatus,
+  work: StatusWork<Result>,
+): Promise<Result> {
+  if (!ctx.hasUI) return work()
+  ctx.ui.setStatus(status.key, status.text)
+  try {
+    return await work()
+  } finally {
+    ctx.ui.setStatus(status.key, undefined)
+  }
+}

package/src/pi/context/types.ts

@@ -0,0 +1,98 @@
+import type { ModelRegistry, SessionEntry } from "@earendil-works/pi-coding-agent"
+
+export type NotifyLevel = "info" | "warning" | "error"
+
+export interface DialogOptions {
+  timeout?: number
+  signal?: AbortSignal
+}
+
+export interface MemoryUi {
+  select(title: string, options: string[]): Promise<string | undefined>
+  confirm(title: string, message: string): Promise<boolean>
+  input(title: string, placeholder?: string, options?: DialogOptions): Promise<string | undefined>
+  notify(message: string, type?: NotifyLevel): void
+  setStatus(key: string, text: string | undefined): void
+}
+
+export type StatusWork<Result> = () => Promise<Result>
+
+export interface MemoryStatus {
+  key: string
+  text: string
+}
+
+export interface ModelPrice {
+  input: number
+  output: number
+}
+
+export interface ChatModelSource {
+  provider: string
+  id: string
+  cost?: ModelPrice
+}
+
+export interface RegisteredModel extends ChatModelSource {
+  maxTokens: number
+}
+
+export type RegistryContext = Parameters<ModelRegistry["complete"]>[1]
+
+export type RegistryOptions = Parameters<ModelRegistry["complete"]>[2]
+
+export type RegistryMessage = Awaited<ReturnType<ModelRegistry["complete"]>>
+
+export type ClassifierModelRef = Parameters<ModelRegistry["classify"]>[0]
+
+export type ClassifierPrompt = Parameters<ModelRegistry["classify"]>[1]
+
+export type ClassifierOptions = Parameters<ModelRegistry["classify"]>[2]
+
+export type ClassifierOutcome = Awaited<ReturnType<ModelRegistry["classify"]>>
+
+export interface ModelAuthResolved {
+  ok: true
+}
+
+export interface ModelAuthRefused {
+  ok: false
+  error: string
+}
+
+export type ModelAuthResult = ModelAuthResolved | ModelAuthRefused
+
+export interface AvailableModels {
+  getAvailable(): ChatModelSource[]
+  find(provider: string, modelId: string): RegisteredModel | undefined
+  hasConfiguredAuth(model: ChatModelSource): boolean
+  getApiKeyAndHeaders(model: ChatModelSource): Promise<ModelAuthResult>
+  getApiKeyForProvider(provider: string): Promise<string | undefined>
+  findOfType(type: "classifier", provider: string, modelId: string): ClassifierModelRef | undefined
+  classify(model: ClassifierModelRef, prompt: ClassifierPrompt, options: ClassifierOptions): Promise<ClassifierOutcome>
+  complete(model: ChatModelSource, context: RegistryContext, options: RegistryOptions): Promise<RegistryMessage>
+}
+
+export interface SessionIdSource {
+  getSessionId(): string
+  getBranch(): SessionEntry[]
+}
+
+export interface MemoryPiContext {
+  cwd: string
+  hasUI: boolean
+  ui: MemoryUi
+  model: ChatModelSource | undefined
+  modelRegistry: AvailableModels
+  sessionManager: SessionIdSource
+}
+
+export interface MemoryPaths {
+  configPath: string
+  indexPath: string
+}
+
+export interface MemoryCommand {
+  description: string
+  handler(args: string, ctx: MemoryPiContext): Promise<void>
+}

package/src/pi/extension.ts

@@ -0,0 +1,100 @@
+import { homedir } from "node:os"
+
+import { type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent"
+
+import {
+  beforeCompactHandler,
+  CaptureCadence,
+  CaptureRuntime,
+  type CompletionFactory,
+  flushOnShutdownHandler,
+  messageEndHandler,
+  registryCompletion,
+  turnEndHandler,
+} from "#src/pi/capture"
+import type { MemoryPaths } from "#src/pi/context"
+import { memoryAddTool } from "#src/pi/memory-add"
+import { memoryArchiveTool } from "#src/pi/memory-archive"
+import { MemoryBlock } from "#src/pi/memory-block"
+import { MEMORY_DOCTOR_COMMAND, memoryDoctorCommand } from "#src/pi/memory-doctor"
+import { MEMORY_EXPORT_COMMAND, memoryExportCommand } from "#src/pi/memory-export"
+import { memoryGetTool } from "#src/pi/memory-get"
+import { MEMORY_INIT_COMMAND, memoryInitCommand } from "#src/pi/memory-init"
+import { memorySearchTool } from "#src/pi/memory-search"
+import { MemorySessionKeeper } from "#src/pi/memory-session"
+import { MEMORY_SETUP_COMMAND, memorySetupCommand } from "#src/pi/memory-setup"
+import { memorySucceedTool } from "#src/pi/memory-succeed"
+import { memoryUpdateTool } from "#src/pi/memory-update"
+import { memoryConfigPath, memoryIndexPath, memoryModelCachePath } from "#src/pi/paths"
+import { RelevantMemoryRuntime } from "#src/pi/relevant-memory"
+import { SemanticRuntime } from "#src/pi/semantic"
+import { sessionStartHandler } from "#src/pi/session-start"
+import { shellEditGuardHandler } from "#src/pi/shell-edit-guard"
+import { vaultGuardHandler } from "#src/pi/vault-guard"
+import { loadDontForget } from "#src/usecases"
+import { registrarFor } from "./registrar.ts"
+import type { ExtensionOverrides, ExtensionRegistrar } from "./types.ts"
+
+export default function extension(pi: ExtensionAPI): void {
+  registerExtension(registrarFor(pi), getAgentDir())
+}
+
+export function registerExtension(
+  registrar: ExtensionRegistrar,
+  agentDir: string,
+  overrides?: ExtensionOverrides,
+): void {
+  const paths = { configPath: memoryConfigPath(agentDir), indexPath: memoryIndexPath(agentDir) }
+  const semantic = new SemanticRuntime(memoryModelCachePath(agentDir), overrides?.localModel)
+  const sessions = new MemorySessionKeeper(semantic)
+  const block = new MemoryBlock(loadDontForget)
+  registerTools(registrar, paths, sessions)
+  registerCommands(registrar, paths, sessions, memoryModelCachePath(agentDir))
+  let completionOf: CompletionFactory = registryCompletion
+  if (overrides?.completionOf) completionOf = overrides.completionOf
+  const relevant = new RelevantMemoryRuntime({ paths, sessions, completionOf })
+  registrar.onSessionStart(sessionStartHandler(paths, sessions, block, relevant))
+  registrar.onBeforeAgentStart(block.beforeAgentStart())
+  registrar.onBeforeAgentStart(relevant.beforeAgentStart())
+  registrar.onToolCall(vaultGuardHandler(paths.configPath, homedir()))
+  registrar.onShellToolCall(shellEditGuardHandler())
+  const capture = new CaptureRuntime({
+    paths,
+    sessions,
+    completionOf,
+    writeCursor: (data) => registrar.appendCursor(data),
+  })
+  const cadence = new CaptureCadence(capture, { paths, sessions })
+  const flushOnShutdown = flushOnShutdownHandler(cadence, capture)
+  registrar.onMessageEnd(messageEndHandler(cadence))
+  registrar.onTurnEnd(turnEndHandler(cadence))
+  registrar.onBeforeCompact(beforeCompactHandler(cadence))
+  registrar.onSessionShutdown(async (event, ctx) => {
+    await flushOnShutdown(event, ctx)
+    sessions.shutdown()
+    await block.settled()
+    block.clear()
+    await semantic.shutdown()
+  })
+}
+
+function registerTools(registrar: ExtensionRegistrar, paths: MemoryPaths, sessions: MemorySessionKeeper): void {
+  registrar.registerAddTool(memoryAddTool(paths, sessions))
+  registrar.registerSearchTool(memorySearchTool(paths, sessions))
+  registrar.registerGetTool(memoryGetTool(paths, sessions))
+  registrar.registerUpdateTool(memoryUpdateTool(paths, sessions))
+  registrar.registerArchiveTool(memoryArchiveTool(paths, sessions))
+  registrar.registerSucceedTool(memorySucceedTool(paths, sessions))
+}
+
+function registerCommands(
+  registrar: ExtensionRegistrar,
+  paths: MemoryPaths,
+  sessions: MemorySessionKeeper,
+  modelCachePath: string,
+): void {
+  registrar.registerCommand(MEMORY_SETUP_COMMAND, memorySetupCommand(paths, sessions))
+  registrar.registerCommand(MEMORY_INIT_COMMAND, memoryInitCommand(paths, sessions))
+  registrar.registerCommand(MEMORY_EXPORT_COMMAND, memoryExportCommand(paths, sessions))
+  registrar.registerCommand(MEMORY_DOCTOR_COMMAND, memoryDoctorCommand(paths, sessions, modelCachePath))
+}

package/src/pi/index.ts

@@ -0,0 +1,26 @@
+export * from "./capture/index.ts"
+export * from "./change-report/index.ts"
+export * from "./context/index.ts"
+export * from "./extension.ts"
+export * from "./memory-add/index.ts"
+export * from "./memory-archive/index.ts"
+export * from "./memory-block/index.ts"
+export * from "./memory-doctor/index.ts"
+export * from "./memory-export/index.ts"
+export * from "./memory-get/index.ts"
+export * from "./memory-init/index.ts"
+export * from "./memory-search/index.ts"
+export * from "./memory-session/index.ts"
+export * from "./memory-settings/index.ts"
+export * from "./memory-setup/index.ts"
+export * from "./memory-succeed/index.ts"
+export * from "./memory-update/index.ts"
+export * from "./paths/index.ts"
+export * from "./registrar.ts"
+export * from "./registration-report/index.ts"
+export * from "./relevant-memory/index.ts"
+export * from "./semantic/index.ts"
+export * from "./session-start/index.ts"
+export * from "./shell-edit-guard/index.ts"
+export * from "./types.ts"
+export * from "./vault-guard/index.ts"