liminal 0.1.0-beta.25

package/src/deps/jsr.io/@std/internal/1.0.5/styles.ts

@@ -0,0 +1,233 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+// on npm.
+
+// This code is vendored from `fmt/colors.ts`.
+
+// deno-lint-ignore no-explicit-any
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+const { Deno } = dntShim.dntGlobalThis as any;
+const noColor = typeof Deno?.noColor === "boolean"
+  ? Deno.noColor as boolean
+  : false;
+
+interface Code {
+  open: string;
+  close: string;
+  regexp: RegExp;
+}
+
+const enabled = !noColor;
+
+function code(open: number[], close: number): Code {
+  return {
+    open: `\x1b[${open.join(";")}m`,
+    close: `\x1b[${close}m`,
+    regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+  };
+}
+
+function run(str: string, code: Code): string {
+  return enabled
+    ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+    : str;
+}
+
+/**
+ * Sets the style of text to be printed to bold.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make bold
+ *
+ * @returns Bold text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bold } from "@std/internal/styles";
+ *
+ * console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+ * ```
+ */
+export function bold(str: string): string {
+  return run(str, code([1], 22));
+}
+
+/**
+ * Sets the color of text to be printed to red.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make red
+ *
+ * @returns Red text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red } from "@std/internal/styles";
+ *
+ * console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+ * ```
+ */
+export function red(str: string): string {
+  return run(str, code([31], 39));
+}
+
+/**
+ * Sets the color of text to be printed to green.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make green
+ *
+ * @returns Green text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { green } from "@std/internal/styles";
+ *
+ * console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+ * ```
+ */
+export function green(str: string): string {
+  return run(str, code([32], 39));
+}
+
+/**
+ * Sets the color of text to be printed to yellow.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make yellow
+ *
+ * @returns Yellow text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { yellow } from "@std/internal/styles";
+ *
+ * console.log(yellow("Hello, world!")); // Prints "Hello, world!" in yellow
+ * ```
+ */
+export function yellow(str: string): string {
+  return run(str, code([33], 39));
+}
+
+/**
+ * Sets the color of text to be printed to white.
+ *
+ * @param str Text to make white
+ *
+ * @returns White text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { white } from "@std/internal/styles";
+ *
+ * console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+ * ```
+ */
+export function white(str: string): string {
+  return run(str, code([37], 39));
+}
+
+/**
+ * Sets the color of text to be printed to gray.
+ *
+ * @param str Text to make gray
+ *
+ * @returns Gray text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { gray } from "@std/internal/styles";
+ *
+ * console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+ * ```
+ */
+export function gray(str: string): string {
+  return brightBlack(str);
+}
+
+/**
+ * Sets the color of text to be printed to bright-black.
+ *
+ * @param str Text to make bright-black
+ *
+ * @returns Bright-black text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { brightBlack } from "@std/internal/styles";
+ *
+ * console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+ * ```
+ */
+export function brightBlack(str: string): string {
+  return run(str, code([90], 39));
+}
+
+/**
+ * Sets the background color of text to be printed to red.
+ *
+ * @param str Text to make its background red
+ *
+ * @returns Red background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgRed } from "@std/internal/styles";
+ *
+ * console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+ * ```
+ */
+export function bgRed(str: string): string {
+  return run(str, code([41], 49));
+}
+
+/**
+ * Sets the background color of text to be printed to green.
+ *
+ * @param str Text to make its background green
+ *
+ * @returns Green background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgGreen } from "@std/internal/styles";
+ *
+ * console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+ * ```
+ */
+export function bgGreen(str: string): string {
+  return run(str, code([42], 49));
+}
+
+// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+const ANSI_PATTERN = new RegExp(
+  [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
+  ].join("|"),
+  "g",
+);
+
+/**
+ * Remove ANSI escape codes from the string.
+ *
+ * @param string Text to remove ANSI escape codes from
+ *
+ * @returns Text without ANSI escape codes
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red, stripAnsiCode } from "@std/internal/styles";
+ *
+ * console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+ * ```
+ */
+export function stripAnsiCode(string: string): string {
+  return string.replace(ANSI_PATTERN, "");
+}

package/src/deps/jsr.io/@std/internal/1.0.5/types.ts

@@ -0,0 +1,18 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+/** Ways that lines in a diff can be different. */
+export type DiffType = "removed" | "common" | "added";
+
+/**
+ * Represents the result of a diff operation.
+ *
+ * @typeParam T The type of the value in the diff result.
+ */
+export interface DiffResult<T> {
+  /** The type of the diff. */
+  type: DiffType;
+  /** The value of the diff. */
+  value: T;
+  /** The details of the diff. */
+  details?: DiffResult<T>[];
+}

package/src/json_schema/Hydrated.ts

@@ -0,0 +1,52 @@
+import { L, type Type } from "../core/mod.js"
+import type { JSONType } from "./JSONSchema.js"
+
+export function Hydrated(type: JSONType): Type<unknown> {
+  const types: Record<string, undefined | Type<unknown>> = {}
+  return visit(type) as never
+
+  function visit(type: JSONType) {
+    const initial = ((): Type<unknown> => {
+      if ("$defs" in type && type.$defs) {
+        Object.entries(type.$defs).forEach(([id, jsonType]) => {
+          if (!(id in types)) {
+            types[id] = undefined
+            types[id] = visit(jsonType)
+          }
+        })
+      }
+      if ("$ref" in type) {
+        const id = type.$ref.split("#/$defs/").pop()!
+        return L.ref(() => types[id]!)
+      } else if ("anyOf" in type) {
+        return L.union(...type.anyOf.map(visit))
+      }
+      switch (type.type) {
+        case "null": {
+          return L.null
+        }
+        case "boolean": {
+          return L.boolean
+        }
+        case "integer": {
+          return L.integer
+        }
+        case "number": {
+          return L.number
+        }
+        case "string": {
+          return type.enum ? L.enum(...type.enum) : L.string
+        }
+        case "array": {
+          return L.array(visit(type.items))
+        }
+        case "object": {
+          return L.object(
+            Object.fromEntries(Object.entries(type.properties).map(([k, v]) => [k, visit(v)])),
+          )
+        }
+      }
+    })()(type.description)
+    return type.const ? L.const(initial, type.const) : initial
+  }
+}

package/src/json_schema/JSONSchema.ts

@@ -0,0 +1,95 @@
+import { unreachable } from "../deps/jsr.io/@std/assert/1.0.10/mod.js"
+import { L, type PartialType } from "../core/mod.js"
+import type { Expand } from "../util/mod.js"
+
+export type JSONType = JSONTypes[JSONTypeName]
+export type JSONTypeName = keyof JSONTypes
+export type JSONTypes = JSONTypes.Make<{
+  null: {
+    type: "null"
+  }
+  boolean: {
+    type: "boolean"
+  }
+  integer: {
+    type: "integer"
+  }
+  number: {
+    type: "number"
+  }
+  string: {
+    type: "string"
+    enum?: Array<string>
+  }
+  array: {
+    type: "array"
+    items: JSONType
+  }
+  object: {
+    type: "object"
+    properties: Record<string, JSONType>
+    additionalProperties: false
+    required: Array<string>
+    $defs?: Record<string, JSONType>
+  }
+  union: {
+    anyOf: Array<JSONType>
+  }
+  ref: {
+    $ref: string
+  }
+}>
+namespace JSONTypes {
+  export type Make<T> = {
+    [K in keyof T]: Expand<
+      T[K] & {
+        description?: string
+        const?: unknown
+      }
+    >
+  }
+}
+
+export function jsonTypeName(type: PartialType): JSONTypeName {
+  switch (type.declaration.getAtom?.()) {
+    case L.null: {
+      return "null"
+    }
+    case L.boolean: {
+      return "boolean"
+    }
+    case L.number: {
+      return "number"
+    }
+    case L.integer: {
+      return "integer"
+    }
+    case L.string: {
+      return "string"
+    }
+  }
+  switch (type.declaration.factory) {
+    case L.const: {
+      return jsonTypeName(type.declaration.args[0] as PartialType)
+    }
+    case L.array: {
+      return "array"
+    }
+    case L.object: {
+      return "object"
+    }
+    case L.enum: {
+      return "string"
+    }
+    case L.union: {
+      return "union"
+    }
+    case L.ref: {
+      return "ref"
+    }
+    case L.transform: {
+      return jsonTypeName(type.declaration.args[0] as PartialType)
+    }
+  }
+  unreachable()
+}

package/src/json_schema/MetaType.ts

@@ -0,0 +1,32 @@
+import { L, type PartialType, type Type } from "../core/mod.js"
+import { Hydrated } from "./Hydrated.js"
+import type { JSONType } from "./JSONSchema.js"
+
+const JSONType_: Type<JSONType> = L.transform(
+  L.TaggedUnion({
+    null: null,
+    boolean: null,
+    integer: null,
+    number: null,
+    string: null,
+    array: L.object({
+      items: L.ref((): PartialType => JSONType_),
+    }),
+    object: L.transform(L.Record(L.ref((): PartialType => JSONType_)), (properties) => ({
+      properties,
+      required: Object.keys(properties),
+      additionalProperties: false,
+    })),
+    union: L.object({
+      anyOf: L.ref(() => JSONType_),
+    }),
+  }),
+  ({ type, value }) => ({
+    ...type === "union" ? {} : { type },
+    ...value ? value : {},
+  }),
+) as never
+
+export type MetaType<P extends symbol> = Type<Type<unknown>, P>
+
+export const MetaType: MetaType<never> = L.transform(JSONType_, Hydrated)

package/src/json_schema/MetaTypeMigration.ts

@@ -0,0 +1,31 @@
+import { L, type Type } from "../core/mod.js"
+import { MetaType } from "./MetaType.js"
+import { PathLike } from "./PathLike.js"
+
+export type MetaTypeMigration<P extends symbol> = Type<{
+  id: string
+  defId: string
+  path: PathLike
+  change: {
+    type: "Create"
+    value: Type<unknown>
+  } | {
+    type: "Update"
+    value: Type<unknown>
+  } | {
+    type: "Delete"
+  }
+  rationale: string
+}, P>
+
+export const MetaTypeMigration: MetaTypeMigration<never> = L.object({
+  id: L.string,
+  defId: L.string,
+  path: PathLike,
+  change: L.TaggedUnion({
+    Create: MetaType,
+    Update: MetaType,
+    Delete: null,
+  }),
+  rationale: L.string,
+})

package/src/json_schema/PathLike.ts

@@ -0,0 +1,9 @@
+import { L, type Type } from "../core/mod.js"
+
+export type PathLike = [number | string | Array<number | string>][0]
+
+export const PathLike: Type<PathLike> = L.union(
+  L.integer,
+  L.string,
+  L.array(L.union(L.integer, L.string)),
+)

package/src/json_schema/mod.ts

@@ -0,0 +1,8 @@
+// moderate
+
+export * from "./Hydrated.js"
+export * from "./JSONSchema.js"
+export * from "./MetaType.js"
+export * from "./MetaTypeMigration.js"
+export * from "./PathLike.js"
+export * from "./toJSONSchema.js"

package/src/json_schema/toJSONSchema.ts

@@ -0,0 +1,114 @@
+import {
+  DescriptionContext,
+  isType,
+  type PartialType,
+  type Type,
+  TypeVisitor,
+} from "../core/mod.js"
+import type { JSONType } from "./JSONSchema.js"
+
+export function toJSONSchema(type: Type<unknown, any>): JSONType {
+  const ctx = new VisitorContext(
+    new Map(),
+    {},
+    new DescriptionContext(new Map(), {}),
+  )
+  const root = visit(ctx, type)
+  const { "0": _root, ...$defs } = ctx.defs
+  return { ...root, $defs } as never
+}
+
+class VisitorContext {
+  constructor(
+    readonly ids: Map<PartialType, string>,
+    readonly defs: Record<string, undefined | JSONType>,
+    readonly descriptionCtx: DescriptionContext,
+  ) {}
+
+  id(type: PartialType): string {
+    let id = this.ids.get(type)
+    if (id === undefined) {
+      id = this.ids.size.toString()
+      this.ids.set(type, id)
+    }
+    return id
+  }
+}
+
+const visit = TypeVisitor<VisitorContext, JSONType>({
+  hook(next, { descriptionCtx: { args, pins }, ids, defs }, type) {
+    let jsonType: JSONType
+    args = { ...args }
+    const descriptionCtx = new DescriptionContext(pins, args)
+    const description = descriptionCtx.format(type as never)
+    const ctx = new VisitorContext(ids, defs, descriptionCtx)
+    if (isType(type, "array", "object", "union")) {
+      const id = ctx.id(type)
+      if (id in defs) {
+        return defs[id] ?? {
+          $ref: id === "0" ? "#" : `#/$defs/${id}`,
+        }
+      } else {
+        defs[id] = undefined
+        jsonType = next(ctx, type)
+        defs[id] = jsonType
+      }
+    } else {
+      jsonType = next(ctx, type)
+    }
+    return { description, ...jsonType }
+  },
+  null() {
+    return { type: "null" }
+  },
+  boolean() {
+    return { type: "boolean" }
+  },
+  integer() {
+    return { type: "integer" }
+  },
+  number() {
+    return { type: "number" }
+  },
+  string() {
+    return { type: "string" }
+  },
+  const(ctx, _1, valueType, value): JSONType {
+    return {
+      ...visit(ctx, valueType),
+      const: value,
+    }
+  },
+  array(ctx, _1, element): JSONType {
+    return {
+      type: "array",
+      items: visit(ctx, element),
+    }
+  },
+  object(ctx, _1, fields): JSONType {
+    const required = Object.keys(fields)
+    return {
+      type: "object",
+      properties: Object.fromEntries(required.map((k) => [k, visit(ctx, fields[k]!)])),
+      required,
+      additionalProperties: false,
+    }
+  },
+  enum(_0, _1, ...values) {
+    return {
+      type: "string",
+      enum: values,
+    }
+  },
+  union(ctx, _1, ...members): JSONType {
+    return {
+      anyOf: members.map((member) => visit(ctx, member)),
+    }
+  },
+  ref(ctx, _1, get): JSONType {
+    return visit(ctx, get())
+  },
+  transform(ctx, _1, from): JSONType {
+    return visit(ctx, from)
+  },
+})

package/src/mod.ts

@@ -0,0 +1,3 @@
+export * from "./client/mod.js"
+export * from "./core/mod.js"
+export * from "./json_schema/mod.js"

package/src/providers/OpenAI/OpenAIAdapter.ts

@@ -0,0 +1,89 @@
+import type Openai from "openai"
+import type { ChatModel } from "openai/resources/chat/chat"
+import type {
+  ChatCompletion,
+  ChatCompletionMessage,
+  ChatCompletionMessageParam,
+} from "openai/resources/chat/completions"
+import {
+  type Adapter,
+  DEFAULT_INSTRUCTIONS,
+  DescriptionContext,
+  L,
+  signatureHash,
+  toJSONSchema,
+} from "../../mod.js"
+import { unwrapOutput, unwrapRaw } from "./openai_util.js"
+
+export type OpenAIAdapter = Adapter<{
+  role: "system" | "user"
+  model: (string & {}) | ChatModel
+  completion: ChatCompletion
+  I: ChatCompletionMessageParam
+  O: ChatCompletionMessage
+}>
+
+export function OpenAIAdapter({
+  openai,
+  defaultModel = "gpt-4o-mini",
+  defaultInstructions = DEFAULT_INSTRUCTIONS,
+}: {
+  openai: Openai
+  defaultModel?: (string & {}) | ChatModel
+  defaultInstructions?: string
+}): OpenAIAdapter {
+  const formatInput: OpenAIAdapter["formatInput"] = (texts, role) => ({
+    role: role ?? "system",
+    content: texts.filter((v): v is string => !!v).map((text) => ({
+      type: "text",
+      text,
+    })),
+  })
+
+  const text: OpenAIAdapter["text"] = (messages, config) =>
+    openai.chat.completions.create({
+      model: config?.model ?? defaultModel,
+      messages,
+    })
+
+  return {
+    defaults: {
+      model: defaultModel,
+      role: "user",
+      opening: {
+        role: "system",
+        content: defaultInstructions,
+      },
+    },
+    formatInput,
+    unwrapOutput,
+    unwrapRaw,
+    text,
+    value: async (type, { messages, name, description, model }) => {
+      messages ??= []
+      const descriptionCtx = new DescriptionContext()
+      if (type.declaration.factory === L.string) {
+        return text([
+          ...messages ?? [],
+          formatInput([description, descriptionCtx.format(type)], "system"),
+        ])
+      }
+      if (!name) {
+        name = await signatureHash(type)
+      }
+      return openai.chat.completions.create({
+        model: model ?? defaultModel,
+        messages,
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            name,
+            description,
+            schema: toJSONSchema(type),
+            strict: true,
+          },
+        },
+      })
+    },
+  }
+}