@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/config/config-parser.test.ts

@@ -1,319 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import os from "os";
-import { ProtocolResolver } from "./protocol-resolver";
-
-describe("parseJSONC", () => {
-  test("should parse valid JSON", () => {
-    // Dynamic import to ensure module is loaded
-    const { parseJSONC } = require("./config-parser");
-    const content = '{"name": "test", "value": 123}';
-    const result = parseJSONC(content);
-    expect(result).toEqual({ name: "test", value: 123 });
-  });
-
-  test("should handle single-line comments", () => {
-    const { parseJSONC } = require("./config-parser");
-    const content = `{
-      // This is a comment
-      "name": "test"
-    }`;
-    const result = parseJSONC(content);
-    expect(result).toEqual({ name: "test" });
-  });
-
-  test("should handle multi-line comments", () => {
-    const { parseJSONC } = require("./config-parser");
-    const content = `{
-      /* This is
-         a multi-line
-         comment */
-      "name": "test"
-    }`;
-    const result = parseJSONC(content);
-    expect(result).toEqual({ name: "test" });
-  });
-
-  test("should handle trailing comments", () => {
-    const { parseJSONC } = require("./config-parser");
-    const content = `{
-      "name": "test"  // trailing comment
-    }`;
-    const result = parseJSONC(content);
-    expect(result).toEqual({ name: "test" });
-  });
-
-  test("should handle mixed comments", () => {
-    const { parseJSONC } = require("./config-parser");
-    const content = `{
-      // Header comment
-      "name": "test",  // inline comment
-      /* Block comment */
-      "value": 123
-    }`;
-    const result = parseJSONC(content);
-    expect(result).toEqual({ name: "test", value: 123 });
-  });
-
-  test("should handle empty JSONC file", () => {
-    const { parseJSONC } = require("./config-parser");
-    const result = parseJSONC("// just a comment\n\n// another comment");
-    expect(result).toEqual({});
-  });
-});
-
-describe("substituteEnvVars", () => {
-  test("should substitute simple env var", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.TEST_VAR = "hello";
-    const result = substituteEnvVars("${TEST_VAR}");
-    expect(result).toBe("hello");
-    delete process.env.TEST_VAR;
-  });
-
-  test("should handle missing env var with empty string", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    delete process.env.NONEXISTENT_VAR;
-    const result = substituteEnvVars("${NONEXISTENT_VAR}");
-    expect(result).toBe("");
-  });
-
-  test("should handle default value syntax", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    delete process.env.NONEXISTENT_VAR;
-    const result = substituteEnvVars("${NONEXISTENT_VAR:-fallback}");
-    expect(result).toBe("fallback");
-  });
-
-  test("should prefer env var over default", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.EXISTING_VAR = "actual";
-    const result = substituteEnvVars("${EXISTING_VAR:-default}");
-    expect(result).toBe("actual");
-    delete process.env.EXISTING_VAR;
-  });
-
-  test("should substitute in object values", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.API_KEY = "secret123";
-    const result = substituteEnvVars({ apiKey: "${API_KEY}" });
-    expect(result).toEqual({ apiKey: "secret123" });
-    delete process.env.API_KEY;
-  });
-
-  test("should handle nested objects", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.HOST = "localhost";
-    process.env.PORT = "3000";
-    const result = substituteEnvVars({
-      server: { host: "${HOST}", port: "${PORT}" }
-    });
-    expect(result).toEqual({ server: { host: "localhost", port: "3000" } });
-    delete process.env.HOST;
-    delete process.env.PORT;
-  });
-
-  test("should preserve non-string values", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.NUM = "42";
-    const result = substituteEnvVars({ count: "${NUM}", enabled: true, rate: 0.5 });
-    expect(result).toEqual({ count: "42", enabled: true, rate: 0.5 });
-    delete process.env.NUM;
-  });
-
-  test("should handle arrays", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.ITEM1 = "a";
-    process.env.ITEM2 = "b";
-    const result = substituteEnvVars(["${ITEM1}", "${ITEM2}"]);
-    expect(result).toEqual(["a", "b"]);
-    delete process.env.ITEM1;
-    delete process.env.ITEM2;
-  });
-
-  test("should handle mixed arrays with strings and values", () => {
-    const { substituteEnvVars } = require("./config-parser");
-    process.env.VALUE = "test";
-    const result = substituteEnvVars(["${VALUE}", 123, true, null]);
-    expect(result).toEqual(["test", 123, true, null]);
-    delete process.env.VALUE;
-  });
-});
-
-describe("parseJSONCWithEnv", () => {
-  test("should parse JSONC and substitute env vars", () => {
-    const { parseJSONCWithEnv } = require("./config-parser");
-    process.env.API_KEY = "my-secret";
-    const content = '{\n      // API Configuration\n      "apiKey": "${API_KEY}",\n      "model": "gpt-4o"\n    }';
-    const result = parseJSONCWithEnv(content);
-    expect(result).toEqual({ apiKey: "my-secret", model: "gpt-4o" });
-    delete process.env.API_KEY;
-  });
-});
-
-describe("substituteProtocolRefs", () => {
-  const testDir = path.join(__dirname, ".test-protocol-subst");
-  let resolver: ProtocolResolver;
-
-  beforeEach(async () => {
-    // 创建测试目录
-    await fs.promises.mkdir(testDir, { recursive: true });
-    resolver = new ProtocolResolver({ xdgDataHome: testDir });
-  });
-
-  afterEach(async () => {
-    // 清理测试目录
-    try {
-      await fs.promises.rm(testDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  test("should substitute file:// protocol reference", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    // 创建测试文件
-    const configPath = path.join(testDir, "api.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({ key: "file-key-123" }), "utf-8");
-    
-    const result = substituteProtocolRefs("${file://api.json#key}", resolver);
-    expect(result).toBe("file-key-123");
-  });
-
-  test("should substitute file:// protocol reference from external file", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const refPath = path.join(testDir, "ref.json");
-    await fs.promises.writeFile(refPath, JSON.stringify({ token: "file-token-456" }), "utf-8");
-    
-    const fileResolver = new ProtocolResolver({
-      xdgDataHome: testDir,
-    });
-    
-    const result = substituteProtocolRefs("${file://ref.json#token}", fileResolver);
-    expect(result).toBe("file-token-456");
-  });
-
-  test("should substitute env:// protocol reference", () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    process.env.PROTOCOL_TEST_VAR = "env-value-789";
-    
-    const result = substituteProtocolRefs("${env://PROTOCOL_TEST_VAR}", resolver);
-    expect(result).toBe("env-value-789");
-    
-    delete process.env.PROTOCOL_TEST_VAR;
-  });
-
-  test("should preserve original value when protocol reference is invalid", () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const result = substituteProtocolRefs("plain text", resolver);
-    expect(result).toBe("plain text");
-  });
-
-  test("should preserve original value when file does not exist", () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const result = substituteProtocolRefs("${file://nonexistent.json#key}", resolver);
-    expect(result).toBe("${file://nonexistent.json#key}");
-  });
-
-  test("should substitute in object values", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const configPath = path.join(testDir, "server.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({ host: "localhost", port: 8080 }), "utf-8");
-    
-    const result = substituteProtocolRefs(
-      { api: "${file://server.json#host}", port: "${file://server.json#port}" },
-      resolver
-    );
-    expect(result).toEqual({ api: "localhost", port: 8080 });
-  });
-
-  test("should handle nested objects", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const configPath = path.join(testDir, "nested.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({
-      db: { host: "db.example.com", credentials: { user: "admin" } }
-    }), "utf-8");
-    
-    const result = substituteProtocolRefs(
-      { connection: "${file://nested.json#db.host}", user: "${file://nested.json#db.credentials.user}" },
-      resolver
-    );
-    expect(result).toEqual({ connection: "db.example.com", user: "admin" });
-  });
-
-  test("should preserve non-string values", () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const result = substituteProtocolRefs(
-      { count: 123, enabled: true, data: null },
-      resolver
-    );
-    expect(result).toEqual({ count: 123, enabled: true, data: null });
-  });
-
-  test("should handle arrays with protocol references", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const configPath = path.join(testDir, "items.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({ item1: "a", item2: "b" }), "utf-8");
-    
-    const result = substituteProtocolRefs(
-      ["${file://items.json#item1}", "${file://items.json#item2}"],
-      resolver
-    );
-    expect(result).toEqual(["a", "b"]);
-  });
-
-  test("should handle mixed arrays with protocol references and regular values", async () => {
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const configPath = path.join(testDir, "mixed.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({ value: "from-file" }), "utf-8");
-    
-    const result = substituteProtocolRefs(
-      ["${file://mixed.json#value}", 123, true, "plain"],
-      resolver
-    );
-    expect(result).toEqual(["from-file", 123, true, "plain"]);
-  });
-});
-
-describe("parseJSONCWithProtocols", () => {
-  const testDir = path.join(__dirname, ".test-protocol-parse");
-  let resolver: ProtocolResolver;
-
-  beforeEach(async () => {
-    await fs.promises.mkdir(testDir, { recursive: true });
-    resolver = new ProtocolResolver({ xdgDataHome: testDir });
-  });
-
-  afterEach(async () => {
-    try {
-      await fs.promises.rm(testDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  test("should parse JSONC and substitute protocol refs", async () => {
-    // 注意：JSONC 的单行注释解析器会错误处理字符串内部的 "//" 语法
-    // 所以这里使用 substituteProtocolRefs 直接测试，绕过 JSONC 解析
-    const { substituteProtocolRefs } = require("./config-parser");
-    
-    const configPath = path.join(testDir, "api.json");
-    await fs.promises.writeFile(configPath, JSON.stringify({ key: "secret-key" }), "utf-8");
-    
-    // 先创建已解析的 JSON 对象（模拟 parseJSONC 的结果）
-    const parsed = { apiKey: "${file://api.json#key}", model: "gpt-4o" };
-    
-    const result = substituteProtocolRefs(parsed, resolver);
-    expect(result).toEqual({ apiKey: "secret-key", model: "gpt-4o" });
-  });
-});

package/src/config/config-parser.ts

@@ -1,203 +0,0 @@
-/**
- * Configuration Parser
- * 
- * Provides JSONC parsing and environment/protocol variable substitution
- */
-import { parse as parseJSONCInternal, ParseErrorCode } from "jsonc-parser";
-import { ProtocolResolver } from "./protocol-resolver";
-
-/**
- * Parse JSONC (JSON with Comments) content
- * Supports single-line comments (//) and multi-line comments
- * 
- * @param content - JSONC content string
- * @returns Parsed JSON object
- */
-export function parseJSONC(content: string): Record<string, unknown> {
-  const errors: any[] = [];
-  const result = parseJSONCInternal(content, errors, {
-    allowTrailingComma: true,
-    disallowComments: false,
-  });
-  
-  if (errors.length > 0) {
-    // 过滤掉"没有值"的警告（文件只有注释时会出现）
-    // 只有当 result 是 undefined 且只有一个 ValueExpected 错误时才忽略
-    const hasOnlyValueExpected = 
-      result === undefined && 
-      errors.length === 1 && 
-      errors[0].error === ParseErrorCode.ValueExpected;
-    
-    if (!hasOnlyValueExpected) {
-      const error = errors[0];
-      const offset = error.offset;
-      const lines = content.substring(0, offset).split("\n");
-      const line = lines.length;
-      const col = lines[lines.length - 1].length + 1;
-      
-      const errorMessages: Record<number, string> = {
-        [ParseErrorCode.UnexpectedEndOfString]: "Unexpected end of string",
-        [ParseErrorCode.InvalidCharacter]: "Invalid character",
-        [ParseErrorCode.PropertyNameExpected]: "Property name expected",
-        [ParseErrorCode.ValueExpected]: "Value expected",
-        [ParseErrorCode.ColonExpected]: "Colon expected",
-        [ParseErrorCode.CommaExpected]: "Comma expected",
-        [ParseErrorCode.CloseBraceExpected]: "Close brace expected",
-        [ParseErrorCode.CloseBracketExpected]: "Close bracket expected",
-        [ParseErrorCode.EndOfFileExpected]: "Unexpected end of input",
-        [ParseErrorCode.InvalidSymbol]: "Invalid symbol",
-      };
-      
-      throw new Error(
-        `JSONC parse error at line ${line}, col ${col}: ${errorMessages[error.error] || "Unknown error"}`
-      );
-    }
-  }
-  
-  // 处理空内容（只有注释的情况）
-  if (result === undefined || result === null) {
-    return {};
-  }
-  
-  return result as Record<string, unknown>;
-}
-
-/**
- * Substitute environment variables in a value
- * Supports ${VAR} and ${VAR:-default} syntax
- * 
- * @param value - Value to substitute (string, object, array, or primitive)
- * @returns Value with environment variables substituted
- */
-export function substituteEnvVars(value: unknown): unknown {
-  if (typeof value === "string") {
-    return value.replace(/\$\{([^}]+)\}/g, (match, varExpr) => {
-      const [varName, defaultValue] = varExpr.split(":-");
-      const envValue = process.env[varName.trim()];
-      if (envValue !== undefined) {
-        return envValue;
-      }
-      if (defaultValue !== undefined) {
-        return defaultValue;
-      }
-      return "";
-    });
-  }
-  
-  if (Array.isArray(value)) {
-    return value.map(item => substituteEnvVars(item));
-  }
-  
-  if (value !== null && typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = substituteEnvVars(val);
-    }
-    return result;
-  }
-  
-  return value;
-}
-
-/**
- * Parse JSONC content and substitute environment variables
- * 
- * @param content - JSONC content string
- * @returns Parsed JSON object with env vars substituted
- */
-export function parseJSONCWithEnv(content: string): Record<string, unknown> {
-  const parsed = parseJSONC(content);
-  return substituteEnvVars(parsed) as Record<string, unknown>;
-}
-
-/**
- * Protocol reference pattern - 支持带默认值的协议引用
- * 格式: ${protocol://path#key:-default} 或 ${protocol://path:-default}
- */
-const PROTOCOL_REF_PATTERN = /^\$\{([^:]+):\/\/[^}]+\}$/;
-
-/**
- * Protocol reference with default value pattern
- * 格式: ${protocol://path#key:-default}
- */
-const PROTOCOL_REF_WITH_DEFAULT_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
-
-/**
- * Check if a string is a protocol reference
- */
-function isProtocolRefString(value: string): boolean {
-  return PROTOCOL_REF_PATTERN.test(value);
-}
-
-/**
- * Extract default value from protocol reference string
- */
-function extractDefaultValue(ref: string): string | undefined {
-  const match = ref.match(PROTOCOL_REF_WITH_DEFAULT_PATTERN);
-  return match ? match[4] : undefined;
-}
-
-/**
- * Substitute protocol references in a value using the provided resolver
- * 
- * Supports:
- * - ${file://path#key} - Read from file
- * - ${env://varName} - Read from environment variable
- * - All above with default values: ${protocol://...:-default}
- * 
- * @param value - Value to substitute (string, object, array, or primitive)
- * @param resolver - ProtocolResolver instance
- * @returns Value with protocol references substituted
- */
-export function substituteProtocolRefs(
-  value: unknown,
-  resolver: ProtocolResolver
-): unknown {
-  if (typeof value === "string") {
-    // 如果整个字符串就是协议引用，尝试解析
-    if (isProtocolRefString(value)) {
-      const result = resolver.resolve(value);
-      if (result !== null) {
-        return result.value;
-      }
-      // 解析失败，检查是否有默认值
-      const defaultValue = extractDefaultValue(value);
-      if (defaultValue !== undefined) {
-        return defaultValue;
-      }
-    }
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(item => substituteProtocolRefs(item, resolver));
-  }
-
-  if (value !== null && typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = substituteProtocolRefs(val, resolver);
-    }
-    return result;
-  }
-
-  return value;
-}
-
-/**
- * Parse JSONC content and substitute protocol references
- * 
- * @param content - JSONC content string
- * @param resolver - ProtocolResolver instance
- * @returns Parsed JSON object with protocol refs substituted
- */
-export function parseJSONCWithProtocols(
-  content: string,
-  resolver: ProtocolResolver
-): Record<string, unknown> {
-  const parsed = parseJSONC(content);
-  // 先解析协议引用（保护协议引用不被环境变量替换破坏）
-  const withProtocols = substituteProtocolRefs(parsed, resolver) as Record<string, unknown>;
-  // 再解析环境变量（只处理非协议引用的字符串）
-  return substituteEnvVars(withProtocols) as Record<string, unknown>;
-}