pi-obsidian-memory 0.0.0 → 0.1.0

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

@@ -0,0 +1,27 @@
+import { archiveStoredFile, displayNotePath, today } from "#src/services"
+import { changeLeasedMemory, reportPartial, warningsOf } from "#src/usecases/memory-change"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import type { ArchiveMemoryRequest, ArchiveMemoryResult } from "./types.ts"
+
+export async function archiveMemory(
+  request: ArchiveMemoryRequest,
+  context: MemoryOperationContext,
+): Promise<ArchiveMemoryResult> {
+  const address = { vault: request.vault, path: request.path }
+  return changeLeasedMemory(address, context, async ({ target, receipted }) => {
+    const { note, folder, read } = receipted
+    const archived = await archiveStoredFile(target.vault, {
+      path: read.path,
+      note: { folder, note },
+      hashWhenRead: read.rawHash,
+      today: today(),
+    })
+    if (!archived.succeeded) return reportPartial(archived)
+    const { folder: archiveFolder, note: archivedNote } = archived.output
+    const archivedPath = displayNotePath(archiveFolder, archivedNote.statement)
+    return {
+      succeeded: true,
+      output: { vault: request.vault, path: request.path, archivedPath, maintenanceProblems: warningsOf(archived) },
+    }
+  })
+}

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

@@ -0,0 +1,3 @@
+export * from "./archive-memory.ts"
+export * from "./schemas.ts"
+export * from "./types.ts"

package/src/usecases/archive-memory/schemas.ts

@@ -0,0 +1,11 @@
+import Type from "typebox"
+
+import { MemoryScopeSchema } from "#src/services"
+
+export const ArchiveMemoryRequestSchema = Type.Object(
+  {
+    vault: MemoryScopeSchema,
+    path: Type.String(),
+  },
+  { additionalProperties: false },
+)

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

@@ -0,0 +1,17 @@
+import type { Static } from "typebox"
+
+import type { LifecycleRefusal, MemoryScope } from "#src/services"
+import type { Succeeded } from "#src/shared"
+import type { ChangeRefusal, PartialMemoryChange } from "#src/usecases/memory-change"
+import type { ArchiveMemoryRequestSchema } from "./schemas.ts"
+
+export type ArchiveMemoryRequest = Static<typeof ArchiveMemoryRequestSchema>
+
+export interface ArchivedMemory {
+  vault: MemoryScope
+  path: string
+  archivedPath: string
+  maintenanceProblems: string[]
+}
+
+export type ArchiveMemoryResult = Succeeded<ArchivedMemory> | LifecycleRefusal | PartialMemoryChange | ChangeRefusal

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

@@ -0,0 +1,73 @@
+import type { CaptureDraft } from "#src/services"
+import { addMemory } from "#src/usecases/add-memory"
+import { archiveMemory } from "#src/usecases/archive-memory"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import { succeedMemory } from "#src/usecases/succeed-memory"
+import { updateMemory } from "#src/usecases/update-memory"
+import { CHANGED_SINCE_READ, DIFFERENT_NOTE, NO_DETAIL } from "./constants.ts"
+import type { AppliedWrite, ChangeAction, FinishedWrite, WriteAction } from "./types.ts"
+
+export async function applyWrite(action: WriteAction, context: MemoryOperationContext): Promise<AppliedWrite> {
+  const { vault } = action
+  if (action.action === "add") return applyAdd(vault, action.note, context)
+  const mismatch = readMismatch(action, context)
+  if (mismatch) return outcome(action.action, vault, action.path, "conflict", mismatch)
+  if (action.action === "archive") {
+    return finished("archive", vault, action.path, await archiveMemory({ vault, path: action.path }, context))
+  }
+  const { note } = action
+  if (action.action === "update") {
+    const request = { vault, path: action.path, body: note.body, type: note.type, dontForget: note.dontForget }
+    return finished("update", vault, action.path, await updateMemory(request, context))
+  }
+  const draft = { statement: note.statement, type: note.type, body: note.body, dontForget: note.dontForget }
+  const succession = await succeedMemory({ vault, path: action.path, folder: note.folder, draft }, context)
+  return finished("succeed", vault, action.path, succession)
+}
+
+async function applyAdd(
+  vault: AppliedWrite["vault"],
+  note: CaptureDraft,
+  context: MemoryOperationContext,
+): Promise<AppliedWrite> {
+  const draft = { statement: note.statement, type: note.type, body: note.body, dontForget: note.dontForget }
+  const result = await addMemory({ scope: vault, folder: note.folder, draft }, context)
+  if (result.succeeded) return outcome("add", vault, result.output.notePath, "applied", "Saved")
+  return outcome("add", vault, `${note.folder}/${note.statement}.md`, "refused", problemsOf(result.problems))
+}
+
+function finished(
+  operation: AppliedWrite["operation"],
+  vault: AppliedWrite["vault"],
+  path: string,
+  result: FinishedWrite,
+): AppliedWrite {
+  if (result.succeeded) return outcome(operation, vault, path, "applied", "Applied")
+  const detail = problemsOf(result.problems)
+  if (result.reason === "conflict") return outcome(operation, vault, path, "conflict", detail)
+  return outcome(operation, vault, path, "refused", detail)
+}
+
+function outcome(
+  operation: AppliedWrite["operation"],
+  vault: AppliedWrite["vault"],
+  path: string,
+  status: AppliedWrite["status"],
+  detail: string,
+): AppliedWrite {
+  return { operation, status, vault, path, detail }
+}
+
+function problemsOf(problems: string[]): string {
+  const joined = problems.join("; ")
+  if (joined === "") return NO_DETAIL
+  return joined
+}
+
+function readMismatch(action: ChangeAction, context: MemoryOperationContext): string | null {
+  const read = context.session.getReceipt(context.stamp, { vault: action.vault, path: action.path })
+  if (!read) return null
+  if (read.rawHash !== action.expectedHash) return CHANGED_SINCE_READ
+  if (read.id !== action.id) return DIFFERENT_NOTE
+  return null
+}

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)
+}