pi-obsidian-memory 0.0.1 → 0.1.1

package/src/usecases/capture-memory/capture-memory.ts

@@ -0,0 +1,117 @@
+import {
+  type CaptureAction,
+  type CaptureObservation,
+  type CompletionPort,
+  captureStep,
+  type ReadObservation,
+  refusalObservation,
+  type TranscriptMessage,
+} from "#src/services"
+import { type MemoryOperationContext, memoryOperationInterruption } from "#src/usecases/operation-context"
+import { resolveMemory } from "#src/usecases/resolve-memory"
+import { applyWrite } from "./apply.ts"
+import { INTERRUPTED } from "./constants.ts"
+import { observeGet, observeList, observeRead, observeSearch } from "./observe.ts"
+import type {
+  CaptureBase,
+  CaptureFailure,
+  CaptureMemoryResult,
+  CaptureReport,
+  CaptureRun,
+  NextStep,
+  ReviewTools,
+  WriteAction,
+} from "./types.ts"
+
+export async function captureMemory(
+  run: CaptureRun,
+  context: MemoryOperationContext,
+  complete: CompletionPort,
+): Promise<CaptureMemoryResult> {
+  const resolved = await resolveMemory(context)
+  if (!resolved.succeeded) {
+    if (memoryOperationInterruption(context)) {
+      return {
+        succeeded: false,
+        reason: "interrupted",
+        problems: [INTERRUPTED],
+        report: { reviewed: false, applied: [] },
+      }
+    }
+    return resolved
+  }
+  const { config, project } = resolved.output
+  const explicitSaves: ReadObservation[] = []
+  for (const save of run.explicitSaves) {
+    const read = await observeRead(save, context)
+    if (typeof read !== "string") explicitSaves.push(read)
+  }
+  let projectName: string | null = null
+  if (project) projectName = project.vault.name
+  const base: CaptureBase = {
+    context: { project: projectName, folder: context.workingFolder },
+    explicitSaves,
+    limits: { maxBodyChars: config.limits.maxBodyChars, maxStatementChars: config.limits.maxStatementChars },
+    model: config.capture.model,
+    signal: context.signal,
+  }
+  const report: CaptureReport = { reviewed: false, applied: [] }
+  const tools: ReviewTools = { context, complete, report }
+  if (run.messages.length > 0) {
+    report.reviewed = true
+    const failure = await reviewTranscript(run.messages, base, tools)
+    if (failure) return failure
+  }
+  return { succeeded: true, output: report }
+}
+
+async function reviewTranscript(
+  transcriptDelta: TranscriptMessage[],
+  base: CaptureBase,
+  tools: ReviewTools,
+): Promise<CaptureFailure | null> {
+  const observations: CaptureObservation[] = []
+  for (;;) {
+    if (memoryOperationInterruption(tools.context)) return failureOf("interrupted", [INTERRUPTED], tools)
+    const step = await captureStep({ ...base, transcriptDelta, observations }, tools.complete)
+    if (!step.succeeded && "modelCall" in step) {
+      if (memoryOperationInterruption(tools.context)) return failureOf("interrupted", [INTERRUPTED], tools)
+      return failureOf("model-failed", step.problems, tools)
+    }
+    if (!step.succeeded) {
+      observations.push(refusalObservation(step.problems))
+      continue
+    }
+    if ((await act(step.output, observations, tools)) === "stop") return endOfReview(tools)
+  }
+}
+
+function endOfReview(tools: ReviewTools): CaptureFailure | null {
+  if (memoryOperationInterruption(tools.context)) return failureOf("interrupted", [INTERRUPTED], tools)
+  return null
+}
+
+async function act(action: CaptureAction, observations: CaptureObservation[], tools: ReviewTools): Promise<NextStep> {
+  const { context } = tools
+  if (action.action === "finish") return "stop"
+  if (action.action === "search") {
+    observations.push(await observeSearch(action.vault, action.query, context))
+  } else if (action.action === "get") {
+    observations.push(await observeGet({ vault: action.vault, path: action.path }, context))
+  } else if (action.action === "list") {
+    observations.push(await observeList(action.vault, action.folder, context))
+  } else {
+    await write(action, observations, tools)
+  }
+  return "continue"
+}
+
+async function write(action: WriteAction, observations: CaptureObservation[], tools: ReviewTools): Promise<void> {
+  const applied = await applyWrite(action, tools.context)
+  tools.report.applied.push(applied)
+  observations.push({ kind: "write", ...applied })
+}
+
+function failureOf(reason: CaptureFailure["reason"], problems: string[], tools: ReviewTools): CaptureFailure {
+  return { succeeded: false, reason, problems, report: tools.report }
+}

package/src/usecases/capture-memory/constants.ts

@@ -0,0 +1,15 @@
+export const NO_DETAIL = "No further detail"
+
+export const SOURCE_CALL = "capture"
+
+export const DONT_FORGET_MARK = "don't forget"
+
+export const SUBFOLDER_LINE = /^- \[\[(.+)\/index\|[^\]]*\]\]$/
+
+export const NOTE_LINE = /^- \[\[([^|\]]+)\|([^\]]+)\]\] · ([a-z]+)(?: · (.*))?$/
+
+export const CHANGED_SINCE_READ = "The note changed since it was read; read it again before changing it"
+
+export const DIFFERENT_NOTE = "The note is not the one that was read (its id differs); read it again"
+
+export const INTERRUPTED = "Capture was interrupted before it finished"

package/src/usecases/capture-memory/index.ts

@@ -0,0 +1,5 @@
+export * from "./apply.ts"
+export * from "./capture-memory.ts"
+export * from "./observe.ts"
+export * from "./settings.ts"
+export * from "./types.ts"

package/src/usecases/capture-memory/observe.ts

@@ -0,0 +1,122 @@
+import type { MemoryObservation, ReadObservation } from "#src/services"
+import type { Failed } from "#src/shared"
+import { BLANK_NOTE_TYPES } from "#src/usecases/complete-blank-memory"
+import { getMemory } from "#src/usecases/get-memory"
+import { listMemory } from "#src/usecases/list-memory"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import { searchMemory } from "#src/usecases/search-memory"
+import { DONT_FORGET_MARK, NO_DETAIL, NOTE_LINE, SOURCE_CALL, SUBFOLDER_LINE } from "./constants.ts"
+import type { ExplicitSave, ListedNote, UnreadableNote } from "./types.ts"
+
+export async function observeRead(
+  save: ExplicitSave,
+  context: MemoryOperationContext,
+): Promise<ReadObservation | string> {
+  const read = await observeLoadedNote(save, context)
+  if (read.kind === "unreadable") return read.detail
+  return read
+}
+
+export async function observeLoadedNote(
+  save: ExplicitSave,
+  context: MemoryOperationContext,
+): Promise<ReadObservation | UnreadableNote> {
+  const result = await getMemory({ vault: save.vault, path: save.path, sourceCallId: SOURCE_CALL }, context)
+  if (!result.succeeded) {
+    return { kind: "unreadable", existence: existenceAfterFailure(result), detail: detailOf(result.problems) }
+  }
+  if (result.output.kind !== "note") {
+    return { kind: "unreadable", existence: "present", detail: `${save.path} is a folder, not a note` }
+  }
+  const { file } = result.output
+  const { frontmatter, parsed } = file.analysis
+  if (!frontmatter) {
+    return {
+      kind: "unreadable",
+      existence: "present",
+      detail: `${save.path} has invalid frontmatter and cannot be changed`,
+    }
+  }
+  if (parsed.body.length === 0) return { kind: "unreadable", existence: "present", detail: `${save.path} has no body` }
+  return {
+    kind: "read",
+    vault: save.vault,
+    path: save.path,
+    id: frontmatter.id,
+    hash: file.rawHash,
+    statement: parsed.statement,
+    body: parsed.body,
+    type: frontmatter.type,
+    dontForget: "dontForget" in frontmatter,
+  }
+}
+
+function existenceAfterFailure(failure: Failed): UnreadableNote["existence"] {
+  if (!("reason" in failure)) return "unknown"
+  if (failure.reason === "not-found" || failure.reason === "not-directory") return "gone"
+  if (failure.reason === "unclosed-frontmatter") return "present"
+  return "unknown"
+}
+
+export async function observeGet(save: ExplicitSave, context: MemoryOperationContext): Promise<MemoryObservation> {
+  const read = await observeRead(save, context)
+  if (typeof read === "string") return { kind: "unavailable", operation: "get", detail: read }
+  return read
+}
+
+export async function observeSearch(
+  vault: ExplicitSave["vault"],
+  query: string,
+  context: MemoryOperationContext,
+): Promise<MemoryObservation> {
+  const result = await searchMemory({ query, vault }, context)
+  if (!result.succeeded) return { kind: "unavailable", operation: "search", detail: detailOf(result.problems) }
+  const found = result.output.vaults.find((entry) => entry.vault === vault)
+  if (!found || !("hits" in found)) {
+    return { kind: "unavailable", operation: "search", detail: "That vault is not available" }
+  }
+  const candidates = found.hits.map((hit) => ({
+    vault,
+    path: hit.path,
+    id: hit.id,
+    statement: hit.statement,
+    snippet: hit.statement,
+  }))
+  return { kind: "search", query, candidates }
+}
+
+export async function observeList(
+  vault: ExplicitSave["vault"],
+  folder: string,
+  context: MemoryOperationContext,
+): Promise<MemoryObservation> {
+  const result = await listMemory({ vault, folder }, context)
+  if (!result.succeeded) return { kind: "unavailable", operation: "list", detail: detailOf(result.problems) }
+  const lines = result.output.text.split("\n")
+  const folders = lines.flatMap(subfolderOf)
+  const notes = lines.flatMap((line) => noteOf(vault, line))
+  return { kind: "listing", vault, folder, folders, notes }
+}
+
+function subfolderOf(line: string): string[] {
+  const match = SUBFOLDER_LINE.exec(line)
+  if (!match?.[1]) return []
+  return [match[1]]
+}
+
+function noteOf(vault: ExplicitSave["vault"], line: string): ListedNote[] {
+  const match = NOTE_LINE.exec(line)
+  if (!match) return []
+  const [, target, statement, name, rest] = match
+  const type = BLANK_NOTE_TYPES.find((candidate) => candidate === name)
+  if (!target || !statement || !type) return []
+  const listed: ListedNote = { vault, path: `${target}.md`, type, statement }
+  if (typeof rest === "string" && rest.toLowerCase().includes(DONT_FORGET_MARK)) listed.dontForget = true
+  return [listed]
+}
+
+export function detailOf(problems: string[]): string {
+  const joined = problems.join("; ")
+  if (joined === "") return NO_DETAIL
+  return joined
+}

package/src/usecases/capture-memory/settings.ts

@@ -0,0 +1,20 @@
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import { resolveMemory } from "#src/usecases/resolve-memory"
+import type { CaptureSettingsResult } from "./types.ts"
+
+export async function captureSettings(context: MemoryOperationContext): Promise<CaptureSettingsResult> {
+  const resolved = await resolveMemory(context)
+  if (!resolved.succeeded) return resolved
+  const { capture } = resolved.output.config
+  return {
+    succeeded: true,
+    output: {
+      nudgeInterval: capture.nudgeInterval,
+      nudgeToolCalls: capture.nudgeToolCalls,
+      flushMinTurns: capture.flushMinTurns,
+      reviewEnabled: capture.reviewEnabled,
+      flushOnCompact: capture.flushOnCompact,
+      flushOnShutdown: capture.flushOnShutdown,
+    },
+  }
+}

package/src/usecases/capture-memory/types.ts

@@ -0,0 +1,103 @@
+import type {
+  CaptureAction,
+  CaptureCadenceSettings,
+  CaptureInput,
+  CaptureObservation,
+  ChatModelReference,
+  CompletionPort,
+  MemoryScope,
+  ReadObservation,
+  TranscriptMessage,
+} from "#src/services"
+import type { Failed, Succeeded } from "#src/shared"
+import type { ArchiveMemoryResult } from "#src/usecases/archive-memory"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import type { MemoryResolutionRefusal } from "#src/usecases/resolve-memory"
+import type { SucceedMemoryResult } from "#src/usecases/succeed-memory"
+import type { UpdateMemoryResult } from "#src/usecases/update-memory"
+
+export type {
+  CaptureCadenceSettings,
+  CaptureTally,
+  CompletionPort,
+  CompletionRequest,
+  FinishedTurn,
+  FlushMoment,
+  TranscriptMessage,
+  TurnOutcome,
+} from "#src/services"
+export { EMPTY_TALLY, shouldFlush, tallyTurn, tallyUserMessage } from "#src/services"
+
+export interface ExplicitSave {
+  vault: MemoryScope
+  path: string
+}
+
+export type CaptureSettingsResult = Succeeded<CaptureCadenceSettings> | MemoryResolutionRefusal
+
+export interface UnreadableNote {
+  kind: "unreadable"
+  existence: "gone" | "present" | "unknown"
+  detail: string
+}
+
+export interface CaptureRun {
+  messages: TranscriptMessage[]
+  explicitSaves: ExplicitSave[]
+}
+
+export interface AppliedWrite {
+  operation: "add" | "update" | "archive" | "succeed"
+  status: "applied" | "conflict" | "refused"
+  vault: MemoryScope
+  path: string
+  detail: string
+}
+
+export interface CaptureReport {
+  reviewed: boolean
+  applied: AppliedWrite[]
+}
+
+export interface CaptureFailure extends Failed {
+  reason: "model-failed" | "interrupted"
+  report: CaptureReport
+}
+
+export type CaptureMemoryResult = Succeeded<CaptureReport> | MemoryResolutionRefusal | CaptureFailure
+
+export interface NonWriteActions {
+  action: "search" | "get" | "list" | "finish"
+}
+
+export type WriteAction = Exclude<CaptureAction, NonWriteActions>
+
+export type FinishedWrite = UpdateMemoryResult | ArchiveMemoryResult | SucceedMemoryResult
+
+export interface CaptureBase {
+  context: CaptureInput["context"]
+  explicitSaves: ReadObservation[]
+  limits: CaptureInput["limits"]
+  model: ChatModelReference
+  signal: AbortSignal
+}
+
+export interface ReviewTools {
+  context: MemoryOperationContext
+  complete: CompletionPort
+  report: CaptureReport
+}
+
+export type NextStep = "continue" | "stop"
+
+export interface ListingDiscriminant {
+  kind: "listing"
+}
+
+export type ListedNote = Extract<CaptureObservation, ListingDiscriminant>["notes"][number]
+
+export interface ChangeDiscriminant {
+  action: "update" | "archive" | "succeed"
+}
+
+export type ChangeAction = Extract<WriteAction, ChangeDiscriminant>

package/src/usecases/check-shell-edit/check-shell-edit.ts

@@ -0,0 +1,28 @@
+import {
+  askShellEdit,
+  defaultJevModel,
+  executedFiles,
+  firedQuestions,
+  readExecutedScripts,
+  SHELL_EDIT_CUTOFFS,
+  shellEditRefusal,
+  shellEditUncheckable,
+} from "#src/services"
+import type { CheckShellEditResult, ShellEditCommand, ShellEditDeps } from "./types.ts"
+
+export async function checkShellEdit(input: ShellEditCommand, deps: ShellEditDeps): Promise<CheckShellEditResult> {
+  const read = await readExecutedScripts(input.cwd, executedFiles(input.command))
+  if (!read.succeeded) return refused(shellEditUncheckable(read.problems.join("; ")))
+  const jev = await deps.jev(defaultJevModel)
+  if (!jev.available) return refused(shellEditUncheckable(jev.reason))
+  const state = { command: input.command, cwd: input.cwd, scripts: read.output.scripts, missing: read.output.missing }
+  const asked = await askShellEdit({ classifier: jev.classifier, state, signal: deps.signal })
+  if (!asked.succeeded) return refused(shellEditUncheckable(asked.problems.join("; ")))
+  const [first, ...rest] = firedQuestions(asked.output.scores, SHELL_EDIT_CUTOFFS)
+  if (first) return refused(shellEditRefusal([first, ...rest]))
+  return { succeeded: true }
+}
+
+function refused(problem: string): CheckShellEditResult {
+  return { succeeded: false, problems: [problem] }
+}

package/src/usecases/check-shell-edit/index.ts

@@ -0,0 +1,2 @@
+export * from "./check-shell-edit.ts"
+export * from "./types.ts"

package/src/usecases/check-shell-edit/types.ts

@@ -0,0 +1,30 @@
+export type { ShellEditPrompt, ShellEditQuestion } from "#src/services"
+
+import type { ShellEditClassifierPort } from "#src/services"
+import type { Done, Failed } from "#src/shared"
+
+export interface ShellEditCommand {
+  command: string
+  cwd: string
+}
+
+export interface ShellEditJevAvailable {
+  available: true
+  classifier: ShellEditClassifierPort
+}
+
+export interface ShellEditJevMissing {
+  available: false
+  reason: string
+}
+
+export type ShellEditJev = ShellEditJevAvailable | ShellEditJevMissing
+
+export type ShellEditJevSource = (modelId: string) => Promise<ShellEditJev>
+
+export interface ShellEditDeps {
+  jev: ShellEditJevSource
+  signal: AbortSignal
+}
+
+export type CheckShellEditResult = Done | Failed

package/src/usecases/check-vault-access/check-vault-access.ts

@@ -0,0 +1,23 @@
+import { readConfig, VAULT_ACCESS_REFUSAL } from "#src/services"
+import { isRawDevicePath } from "./raw-device.ts"
+import { guardedTargets, hitsTargets } from "./targets.ts"
+import type { CheckVaultAccessInput, CheckVaultAccessResult } from "./types.ts"
+
+export async function checkVaultAccess(input: CheckVaultAccessInput): Promise<CheckVaultAccessResult> {
+  const { request, cwd, home, platform } = input
+  const config = await readConfig(input.configPath, platform)
+  if (!config.succeeded) return allowed()
+  const written = [config.output.global.vault, ...config.output.projects.map((project) => project.vault)]
+  if (request.kind !== "command" && isRawDevicePath(request.path, cwd, platform)) return refusal()
+  const targets = await guardedTargets(written)
+  if (await hitsTargets({ request, cwd, home, platform, targets })) return refusal()
+  return allowed()
+}
+
+function refusal(): CheckVaultAccessResult {
+  return { succeeded: false, reason: "vault-access", problems: [VAULT_ACCESS_REFUSAL] }
+}
+
+function allowed(): CheckVaultAccessResult {
+  return { succeeded: true }
+}

package/src/usecases/check-vault-access/constants.ts

@@ -0,0 +1,7 @@
+export const NO_FILE_ID = "0"
+
+export const POSIX_PROCESS_RELATIVE_PATH = /^\/(?:proc\/(?:self\/fd|\d+\/root)|dev\/fd)(?:\/|$)/
+
+export const NAMESPACE_PATH_START = /^\\\\[?.]\\/
+
+export const NAMED_FILE_UNDER_ROOT = /^\\\\[?.]\\(?:[a-z]:|UNC|Volume\{[^}]+\})\\[^\\]/i

package/src/usecases/check-vault-access/index.ts

@@ -0,0 +1,4 @@
+export * from "./check-vault-access.ts"
+export * from "./raw-device.ts"
+export * from "./targets.ts"
+export * from "./types.ts"

package/src/usecases/check-vault-access/raw-device.ts

@@ -0,0 +1,10 @@
+import { posix, win32 } from "node:path"
+
+import { NAMED_FILE_UNDER_ROOT, NAMESPACE_PATH_START, POSIX_PROCESS_RELATIVE_PATH } from "./constants.ts"
+import type { PathPlatform } from "./types.ts"
+
+export function isRawDevicePath(path: string, cwd: string, platform: PathPlatform): boolean {
+  if (platform !== "win32") return POSIX_PROCESS_RELATIVE_PATH.test(posix.resolve(cwd, path))
+  const resolved = win32.resolve(cwd, path)
+  return NAMESPACE_PATH_START.test(resolved) && !NAMED_FILE_UNDER_ROOT.test(resolved)
+}

package/src/usecases/check-vault-access/targets.ts

@@ -0,0 +1,49 @@
+import {
+  absoluteCandidate,
+  canonicalizeAccessPath,
+  fileIdentity,
+  type PathIdentity,
+  pathIdentities,
+  vaultAccessRefusal,
+} from "#src/services"
+import { NAMESPACE_PATH_START, NO_FILE_ID } from "./constants.ts"
+import type { GuardedTargets, TargetCheck } from "./types.ts"
+
+export async function guardedTargets(written: string[]): Promise<GuardedTargets> {
+  const roots = [...written]
+  const identities: PathIdentity[] = []
+  for (const path of written) {
+    const canonical = await canonicalizeAccessPath(path)
+    if (canonical.succeeded) roots.push(canonical.output)
+    const identity = await fileIdentity(path)
+    if (identity.succeeded && hasFileId(identity.output)) identities.push(identity.output)
+  }
+  return { roots, identities }
+}
+
+export async function hitsTargets(check: TargetCheck): Promise<boolean> {
+  const { request, cwd, home, platform, targets } = check
+  if (vaultAccessRefusal(request, cwd, home, targets.roots, platform)) return true
+  if (request.kind === "command") return false
+  const absolute = absoluteCandidate(request.path, cwd, home, platform)
+  const canonical = await canonicalizeAccessPath(absolute)
+  if (
+    canonical.succeeded &&
+    vaultAccessRefusal({ kind: request.kind, path: canonical.output }, cwd, home, targets.roots, platform)
+  ) {
+    return true
+  }
+  return sharesIdentity(absolute, targets.identities)
+}
+
+async function sharesIdentity(absolute: string, identities: PathIdentity[]): Promise<boolean> {
+  const found = await pathIdentities(absolute)
+  if (!found.succeeded) return NAMESPACE_PATH_START.test(absolute)
+  return found.output
+    .filter(hasFileId)
+    .some((seen) => identities.some((target) => target.device === seen.device && target.inode === seen.inode))
+}
+
+function hasFileId(identity: PathIdentity): boolean {
+  return identity.inode !== NO_FILE_ID
+}

package/src/usecases/check-vault-access/types.ts

@@ -0,0 +1,33 @@
+export type { VaultAccessRequest } from "#src/services"
+
+import type { PathIdentity, PathPlatform, VaultAccessRequest } from "#src/services"
+import type { Done, Failed } from "#src/shared"
+
+export type { PathPlatform } from "#src/services"
+
+export interface CheckVaultAccessInput {
+  configPath: string
+  cwd: string
+  home: string
+  platform: PathPlatform
+  request: VaultAccessRequest
+}
+
+export interface VaultAccessRefusal extends Failed {
+  reason: "vault-access"
+}
+
+export type CheckVaultAccessResult = Done | VaultAccessRefusal
+
+export interface GuardedTargets {
+  roots: string[]
+  identities: PathIdentity[]
+}
+
+export interface TargetCheck {
+  request: VaultAccessRequest
+  cwd: string
+  home: string
+  platform: PathPlatform
+  targets: GuardedTargets
+}

package/src/usecases/complete-blank-memory/complete-blank-memory.ts

@@ -0,0 +1,48 @@
+import { completeBlankFile, type Note, newNoteId, refreshIndexes, today } from "#src/services"
+import { refreshWarnings, warningsOf } from "#src/usecases/memory-change"
+import {
+  captureMemoryOperationContext,
+  type MemoryOperationContext,
+  memoryAdmissionRefusal,
+} from "#src/usecases/operation-context"
+import { resolveLeasedMemory, selectMemoryVault } from "#src/usecases/resolve-memory/leased"
+import type { CompleteBlankMemoryRequest, CompleteBlankMemoryResult } from "./types.ts"
+
+export async function completeBlankMemory(
+  request: CompleteBlankMemoryRequest,
+  callerContext: MemoryOperationContext,
+): Promise<CompleteBlankMemoryResult> {
+  const context = captureMemoryOperationContext(callerContext)
+  const lease = await context.session.acquire(context.stamp, context.signal)
+  if (!lease) return memoryAdmissionRefusal(context)
+  try {
+    const memory = await resolveLeasedMemory(context)
+    if (!memory.succeeded) return memory
+    const target = selectMemoryVault(memory.output, request.vault)
+    if (!target.succeeded) return target
+    const day = today()
+    const note: Note = {
+      statement: statementOf(request.path),
+      frontmatter: { id: newNoteId(), type: request.type, created: day, updated: day },
+      body: request.body,
+    }
+    const completed = await completeBlankFile(target.output.vault, {
+      path: request.path,
+      expectedHash: request.expectedHash,
+      note,
+      confirmed: true,
+    })
+    if (!completed.succeeded) return completed
+    const folder = request.path.slice(0, Math.max(0, request.path.lastIndexOf("/")))
+    const refreshed = await refreshIndexes(target.output.vault, folder)
+    const maintenanceProblems = [...warningsOf(completed), ...refreshWarnings(refreshed)]
+    return { succeeded: true, output: { vault: request.vault, path: request.path, maintenanceProblems } }
+  } finally {
+    lease.release()
+  }
+}
+
+function statementOf(path: string): string {
+  const name = path.slice(path.lastIndexOf("/") + 1)
+  return name.slice(0, -".md".length)
+}

package/src/usecases/complete-blank-memory/constants.ts

@@ -0,0 +1,3 @@
+import { CompleteBlankMemoryRequestSchema } from "./schemas.ts"
+
+export const BLANK_NOTE_TYPES = CompleteBlankMemoryRequestSchema.properties.type.enum

package/src/usecases/complete-blank-memory/index.ts

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

package/src/usecases/complete-blank-memory/schemas.ts

@@ -0,0 +1,14 @@
+import Type from "typebox"
+
+import { MemoryDraftSchema, MemoryScopeSchema } from "#src/services"
+
+export const CompleteBlankMemoryRequestSchema = Type.Object(
+  {
+    vault: MemoryScopeSchema,
+    path: Type.String(),
+    expectedHash: Type.String(),
+    type: MemoryDraftSchema.properties.type,
+    body: MemoryDraftSchema.properties.body,
+  },
+  { additionalProperties: false },
+)