@h-ai/core 0.1.0-alpha5

package/dist/node.d.ts

@@ -0,0 +1,82 @@
+import { H as HaiError, a as HaiResult, C as CoreOptions, b as CoreLogger, I as I18nFn, c as IdFn, T as TypeUtilFn, O as ObjectFn, S as StringFn, A as ArrayFn, d as AsyncFn, e as TimeFn, E as ErrorFn, M as ModuleFn } from './core-util-module-B-wH5_ZT.js';
+export { f as CoreConfig, g as CoreConfigSchema, h as CoreFunctions, i as Env, j as EnvSchema, k as ErrorInfo, l as ErrorInfoValue, m as HaiCommonError, n as HaiConfigError, o as HaiErrorDef, p as IdConfig, q as IdConfigSchema, r as InterpolationParams, L as Locale, s as LocaleInfo, t as LocaleMessages, u as LogContext, v as LogFormat, w as LogFormatSchema, x as LogLevel, y as LogLevelSchema, z as Logger, B as LoggerFunctions, D as LoggerOptions, F as LoggingConfig, G as LoggingConfigSchema, J as MatchHandlers, K as MessageDictionary, N as MessageOptions, P as PaginatedResult, Q as PaginationOptions, R as PaginationOptionsInput, U as err, V as ok } from './core-util-module-B-wH5_ZT.js';
+import * as zod from 'zod';
+
+/**
+ * @h-ai/core — 配置管理（Node.js 专用）
+ *
+ * 提供 YAML 配置文件加载、环境变量插值、缓存管理。
+ * @module core-function-config
+ */
+
+/**
+ * 监听回调类型。
+ *
+ * @template T - 配置数据类型
+ *
+ * @example
+ * ```ts
+ * const callback: WatchCallback<AppConfig> = (cfg, error) => {
+ *   if (error) { core.logger.error('Config reload failed', { error }); return }
+ *   // 使用更新后的 cfg
+ * }
+ * ```
+ */
+type WatchCallback<T = unknown> = (config: T | null, error?: HaiError) => void;
+
+/**
+ * Core 服务对象 - 聚合常用功能（Node.js）。
+ *
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * core.init({ configDir: './config' })
+ * ```
+ */
+declare const core: {
+    /** 配置管理 */
+    config: {
+        load<T>(name: string, filePath: string, schema?: zod.ZodType<T>): HaiResult<T>;
+        validate<T>(name: string, schema: zod.ZodType<T>): HaiResult<T>;
+        get<T>(name: string): T | undefined;
+        getOrThrow<T>(name: string): T;
+        reload(name: string): HaiResult<unknown>;
+        has(name: string): boolean;
+        clear(name?: string): void;
+        keys(): string[];
+        watch<T = unknown>(name: string, callback: WatchCallback<T>): () => void;
+        unwatch(name?: string): void;
+        isWatching(name: string): boolean;
+    };
+    /** 初始化 Core */
+    init: typeof initCore;
+    logger: CoreLogger;
+    i18n: I18nFn;
+    id: IdFn;
+    typeUtils: TypeUtilFn;
+    object: ObjectFn;
+    string: StringFn;
+    array: ArrayFn;
+    async: AsyncFn;
+    time: TimeFn;
+    error: ErrorFn;
+    module: ModuleFn;
+};
+/**
+ * 初始化 Core（内部实现，通过 `core.init()` 调用）。
+ *
+ * 执行流程：
+ * 1. 配置日志（若提供 `options.logging`）
+ * 2. 扫描并加载配置目录中的所有 YAML 文件
+ * 3. 启用配置文件监听（若 `options.watchConfig` 为 true）
+ *
+ * @param options - 初始化选项
+ *
+ * @example
+ * ```ts
+ * core.init({ configDir: './config', watchConfig: true })
+ * ```
+ */
+declare function initCore(options?: CoreOptions): void;
+
+export { CoreLogger, CoreOptions, HaiError, HaiResult, core };

package/dist/node.js

@@ -0,0 +1,643 @@
+import { createCore, CoreConfigSchema, i18n, err, HaiConfigError, ok, typeUtils } from './chunk-2GTCDC56.js';
+export { CoreConfigSchema, EnvSchema, HaiCommonError, HaiConfigError, IdConfigSchema, LogFormatSchema, LogLevelSchema, LoggingConfigSchema, err, ok } from './chunk-2GTCDC56.js';
+import { existsSync, readdirSync, watch, readFileSync } from 'fs';
+import { join } from 'path';
+import process2 from 'process';
+import { parse } from 'yaml';
+import { execSync } from 'child_process';
+import pino from 'pino';
+
+var ENV_VAR_PATTERN = /\$\{([^}:]+)(?::([^}]*))?\}/g;
+var FULL_VAR_PATTERN = /^\$\{[^}:]+(?::[^}]*)?\}$/;
+function interpolateEnv(value) {
+  if (typeof value === "string") {
+    let result = value;
+    ENV_VAR_PATTERN.lastIndex = 0;
+    while (true) {
+      const match = ENV_VAR_PATTERN.exec(value);
+      if (!match)
+        break;
+      const [fullMatch, varName, defaultValue] = match;
+      const envValue = process2.env[varName];
+      if (envValue === void 0 && defaultValue === void 0) {
+        return err(HaiConfigError.CONFIG_ENV_VAR_MISSING, i18n.coreM("core_configEnvVarMissing", { params: { varName } }));
+      }
+      result = result.replace(fullMatch, envValue ?? defaultValue ?? "");
+    }
+    if (FULL_VAR_PATTERN.test(value)) {
+      try {
+        const coerced = parse(result);
+        if (coerced !== void 0)
+          return ok(coerced);
+      } catch {
+      }
+    }
+    return ok(result);
+  }
+  if (Array.isArray(value)) {
+    const results = [];
+    for (const item of value) {
+      const r = interpolateEnv(item);
+      if (!r.success)
+        return r;
+      results.push(r.data);
+    }
+    return ok(results);
+  }
+  if (typeUtils.isObject(value)) {
+    const results = {};
+    for (const [k, v] of Object.entries(value)) {
+      const r = interpolateEnv(v);
+      if (!r.success)
+        return r;
+      results[k] = r.data;
+    }
+    return ok(results);
+  }
+  return ok(value);
+}
+var configCache = /* @__PURE__ */ new Map();
+var watchEntries = /* @__PURE__ */ new Map();
+function createNotLoadedError(name) {
+  const result = err(HaiConfigError.CONFIG_NOT_LOADED, i18n.coreM("core_configNotLoaded", { params: { name } }));
+  if (!result.success)
+    return result.error;
+  throw new Error("unreachable");
+}
+function notifyWatchCallbacks(name, result) {
+  const entry = watchEntries.get(name);
+  if (!entry)
+    return;
+  if (result.success) {
+    for (const callback of entry.callbacks) {
+      try {
+        callback(result.data, void 0);
+      } catch {
+      }
+    }
+  } else {
+    for (const callback of entry.callbacks) {
+      try {
+        callback(null, result.error);
+      } catch {
+      }
+    }
+  }
+}
+function loadYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return err(HaiConfigError.CONFIG_FILE_NOT_FOUND, i18n.coreM("core_configFileNotExist", { params: { filePath } }));
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parse(content);
+    return interpolateEnv(parsed);
+  } catch (error) {
+    return err(HaiConfigError.CONFIG_PARSE_ERROR, i18n.coreM("core_configParseFailed", { params: { filePath } }), error);
+  }
+}
+function loadConfig(filePath, schema) {
+  const yamlResult = loadYaml(filePath);
+  if (!yamlResult.success)
+    return yamlResult;
+  const parseResult = schema.safeParse(yamlResult.data);
+  if (!parseResult.success) {
+    return err(HaiConfigError.CONFIG_VALIDATION_ERROR, i18n.coreM("core_configValidationFailed"), parseResult.error.issues);
+  }
+  return ok(parseResult.data);
+}
+function loadAndCache(name, filePath, schema) {
+  const result = schema ? loadConfig(filePath, schema) : loadYaml(filePath);
+  if (result.success) {
+    configCache.set(name, {
+      data: result.data,
+      filePath,
+      schema,
+      loadedAt: Date.now()
+    });
+  }
+  return result;
+}
+function validateLoadedConfig(name, schema) {
+  const entry = configCache.get(name);
+  if (!entry) {
+    return err(createNotLoadedError(name));
+  }
+  const parseResult = schema.safeParse(entry.data);
+  if (!parseResult.success) {
+    return err(HaiConfigError.CONFIG_VALIDATION_ERROR, i18n.coreM("core_configValidationFailed"), parseResult.error.issues);
+  }
+  const validated = parseResult.data;
+  configCache.set(name, {
+    ...entry,
+    data: validated,
+    schema,
+    loadedAt: Date.now()
+  });
+  return ok(validated);
+}
+function reloadAndNotify(name) {
+  const entry = configCache.get(name);
+  if (!entry) {
+    const result2 = err(createNotLoadedError(name));
+    notifyWatchCallbacks(name, result2);
+    return result2;
+  }
+  const result = entry.schema ? loadConfig(entry.filePath, entry.schema) : loadYaml(entry.filePath);
+  if (result.success) {
+    configCache.set(name, {
+      ...entry,
+      data: result.data,
+      loadedAt: Date.now()
+    });
+  }
+  notifyWatchCallbacks(name, result);
+  return result;
+}
+function startFileWatcher(name) {
+  const existing = watchEntries.get(name);
+  if (existing)
+    return existing;
+  const entry = configCache.get(name);
+  if (!entry)
+    return null;
+  try {
+    const watchEntry = {
+      watcher: null,
+      callbacks: /* @__PURE__ */ new Set(),
+      debounceTimer: null
+    };
+    const watcher = watch(entry.filePath, (eventType) => {
+      if (eventType === "change") {
+        if (watchEntry.debounceTimer)
+          clearTimeout(watchEntry.debounceTimer);
+        watchEntry.debounceTimer = setTimeout(() => {
+          watchEntry.debounceTimer = null;
+          reloadAndNotify(name);
+        }, 100);
+      }
+    });
+    watchEntry.watcher = watcher;
+    watchEntries.set(name, watchEntry);
+    return watchEntry;
+  } catch {
+    return null;
+  }
+}
+function registerWatch(name, callback) {
+  const entry = startFileWatcher(name);
+  if (!entry) {
+    callback(null, createNotLoadedError(name));
+    return () => {
+    };
+  }
+  entry.callbacks.add(callback);
+  return () => {
+    const current = watchEntries.get(name);
+    if (!current)
+      return;
+    current.callbacks.delete(callback);
+    if (current.callbacks.size === 0) {
+      if (current.debounceTimer)
+        clearTimeout(current.debounceTimer);
+      current.watcher.close();
+      watchEntries.delete(name);
+    }
+  };
+}
+function stopWatching(name) {
+  if (name) {
+    const entry = watchEntries.get(name);
+    if (entry) {
+      if (entry.debounceTimer)
+        clearTimeout(entry.debounceTimer);
+      entry.watcher.close();
+      watchEntries.delete(name);
+    }
+  } else {
+    for (const entry of watchEntries.values()) {
+      if (entry.debounceTimer)
+        clearTimeout(entry.debounceTimer);
+      entry.watcher.close();
+    }
+    watchEntries.clear();
+  }
+}
+function clearCache(name) {
+  if (name) {
+    configCache.delete(name);
+    stopWatching(name);
+  } else {
+    configCache.clear();
+    stopWatching();
+  }
+}
+var config = {
+  /**
+   * 加载配置到缓存。
+   *
+   * 加载 YAML 文件并可选地用 Zod Schema 校验，成功后写入缓存。
+   *
+   * @param name - 配置名称（缓存 key）
+   * @param filePath - YAML 文件路径
+   * @param schema - 可选 Zod Schema（不传则跳过校验）
+   * @returns 成功时返回解析后的配置数据；失败时返回 HaiError
+   *
+   * @example
+   * ```ts
+   * const result = config.load('core', './config/_core.yml', CoreConfigSchema)
+   * if (result.success) {
+   *   // result.data 为校验后的配置
+   * }
+   * ```
+   */
+  load(name, filePath, schema) {
+    return loadAndCache(name, filePath, schema);
+  },
+  /**
+   * 验证已加载的配置数据。
+   *
+   * 对缓存中的配置数据重新用 Schema 校验，校验通过后更新缓存。
+   *
+   * @param name - 配置名称
+   * @param schema - Zod 验证模式
+   * @returns 校验结果；未加载时返回 NOT_LOADED，格式错误返回 VALIDATION_ERROR
+   *
+   * @example
+   * ```ts
+   * const result = config.validate('app', AppSchema)
+   * if (!result.success) {
+   *   // result.error.code 可能为 NOT_LOADED 或 VALIDATION_ERROR
+   * }
+   * ```
+   */
+  validate(name, schema) {
+    return validateLoadedConfig(name, schema);
+  },
+  /**
+   * 获取已加载的配置。
+   *
+   * @param name - 配置名称
+   * @returns 配置数据；未加载时返回 undefined
+   *
+   * @example
+   * ```ts
+   * const cfg = config.get<CoreConfig>('core')
+   * if (cfg) {
+   *   // 使用 cfg
+   * }
+   * ```
+   */
+  get(name) {
+    return configCache.get(name)?.data;
+  },
+  /**
+   * 获取配置，不存在时抛出错误。
+   *
+   * @param name - 配置名称
+   * @returns 配置数据
+   * @throws 配置未加载时抛出 Error
+   *
+   * @example
+   * ```ts
+   * try {
+   *   const cfg = config.getOrThrow<CoreConfig>('core')
+   * } catch (e) {
+   *   // 配置未加载
+   * }
+   * ```
+   */
+  getOrThrow(name) {
+    const data = this.get(name);
+    if (data === void 0) {
+      throw new Error(i18n.coreM("core_configNotLoaded", { params: { name } }));
+    }
+    return data;
+  },
+  /**
+   * 重新加载配置。
+   *
+   * 从磁盘重新读取配置文件并更新缓存，同时通知所有 watch 回调。
+   *
+   * @param name - 配置名称
+   * @returns 重载结果；未加载时返回 NOT_LOADED
+   *
+   * @example
+   * ```ts
+   * const result = config.reload('app')
+   * ```
+   */
+  reload(name) {
+    return reloadAndNotify(name);
+  },
+  /**
+   * 检查配置是否已加载。
+   *
+   * @param name - 配置名称
+   * @returns 是否已加载到缓存
+   *
+   * @example
+   * ```ts
+   * if (config.has('db')) {
+   *   const dbCfg = config.get('db')
+   * }
+   * ```
+   */
+  has(name) {
+    return configCache.has(name);
+  },
+  /**
+   * 清除配置缓存（同时停止对应监听）。
+   *
+   * @param name - 配置名称；不传则清除全部
+   *
+   * @example
+   * ```ts
+   * config.clear('app')   // 清除单个
+   * config.clear()        // 清除全部
+   * ```
+   */
+  clear(name) {
+    clearCache(name);
+  },
+  /**
+   * 获取所有已加载的配置名称。
+   *
+   * @returns 配置名称数组
+   *
+   * @example
+   * ```ts
+   * const names = config.keys() // ['core', 'db', 'app']
+   * ```
+   */
+  keys() {
+    return Array.from(configCache.keys());
+  },
+  /**
+   * 监听配置文件变更并自动重载。
+   *
+   * 文件变更时自动重新加载并调用回调。配置未加载时立即回调 NOT_LOADED 错误。
+   *
+   * @param name - 配置名称
+   * @param callback - 配置变更回调，接收新配置或错误
+   * @returns 取消监听函数
+   *
+   * @example
+   * ```ts
+   * const unwatch = config.watch('app', (cfg, error) => {
+   *   if (error) { core.logger.error('reload failed', { error }); return }
+   *   core.logger.info('config updated', { cfg })
+   * })
+   * // 取消监听
+   * unwatch()
+   * ```
+   */
+  watch(name, callback) {
+    return registerWatch(name, callback);
+  },
+  /**
+   * 停止配置文件监听。
+   *
+   * @param name - 配置名称；不传则停止所有监听
+   *
+   * @example
+   * ```ts
+   * config.unwatch('app')  // 停止单个
+   * config.unwatch()       // 停止全部
+   * ```
+   */
+  unwatch(name) {
+    stopWatching(name);
+  },
+  /**
+   * 检查是否正在监听某个配置。
+   *
+   * @param name - 配置名称
+   * @returns 是否有活跃的 watcher
+   *
+   * @example
+   * ```ts
+   * if (config.isWatching('app')) {
+   *   config.unwatch('app')
+   * }
+   * ```
+   */
+  isWatching(name) {
+    return watchEntries.has(name);
+  }
+};
+if (process2.platform === "win32" && process2.stdout.isTTY) {
+  try {
+    execSync("chcp 65001 > nul", { stdio: "ignore" });
+    if (process2.stdout.setDefaultEncoding) {
+      process2.stdout.setDefaultEncoding("utf8");
+    }
+    if (process2.stderr.setDefaultEncoding) {
+      process2.stderr.setDefaultEncoding("utf8");
+    }
+    process2.env.LANG = "zh_CN.UTF-8";
+    process2.env.LC_ALL = "zh_CN.UTF-8";
+    process2.env.PYTHONIOENCODING = "utf-8";
+  } catch (_e) {
+  }
+}
+var globalLevel = "info";
+var globalFormat = "pretty";
+var globalContext = {};
+var globalRedact = [];
+var defaultLogger = null;
+function configureLogger(config2) {
+  if (config2.level)
+    globalLevel = config2.level;
+  if (config2.format)
+    globalFormat = config2.format;
+  if (config2.context)
+    globalContext = { ...globalContext, ...config2.context };
+  if (config2.redact)
+    globalRedact = config2.redact;
+  defaultLogger = null;
+}
+function setLogLevel(level) {
+  globalLevel = level;
+}
+function getLogLevel() {
+  return globalLevel;
+}
+function wrapPino(pinoLogger, context) {
+  return {
+    trace(message, ctx) {
+      pinoLogger.trace({ ...context, ...ctx }, message);
+    },
+    debug(message, ctx) {
+      pinoLogger.debug({ ...context, ...ctx }, message);
+    },
+    info(message, ctx) {
+      pinoLogger.info({ ...context, ...ctx }, message);
+    },
+    warn(message, ctx) {
+      pinoLogger.warn({ ...context, ...ctx }, message);
+    },
+    error(message, ctx) {
+      pinoLogger.error({ ...context, ...ctx }, message);
+    },
+    fatal(message, ctx) {
+      pinoLogger.fatal({ ...context, ...ctx }, message);
+    },
+    child(childContext) {
+      return wrapPino(pinoLogger.child(childContext), { ...context, ...childContext });
+    }
+  };
+}
+function createLogger(options = {}) {
+  const level = options.level ?? globalLevel;
+  const format = options.format ?? globalFormat;
+  const context = { ...globalContext, ...options.context };
+  const pinoOptions = {
+    level,
+    name: options.name,
+    formatters: {
+      level: (label) => ({ level: label })
+    }
+  };
+  if (globalRedact.length > 0) {
+    pinoOptions.redact = {
+      paths: globalRedact,
+      censor: "[REDACTED]"
+    };
+  }
+  let pinoInstance;
+  if (format === "pretty") {
+    pinoInstance = pino({
+      ...pinoOptions,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname"
+        }
+      }
+    });
+  } else {
+    pinoInstance = pino(pinoOptions);
+  }
+  return wrapPino(pinoInstance, context);
+}
+function getLogger() {
+  if (!defaultLogger) {
+    defaultLogger = createLogger();
+  }
+  return defaultLogger;
+}
+var logger = {
+  configureLogger,
+  setLogLevel,
+  getLogLevel,
+  createLogger,
+  getLogger
+};
+
+// src/core-main.node.ts
+function createNodeCore() {
+  const baseCore = createCore({
+    createLogger: logger.createLogger,
+    getLogger: logger.getLogger,
+    configureLogger: logger.configureLogger,
+    setLogLevel: logger.setLogLevel,
+    getLogLevel: logger.getLogLevel
+  });
+  return {
+    ...baseCore,
+    /** 配置管理 */
+    config,
+    /** 初始化 Core */
+    init: initCore
+  };
+}
+var core = createNodeCore();
+function scanConfigDir(configDir) {
+  const logger2 = core.logger;
+  const items = [];
+  if (!existsSync(configDir)) {
+    logger2.warn(`[core] Config directory not found: ${configDir}`);
+    return items;
+  }
+  const files = readdirSync(configDir).filter(
+    (f) => f.endsWith(".yml") || f.endsWith(".yaml")
+  );
+  for (const file of files) {
+    const filePath = join(configDir, file);
+    const baseName = file.replace(/\.ya?ml$/, "");
+    if (baseName.startsWith("_")) {
+      const moduleName = baseName.slice(1);
+      items.push({
+        name: moduleName,
+        filePath
+      });
+    } else {
+      items.push({
+        name: baseName,
+        filePath
+      });
+    }
+  }
+  return items;
+}
+function initCore(options = {}) {
+  const startTime = Date.now();
+  const logger2 = core.logger;
+  if (options.logging) {
+    core.logger.configure(options.logging);
+  }
+  logger2.info("[core] Initializing...");
+  let configItems = [];
+  if (options.configDir) {
+    configItems = scanConfigDir(options.configDir);
+  }
+  for (const item of configItems) {
+    if (item.name === "core") {
+      const result = config.load(item.name, item.filePath, CoreConfigSchema);
+      if (result.success) {
+        if (!options.logging) {
+          core.logger.configure(result.data.logging || {});
+        }
+        logger2.info(`[core] Config loaded: ${item.name} <- ${item.filePath}`);
+      } else {
+        logger2.error(`[core] Config load failed: ${item.name}`, {
+          error: result.error
+        });
+      }
+    } else {
+      const result = config.load(item.name, item.filePath);
+      if (result.success) {
+        logger2.info(`[core] Config loaded: ${item.name} <- ${item.filePath}`);
+      } else {
+        logger2.error(`[core] Config load failed: ${item.name}`, {
+          error: result.error
+        });
+      }
+    }
+  }
+  if (options.watchConfig && configItems.length > 0) {
+    setupConfigWatch(configItems);
+  }
+  const duration = Date.now() - startTime;
+  logger2.info(`[core] Initialized (${duration}ms)`);
+}
+function setupConfigWatch(configs) {
+  const logger2 = core.logger;
+  for (const item of configs) {
+    config.watch(item.name, (_config, error) => {
+      if (error) {
+        logger2.error(`[core] Config reload failed: ${item.name}`, { error });
+        return;
+      }
+      logger2.info(`[core] Config reloaded: ${item.name}`);
+    });
+    logger2.debug(`[core] Config watch enabled: ${item.name}`);
+  }
+}
+
+export { core };
+//# sourceMappingURL=node.js.map
+//# sourceMappingURL=node.js.map