pi-obsidian-memory 0.0.0 → 0.1.0

package/src/domain/command-flags/constants.ts

@@ -0,0 +1,141 @@
+export const NODE_VALUE_FLAGS = [
+  "--allow-fs-read",
+  "--allow-fs-write",
+  "--build-snapshot-config",
+  "-C",
+  "--conditions",
+  "--cpu-prof-dir",
+  "--cpu-prof-interval",
+  "--cpu-prof-name",
+  "--diagnostic-dir",
+  "--disable-proto",
+  "--disable-warning",
+  "--dns-result-order",
+  "--env-file",
+  "--env-file-if-exists",
+  "--experimental-config-file",
+  "--experimental-default-type",
+  "--experimental-sea-config",
+  "--experimental-test-isolation",
+  "--heap-prof-dir",
+  "--heap-prof-interval",
+  "--heap-prof-name",
+  "--heapsnapshot-near-heap-limit",
+  "--heapsnapshot-signal",
+  "--icu-data-dir",
+  "--input-type",
+  "--inspect-publish-uid",
+  "--debug-port",
+  "--inspect-port",
+  "--localstorage-file",
+  "--max-http-header-size",
+  "--max-old-space-size-percentage",
+  "--network-family-autoselection-attempt-timeout",
+  "--openssl-config",
+  "--redirect-warnings",
+  "--report-directory",
+  "--report-dir",
+  "--report-filename",
+  "--report-signal",
+  "--secure-heap",
+  "--secure-heap-min",
+  "--snapshot-blob",
+  "--test-concurrency",
+  "--test-coverage-branches",
+  "--test-coverage-exclude",
+  "--test-coverage-functions",
+  "--test-coverage-include",
+  "--test-coverage-lines",
+  "--test-name-pattern",
+  "--test-reporter",
+  "--test-reporter-destination",
+  "--test-shard",
+  "--test-skip-pattern",
+  "--test-timeout",
+  "--title",
+  "--tls-cipher-list",
+  "--tls-keylog",
+  "--trace-event-categories",
+  "--trace-event-file-pattern",
+  "--trace-require-module",
+  "--unhandled-rejections",
+  "--use-largepages",
+  "--v8-pool-size",
+  "--watch-kill-signal",
+  "--watch-path",
+]
+
+export const TSX_VALUE_FLAGS = ["--tsconfig", ...NODE_VALUE_FLAGS]
+
+export const TS_NODE_VALUE_FLAGS = [
+  "--cwd",
+  "--dir",
+  "--compiler",
+  "-C",
+  "--compilerOptions",
+  "--compiler-options",
+  "-O",
+  "--project",
+  "-P",
+  "--ignoreDiagnostics",
+  "--ignore-diagnostics",
+  "-D",
+  "--ignore",
+  "-I",
+  "--transpiler",
+  "--scopeDir",
+  "--scope-dir",
+  "--experimentalSpecifierResolution",
+  "--experimental-specifier-resolution",
+]
+
+export const PYTHON_VALUE_FLAGS = ["-W", "-X", "--check-hash-based-pycs"]
+
+export const SHELL_VALUE_FLAGS = ["-o", "+o", "-O", "+O", "--init-file", "--rcfile"]
+
+export const BUN_VALUE_FLAGS = [
+  "--filter",
+  "-F",
+  "--shell",
+  "--unhandled-rejections",
+  "--watch-kill-signal",
+  "--install",
+  "--conditions",
+  "--main-fields",
+  "--extension-order",
+  "--tsconfig-override",
+  "--define",
+  "-d",
+  "--drop",
+  "--loader",
+  "-l",
+  "--jsx-factory",
+  "--jsx-fragment",
+  "--jsx-import-source",
+  "--jsx-runtime",
+  "--port",
+  "--fetch-preconnect",
+  "--max-http-header-size",
+  "--dns-result-order",
+  "--user-agent",
+  "--env-file",
+  "--cwd",
+  "--config",
+  "-c",
+  "--title",
+  "--console-depth",
+  "--elide-lines",
+]
+
+export const BUN_FOLDER_FLAGS = ["--cwd"]
+
+export const INTERPRETER_VALUE_FLAGS = new Map([
+  ["node", NODE_VALUE_FLAGS],
+  ["tsx", TSX_VALUE_FLAGS],
+  ["ts-node", TS_NODE_VALUE_FLAGS],
+  ["python", PYTHON_VALUE_FLAGS],
+  ["python3", PYTHON_VALUE_FLAGS],
+  ["py", PYTHON_VALUE_FLAGS],
+  ["bash", SHELL_VALUE_FLAGS],
+  ["sh", SHELL_VALUE_FLAGS],
+])

package/src/domain/command-flags/index.ts

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

package/src/domain/config/change.ts

@@ -0,0 +1,105 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { COUNT_REASON, COUNT_TEXT, THRESHOLD_REASON, THRESHOLD_TEXT } from "./constants.ts"
+import { parseConfig } from "./parse.ts"
+import { repairDecision } from "./resources.ts"
+import type {
+  ConfigCandidate,
+  DecisionChange,
+  MemoryConfig,
+  NextConfig,
+  ParseConfigResult,
+  ProjectReplacement,
+  SettingChange,
+  SettingNumberKind,
+  SettingNumberResult,
+  ThresholdChange,
+} from "./types.ts"
+
+export function changeSetting(config: MemoryConfig, change: SettingChange, platform: PathPlatform): ParseConfigResult {
+  const next = nextConfig(config, change)
+  if (!next.succeeded) return next
+  return parseConfig(JSON.stringify(next.output), platform)
+}
+
+export function parseSettingNumber(text: string, kind: SettingNumberKind): SettingNumberResult {
+  const trimmed = text.trim()
+  if (kind === "threshold") return parseThreshold(trimmed)
+  return parseCount(trimmed)
+}
+
+function parseThreshold(text: string): SettingNumberResult {
+  const value = Number(text)
+  if (!THRESHOLD_TEXT.test(text) || value > 1) return { succeeded: false, problems: [THRESHOLD_REASON] }
+  return { succeeded: true, output: value }
+}
+
+function parseCount(text: string): SettingNumberResult {
+  const value = Number(text)
+  if (!COUNT_TEXT.test(text) || !Number.isSafeInteger(value) || value < 1) {
+    return { succeeded: false, problems: [COUNT_REASON] }
+  }
+  return { succeeded: true, output: value }
+}
+
+function nextConfig(config: MemoryConfig, change: SettingChange): NextConfig {
+  switch (change.kind) {
+    case "captureModel":
+      return done({ ...config, capture: { ...config.capture, model: change.model } })
+    case "agentModel":
+      return done({ ...config, memoryAgent: { model: change.model } })
+    case "captureCount":
+    case "captureSwitch":
+      return done({ ...config, capture: { ...config.capture, [change.name]: change.value } })
+    case "embeddings":
+      return done({ ...config, embeddings: change.embeddings })
+    case "budgetChars":
+      return done({ ...config, context: { budgetChars: change.value } })
+    case "limit":
+      return done({ ...config, limits: { ...config.limits, [change.name]: change.value } })
+    case "decision":
+      return done(withDecision(config, change))
+    case "gateThreshold":
+    case "relevanceThreshold":
+      return done(withThreshold(config, change))
+    case "projectVault":
+      return withProjects(config, change.name, (project) => ({ ...project, vault: change.vault }))
+    case "removeProject":
+      return withProjects(config, change.name, () => null)
+  }
+}
+
+function done(output: ConfigCandidate): NextConfig {
+  return { succeeded: true, output }
+}
+
+function withDecision(config: MemoryConfig, change: DecisionChange): ConfigCandidate {
+  const current = config.decisionModel
+  if (change.provider === "typesafe") {
+    if (current.provider === "typesafe") return config
+    return { ...config, decisionModel: { provider: "typesafe", model: "jev-latest" } }
+  }
+  if (current.provider === "laya") return { ...config, decisionModel: { ...current, endpoint: change.endpoint } }
+  return { ...config, decisionModel: repairDecision({ provider: "laya", endpoint: change.endpoint }) }
+}
+
+function withThreshold(config: MemoryConfig, change: ThresholdChange): ConfigCandidate {
+  let threshold: number | undefined
+  if (typeof change.value === "number") threshold = change.value
+  return { ...config, decisionModel: { ...config.decisionModel, [change.kind]: threshold } }
+}
+
+function withProjects(config: MemoryConfig, name: string, replace: ProjectReplacement): NextConfig {
+  if (!config.projects.some((project) => project.name === name)) {
+    return { succeeded: false, problems: [`No project named "${name}"`] }
+  }
+  const projects: MemoryConfig["projects"] = []
+  for (const project of config.projects) {
+    if (project.name !== name) {
+      projects.push(project)
+      continue
+    }
+    const replacement = replace(project)
+    if (replacement) projects.push(replacement)
+  }
+  return done({ ...config, projects })
+}

package/src/domain/config/constants.ts

@@ -0,0 +1,25 @@
+import type { CaptureCadenceSettings } from "#src/domain/capture"
+import type { LegacyCaptureWhen } from "./types.ts"
+
+export const THRESHOLD_TEXT = /^\d+(\.\d+)?$/
+
+export const COUNT_TEXT = /^\d+$/
+
+export const THRESHOLD_REASON = "must be a number from 0 to 1, for example 0.5"
+
+export const COUNT_REASON = "must be a whole number of 1 or more"
+
+export const DEFAULT_CAPTURE_CADENCE: CaptureCadenceSettings = {
+  nudgeInterval: 10,
+  nudgeToolCalls: 15,
+  flushMinTurns: 6,
+  reviewEnabled: true,
+  flushOnCompact: true,
+  flushOnShutdown: true,
+}
+
+export const LEGACY_CAPTURE_CADENCE: Record<LegacyCaptureWhen, CaptureCadenceSettings> = {
+  "after-each-turn": DEFAULT_CAPTURE_CADENCE,
+  "at-session-end": { ...DEFAULT_CAPTURE_CADENCE, reviewEnabled: false, flushOnCompact: false },
+  "on-compaction": { ...DEFAULT_CAPTURE_CADENCE, reviewEnabled: false, flushOnShutdown: false },
+}

package/src/domain/config/diagnostics.ts

@@ -0,0 +1,35 @@
+import type { TValidationError } from "typebox/error"
+
+import { describeSchemaErrors } from "#src/domain/validation"
+import type { ConfigObjectRule } from "./types.ts"
+
+export function configValueProblems(path: string, errors: readonly TValidationError[]): string[] {
+  const choices: string[] = []
+  for (const error of errors) {
+    if (error.keyword === "const" && typeof error.params.allowedValue === "string") {
+      choices.push(error.params.allowedValue)
+    }
+  }
+  if (choices.length > 0) return [`${configFieldName(path, "")}: must be one of ${choices.join(", ")}`]
+  return describeSchemaErrors(errors, "config").map(
+    (error) => `${configFieldName(path, "")}: ${error.slice(error.indexOf(":") + 2)}`,
+  )
+}
+
+export function configObjectProblems(rule: ConfigObjectRule, keys: string[]): string[] {
+  const problems: string[] = []
+  for (const key of keys) {
+    if (!rule.keys.includes(key)) problems.push(`${configFieldName(rule.path, key)}: not a known field`)
+  }
+  for (const key of rule.required) {
+    if (!keys.includes(key)) problems.push(`${configFieldName(rule.path, "")}: must have required properties ${key}`)
+  }
+  return problems
+}
+
+export function configFieldName(path: string, key: string): string {
+  const parts = path.split("/").filter(Boolean)
+  if (key.length > 0) parts.push(key)
+  if (parts.length === 0) return "config"
+  return parts.join(".")
+}

package/src/domain/config/disclosures.ts

@@ -0,0 +1,8 @@
+import type { MemoryConfig, SetupDisclosure } from "./types.ts"
+
+export function setupDisclosures(config: MemoryConfig): SetupDisclosure[] {
+  const disclosures: SetupDisclosure[] = ["chat-models"]
+  if (config.decisionModel.provider === "typesafe") disclosures.push("jev")
+  if (config.embeddings.provider !== "local") disclosures.push("remote-embeddings")
+  return disclosures
+}

package/src/domain/config/fields.ts

@@ -0,0 +1,7 @@
+import { readConfigInspection } from "./inspection.ts"
+import { observedConfigFields } from "./observations.ts"
+import type { ConfigFields } from "./types.ts"
+
+export function readConfigFields(text: string): ConfigFields {
+  return observedConfigFields(readConfigInspection(text))
+}

package/src/domain/config/index.ts

@@ -0,0 +1,11 @@
+export * from "./change.ts"
+export * from "./disclosures.ts"
+export * from "./fields.ts"
+export * from "./invariants.ts"
+export * from "./parse.ts"
+export * from "./paths.ts"
+export * from "./registration.ts"
+export * from "./repair.ts"
+export * from "./schemas.ts"
+export * from "./settings.ts"
+export * from "./types.ts"

package/src/domain/config/inspection.ts

@@ -0,0 +1,43 @@
+import { Value } from "typebox/value"
+
+import { configFieldName, configObjectProblems, configValueProblems } from "./diagnostics.ts"
+import { upgradeLegacyCapture } from "./legacy-capture.ts"
+import { configObservationRules, configRuleSelection } from "./observations.ts"
+import { configRules } from "./rules.ts"
+import { ConfigFieldObservationSchema, ConfigObjectSchema, MemoryConfigSchema } from "./schemas.ts"
+import type { ConfigDocumentInspection, ConfigFieldObservation, ConfigInspection } from "./types.ts"
+
+export function inspectConfig(text: string): ConfigInspection {
+  try {
+    return { validJson: true, ...readConfigInspection(text) }
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error
+    return { validJson: false, message: error.message }
+  }
+}
+
+export function readConfigInspection(text: string): ConfigDocumentInspection {
+  const document = JSON.parse(upgradeLegacyCapture(text))
+  const projects = Value.Pointer.Get(document, "/projects")
+  let projectCount = 0
+  if (Array.isArray(projects)) projectCount = projects.length
+  const observations: ConfigFieldObservation[] = []
+  for (const rule of configObservationRules(projectCount)) {
+    const observation = { field: rule.field, index: rule.index, value: Value.Pointer.Get(document, rule.path) }
+    if (Value.Check(ConfigFieldObservationSchema, observation)) observations.push(observation)
+  }
+  const problems = configRules(configRuleSelection(projectCount, observations)).flatMap((rule) => {
+    const value = Value.Pointer.Get(document, rule.path)
+    if (rule.path.length > 0 && !Value.Pointer.Has(document, rule.path)) return []
+    if (rule.kind === "value") return configValueProblems(rule.path, Value.Errors(rule.schema, value))
+    if (Value.Check(ConfigObjectSchema, value)) return configObjectProblems(rule, Object.keys(value))
+    return [`${configFieldName(rule.path, "")}: must be object`]
+  })
+  if (Value.Pointer.Has(document, "/projects") && !Array.isArray(projects)) problems.push("projects: must be array")
+  const max = Value.Pointer.Get(document, "/decisionModel/maxTokens")
+  const head = Value.Pointer.Get(document, "/decisionModel/headMaxTokens")
+  const invalidTokenOrder = typeof max === "number" && typeof head === "number" && head >= max
+  const inspection = { observations, projectCount, shapeProblems: problems, invalidTokenOrder }
+  if (Value.Check(MemoryConfigSchema, document)) return { ...inspection, config: { succeeded: true, output: document } }
+  return { ...inspection, config: { succeeded: false } }
+}

package/src/domain/config/invariants.ts

@@ -0,0 +1,68 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { comparablePath, isInside, pathsOverlap } from "./paths.ts"
+import type { ConfigInfrastructure, ConfigLocationPaths, ConfigRegistrations, VaultRegistration } from "./types.ts"
+
+export function registrationProblems(config: ConfigRegistrations, platform: PathPlatform): string[] {
+  const problems: string[] = []
+  const names = new Map<string, string>()
+  const folders = new Map<string, string>()
+  for (const [index, project] of config.projects.entries()) {
+    if (typeof project.name === "string") {
+      reportDuplicate(names, project.name.toLowerCase(), `projects.${index}.name`, problems)
+    }
+    if (typeof project.folder === "string") {
+      reportDuplicate(folders, comparablePath(project.folder, platform), `projects.${index}.folder`, problems)
+    }
+  }
+  const vaults = registeredVaults(config)
+  for (const [index, vault] of vaults.entries()) {
+    for (const other of vaults.slice(index + 1)) {
+      if (pathsOverlap(vault.path, other.path, platform)) {
+        problems.push(`${vault.field} and ${other.field}: vaults must not be equal or nested`)
+      }
+    }
+  }
+  return problems
+}
+
+export function registeredVaults(config: ConfigRegistrations): VaultRegistration[] {
+  const vaults: VaultRegistration[] = []
+  if (typeof config.global.vault === "string") {
+    vaults.push({ field: "global.vault", path: config.global.vault })
+  }
+  for (const [index, project] of config.projects.entries()) {
+    if (typeof project.vault === "string") {
+      vaults.push({ field: `projects.${index}.vault`, path: project.vault })
+    }
+  }
+  return vaults
+}
+
+export function configLocationProblems(request: ConfigLocationPaths, platform: PathPlatform): string[] {
+  const problems: string[] = []
+  for (const vault of registeredVaults(request.config)) {
+    if (isInside(request.configPath, vault.path, platform)) {
+      problems.push(`configPath and ${vault.field}: config must remain outside vaults`)
+    }
+  }
+  return problems
+}
+
+export function infrastructureProblems(request: ConfigInfrastructure, platform: PathPlatform): string[] {
+  const problems = configLocationProblems(request, platform)
+  for (const vault of registeredVaults(request.config)) {
+    if (pathsOverlap(request.indexPath, vault.path, platform)) {
+      problems.push(`indexPath and ${vault.field}: index and vaults must not overlap`)
+    }
+  }
+  return problems
+}
+
+function reportDuplicate(seen: Map<string, string>, value: string, field: string, problems: string[]): void {
+  const previous = seen.get(value)
+  if (typeof previous === "string") {
+    problems.push(`${previous} and ${field}: duplicate registration`)
+  } else {
+    seen.set(value, field)
+  }
+}

package/src/domain/config/legacy-capture.ts

@@ -0,0 +1,17 @@
+import { Value } from "typebox/value"
+
+import { LEGACY_CAPTURE_CADENCE } from "./constants.ts"
+import { LegacyCaptureSchema } from "./schemas.ts"
+
+export function upgradeLegacyCapture(text: string): string {
+  let document: object | null = null
+  try {
+    document = JSON.parse(text)
+  } catch (error) {
+    if (error instanceof SyntaxError) return text
+    throw error
+  }
+  if (!Value.Check(LegacyCaptureSchema, document)) return text
+  const { when, ...kept } = document.capture
+  return JSON.stringify({ ...document, capture: { ...LEGACY_CAPTURE_CADENCE[when], ...kept } })
+}

package/src/domain/config/observations.ts

@@ -0,0 +1,109 @@
+import { isLoopbackEndpoint } from "#src/domain/decision-model"
+import { ConfigFieldObservationSchema } from "./schemas.ts"
+import type {
+  ConfigDocumentInspection,
+  ConfigFieldObservation,
+  ConfigFields,
+  ConfigObservationRule,
+  ConfigRuleSelection,
+  DecisionFields,
+  EmbeddingFields,
+} from "./types.ts"
+
+export function configObservationRules(projectCount: number): ConfigObservationRule[] {
+  const rules: ConfigObservationRule[] = []
+  for (const schema of ConfigFieldObservationSchema.anyOf) {
+    const field = schema.properties.field.const
+    if (field.startsWith("/projects/")) {
+      for (let index = 0; index < projectCount; index++) {
+        rules.push({ field, index, path: field.replace("/projects/", `/projects/${index}/`) })
+      }
+    } else rules.push({ field, index: 0, path: field })
+  }
+  return rules
+}
+
+export function configRuleSelection(projectCount: number, observations: ConfigFieldObservation[]): ConfigRuleSelection {
+  const selection: ConfigRuleSelection = { projectCount, embeddings: null, decisionModel: null }
+  for (const observation of observations) {
+    if (observation.field === "/embeddings/provider") selection.embeddings = observation.value
+    if (observation.field === "/decisionModel/provider") selection.decisionModel = observation.value
+  }
+  return selection
+}
+
+export function observedConfigFields(inspection: ConfigDocumentInspection): ConfigFields {
+  const fields: ConfigFields = {
+    global: {},
+    projects: Array.from({ length: inspection.projectCount }, () => ({})),
+    limits: {},
+    context: {},
+    capture: { model: {} },
+    memoryAgent: { model: {} },
+    embeddings: observedEmbeddingFields(inspection.observations),
+    decisionModel: observedDecisionFields(inspection.observations),
+  }
+  for (const observation of inspection.observations) {
+    retainRegistrationField(fields, observation)
+    retainSettingField(fields, observation)
+  }
+  return fields
+}
+
+function retainRegistrationField(fields: ConfigFields, observation: ConfigFieldObservation): void {
+  if (observation.field === "/global/vault") fields.global.vault = observation.value
+  const project = fields.projects[observation.index]
+  if (!project) return
+  if (observation.field === "/projects/name") project.name = observation.value
+  if (observation.field === "/projects/folder") project.folder = observation.value
+  if (observation.field === "/projects/vault") project.vault = observation.value
+}
+
+function retainSettingField(fields: ConfigFields, observation: ConfigFieldObservation): void {
+  if (observation.field === "/limits/maxBodyChars") fields.limits.maxBodyChars = observation.value
+  if (observation.field === "/limits/maxStatementChars") fields.limits.maxStatementChars = observation.value
+  if (observation.field === "/limits/maxNotesPerFolder") fields.limits.maxNotesPerFolder = observation.value
+  if (observation.field === "/context/budgetChars") fields.context.budgetChars = observation.value
+  if (observation.field === "/capture/nudgeInterval") fields.capture.nudgeInterval = observation.value
+  if (observation.field === "/capture/nudgeToolCalls") fields.capture.nudgeToolCalls = observation.value
+  if (observation.field === "/capture/flushMinTurns") fields.capture.flushMinTurns = observation.value
+  if (observation.field === "/capture/reviewEnabled") fields.capture.reviewEnabled = observation.value
+  if (observation.field === "/capture/flushOnCompact") fields.capture.flushOnCompact = observation.value
+  if (observation.field === "/capture/flushOnShutdown") fields.capture.flushOnShutdown = observation.value
+  if (observation.field === "/capture/model/provider") fields.capture.model.provider = observation.value
+  if (observation.field === "/capture/model/id") fields.capture.model.id = observation.value
+  if (observation.field === "/memoryAgent/model/provider") fields.memoryAgent.model.provider = observation.value
+  if (observation.field === "/memoryAgent/model/id") fields.memoryAgent.model.id = observation.value
+}
+
+export function observedEmbeddingFields(observations: ConfigFieldObservation[]): EmbeddingFields {
+  const fields: EmbeddingFields = {}
+  for (const observation of observations) {
+    if (observation.field === "/embeddings/provider") fields.provider = observation.value
+    if (observation.field === "/embeddings/model") fields.model = observation.value
+  }
+  return fields
+}
+
+function retainThreshold(fields: DecisionFields, observation: ConfigFieldObservation): void {
+  if (observation.field === "/decisionModel/gateThreshold") fields.gateThreshold = observation.value
+  if (observation.field === "/decisionModel/relevanceThreshold") fields.relevanceThreshold = observation.value
+}
+
+export function observedDecisionFields(observations: ConfigFieldObservation[]): DecisionFields {
+  const fields: DecisionFields = {}
+  for (const observation of observations) {
+    if (observation.field === "/decisionModel/provider") fields.provider = observation.value
+    if (observation.field === "/decisionModel/model") fields.model = observation.value
+    retainThreshold(fields, observation)
+  }
+  if (fields.provider === "typesafe") return fields
+  for (const observation of observations) {
+    if (observation.field === "/decisionModel/endpoint" && isLoopbackEndpoint(observation.value)) {
+      fields.endpoint = observation.value
+    }
+    if (observation.field === "/decisionModel/maxTokens") fields.maxTokens = observation.value
+    if (observation.field === "/decisionModel/headMaxTokens") fields.headMaxTokens = observation.value
+  }
+  return fields
+}

package/src/domain/config/parse.ts

@@ -0,0 +1,25 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { inspectConfig } from "./inspection.ts"
+import { registrationProblems } from "./invariants.ts"
+import { observedConfigFields } from "./observations.ts"
+import { inspectedResourceProblems } from "./resources.ts"
+import type { ConfigInspection, ParseConfigResult } from "./types.ts"
+
+export function parseConfig(text: string, platform: PathPlatform): ParseConfigResult {
+  return parseConfigInspection(inspectConfig(text), platform)
+}
+
+export function parseConfigInspection(inspection: ConfigInspection, platform: PathPlatform): ParseConfigResult {
+  if (!inspection.validJson) {
+    return { succeeded: false, problems: [`config: not valid JSON (${inspection.message})`] }
+  }
+  const problems = [
+    ...inspectedResourceProblems(inspection),
+    ...registrationProblems(observedConfigFields(inspection), platform),
+  ]
+  if (!inspection.config.succeeded) {
+    return { succeeded: false, problems: [...new Set([...inspection.shapeProblems, ...problems])] }
+  }
+  if (problems.length > 0) return { succeeded: false, problems }
+  return inspection.config
+}

package/src/domain/config/paths.ts

@@ -0,0 +1,61 @@
+import { posix, win32 } from "node:path"
+
+import type { PathPlatform } from "#src/domain/path-platform"
+import type { MemoryConfig, ProjectEntry, ResolveProjectResult } from "./types.ts"
+
+export function resolveProject(config: MemoryConfig, folder: string, platform: PathPlatform): ResolveProjectResult {
+  const current = comparablePath(folder, platform)
+  const matching = config.projects.filter((project) =>
+    isInside(current, comparablePath(project.folder, platform), platform),
+  )
+  const mostSpecific = matching.sort((first, second) => byDeepestFolder(first, second, platform))[0]
+
+  if (mostSpecific) {
+    return { succeeded: true, output: mostSpecific }
+  }
+
+  return { succeeded: false }
+}
+
+export function vaultNameOf(vaultPath: string, platform: PathPlatform): string {
+  const path = normalizedPath(vaultPath, platform).replace(/\/+$/, "")
+  return path.slice(path.lastIndexOf("/") + 1)
+}
+
+export function isInside(folder: string, parent: string, platform: PathPlatform): boolean {
+  const current = comparablePath(folder, platform)
+  const root = comparablePath(parent, platform)
+  if (root.endsWith("/")) {
+    return current.startsWith(root)
+  }
+
+  return current === root || current.startsWith(`${root}/`)
+}
+
+export function pathsOverlap(first: string, second: string, platform: PathPlatform): boolean {
+  return isInside(first, second, platform) || isInside(second, first, platform)
+}
+
+function byDeepestFolder(first: ProjectEntry, second: ProjectEntry, platform: PathPlatform): number {
+  return comparablePath(second.folder, platform).length - comparablePath(first.folder, platform).length
+}
+
+export function comparablePath(path: string, platform: PathPlatform): string {
+  const normalized = normalizedPath(path, platform)
+  if (platform === "linux") return normalized
+  return normalized.toLowerCase()
+}
+
+function normalizedPath(path: string, platform: PathPlatform): string {
+  let separated = path
+  if (platform === "win32") separated = path.replaceAll("\\", "/")
+  let normalized = posix.normalize(separated)
+  if (platform === "win32" && /^[A-Za-z]:|^\/\//.test(separated)) {
+    normalized = win32.normalize(separated).replaceAll("\\", "/")
+  }
+  if (normalized === "/" || /^[A-Za-z]:\/$/.test(normalized)) {
+    return normalized
+  }
+
+  return normalized.replace(/\/+$/, "")
+}