pi-obsidian-memory 0.0.0 → 0.1.0

package/src/domain/config/registration.ts

@@ -0,0 +1,34 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { parseConfig } from "./parse.ts"
+import { resolveProject } from "./paths.ts"
+import type { InitProposal, ParseConfigResult, SetupProposal } from "./types.ts"
+
+export function proposeSetup(request: SetupProposal, platform: PathPlatform): ParseConfigResult {
+  const config = {
+    global: { vault: request.vault },
+    projects: request.config.projects,
+    limits: request.config.limits,
+    capture: request.config.capture,
+    memoryAgent: request.config.memoryAgent,
+    context: request.config.context,
+    embeddings: request.config.embeddings,
+    decisionModel: request.config.decisionModel,
+  }
+  return parseConfig(JSON.stringify(config), platform)
+}
+
+export function proposeInit(request: InitProposal, platform: PathPlatform): ParseConfigResult {
+  const existing = resolveProject(request.config, request.folder, platform)
+  let folder = request.folder
+  if (existing.succeeded) {
+    folder = existing.output.folder
+  }
+  const replacement = { name: request.name, folder, vault: request.vault }
+  const projects = [...request.config.projects]
+  if (existing.succeeded) {
+    projects.splice(projects.indexOf(existing.output), 1, replacement)
+  } else {
+    projects.push(replacement)
+  }
+  return parseConfig(JSON.stringify({ ...request.config, projects }), platform)
+}

package/src/domain/config/repair.ts

@@ -0,0 +1,36 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { inspectConfig } from "./inspection.ts"
+import { observedConfigFields } from "./observations.ts"
+import { parseConfigInspection } from "./parse.ts"
+import { repairDecision, repairEmbeddings } from "./resources.ts"
+import { prepareSetupDefaults } from "./settings.ts"
+import type { ConfigAssessment, ConfigInspection, ConfigRepairDraft, ParseConfigResult } from "./types.ts"
+
+export function inspectConfigForRepair(text: string, platform: PathPlatform): ConfigRepairDraft {
+  return assessConfig(text, platform).repair
+}
+
+export function assessConfig(text: string, platform: PathPlatform): ConfigAssessment {
+  const inspection = inspectConfig(text)
+  const lexicalParse = parseConfigInspection(inspection, platform)
+  return { lexicalParse, repair: repairConfigInspection(inspection, lexicalParse) }
+}
+
+function repairConfigInspection(inspection: ConfigInspection, parsed: ParseConfigResult): ConfigRepairDraft {
+  const draft = prepareSetupDefaults(null)
+  if (!parsed.succeeded) draft.problems = [...parsed.problems]
+  if (!inspection.validJson) {
+    draft.replacementRequired = true
+    return draft
+  }
+  const fields = observedConfigFields(inspection)
+  draft.global = fields.global
+  draft.projects = fields.projects
+  draft.limits = { ...draft.limits, ...fields.limits }
+  draft.capture = { ...draft.capture, ...fields.capture }
+  draft.memoryAgent = fields.memoryAgent
+  draft.context = { ...draft.context, ...fields.context }
+  draft.embeddings = repairEmbeddings(fields.embeddings)
+  draft.decisionModel = repairDecision(fields.decisionModel)
+  return draft
+}

package/src/domain/config/resources.ts

@@ -0,0 +1,65 @@
+import { isLoopbackEndpoint } from "#src/domain/decision-model"
+import { EmbeddingConfigurationSchema } from "#src/domain/embeddings"
+import { readConfigInspection } from "./inspection.ts"
+import { configRuleSelection, observedDecisionFields, observedEmbeddingFields } from "./observations.ts"
+import type { ConfigDocumentInspection, DecisionFields, EmbeddingFields } from "./types.ts"
+
+export function readEmbeddingFields(text: string): EmbeddingFields {
+  return observedEmbeddingFields(readConfigInspection(text).observations)
+}
+
+export function readDecisionFields(text: string): DecisionFields {
+  return observedDecisionFields(readConfigInspection(text).observations)
+}
+
+export function resourceProblems(text: string): string[] {
+  return inspectedResourceProblems(readConfigInspection(text))
+}
+
+export function inspectedResourceProblems(inspection: ConfigDocumentInspection): string[] {
+  if (configRuleSelection(inspection.projectCount, inspection.observations).decisionModel === "typesafe") return []
+  const problems: string[] = []
+  for (const observation of inspection.observations) {
+    if (observation.field === "/decisionModel/endpoint" && !isLoopbackEndpoint(observation.value)) {
+      problems.push(
+        "decisionModel.endpoint: must be a loopback HTTP(S) /v1/systemone URL without credentials, query or fragment",
+      )
+    }
+  }
+  if (inspection.invalidTokenOrder) {
+    problems.push("decisionModel.headMaxTokens: must be less than decisionModel.maxTokens")
+  }
+  return problems
+}
+
+export function repairEmbeddings(fields: EmbeddingFields): EmbeddingFields {
+  for (const schema of EmbeddingConfigurationSchema.anyOf) {
+    if (fields.provider === schema.properties.provider.const) {
+      return { model: schema.properties.model.const, ...fields }
+    }
+  }
+  return { provider: "local", model: "Xenova/multilingual-e5-small", ...fields }
+}
+
+function showsLaya(fields: DecisionFields): boolean {
+  return (
+    fields.provider === "laya" ||
+    fields.model === "multilingual" ||
+    typeof fields.endpoint === "string" ||
+    typeof fields.maxTokens === "number" ||
+    typeof fields.headMaxTokens === "number"
+  )
+}
+
+export function repairDecision(fields: DecisionFields): DecisionFields {
+  if (fields.provider === "typesafe" || !showsLaya(fields))
+    return { provider: "typesafe", model: "jev-latest", ...fields }
+  return {
+    provider: "laya",
+    endpoint: "http://127.0.0.1:8000/v1/systemone",
+    model: "multilingual",
+    maxTokens: 8192,
+    headMaxTokens: 192,
+    ...fields,
+  }
+}

package/src/domain/config/rules.ts

@@ -0,0 +1,49 @@
+import type { TObject } from "typebox"
+
+import { EmbeddingConfigurationSchema } from "#src/domain/embeddings"
+import {
+  DecisionSelectionSchema,
+  EmbeddingSelectionSchema,
+  JevConfigurationSchema,
+  LayaConfigurationSchema,
+  MemoryConfigSchema,
+  ProjectEntrySchema,
+} from "./schemas.ts"
+import type { ConfigFieldRule, ConfigRuleSelection } from "./types.ts"
+
+export function configRules(selection: ConfigRuleSelection): ConfigFieldRule[] {
+  const properties = MemoryConfigSchema.properties
+  const keys = Object.keys(properties)
+  const rules: ConfigFieldRule[] = [{ kind: "object", path: "", keys, required: keys }]
+  rules.push(...objectRules("/global", properties.global), ...objectRules("/limits", properties.limits))
+  rules.push(...objectRules("/capture", properties.capture), ...objectRules("/memoryAgent", properties.memoryAgent))
+  rules.push(...objectRules("/context", properties.context))
+  for (let index = 0; index < selection.projectCount; index++) {
+    rules.push(...objectRules(`/projects/${index}`, ProjectEntrySchema))
+  }
+  let embeddings: TObject = EmbeddingSelectionSchema
+  for (const schema of EmbeddingConfigurationSchema.anyOf) {
+    if (schema.properties.provider.const === selection.embeddings) embeddings = schema
+  }
+  rules.push(...objectRules("/embeddings", embeddings))
+  if (selection.decisionModel === "laya") rules.push(...objectRules("/decisionModel", LayaConfigurationSchema))
+  else if (selection.decisionModel === "typesafe") rules.push(...objectRules("/decisionModel", JevConfigurationSchema))
+  else rules.push(...objectRules("/decisionModel", DecisionSelectionSchema))
+  return rules
+}
+
+function objectRules(path: string, schema: TObject): ConfigFieldRule[] {
+  let required: string[] = []
+  if (Array.isArray(schema.required)) required = schema.required
+  const rules: ConfigFieldRule[] = [{ kind: "object", path, keys: Object.keys(schema.properties), required }]
+  for (const [key, property] of Object.entries(schema.properties)) {
+    if (path === "/capture" && key === "model") {
+      rules.push(...objectRules(`${path}/model`, MemoryConfigSchema.properties.capture.properties.model))
+    } else if (path === "/memoryAgent" && key === "model") {
+      rules.push(...objectRules(`${path}/model`, MemoryConfigSchema.properties.memoryAgent.properties.model))
+    } else {
+      rules.push({ kind: "value", path: `${path}/${key}`, schema: property })
+    }
+  }
+  return rules
+}

package/src/domain/config/schemas.ts

@@ -0,0 +1,155 @@
+import Type from "typebox"
+
+import { EmbeddingConfigurationSchema } from "#src/domain/embeddings"
+
+export const ConfigPathSchema = Type.String({
+  pattern: "^(?:[A-Za-z]:[/\\\\]|/(?!/)|[/\\\\]{2}[^/\\\\]+[/\\\\][^/\\\\]+)",
+})
+
+export const ProjectNameSchema = Type.String({ minLength: 1, pattern: "\\S" })
+export const ConfigLimitSchema = Type.Integer({ minimum: 1 })
+export const ChatModelPartSchema = Type.String({ minLength: 1, pattern: "\\S" })
+export const ChatModelReferenceSchema = Type.Object(
+  { provider: ChatModelPartSchema, id: ChatModelPartSchema },
+  { additionalProperties: false },
+)
+export const CaptureWhenSchema = Type.Union([
+  Type.Literal("after-each-turn"),
+  Type.Literal("on-compaction"),
+  Type.Literal("at-session-end"),
+])
+export const LegacyCaptureSchema = Type.Object({ capture: Type.Object({ when: CaptureWhenSchema }) })
+export const LayaMaxTokensSchema = Type.Integer({ minimum: 1, maximum: 8192 })
+export const LayaHeadMaxTokensSchema = Type.Integer({ minimum: 1, maximum: 8191 })
+export const DecisionThresholdSchema = Type.Number({ minimum: 0, maximum: 1 })
+export const LayaConfigurationSchema = Type.Object(
+  {
+    provider: Type.Literal("laya"),
+    endpoint: Type.String(),
+    model: Type.Literal("multilingual"),
+    maxTokens: LayaMaxTokensSchema,
+    headMaxTokens: LayaHeadMaxTokensSchema,
+    gateThreshold: Type.Optional(DecisionThresholdSchema),
+    relevanceThreshold: Type.Optional(DecisionThresholdSchema),
+  },
+  { additionalProperties: false },
+)
+export const JevConfigurationSchema = Type.Object(
+  {
+    provider: Type.Literal("typesafe"),
+    model: Type.Literal("jev-latest"),
+    gateThreshold: Type.Optional(DecisionThresholdSchema),
+    relevanceThreshold: Type.Optional(DecisionThresholdSchema),
+  },
+  { additionalProperties: false },
+)
+export const DecisionConfigurationSchema = Type.Union([LayaConfigurationSchema, JevConfigurationSchema])
+export const ConfigObjectSchema = Type.Object({}, { additionalProperties: true })
+export const EmbeddingSelectionSchema = Type.Object({
+  provider: Type.Index(EmbeddingConfigurationSchema, ["provider"]),
+  model: Type.Index(EmbeddingConfigurationSchema, ["model"]),
+})
+export const DecisionSelectionSchema = Type.Object({
+  provider: Type.Index(DecisionConfigurationSchema, ["provider"]),
+  model: Type.Index(DecisionConfigurationSchema, ["model"]),
+  endpoint: Type.Optional(LayaConfigurationSchema.properties.endpoint),
+  maxTokens: Type.Optional(LayaMaxTokensSchema),
+  headMaxTokens: Type.Optional(LayaHeadMaxTokensSchema),
+  gateThreshold: Type.Optional(DecisionThresholdSchema),
+  relevanceThreshold: Type.Optional(DecisionThresholdSchema),
+})
+
+export const ConfigFieldObservationSchema = Type.Union([
+  Type.Object({ field: Type.Literal("/global/vault"), index: Type.Integer(), value: ConfigPathSchema }),
+  Type.Object({ field: Type.Literal("/projects/name"), index: Type.Integer(), value: ProjectNameSchema }),
+  Type.Object({ field: Type.Literal("/projects/folder"), index: Type.Integer(), value: ConfigPathSchema }),
+  Type.Object({ field: Type.Literal("/projects/vault"), index: Type.Integer(), value: ConfigPathSchema }),
+  Type.Object({ field: Type.Literal("/limits/maxBodyChars"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/limits/maxStatementChars"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/limits/maxNotesPerFolder"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/context/budgetChars"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/capture/nudgeInterval"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/capture/nudgeToolCalls"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/capture/flushMinTurns"), index: Type.Integer(), value: ConfigLimitSchema }),
+  Type.Object({ field: Type.Literal("/capture/reviewEnabled"), index: Type.Integer(), value: Type.Boolean() }),
+  Type.Object({ field: Type.Literal("/capture/flushOnCompact"), index: Type.Integer(), value: Type.Boolean() }),
+  Type.Object({ field: Type.Literal("/capture/flushOnShutdown"), index: Type.Integer(), value: Type.Boolean() }),
+  Type.Object({ field: Type.Literal("/capture/model/provider"), index: Type.Integer(), value: ChatModelPartSchema }),
+  Type.Object({ field: Type.Literal("/capture/model/id"), index: Type.Integer(), value: ChatModelPartSchema }),
+  Type.Object({
+    field: Type.Literal("/memoryAgent/model/provider"),
+    index: Type.Integer(),
+    value: ChatModelPartSchema,
+  }),
+  Type.Object({ field: Type.Literal("/memoryAgent/model/id"), index: Type.Integer(), value: ChatModelPartSchema }),
+  Type.Object({
+    field: Type.Literal("/embeddings/provider"),
+    index: Type.Integer(),
+    value: EmbeddingSelectionSchema.properties.provider,
+  }),
+  Type.Object({
+    field: Type.Literal("/embeddings/model"),
+    index: Type.Integer(),
+    value: EmbeddingSelectionSchema.properties.model,
+  }),
+  Type.Object({
+    field: Type.Literal("/decisionModel/provider"),
+    index: Type.Integer(),
+    value: DecisionSelectionSchema.properties.provider,
+  }),
+  Type.Object({
+    field: Type.Literal("/decisionModel/model"),
+    index: Type.Integer(),
+    value: DecisionSelectionSchema.properties.model,
+  }),
+  Type.Object({ field: Type.Literal("/decisionModel/endpoint"), index: Type.Integer(), value: Type.String() }),
+  Type.Object({ field: Type.Literal("/decisionModel/maxTokens"), index: Type.Integer(), value: LayaMaxTokensSchema }),
+  Type.Object({
+    field: Type.Literal("/decisionModel/headMaxTokens"),
+    index: Type.Integer(),
+    value: LayaHeadMaxTokensSchema,
+  }),
+  Type.Object({
+    field: Type.Literal("/decisionModel/gateThreshold"),
+    index: Type.Integer(),
+    value: DecisionThresholdSchema,
+  }),
+  Type.Object({
+    field: Type.Literal("/decisionModel/relevanceThreshold"),
+    index: Type.Integer(),
+    value: DecisionThresholdSchema,
+  }),
+])
+
+export const ProjectEntrySchema = Type.Object(
+  { name: ProjectNameSchema, folder: ConfigPathSchema, vault: ConfigPathSchema },
+  { additionalProperties: false },
+)
+
+export const MemoryConfigSchema = Type.Object(
+  {
+    global: Type.Object({ vault: ConfigPathSchema }, { additionalProperties: false }),
+    projects: Type.Array(ProjectEntrySchema),
+    limits: Type.Object(
+      { maxBodyChars: ConfigLimitSchema, maxStatementChars: ConfigLimitSchema, maxNotesPerFolder: ConfigLimitSchema },
+      { additionalProperties: false },
+    ),
+    capture: Type.Object(
+      {
+        model: ChatModelReferenceSchema,
+        nudgeInterval: ConfigLimitSchema,
+        nudgeToolCalls: ConfigLimitSchema,
+        flushMinTurns: ConfigLimitSchema,
+        reviewEnabled: Type.Boolean(),
+        flushOnCompact: Type.Boolean(),
+        flushOnShutdown: Type.Boolean(),
+      },
+      { additionalProperties: false },
+    ),
+    memoryAgent: Type.Object({ model: ChatModelReferenceSchema }, { additionalProperties: false }),
+    context: Type.Object({ budgetChars: ConfigLimitSchema }, { additionalProperties: false }),
+    embeddings: EmbeddingConfigurationSchema,
+    decisionModel: DecisionConfigurationSchema,
+  },
+  { additionalProperties: false },
+)

package/src/domain/config/settings.ts

@@ -0,0 +1,23 @@
+import { Value } from "typebox/value"
+
+import { DEFAULT_CAPTURE_CADENCE } from "./constants.ts"
+import { repairDecision, repairEmbeddings } from "./resources.ts"
+import { ChatModelReferenceSchema } from "./schemas.ts"
+import type { ChatModelReference, ConfigRepairDraft } from "./types.ts"
+
+export function prepareSetupDefaults(model: ChatModelReference | null): ConfigRepairDraft {
+  let selected: Partial<ChatModelReference> = {}
+  if (Value.Check(ChatModelReferenceSchema, model)) selected = model
+  return {
+    global: {},
+    projects: [],
+    limits: { maxBodyChars: 1000, maxStatementChars: 100, maxNotesPerFolder: 20 },
+    capture: { model: { ...selected }, ...DEFAULT_CAPTURE_CADENCE },
+    memoryAgent: { model: { ...selected } },
+    context: { budgetChars: 12000 },
+    embeddings: repairEmbeddings({}),
+    decisionModel: repairDecision({}),
+    replacementRequired: false,
+    problems: [],
+  }
+}

package/src/domain/config/types.ts

@@ -0,0 +1,239 @@
+import type { Static, TSchema } from "typebox"
+
+import type { CaptureCadenceSettings } from "#src/domain/capture"
+import type { Absent, Failed, Succeeded } from "#src/shared"
+import type {
+  CaptureWhenSchema,
+  ChatModelReferenceSchema,
+  ConfigFieldObservationSchema,
+  MemoryConfigSchema,
+  ProjectEntrySchema,
+} from "./schemas.ts"
+
+export type MemoryConfig = Static<typeof MemoryConfigSchema>
+
+export type ProjectEntry = Static<typeof ProjectEntrySchema>
+
+export type LegacyCaptureWhen = Static<typeof CaptureWhenSchema>
+
+export type ParseConfigResult = Succeeded<MemoryConfig> | Failed
+
+export type ConfigFieldObservation = Static<typeof ConfigFieldObservationSchema>
+
+export interface ConfigObservationRule {
+  field: ConfigFieldObservation["field"]
+  index: number
+  path: string
+}
+
+export interface ConfigDocumentInspection {
+  config: Succeeded<MemoryConfig> | Absent
+  observations: ConfigFieldObservation[]
+  projectCount: number
+  shapeProblems: string[]
+  invalidTokenOrder: boolean
+}
+
+export interface ConfigJsonInspection extends ConfigDocumentInspection {
+  validJson: true
+}
+
+export interface ConfigSyntaxFailure {
+  validJson: false
+  message: string
+}
+
+export type ConfigInspection = ConfigJsonInspection | ConfigSyntaxFailure
+
+export interface ConfigAssessment {
+  lexicalParse: ParseConfigResult
+  repair: ConfigRepairDraft
+}
+
+export type ResolveProjectResult = Succeeded<ProjectEntry> | Absent
+
+export type ChatModelReference = Static<typeof ChatModelReferenceSchema>
+
+export interface ConfigObjectRule {
+  kind: "object"
+  path: string
+  keys: string[]
+  required: string[]
+}
+
+export interface ConfigValueRule {
+  kind: "value"
+  path: string
+  schema: TSchema
+}
+
+export type ConfigFieldRule = ConfigObjectRule | ConfigValueRule
+
+export interface ConfigRuleSelection {
+  projectCount: number
+  embeddings: string | null
+  decisionModel: string | null
+}
+
+export interface ConfigRegistrations {
+  global: Partial<MemoryConfig["global"]>
+  projects: Partial<ProjectEntry>[]
+}
+
+export interface CaptureFields extends Partial<CaptureCadenceSettings> {
+  model: Partial<ChatModelReference>
+}
+
+export interface MemoryAgentFields {
+  model: Partial<ChatModelReference>
+}
+
+export interface EmbeddingFields {
+  provider?: MemoryConfig["embeddings"]["provider"]
+  model?: MemoryConfig["embeddings"]["model"]
+}
+
+export interface DecisionFields {
+  provider?: MemoryConfig["decisionModel"]["provider"]
+  model?: MemoryConfig["decisionModel"]["model"]
+  endpoint?: string
+  maxTokens?: number
+  headMaxTokens?: number
+  gateThreshold?: number
+  relevanceThreshold?: number
+}
+
+export interface ConfigFields extends ConfigRegistrations {
+  limits: Partial<MemoryConfig["limits"]>
+  capture: CaptureFields
+  memoryAgent: MemoryAgentFields
+  context: Partial<MemoryConfig["context"]>
+  embeddings: EmbeddingFields
+  decisionModel: DecisionFields
+}
+
+export interface ConfigRepairDraft extends ConfigFields {
+  limits: MemoryConfig["limits"]
+  replacementRequired: boolean
+  problems: string[]
+}
+
+export interface SetupProposal {
+  config: ConfigFields
+  vault: string
+}
+
+export interface InitProposal {
+  config: MemoryConfig
+  folder: string
+  name: string
+  vault: string
+}
+
+export interface ConfigLocationPaths {
+  config: ConfigRegistrations
+  configPath: string
+}
+
+export interface ConfigInfrastructure extends ConfigLocationPaths {
+  indexPath: string
+}
+
+export interface VaultRegistration {
+  field: string
+  path: string
+}
+
+export type SetupDisclosure = "chat-models" | "jev" | "remote-embeddings"
+
+export interface CaptureModelChange {
+  kind: "captureModel"
+  model: ChatModelReference
+}
+
+export interface AgentModelChange {
+  kind: "agentModel"
+  model: ChatModelReference
+}
+
+export interface CaptureCountChange {
+  kind: "captureCount"
+  name: "nudgeInterval" | "nudgeToolCalls" | "flushMinTurns"
+  value: number
+}
+
+export interface CaptureSwitchChange {
+  kind: "captureSwitch"
+  name: "reviewEnabled" | "flushOnCompact" | "flushOnShutdown"
+  value: boolean
+}
+
+export interface EmbeddingsChange {
+  kind: "embeddings"
+  embeddings: MemoryConfig["embeddings"]
+}
+
+export interface JevDecisionChange {
+  kind: "decision"
+  provider: "typesafe"
+}
+
+export interface LayaDecisionChange {
+  kind: "decision"
+  provider: "laya"
+  endpoint: string
+}
+
+export interface ThresholdChange {
+  kind: "gateThreshold" | "relevanceThreshold"
+  value: number | null
+}
+
+export interface BudgetChange {
+  kind: "budgetChars"
+  value: number
+}
+
+export interface LimitChange {
+  kind: "limit"
+  name: keyof MemoryConfig["limits"]
+  value: number
+}
+
+export interface ProjectVaultChange {
+  kind: "projectVault"
+  name: string
+  vault: string
+}
+
+export interface RemoveProjectChange {
+  kind: "removeProject"
+  name: string
+}
+
+export type DecisionChange = JevDecisionChange | LayaDecisionChange
+
+export type SettingChange =
+  | CaptureModelChange
+  | AgentModelChange
+  | CaptureCountChange
+  | CaptureSwitchChange
+  | EmbeddingsChange
+  | DecisionChange
+  | ThresholdChange
+  | BudgetChange
+  | LimitChange
+  | ProjectVaultChange
+  | RemoveProjectChange
+
+export type SettingNumberKind = "threshold" | "count"
+
+export interface ConfigCandidate extends Omit<MemoryConfig, "decisionModel"> {
+  decisionModel: DecisionFields
+}
+
+export type NextConfig = Succeeded<ConfigCandidate> | Failed
+
+export type SettingNumberResult = Succeeded<number> | Failed
+
+export type ProjectReplacement = (project: ProjectEntry) => ProjectEntry | null

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

@@ -0,0 +1,7 @@
+import type { DecisionCutoffs, DecisionProvider } from "./types.ts"
+
+export const DEFAULT_CUTOFFS = new Map<DecisionProvider, Partial<DecisionCutoffs>>([
+  ["typesafe", { gate: 0.5, relevance: 0.5 }],
+])
+
+export const MAX_FAILURE_DETAIL_CHARS = 500

package/src/domain/decision-model/cutoffs.ts

@@ -0,0 +1,8 @@
+import { DEFAULT_CUTOFFS } from "./constants.ts"
+import type { DecisionCutoffs, DecisionProvider } from "./types.ts"
+
+export function defaultCutoffs(provider: DecisionProvider): Partial<DecisionCutoffs> {
+  const cutoffs = DEFAULT_CUTOFFS.get(provider)
+  if (cutoffs) return cutoffs
+  return {}
+}

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

@@ -0,0 +1,11 @@
+export function isLoopbackEndpoint(endpoint: string): boolean {
+  try {
+    const url = new URL(endpoint)
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false
+    if (url.username || url.password || url.search || url.hash) return false
+    if (url.pathname !== "/v1/systemone") return false
+    return url.hostname === "127.0.0.1" || url.hostname === "[::1]"
+  } catch {
+    return false
+  }
+}

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

@@ -0,0 +1,8 @@
+import { MAX_FAILURE_DETAIL_CHARS } from "./constants.ts"
+
+export function boundedFailureDetail(detail: string): string {
+  if (detail.length <= MAX_FAILURE_DETAIL_CHARS) return detail
+  const last = detail.charCodeAt(MAX_FAILURE_DETAIL_CHARS - 1)
+  if (last >= 0xd800 && last <= 0xdbff) return detail.slice(0, MAX_FAILURE_DETAIL_CHARS - 1)
+  return detail.slice(0, MAX_FAILURE_DETAIL_CHARS)
+}

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

@@ -0,0 +1,6 @@
+export * from "./constants.ts"
+export * from "./cutoffs.ts"
+export * from "./endpoint.ts"
+export * from "./failure-detail.ts"
+export * from "./rank.ts"
+export * from "./types.ts"