pi-obsidian-memory 0.0.0 → 0.1.0

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

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

@@ -0,0 +1,42 @@
+import type { DecisionResult } from "#src/domain"
+import { initialDiagnostics } from "./diagnostics.ts"
+import { interruptibleDecision } from "./interruption.ts"
+import { classifyJev } from "./jev.ts"
+import { classifyLaya } from "./laya.ts"
+import { decisionPreflight } from "./preflight.ts"
+import { candidatePrompt, memoryPrompt } from "./prompts.ts"
+import type { CandidateDecisionCall, DecisionContext, DecisionPrompt, MemoryDecisionCall } from "./types.ts"
+
+export type { DecisionCutoffs, DecisionProvider } from "#src/domain"
+export { defaultCutoffs, rankCandidates, shouldRetrieveMemory } from "#src/domain"
+
+async function decide(context: DecisionContext, prompt: DecisionPrompt): Promise<DecisionResult> {
+  const diagnostics = initialDiagnostics(context)
+  const refusal = decisionPreflight(context)
+  if (refusal) return { succeeded: false, code: refusal, diagnostics }
+  return interruptibleDecision(context, diagnostics, {
+    async run(signal) {
+      const call = {
+        prompt,
+        diagnostics,
+        signal,
+        question: questionName(prompt),
+      }
+      if (context.provider === "laya") return classifyLaya(context, call)
+      return classifyJev(context, call)
+    },
+  })
+}
+
+function questionName(prompt: DecisionPrompt): "needed" | "relevant" {
+  if ("needed" in prompt.questions) return "needed"
+  return "relevant"
+}
+
+export function decideMemory(call: MemoryDecisionCall): Promise<DecisionResult> {
+  return decide(call.context, memoryPrompt(call.request))
+}
+
+export function scoreCandidate(call: CandidateDecisionCall): Promise<DecisionResult> {
+  return decide(call.context, candidatePrompt(call.request))
+}

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

@@ -0,0 +1,6 @@
+import type { DecisionDiagnostics } from "#src/domain"
+import type { DecisionContext } from "./types.ts"
+
+export function initialDiagnostics(context: DecisionContext): DecisionDiagnostics {
+  return { provider: context.provider, requestedModel: context.model, reportedModel: null, usage: null }
+}

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

@@ -0,0 +1 @@
+export { isLoopbackEndpoint } from "#src/domain"

package/src/services/decision-model/failure-detail.ts

@@ -0,0 +1 @@
+export { boundedFailureDetail } from "#src/domain"

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

@@ -0,0 +1,7 @@
+export * from "./constants.ts"
+export * from "./decide.ts"
+export * from "./jev.ts"
+export * from "./laya-batch.ts"
+export * from "./laya-http-failure.ts"
+export * from "./score-candidates.ts"
+export * from "./types.ts"

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

@@ -0,0 +1,29 @@
+import type { DecisionDiagnostics, DecisionResult } from "#src/domain"
+import type { DecisionContext, DecisionInterruption, DecisionOperation, InterruptibleOperation } from "./types.ts"
+
+export function interruptibleDecision(
+  context: DecisionContext,
+  diagnostics: DecisionDiagnostics,
+  operation: DecisionOperation,
+): Promise<DecisionResult> {
+  return interruptible(context, (code) => ({ succeeded: false, code, diagnostics }), operation)
+}
+
+export async function interruptible<Outcome>(
+  context: DecisionContext,
+  interrupted: DecisionInterruption<Outcome>,
+  operation: InterruptibleOperation<Outcome>,
+): Promise<Outcome> {
+  const { signal } = context
+  if (signal.aborted) return interrupted("aborted")
+  const interruption = Promise.withResolvers<Outcome>()
+  const onAbort = () => interruption.resolve(interrupted("aborted"))
+  signal.addEventListener("abort", onAbort, { once: true })
+  try {
+    return await Promise.race([operation.run(signal), interruption.promise])
+  } catch {
+    return interrupted("unavailable")
+  } finally {
+    signal.removeEventListener("abort", onAbort)
+  }
+}

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

@@ -0,0 +1,61 @@
+import { Value } from "typebox/value"
+
+import type { DecisionResult, DecisionUsage } from "#src/domain"
+import { modelVersionPattern } from "./constants.ts"
+import { JevResultSchema } from "./schemas.ts"
+import type { JevContext, ProviderCall } from "./types.ts"
+
+function modelFamily(id: string): string {
+  return id.slice(0, id.lastIndexOf("-"))
+}
+
+function modelTail(id: string): string {
+  return id.slice(id.lastIndexOf("-") + 1)
+}
+
+export function answeredByRequestedModel(requested: string, reported: string): boolean {
+  if (reported === requested) return true
+  if (!requested.includes("-") || !reported.includes("-")) return false
+  return (
+    modelFamily(requested) === modelFamily(reported) &&
+    !modelVersionPattern.test(modelTail(requested)) &&
+    modelVersionPattern.test(modelTail(reported))
+  )
+}
+
+export async function classifyJev(context: JevContext, call: ProviderCall): Promise<DecisionResult> {
+  const diagnostics = call.diagnostics
+  const result = await context.classifier.classify({
+    model: { provider: "typesafe", id: context.model },
+    context: call.prompt,
+    options: { signal: call.signal, maxRetries: 0 },
+  })
+  if (!Value.Check(JevResultSchema, result)) return { succeeded: false, code: "invalid-response", diagnostics }
+  if (result.stopReason === "aborted") return { succeeded: false, code: "aborted", diagnostics }
+  if (result.stopReason === "error") return { succeeded: false, code: "unavailable", diagnostics }
+  const answer = result.answers[call.question]
+  if (
+    !answeredByRequestedModel(context.model, result.model) ||
+    answer?.type !== "bool" ||
+    typeof answer.probability !== "number"
+  ) {
+    return { succeeded: false, code: "invalid-response", diagnostics }
+  }
+  let usage: DecisionUsage | null = null
+  if (result.usage) usage = { inputTokens: result.usage.input, outputTokens: result.usage.output }
+  return {
+    succeeded: true,
+    output: {
+      probability: answer.probability,
+      diagnostics: { ...diagnostics, reportedModel: result.model, usage },
+    },
+  }
+}
+
+export async function classifyJevSettled(context: JevContext, call: ProviderCall): Promise<DecisionResult> {
+  try {
+    return await classifyJev(context, call)
+  } catch {
+    return { succeeded: false, code: "unavailable", diagnostics: call.diagnostics }
+  }
+}

package/src/services/decision-model/laya-batch.ts

@@ -0,0 +1,64 @@
+import { Value } from "typebox/value"
+
+import type { DecisionFailureCode, DecisionResult } from "#src/domain"
+import { layaServeMaxBatchStates, maxLayaBatchResponseBytes } from "./constants.ts"
+import { layaHeaders, layaNativeQuestions } from "./laya.ts"
+import { layaHttpFailures } from "./laya-http-failure.ts"
+import { interpretLayaValue, readBoundedText } from "./laya-response.ts"
+import { LayaBatchResponseSchema } from "./schemas.ts"
+import type { DecisionBatchItem, LayaBatchCall, LayaContext, LayaResultCandidate } from "./types.ts"
+
+function failAll(items: DecisionBatchItem[], code: DecisionFailureCode): DecisionResult[] {
+  return items.map((item) => ({ succeeded: false, code, diagnostics: item.diagnostics }))
+}
+
+async function readResults(response: Response): Promise<LayaResultCandidate[] | null> {
+  const text = await readBoundedText(response, maxLayaBatchResponseBytes)
+  if (typeof text !== "string") return null
+  try {
+    const parsed = JSON.parse(text)
+    if (!Value.Check(LayaBatchResponseSchema, parsed)) return null
+    return parsed.results
+  } catch {
+    return null
+  }
+}
+
+async function classifyChunk(context: LayaContext, items: DecisionBatchItem[], signal: AbortSignal) {
+  const first = items[0]
+  if (!first) return []
+  const response = await fetch(`${context.endpoint}/batch`, {
+    method: "POST",
+    headers: layaHeaders(context),
+    signal,
+    redirect: "manual",
+    body: JSON.stringify({
+      model: context.model,
+      states: items.map((item) => item.prompt.state),
+      questions: layaNativeQuestions(first.prompt),
+      max_len: context.maxTokens,
+      head_max_len: context.headMaxTokens,
+    }),
+  })
+  if (!response.ok)
+    return layaHttpFailures(
+      response,
+      items.map((item) => item.diagnostics),
+    )
+  const results = await readResults(response)
+  if (!results || results.length !== items.length) return failAll(items, "invalid-response")
+  return items.map((item, index): DecisionResult => {
+    const value = results[index]
+    if (!value) return { succeeded: false, code: "invalid-response", diagnostics: item.diagnostics }
+    return interpretLayaValue(value, { question: "relevant", diagnostics: item.diagnostics })
+  })
+}
+
+export async function classifyLayaBatch(context: LayaContext, call: LayaBatchCall): Promise<DecisionResult[]> {
+  const results: DecisionResult[] = []
+  for (let start = 0; start < call.items.length; start += layaServeMaxBatchStates) {
+    const chunk = call.items.slice(start, start + layaServeMaxBatchStates)
+    results.push(...(await classifyChunk(context, chunk, call.signal)))
+  }
+  return results
+}

package/src/services/decision-model/laya-http-failure.ts

@@ -0,0 +1,41 @@
+import { Value } from "typebox/value"
+
+import type { DecisionDiagnostics, DecisionFailure } from "#src/domain"
+import { maxDecisionResponseBytes } from "./constants.ts"
+import { boundedFailureDetail } from "./failure-detail.ts"
+import { readBoundedText } from "./laya-response.ts"
+import { LayaHttpDetailSchema } from "./schemas.ts"
+
+async function serverDetail(response: Response): Promise<string> {
+  if (response.status !== 422) {
+    await response.body?.cancel()
+    return ""
+  }
+  const text = await readBoundedText(response, maxDecisionResponseBytes)
+  if (typeof text !== "string") return ""
+  try {
+    const parsed = JSON.parse(text)
+    if (!Value.Check(LayaHttpDetailSchema, parsed)) return ""
+    return boundedFailureDetail(parsed.detail)
+  } catch {
+    return ""
+  }
+}
+
+function httpFailure(status: number, detail: string, diagnostics: DecisionDiagnostics): DecisionFailure {
+  const failure: DecisionFailure = { succeeded: false, code: "http-error", httpStatus: status, diagnostics }
+  if (detail) failure.detail = detail
+  return failure
+}
+
+export async function layaHttpFailure(response: Response, diagnostics: DecisionDiagnostics): Promise<DecisionFailure> {
+  return httpFailure(response.status, await serverDetail(response), diagnostics)
+}
+
+export async function layaHttpFailures(
+  response: Response,
+  diagnostics: DecisionDiagnostics[],
+): Promise<DecisionFailure[]> {
+  const detail = await serverDetail(response)
+  return diagnostics.map((item) => httpFailure(response.status, detail, item))
+}