paseo-plugin-zcode-provider 0.0.0-stage → 0.2.0

package/server/vendor/zcode/packages/model-option-map/src/parser.ts

@@ -0,0 +1,240 @@
+import { RestrictedCelError, type ModelOptionName } from "./types.js";
+import type { RestrictedCelToken } from "./tokenizer.js";
+
+export type RestrictedCelExpression =
+  | {
+      readonly type: "literal";
+      readonly value: string | number | boolean | null;
+      readonly offset: number;
+    }
+  | { readonly type: "input"; readonly offset: number }
+  | {
+      readonly type: "array";
+      readonly elements: readonly RestrictedCelExpression[];
+      readonly offset: number;
+    }
+  | {
+      readonly type: "object";
+      readonly entries: readonly {
+        readonly key: string;
+        readonly value: RestrictedCelExpression;
+        readonly offset: number;
+      }[];
+      readonly offset: number;
+    }
+  | {
+      readonly type: "unary";
+      readonly operator: "!" | "-" | "+";
+      readonly operand: RestrictedCelExpression;
+      readonly offset: number;
+    }
+  | {
+      readonly type: "binary";
+      readonly operator: string;
+      readonly left: RestrictedCelExpression;
+      readonly right: RestrictedCelExpression;
+      readonly offset: number;
+    }
+  | {
+      readonly type: "conditional";
+      readonly condition: RestrictedCelExpression;
+      readonly whenTrue: RestrictedCelExpression;
+      readonly whenFalse: RestrictedCelExpression;
+      readonly offset: number;
+    };
+
+export function parseRestrictedCel(
+  tokens: readonly RestrictedCelToken[],
+  variableName: ModelOptionName,
+): RestrictedCelExpression {
+  return new Parser(tokens, variableName).parse();
+}
+
+class Parser {
+  #index = 0;
+
+  constructor(
+    private readonly tokens: readonly RestrictedCelToken[],
+    private readonly variableName: ModelOptionName,
+  ) {}
+
+  parse(): RestrictedCelExpression {
+    const expression = this.parseConditional();
+    const trailing = this.current();
+    if (trailing.kind !== "eof") {
+      if (trailing.value === ".") {
+        throw new RestrictedCelError("member access is not supported", trailing.offset);
+      }
+      if (trailing.value === "(") {
+        throw new RestrictedCelError("function calls are not supported", trailing.offset);
+      }
+      throw new RestrictedCelError(
+        `unexpected token ${JSON.stringify(trailing.value)}`,
+        trailing.offset,
+      );
+    }
+    return expression;
+  }
+
+  private parseConditional(): RestrictedCelExpression {
+    const condition = this.parseLogicalOr();
+    if (!this.consume("?")) return condition;
+    const whenTrue = this.parseConditional();
+    this.expect(":");
+    const whenFalse = this.parseConditional();
+    return { type: "conditional", condition, whenTrue, whenFalse, offset: condition.offset };
+  }
+
+  private parseLogicalOr(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseLogicalAnd(), new Set(["||"]));
+  }
+
+  private parseLogicalAnd(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseEquality(), new Set(["&&"]));
+  }
+
+  private parseEquality(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseRelational(), new Set(["==", "!="]));
+  }
+
+  private parseRelational(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseAdditive(), new Set(["<", "<=", ">", ">="]));
+  }
+
+  private parseAdditive(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseMultiplicative(), new Set(["+", "-"]));
+  }
+
+  private parseMultiplicative(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseUnary(), new Set(["*", "/", "%"]));
+  }
+
+  private parseBinary(
+    parseOperand: () => RestrictedCelExpression,
+    operators: ReadonlySet<string>,
+  ): RestrictedCelExpression {
+    let expression = parseOperand();
+    while (this.current().kind === "operator" && operators.has(this.current().value)) {
+      const operator = this.advance();
+      expression = {
+        type: "binary",
+        operator: operator.value,
+        left: expression,
+        right: parseOperand(),
+        offset: operator.offset,
+      };
+    }
+    return expression;
+  }
+
+  private parseUnary(): RestrictedCelExpression {
+    const token = this.current();
+    if (
+      token.kind === "operator" &&
+      (token.value === "!" || token.value === "-" || token.value === "+")
+    ) {
+      this.advance();
+      return {
+        type: "unary",
+        operator: token.value,
+        operand: this.parseUnary(),
+        offset: token.offset,
+      };
+    }
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): RestrictedCelExpression {
+    const token = this.advance();
+    if (token.kind === "number") {
+      const value = Number(token.value);
+      if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+        throw new RestrictedCelError("number literal is not JSON-safe", token.offset);
+      }
+      return { type: "literal", value, offset: token.offset };
+    }
+    if (token.kind === "string")
+      return { type: "literal", value: token.value, offset: token.offset };
+    if (token.kind === "identifier") {
+      if (this.current().value === "(") {
+        throw new RestrictedCelError("function calls are not supported", this.current().offset);
+      }
+      if (token.value === this.variableName) return { type: "input", offset: token.offset };
+      if (token.value === "true" || token.value === "false") {
+        return { type: "literal", value: token.value === "true", offset: token.offset };
+      }
+      if (token.value === "null") return { type: "literal", value: null, offset: token.offset };
+      throw new RestrictedCelError(
+        `unknown identifier ${JSON.stringify(token.value)}`,
+        token.offset,
+      );
+    }
+    if (token.value === "(") {
+      const expression = this.parseConditional();
+      this.expect(")");
+      return expression;
+    }
+    if (token.value === "[") return this.parseArray(token.offset);
+    if (token.value === "{") return this.parseObject(token.offset);
+    throw new RestrictedCelError(`unexpected token ${JSON.stringify(token.value)}`, token.offset);
+  }
+
+  private parseArray(offset: number): RestrictedCelExpression {
+    const elements: RestrictedCelExpression[] = [];
+    if (!this.consume("]")) {
+      do elements.push(this.parseConditional());
+      while (this.consume(","));
+      this.expect("]");
+    }
+    return { type: "array", elements: Object.freeze(elements), offset };
+  }
+
+  private parseObject(offset: number): RestrictedCelExpression {
+    const entries: { key: string; value: RestrictedCelExpression; offset: number }[] = [];
+    const keys = new Set<string>();
+    if (!this.consume("}")) {
+      do {
+        const key = this.advance();
+        if (key.kind !== "string") {
+          throw new RestrictedCelError("object keys must be string literals", key.offset);
+        }
+        if (keys.has(key.value)) {
+          throw new RestrictedCelError(
+            `duplicate object key ${JSON.stringify(key.value)}`,
+            key.offset,
+          );
+        }
+        keys.add(key.value);
+        this.expect(":");
+        entries.push({ key: key.value, value: this.parseConditional(), offset: key.offset });
+      } while (this.consume(","));
+      this.expect("}");
+    }
+    return { type: "object", entries: Object.freeze(entries), offset };
+  }
+
+  private consume(value: string): boolean {
+    if (this.current().value !== value) return false;
+    this.#index += 1;
+    return true;
+  }
+
+  private expect(value: string): RestrictedCelToken {
+    const token = this.current();
+    if (token.value !== value) {
+      throw new RestrictedCelError(`expected ${JSON.stringify(value)}`, token.offset);
+    }
+    this.#index += 1;
+    return token;
+  }
+
+  private advance(): RestrictedCelToken {
+    const token = this.current();
+    if (token.kind !== "eof") this.#index += 1;
+    return token;
+  }
+
+  private current(): RestrictedCelToken {
+    return this.tokens[this.#index] ?? this.tokens[this.tokens.length - 1]!;
+  }
+}

package/server/vendor/zcode/packages/model-option-map/src/tokenizer.ts

@@ -0,0 +1,141 @@
+import { RestrictedCelError } from "./types.js";
+
+export type RestrictedCelTokenKind =
+  | "identifier"
+  | "string"
+  | "number"
+  | "operator"
+  | "punctuation"
+  | "eof";
+
+export interface RestrictedCelToken {
+  readonly kind: RestrictedCelTokenKind;
+  readonly value: string;
+  readonly offset: number;
+  readonly end: number;
+}
+
+const DOUBLE_OPERATORS = new Set(["&&", "||", "==", "!=", "<=", ">="]);
+const SINGLE_OPERATORS = new Set(["+", "-", "*", "/", "%", "!", "<", ">"]);
+const PUNCTUATION = new Set(["{", "}", "[", "]", "(", ")", ",", ":", "?", "."]);
+
+export function tokenizeRestrictedCel(source: string): readonly RestrictedCelToken[] {
+  const tokens: RestrictedCelToken[] = [];
+  let offset = 0;
+  while (offset < source.length) {
+    const character = source[offset]!;
+    if (/\s/u.test(character)) {
+      offset += 1;
+      continue;
+    }
+
+    if (character === "'" || character === '"') {
+      const token = readString(source, offset, character);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+
+    if (/[0-9]/u.test(character)) {
+      const token = readNumber(source, offset);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+
+    if (/[A-Za-z_]/u.test(character)) {
+      const end = readWhile(source, offset + 1, /[A-Za-z0-9_]/u);
+      tokens.push({ kind: "identifier", value: source.slice(offset, end), offset, end });
+      offset = end;
+      continue;
+    }
+
+    const pair = source.slice(offset, offset + 2);
+    if (DOUBLE_OPERATORS.has(pair)) {
+      tokens.push({ kind: "operator", value: pair, offset, end: offset + 2 });
+      offset += 2;
+      continue;
+    }
+    if (SINGLE_OPERATORS.has(character)) {
+      tokens.push({ kind: "operator", value: character, offset, end: offset + 1 });
+      offset += 1;
+      continue;
+    }
+    if (PUNCTUATION.has(character)) {
+      tokens.push({ kind: "punctuation", value: character, offset, end: offset + 1 });
+      offset += 1;
+      continue;
+    }
+    throw new RestrictedCelError(`unsupported token ${JSON.stringify(character)}`, offset);
+  }
+  tokens.push({ kind: "eof", value: "", offset: source.length, end: source.length });
+  return Object.freeze(tokens);
+}
+
+function readNumber(source: string, offset: number): RestrictedCelToken {
+  const match = /^(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(source.slice(offset));
+  if (!match) throw new RestrictedCelError("invalid number literal", offset);
+  const value = match[0];
+  const end = offset + value.length;
+  return { kind: "number", value, offset, end };
+}
+
+function readString(source: string, offset: number, quote: "'" | '"'): RestrictedCelToken {
+  let cursor = offset + 1;
+  let value = "";
+  while (cursor < source.length) {
+    const character = source[cursor]!;
+    if (character === quote) {
+      return { kind: "string", value, offset, end: cursor + 1 };
+    }
+    if (character === "\n" || character === "\r") {
+      throw new RestrictedCelError("unterminated string literal", offset);
+    }
+    if (character !== "\\") {
+      value += character;
+      cursor += 1;
+      continue;
+    }
+
+    const escapeOffset = cursor;
+    cursor += 1;
+    const escaped = source[cursor];
+    if (escaped === undefined) {
+      throw new RestrictedCelError("unterminated string escape", escapeOffset);
+    }
+    const simpleEscape = SIMPLE_ESCAPES[escaped];
+    if (simpleEscape !== undefined) {
+      value += simpleEscape;
+      cursor += 1;
+      continue;
+    }
+    if (escaped === "u") {
+      const digits = source.slice(cursor + 1, cursor + 5);
+      if (!/^[0-9A-Fa-f]{4}$/u.test(digits)) {
+        throw new RestrictedCelError("invalid unicode escape", escapeOffset);
+      }
+      value += String.fromCharCode(Number.parseInt(digits, 16));
+      cursor += 5;
+      continue;
+    }
+    throw new RestrictedCelError(`unsupported string escape \\${escaped}`, escapeOffset);
+  }
+  throw new RestrictedCelError("unterminated string literal", offset);
+}
+
+const SIMPLE_ESCAPES: Readonly<Record<string, string>> = Object.freeze({
+  "'": "'",
+  '"': '"',
+  "\\": "\\",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "\t",
+});
+
+function readWhile(source: string, offset: number, pattern: RegExp): number {
+  let cursor = offset;
+  while (cursor < source.length && pattern.test(source[cursor]!)) cursor += 1;
+  return cursor;
+}

package/server/vendor/zcode/packages/model-option-map/src/types.ts

@@ -0,0 +1,36 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+
+export interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
+export type RestrictedCelValue = string | number;
+export type ModelOptionName = "reasoningLevel" | "maxOutputTokens";
+
+export interface RestrictedCelProgram {
+  readonly source: string;
+  evaluate(input: RestrictedCelValue): JsonValue;
+}
+
+export interface ModelOptionMapProgram {
+  readonly source: string;
+  evaluate(input: RestrictedCelValue): JsonObject;
+}
+
+export class RestrictedCelError extends Error {
+  readonly offset: number;
+
+  constructor(message: string, offset: number) {
+    super(`${message} at offset ${offset}`);
+    this.name = "RestrictedCelError";
+    this.offset = offset;
+  }
+}
+
+export class ModelOptionMapError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ModelOptionMapError";
+  }
+}

package/server/vendor/zcode/packages/rpc/src/buffer.ts

@@ -0,0 +1,88 @@
+/**
+ * Layer 0.5: 跨平台 Buffer 抽象
+ *
+ * VS Code 需要在 Node.js (Buffer) 和浏览器 (Uint8Array) 之间统一二进制操作。
+ * VSBuffer 是对 Uint8Array 的薄封装，提供统一的读写接口。
+ *
+ * 这是序列化层和传输层的基础。
+ */
+
+export class VSBuffer {
+  readonly buffer: Uint8Array;
+  readonly byteLength: number;
+
+  private constructor(buffer: Uint8Array) {
+    this.buffer = buffer;
+    this.byteLength = buffer.byteLength;
+  }
+
+  /** 分配指定大小的空 buffer */
+  static alloc(byteLength: number): VSBuffer {
+    return new VSBuffer(new Uint8Array(byteLength));
+  }
+
+  /** 包装已有的 Uint8Array */
+  static wrap(buffer: Uint8Array): VSBuffer {
+    return new VSBuffer(buffer);
+  }
+
+  /** 从字符串创建 buffer (UTF-8) */
+  static fromString(str: string): VSBuffer {
+    const encoder = new TextEncoder();
+    return new VSBuffer(encoder.encode(str));
+  }
+
+  /** 拼接多个 buffer */
+  static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer {
+    const len = totalLength ?? buffers.reduce((sum, b) => sum + b.byteLength, 0);
+    const result = VSBuffer.alloc(len);
+    let offset = 0;
+    for (const buf of buffers) {
+      result.set(buf, offset);
+      offset += buf.byteLength;
+    }
+    return result;
+  }
+
+  /** 转为 UTF-8 字符串 */
+  toString(): string {
+    const decoder = new TextDecoder();
+    return decoder.decode(this.buffer);
+  }
+
+  /** 切片 */
+  slice(start: number, end?: number): VSBuffer {
+    return new VSBuffer(this.buffer.slice(start, end));
+  }
+
+  /** 拷贝数据到 this buffer 的指定位置 */
+  set(source: VSBuffer | Uint8Array, offset = 0): void {
+    const raw = source instanceof VSBuffer ? source.buffer : source;
+    this.buffer.set(raw, offset);
+  }
+
+  readUInt8(offset: number): number {
+    return this.buffer[offset];
+  }
+
+  writeUInt8(value: number, offset: number): void {
+    this.buffer[offset] = value;
+  }
+
+  readUInt32BE(offset: number): number {
+    return (
+      ((this.buffer[offset] << 24) |
+        (this.buffer[offset + 1] << 16) |
+        (this.buffer[offset + 2] << 8) |
+        this.buffer[offset + 3]) >>>
+      0
+    );
+  }
+
+  writeUInt32BE(value: number, offset: number): void {
+    this.buffer[offset] = (value >>> 24) & 0xff;
+    this.buffer[offset + 1] = (value >>> 16) & 0xff;
+    this.buffer[offset + 2] = (value >>> 8) & 0xff;
+    this.buffer[offset + 3] = value & 0xff;
+  }
+}