pi-obsidian-memory 0.0.1 → 0.1.1

package/src/services/config/canonicalize.ts

@@ -0,0 +1,163 @@
+import { lstat, realpath, stat } from "node:fs/promises"
+import { join, parse, resolve, sep } from "node:path"
+
+import {
+  configLocationProblems,
+  infrastructureProblems,
+  type MemoryConfig,
+  type ProjectEntry,
+  parseConfig,
+  registrationProblems,
+} from "#src/domain"
+import { isFullyQualifiedPath } from "./fully-qualified-path.ts"
+import type {
+  CanonicalConfigResult,
+  CanonicalPathResult,
+  ConfigRegistrationLocation,
+  ConfigRegistrationLocationResult,
+  RegistrationPaths,
+  RegistrationPathsResult,
+} from "./types.ts"
+import { isNamespaceVolumeRoot } from "./volume-namespace.ts"
+
+export async function canonicalizeRegistration(request: RegistrationPaths): Promise<RegistrationPathsResult> {
+  const location = await canonicalizeConfigLocation(request)
+  const index = await canonicalField(request.indexPath, "indexPath", "directory")
+  const problems: string[] = []
+  if (!location.succeeded) problems.push(...location.problems)
+  if (!index.succeeded) problems.push(...index.problems)
+  if (!location.succeeded || !index.succeeded) {
+    return { succeeded: false, problems }
+  }
+
+  const canonical = { ...location.output, indexPath: index.output }
+  problems.push(
+    ...infrastructureProblems(request, request.platform),
+    ...infrastructureProblems(canonical, request.platform),
+  )
+  if (problems.length > 0) {
+    return { succeeded: false, problems: [...new Set(problems)] }
+  }
+
+  return { succeeded: true, output: canonical }
+}
+
+export async function canonicalizeConfigLocation(
+  request: ConfigRegistrationLocation,
+): Promise<ConfigRegistrationLocationResult> {
+  const parsed = parseConfig(JSON.stringify(request.config), request.platform)
+  if (!parsed.succeeded) {
+    return parsed
+  }
+
+  const config = await canonicalConfig(parsed.output)
+  const path = await canonicalField(request.configPath, "configPath", "file")
+  const problems: string[] = []
+  if (!config.succeeded) problems.push(...config.problems)
+  if (!path.succeeded) problems.push(...path.problems)
+  if (!config.succeeded || !path.succeeded) {
+    return { succeeded: false, problems }
+  }
+
+  const canonical = { config: config.output, configPath: path.output, platform: request.platform }
+  problems.push(
+    ...registrationProblems(canonical.config, request.platform),
+    ...configLocationProblems(request, request.platform),
+    ...configLocationProblems(canonical, request.platform),
+  )
+  if (problems.length > 0) {
+    return { succeeded: false, problems: [...new Set(problems)] }
+  }
+
+  return { succeeded: true, output: canonical }
+}
+
+async function canonicalConfig(config: MemoryConfig): Promise<CanonicalConfigResult> {
+  const problems: string[] = []
+  const global = await canonicalField(config.global.vault, "global.vault", "directory")
+  if (!global.succeeded) problems.push(...global.problems)
+
+  const projects: ProjectEntry[] = []
+  for (const [index, project] of config.projects.entries()) {
+    const folder = await canonicalField(project.folder, `projects.${index}.folder`, "directory")
+    const vault = await canonicalField(project.vault, `projects.${index}.vault`, "directory")
+    if (!folder.succeeded) problems.push(...folder.problems)
+    if (!vault.succeeded) problems.push(...vault.problems)
+    if (folder.succeeded && vault.succeeded) {
+      projects.push({ ...project, folder: folder.output, vault: vault.output })
+    }
+  }
+  if (!global.succeeded || problems.length > 0) {
+    return { succeeded: false, problems }
+  }
+
+  return { succeeded: true, output: { ...config, global: { vault: global.output }, projects } }
+}
+
+export function canonicalizeWorkingFolder(path: string): Promise<CanonicalPathResult> {
+  return canonicalField(path, "workingFolder", "directory")
+}
+
+export function canonicalizeAccessPath(absolute: string): Promise<CanonicalPathResult> {
+  return canonicalField(absolute, "accessPath", "file")
+}
+
+async function canonicalField(path: string, field: string, kind: "file" | "directory"): Promise<CanonicalPathResult> {
+  try {
+    if (kind === "directory") {
+      return { succeeded: true, output: await canonicalDirectory(path) }
+    }
+
+    return { succeeded: true, output: await canonicalPath(path) }
+  } catch (error) {
+    return { succeeded: false, problems: [`${field}: ${String(error)}`] }
+  }
+}
+
+async function canonicalDirectory(path: string): Promise<string> {
+  const canonical = await canonicalPath(path)
+
+  try {
+    if (!(await stat(canonical)).isDirectory()) {
+      throw new Error(`${path}: expected a directory`)
+    }
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      throw error
+    }
+  }
+
+  return canonical
+}
+
+async function canonicalPath(path: string): Promise<string> {
+  if (!isFullyQualifiedPath(path)) {
+    throw new Error(`${path}: expected a fully qualified absolute path on this platform`)
+  }
+
+  const absolute = resolve(path)
+  const root = parse(absolute).root
+  if (isNamespaceVolumeRoot(root)) {
+    throw new Error(`${path}: volume GUID paths are not supported`)
+  }
+  const parts = absolute.slice(root.length).split(sep).filter(Boolean)
+  let current = await realpath(root)
+
+  for (const [index, part] of parts.entries()) {
+    if (!(await stat(current)).isDirectory()) {
+      throw new Error(`${current}: expected an existing ancestor directory`)
+    }
+    const candidate = join(current, part)
+    try {
+      await lstat(candidate)
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return join(current, ...parts.slice(index))
+      }
+      throw error
+    }
+    current = await realpath(candidate)
+  }
+
+  return current
+}

package/src/services/config/constants.ts

@@ -0,0 +1 @@
+export const NAMESPACE_VOLUME_ROOT = /^\\\\[?.]\\Volume\{[^}]+\}\\?$/i

package/src/services/config/fully-qualified-path.ts

@@ -0,0 +1,14 @@
+import { isAbsolute, parse, sep } from "node:path"
+
+export function isFullyQualifiedPath(path: string): boolean {
+  if (!isAbsolute(path)) {
+    return false
+  }
+
+  const root = parse(path).root.replaceAll("\\", "/")
+  if (sep === "\\" && !root.includes(":") && !root.startsWith("//")) {
+    return false
+  }
+
+  return true
+}

package/src/services/config/index.ts

@@ -0,0 +1,12 @@
+export * from "./canonicalize.ts"
+export * from "./fully-qualified-path.ts"
+export * from "./path-identity.ts"
+export * from "./read.ts"
+export * from "./registration.ts"
+export * from "./resolve-input.ts"
+export * from "./snapshot.ts"
+export * from "./target.ts"
+export * from "./types.ts"
+export * from "./vault-access.ts"
+export * from "./volume-namespace.ts"
+export * from "./write.ts"

package/src/services/config/path-identity.ts

@@ -0,0 +1,65 @@
+import { stat } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+
+import { isFullyQualifiedPath } from "./fully-qualified-path.ts"
+import type { FileIdentityResult, PathIdentitiesResult, PathIdentity } from "./types.ts"
+import { isNamespaceVolumeRoot } from "./volume-namespace.ts"
+
+export async function fileIdentity(path: string): Promise<FileIdentityResult> {
+  if (!isFullyQualifiedPath(path)) {
+    return { succeeded: false, problems: [`${path}: expected a fully qualified absolute path on this platform`] }
+  }
+
+  try {
+    return { succeeded: true, output: await identityOf(path) }
+  } catch (error) {
+    return { succeeded: false, problems: [`${path}: ${String(error)}`] }
+  }
+}
+
+export async function pathIdentities(absolute: string): Promise<PathIdentitiesResult> {
+  if (!isFullyQualifiedPath(absolute)) {
+    return { succeeded: false, problems: [`${absolute}: expected a fully qualified absolute path on this platform`] }
+  }
+
+  const identities: PathIdentity[] = []
+  try {
+    for (const path of chain(resolve(absolute))) {
+      if (await exists(path)) {
+        identities.push(await identityOf(path))
+      }
+    }
+  } catch (error) {
+    return { succeeded: false, problems: [`${absolute}: ${String(error)}`] }
+  }
+
+  if (identities.length === 0) {
+    return { succeeded: false, problems: [`${absolute}: no existing ancestor`] }
+  }
+  return { succeeded: true, output: identities }
+}
+
+function chain(path: string): string[] {
+  const paths = [path]
+  for (let parent = dirname(path); parent !== paths.at(-1); parent = dirname(parent)) {
+    paths.push(parent)
+  }
+  return paths.filter((path) => !isNamespaceVolumeRoot(path))
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return false
+    }
+    throw error
+  }
+}
+
+async function identityOf(path: string): Promise<PathIdentity> {
+  const stats = await stat(path, { bigint: true })
+  return { device: String(stats.dev), inode: String(stats.ino) }
+}

package/src/services/config/publication.ts

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto"
+import { link, open, rename, unlink } from "node:fs/promises"
+
+import { readConfigSnapshot } from "./snapshot.ts"
+import type {
+  CheckConfigSnapshotResult,
+  ConfigPublicationRequest,
+  WriteConfigRequest,
+  WriteConfigResult,
+} from "./types.ts"
+
+export async function checkConfigSnapshot(request: WriteConfigRequest): Promise<CheckConfigSnapshotResult> {
+  const snapshot = await readConfigSnapshot(request)
+  if (!snapshot.succeeded) {
+    return { ...snapshot, reason: "unavailable", warnings: [] }
+  }
+  if (snapshot.output.hash !== request.expectedHash) {
+    return { succeeded: false, reason: "conflict", problems: ["config changed since it was read"], warnings: [] }
+  }
+  if (
+    snapshot.output.state === "present" &&
+    snapshot.output.repair.replacementRequired &&
+    !request.replacementConfirmed
+  ) {
+    return {
+      succeeded: false,
+      reason: "replacement-required",
+      problems: ["invalid JSON requires explicit replacement confirmation"],
+      warnings: [],
+    }
+  }
+  return snapshot
+}
+
+export async function publishConfig(context: ConfigPublicationRequest): Promise<WriteConfigResult> {
+  const { request, temporaryPath, warnings } = context
+  const text = `${JSON.stringify(request.config, null, 2)}\n`
+  const handle = await open(temporaryPath, "wx")
+  try {
+    try {
+      await handle.writeFile(text, "utf8")
+      await handle.sync()
+    } finally {
+      await handle.close()
+    }
+    return await installConfig(context, text)
+  } finally {
+    await removeConfigArtifact(temporaryPath, warnings)
+  }
+}
+
+async function installConfig(context: ConfigPublicationRequest, text: string): Promise<WriteConfigResult> {
+  const { request, temporaryPath, warnings } = context
+  const snapshot = await checkConfigSnapshot(request)
+  if (!snapshot.succeeded) {
+    return { ...snapshot, warnings }
+  }
+  if (snapshot.output.state === "missing") {
+    await link(temporaryPath, request.path)
+  } else {
+    await rename(temporaryPath, request.path)
+  }
+  return { succeeded: true, output: { hash: createHash("sha256").update(text).digest("hex") }, warnings }
+}
+
+export async function removeConfigArtifact(path: string, warnings: string[]): Promise<void> {
+  try {
+    await unlink(path)
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return
+    }
+    warnings.push(`${path}: could not remove registration artifact (${String(error)})`)
+  }
+}

package/src/services/config/read.ts

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises"
+
+import type { PathPlatform } from "#src/domain"
+import { parseConfig } from "#src/domain"
+import { canonicalizeConfigLocation } from "./canonicalize.ts"
+import type { ReadConfigResult } from "./types.ts"
+
+export async function readConfig(path: string, platform: PathPlatform): Promise<ReadConfigResult> {
+  let text: string
+  try {
+    text = await readFile(path, "utf8")
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {
+        succeeded: false,
+        reason: "not-configured",
+        configPath: path,
+        problems: ["memory is not configured"],
+      }
+    }
+
+    let code = "UNKNOWN"
+    if (error instanceof Error && "code" in error && typeof error.code === "string") {
+      code = error.code
+    }
+
+    return {
+      succeeded: false,
+      reason: "unreadable",
+      configPath: path,
+      code,
+      problems: [`${path}: cannot read config (${code})`],
+    }
+  }
+
+  const parsed = parseConfig(text, platform)
+  if (!parsed.succeeded) {
+    return { succeeded: false, reason: "invalid-config", configPath: path, problems: parsed.problems }
+  }
+
+  const canonical = await canonicalizeConfigLocation({ config: parsed.output, configPath: path, platform })
+  if (!canonical.succeeded) {
+    return { succeeded: false, reason: "invalid-config", configPath: path, problems: canonical.problems }
+  }
+
+  return parsed
+}

package/src/services/config/registration.ts

@@ -0,0 +1,26 @@
+export type {
+  ChatModelReference,
+  ConfigFields,
+  ConfigRepairDraft,
+  InitProposal,
+  MemoryConfig,
+  ParseConfigResult,
+  ProjectEntry,
+  ResolveProjectResult,
+  SettingChange,
+  SettingNumberKind,
+  SettingNumberResult,
+  SetupDisclosure,
+  SetupProposal,
+} from "#src/domain"
+export {
+  changeSetting,
+  inspectConfigForRepair,
+  parseSettingNumber,
+  prepareSetupDefaults,
+  proposeInit,
+  proposeSetup,
+  resolveProject,
+  setupDisclosures,
+} from "#src/domain"
+export { checkConfigSnapshot } from "./publication.ts"

package/src/services/config/resolve-input.ts

@@ -0,0 +1,27 @@
+import { isAbsolute, parse, resolve, sep } from "node:path"
+
+import type { CanonicalPathResult, RegistrationVaultInput } from "./types.ts"
+
+export function resolveRegistrationVault(request: RegistrationVaultInput): CanonicalPathResult {
+  if (!fullyQualified(request.workingFolder)) {
+    return { succeeded: false, problems: ["workingFolder must be a fully qualified absolute path"] }
+  }
+  if (request.vault.trim() === "" || ambiguousWindowsPath(request.vault)) {
+    return { succeeded: false, problems: ["vault must be a nonblank unambiguous path"] }
+  }
+  if (isAbsolute(request.vault) && !fullyQualified(request.vault)) {
+    return { succeeded: false, problems: ["vault must include its absolute root"] }
+  }
+  return { succeeded: true, output: resolve(request.workingFolder, request.vault) }
+}
+
+function fullyQualified(path: string): boolean {
+  if (!isAbsolute(path) || ambiguousWindowsPath(path)) return false
+  const root = parse(path).root.replaceAll("\\", "/")
+  if (sep === "\\" && !root.includes(":") && !root.startsWith("//")) return false
+  return true
+}
+
+function ambiguousWindowsPath(path: string): boolean {
+  return /^[A-Za-z]:(?![/\\])/.test(path) || /^\\(?!\\)/.test(path)
+}

package/src/services/config/snapshot.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto"
+import { readFile } from "node:fs/promises"
+
+import { assessConfig } from "#src/domain"
+import type { ConfigLocation, ReadConfigSnapshotResult } from "./types.ts"
+
+export async function readConfigSnapshot(request: ConfigLocation): Promise<ReadConfigSnapshotResult> {
+  try {
+    const bytes = await readFile(request.path)
+    const text = bytes.toString("utf8")
+    return {
+      succeeded: true,
+      output: {
+        state: "present",
+        hash: createHash("sha256").update(bytes).digest("hex"),
+        text,
+        ...assessConfig(text, request.platform),
+      },
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { succeeded: true, output: { state: "missing", hash: null } }
+    }
+    return { succeeded: false, problems: [`${request.path}: ${String(error)}`] }
+  }
+}

package/src/services/config/target.ts

@@ -0,0 +1,2 @@
+export type { MemoryScope, NoProjectRefusal, TargetVaultResult, VaultTarget } from "#src/domain"
+export { MemoryScopeSchema, targetVault } from "#src/domain"

package/src/services/config/types.ts

@@ -0,0 +1,97 @@
+import type { ConfigRepairDraft, MemoryConfig, ParseConfigResult, PathPlatform } from "#src/domain"
+import type { Failed, Succeeded } from "#src/shared"
+
+export type ConfigFailureReason = "not-configured" | "invalid-config" | "unreadable"
+
+export interface ConfigRefusal extends Failed {
+  reason: ConfigFailureReason
+  configPath: string
+}
+
+export interface ConfigUnreadable extends ConfigRefusal {
+  reason: "unreadable"
+  code: string
+}
+
+export type ReadConfigResult = Succeeded<MemoryConfig> | ConfigRefusal | ConfigUnreadable
+
+export interface ConfigLocation {
+  path: string
+  platform: PathPlatform
+}
+
+export interface RegistrationVaultInput {
+  vault: string
+  workingFolder: string
+}
+
+export interface MissingConfigSnapshot {
+  state: "missing"
+  hash: null
+}
+
+export interface PresentConfigSnapshot {
+  state: "present"
+  hash: string
+  text: string
+  lexicalParse: ParseConfigResult
+  repair: ConfigRepairDraft
+}
+
+export type ConfigSnapshot = MissingConfigSnapshot | PresentConfigSnapshot
+export type ReadConfigSnapshotResult = Succeeded<ConfigSnapshot> | Failed
+
+export interface ConfigRegistrationLocation {
+  config: MemoryConfig
+  configPath: string
+  platform: PathPlatform
+}
+
+export type ConfigRegistrationLocationResult = Succeeded<ConfigRegistrationLocation> | Failed
+
+export interface RegistrationPaths extends ConfigRegistrationLocation {
+  indexPath: string
+}
+
+export type RegistrationPathsResult = Succeeded<RegistrationPaths> | Failed
+export type CanonicalPathResult = Succeeded<string> | Failed
+export type CanonicalConfigResult = Succeeded<MemoryConfig> | Failed
+
+export interface WriteConfigRequest extends ConfigLocation {
+  indexPath: string
+  config: MemoryConfig
+  expectedHash: string | null
+  replacementConfirmed?: true
+}
+
+export interface ConfigPublication {
+  hash: string
+}
+
+export interface ConfigWritten extends Succeeded<ConfigPublication> {
+  warnings: string[]
+}
+
+export type ConfigWriteFailureReason = "conflict" | "invalid-config" | "replacement-required" | "unavailable"
+
+export interface ConfigWriteRefusal extends Failed {
+  reason: ConfigWriteFailureReason
+  warnings: string[]
+}
+
+export type WriteConfigResult = ConfigWritten | ConfigWriteRefusal
+export type CheckConfigSnapshotResult = Succeeded<ConfigSnapshot> | ConfigWriteRefusal
+
+export interface ConfigPublicationRequest {
+  request: WriteConfigRequest
+  temporaryPath: string
+  warnings: string[]
+}
+
+export interface PathIdentity {
+  device: string
+  inode: string
+}
+
+export type FileIdentityResult = Succeeded<PathIdentity> | Failed
+export type PathIdentitiesResult = Succeeded<PathIdentity[]> | Failed

package/src/services/config/vault-access.ts

@@ -0,0 +1,2 @@
+export type { PathPlatform, VaultAccessRequest } from "#src/domain"
+export { absoluteCandidate, VAULT_ACCESS_REFUSAL, vaultAccessRefusal } from "#src/domain"

package/src/services/config/volume-namespace.ts

@@ -0,0 +1,5 @@
+import { NAMESPACE_VOLUME_ROOT } from "./constants.ts"
+
+export function isNamespaceVolumeRoot(path: string): boolean {
+  return NAMESPACE_VOLUME_ROOT.test(path)
+}

package/src/services/config/write.ts

@@ -0,0 +1,63 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open } from "node:fs/promises"
+import { basename, dirname, join } from "node:path"
+
+import { canonicalizeRegistration } from "./canonicalize.ts"
+import { checkConfigSnapshot, publishConfig, removeConfigArtifact } from "./publication.ts"
+import type { WriteConfigRequest, WriteConfigResult } from "./types.ts"
+
+export async function writeConfig(request: WriteConfigRequest): Promise<WriteConfigResult> {
+  const canonical = await canonicalizeRegistration({
+    config: request.config,
+    configPath: request.path,
+    indexPath: request.indexPath,
+    platform: request.platform,
+  })
+  if (!canonical.succeeded) {
+    return { ...canonical, reason: "invalid-config", warnings: [] }
+  }
+  const resolved = { ...request, path: canonical.output.configPath }
+  try {
+    await mkdir(dirname(resolved.path), { recursive: true })
+    return await writeWithLock(resolved)
+  } catch (error) {
+    return { succeeded: false, reason: "unavailable", problems: [String(error)], warnings: [] }
+  }
+}
+
+async function writeWithLock(request: WriteConfigRequest): Promise<WriteConfigResult> {
+  const lockPath = join(dirname(request.path), `.${basename(request.path)}.lock`)
+  const lock = await open(lockPath, "wx")
+  const warnings: string[] = []
+  try {
+    return await writeCheckedConfig(request, warnings)
+  } finally {
+    try {
+      await lock.close()
+    } catch (error) {
+      warnings.push(`${lockPath}: could not close lock (${String(error)})`)
+    }
+    await removeConfigArtifact(lockPath, warnings)
+  }
+}
+
+async function writeCheckedConfig(request: WriteConfigRequest, warnings: string[]): Promise<WriteConfigResult> {
+  const temporaryPath = join(dirname(request.path), `.${basename(request.path)}.tmp-${randomUUID()}`)
+  try {
+    const snapshot = await checkConfigSnapshot(request)
+    if (!snapshot.succeeded) {
+      return { ...snapshot, warnings }
+    }
+    return await publishConfig({ request, temporaryPath, warnings })
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+      return {
+        succeeded: false,
+        reason: "conflict",
+        problems: ["config publication destination already exists"],
+        warnings,
+      }
+    }
+    return { succeeded: false, reason: "unavailable", problems: [String(error)], warnings }
+  }
+}

package/src/services/decision-model/constants.ts

@@ -0,0 +1,16 @@
+export const defaultLayaSettings = {
+  provider: "laya",
+  endpoint: "http://127.0.0.1:8000/v1/systemone",
+  model: "multilingual",
+  maxTokens: 8192,
+  headMaxTokens: 192,
+} as const
+
+export const defaultJevModel = "jev-latest"
+export const maxDecisionResponseBytes = 65_536
+
+export const modelVersionPattern = /^\d+(?:\.\d+)*$/
+
+export const layaNoulLabels = { true: "A", false: "B" } as const
+export const layaServeMaxBatchStates = 64
+export const maxLayaBatchResponseBytes = layaServeMaxBatchStates * maxDecisionResponseBytes