@longzai-intelligence-issues/config 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# 更新日志
+
+本项目的所有重要更改都将记录在此文件中。
+
+格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，
+本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
+
+## [0.0.1] - 2026-09-14
+
+### 新增
+
+- 新增 config 包：lzi-issues.config.ts 单一真源 schema（zod 形态+字段级默认）、跨条目语义校验、loadUnifiedConfig 加载封装（standalone>unified）、init 脚手架渲染（create/append）、棘轮基线再生渲染

package/README.md

@@ -0,0 +1,23 @@
+# @longzai-intelligence-issues/config
+
+lzi-issues 配置包，定义单一真源 `lzi-issues.config.ts` 的形态、校验与加载，并承载 init 脚手架渲染与棘轮基线再生渲染。
+
+## 意图
+
+引擎零仓库知识——一切仓库特有信息（scope 注册、扫描面、门禁正则、提示词开关）只存在于仓库根的 lzi-issues.config.ts；本包让这份配置具备「非法即加载失败」的强校验与跨包一致的消费入口，避免引擎携带任何仓库知识、也避免各工具自建查找逻辑。
+
+## 定位
+
+位于 `longzai-intelligence-issues` 项目 `packages/config`，是配置层。向下依赖 zod（形态校验）与 `@longzai-intelligence-shared-config/core` 的 loadUnifiedConfig（统一加载优先级链）；向上被 packages/ledger（引擎消费配置类型）、apps/cli（命令加载入口）消费。
+
+## 职能
+
+- defineConfig（identity 工厂）与 zod schema：storage（五策略，默认 files）、scopes（key/paths/registryDir/保留号/slug 数字策略）、lint（基线/strictLegacy/规则包）、numbering（豁免/全局排除/审计根与 pending）、docs（扫描根/扩展白名单/排除/基线）、close（挂起词/重度与全量正则/阻塞门禁）、prompts 各节的字段级默认值。
+- 跨条目语义校验（纯函数）：scope key 与保留号查重、基线 (file, rule) 查重、豁免指向已登记 scope 与条目查重、glob 形态与查重、审计根相对路径形态——任一违规在加载即抛错。
+- 加载封装：优先级 lzi-issues.config.ts（cwd 向上查找）> lzi.config.ts 的 issues 字段，支持 --config 显式路径；命中后统一走解析 + 跨条目校验。
+- init 脚手架渲染：create 模式生成完整配置文件（defineConfig 范式 + 契约注释头），append 模式在既有 scopes 数组内做括号配平插入（不动其他节、key 冲突显式抛错）。
+- 棘轮基线再生渲染：以解析值重建配置文件（棘轮治理契约头 + 生成段），供 lint / docs 的 --write-baseline 落盘。
+
+## 实现情况
+
+已实现 schema、跨条目校验、加载封装、脚手架与基线再生（30 个 bun test 用例，含生成文件动态导入回环解析用例）；lint / typecheck / build / test 四道门禁通过。配置各节字段语义的速览亦可参考项目根 lzi-issues.config.ts 的契约注释头。

package/dist/index.d.ts

@@ -0,0 +1,400 @@
+import "./rolldown-runtime-BqT_7tdF.js";
+import * as z from "zod";
+//#region src/schema/lzi-issues-config.schema.d.ts
+/**
+ * 存储策略全集（ADR-0048 多策略）：files 为 Local First 默认
+ */
+declare const STORAGE_STRATEGIES: readonly ['files', 'sqlite', 'postgres', 'mysql', 'memory'];
+/**
+ * 存储策略类型
+ */
+type StorageStrategy = (typeof STORAGE_STRATEGIES)[number];
+/**
+ * 关闭门禁挂起词默认集（状态行命中任一即拒绝收口——诚实黄灯维持）
+ */
+declare const DEFAULT_PENDING_WORDS: readonly ['待补跑', '待复跑', '待低负载', '环境不具备', '挂起', '后补跑'];
+/**
+ * audit 覆盖面「形似编号」筛选默认模式
+ */
+declare const DEFAULT_NUMBERISH_PATTERN = "^\\d{1,4}[-._]";
+/**
+ * audit 默认审计根（docs 树）
+ */
+declare const DEFAULT_AUDIT_ROOTS: readonly ['docs'];
+/**
+ * init 缺省注册表目录
+ */
+declare const DEFAULT_REGISTRY_DIR = "docs/issues";
+/**
+ * sqlite 策略缺省库文件路径（统一收纳 .lzi/issues/ 命名空间）
+ */
+declare const DEFAULT_SQLITE_PATH = ".lzi/issues/issues.sqlite";
+/**
+ * scope key 合法形态（kebab-case）
+ */
+declare const SCOPE_KEY_PATTERN: RegExp;
+/**
+ * 编号形态（数字字符串，零填充原文）
+ */
+declare const NUMBER_PATTERN: RegExp;
+/**
+ * 扩展名形态（如 .md）
+ */
+declare const EXTENSION_PATTERN: RegExp;
+/**
+ * 棘轮基线条目 schema（豁免必须携带 issue 收编指针）
+ */
+declare const baselineEntrySchema: z.ZodObject<{
+  file: z.ZodString;
+  rule: z.ZodString;
+  issue: z.ZodString;
+}, z.core.$strip>;
+/**
+ * scope 注册条目 schema
+ */
+declare const scopeSchema: z.ZodObject<{
+  key: z.ZodString;
+  title: z.ZodString;
+  paths: z.ZodArray<z.ZodString>;
+  registryDir: z.ZodString;
+  numbering: z.ZodDefault<z.ZodObject<{
+    reserved: z.ZodArray<z.ZodObject<{
+      number: z.ZodString;
+      reason: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  slugDigitPolicy: z.ZodOptional<z.ZodLiteral<"forbid">>;
+}, z.core.$strip>;
+/**
+ * scope 注册条目（书写形态）
+ */
+type ScopeEntryInput = z.input<typeof scopeSchema>;
+/**
+ * scope 注册条目（解析后形态）
+ */
+type ScopeEntry = z.output<typeof scopeSchema>;
+/**
+ * lzi-issues 配置根 schema
+ *
+ * docs 节整体可选（未配置时 docs 引用检查命令显式拒绝，不设隐式扫描面）；
+ * 其余节缺省时整体回退该节全默认值。
+ */
+declare const lziIssuesConfigSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  storage: z.ZodDefault<z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<{
+      files: "files";
+      memory: "memory";
+      mysql: "mysql";
+      postgres: "postgres";
+      sqlite: "sqlite";
+    }>>;
+    sqlitePath: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>>;
+  scopes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    registryDir: z.ZodString;
+    numbering: z.ZodDefault<z.ZodObject<{
+      reserved: z.ZodArray<z.ZodObject<{
+        number: z.ZodString;
+        reason: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    slugDigitPolicy: z.ZodOptional<z.ZodLiteral<"forbid">>;
+  }, z.core.$strip>>;
+  lint: z.ZodDefault<z.ZodObject<{
+    baseline: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      file: z.ZodString;
+      rule: z.ZodString;
+      issue: z.ZodString;
+    }, z.core.$strip>>>;
+    strictLegacy: z.ZodDefault<z.ZodBoolean>;
+    rulePacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  numbering: z.ZodDefault<z.ZodObject<{
+    allowlist: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      scopeKey: z.ZodString;
+      number: z.ZodString;
+      files: z.ZodArray<z.ZodString>;
+      status: z.ZodEnum<{
+        待清偿: "待清偿";
+        维持现状: "维持现状";
+      }>;
+      reason: z.ZodString;
+    }, z.core.$strip>>>;
+    globalExclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      glob: z.ZodString;
+      reason: z.ZodString;
+    }, z.core.$strip>>>;
+    audit: z.ZodDefault<z.ZodObject<{
+      roots: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      numberishPattern: z.ZodDefault<z.ZodString>;
+      pending: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        glob: z.ZodString;
+        reason: z.ZodString;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  slugDigitAllowlist: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    glob: z.ZodString;
+    reason: z.ZodString;
+  }, z.core.$strip>>>;
+  docs: z.ZodOptional<z.ZodObject<{
+    scanRoots: z.ZodArray<z.ZodString>;
+    includeExtensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      glob: z.ZodString;
+      reason: z.ZodString;
+    }, z.core.$strip>>>;
+    baseline: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      file: z.ZodString;
+      rule: z.ZodString;
+      issue: z.ZodString;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+  close: z.ZodDefault<z.ZodObject<{
+    pendingWords: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    heavyPattern: z.ZodOptional<z.ZodString>;
+    fullPattern: z.ZodOptional<z.ZodString>;
+    blockingMustBeGreen: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  prompts: z.ZodDefault<z.ZodObject<{
+    builtin: z.ZodDefault<z.ZodBoolean>;
+    extraDir: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * lzi-issues 配置（用户书写形态，可省略各默认值）
+ */
+type LziIssuesConfigInput = z.input<typeof lziIssuesConfigSchema>;
+/**
+ * lzi-issues 配置（解析后形态，默认值全部落定）
+ */
+type LziIssuesConfig = z.output<typeof lziIssuesConfigSchema>;
+/**
+ * 棘轮基线条目
+ */
+type LintBaselineEntry = z.infer<typeof baselineEntrySchema>;
+/**
+ * 解析并校验配置（非法即抛，加载即失败）
+ *
+ * @param input - 配置原始对象（defineConfig 产物或统一配置字段值）
+ * @returns 默认值落定的配置
+ * @throws {@link Error} 形态违规（消息聚合全部违规项；跨条目语义校验由
+ * validateLziIssuesConfig 在加载链路上追加执行）
+ */
+declare function parseLziIssuesConfig(input: unknown): LziIssuesConfig;
+/**
+ * 定义 lzi-issues 配置（identity 工厂）
+ *
+ * 类型透传，与 lzi-dev.config.ts / oxfmt.config.ts 等 workspace 配置惯例同构：
+ * 不在工厂层做任何合并——默认值由本模块 schema 解析层统一落定。
+ *
+ * @param config - 配置对象（可省略各默认值）
+ * @returns 原样返回传入的配置对象
+ */
+declare function defineConfig(config: LziIssuesConfigInput): LziIssuesConfigInput;
+//#endregion
+//#region src/baseline/render-baseline.renderer.d.ts
+/**
+ * 棘轮契约注释头（再生文件头）
+ */
+declare const RATCHET_CONTRACT_HEADER: string;
+/**
+ * 基线再生目标节
+ */
+type BaselineSection = 'lint' | 'docs';
+/**
+ * 基线条目排序与去重（(file, rule) 唯一，file 升序、rule 次序）
+ *
+ * @param entries - 原始条目列表
+ * @returns 排序去重后的条目列表
+ */
+declare function deriveBaselineEntries(entries: readonly LintBaselineEntry[]): LintBaselineEntry[];
+/**
+ * 渲染基线再生后的完整配置文件
+ *
+ * @param config - 当前解析后配置（其余节值原样保留）
+ * @param section - 再生目标节（lint / docs）
+ * @param baseline - 再生基线条目（通常为 deriveBaselineEntries 产物）
+ * @returns 完整配置文件文本（棘轮契约头 + defineConfig 体）
+ * @throws {@link Error} section 为 docs 但配置未登记 docs 节
+ */
+declare function renderBaselineRegeneratedConfig(config: LziIssuesConfig, section: BaselineSection, baseline: readonly LintBaselineEntry[]): string;
+//#endregion
+//#region src/loader/load-issues-config.utils.d.ts
+/**
+ * 配置来源类型
+ */
+type LziIssuesConfigSource = 'standalone' | 'unified' | 'explicit';
+/**
+ * 加载成功结果
+ */
+type LoadLziIssuesConfigSuccess = {
+  /**
+   * 加载成功标记
+   */
+  ok: true;
+  /**
+   * 解析并校验后的配置（默认值全部落定）
+   */
+  config: LziIssuesConfig;
+  /**
+   * 命中的配置文件绝对路径
+   */
+  configFilePath: string;
+  /**
+   * 配置来源
+   */
+  source: LziIssuesConfigSource;
+};
+/**
+ * 加载失败结果（未找到配置）
+ */
+type LoadLziIssuesConfigFailure = {
+  /**
+   * 加载成功标记
+   */
+  ok: false;
+  /**
+   * 失败原因
+   */
+  reason: string;
+};
+/**
+ * 加载结果
+ */
+type LoadLziIssuesConfigResult = LoadLziIssuesConfigSuccess | LoadLziIssuesConfigFailure;
+/**
+ * 加载选项
+ */
+type LoadLziIssuesConfigOptions = {
+  /**
+   * 查找起点目录（缺省 process.cwd()）
+   */
+  cwd?: string;
+  /**
+   * 显式配置文件路径（优先级最高，绕过向上查找）
+   */
+  configPath?: string;
+};
+/**
+ * 加载 lzi-issues 配置
+ *
+ * @param options - 加载选项
+ * @returns 加载结果：命中返回解析后配置；未找到返回失败（显式路径不存在也按失败处理）
+ * @throws {@link Error} 命中配置但形态/跨条目非法（加载即失败语义）
+ */
+declare function loadLziIssuesConfig(options?: LoadLziIssuesConfigOptions): Promise<LoadLziIssuesConfigResult>;
+/**
+ * 按显式文件 URL 动态导入配置模块（测试与工具内部使用）
+ *
+ * @param configPath - 配置文件绝对路径
+ * @returns 配置模块 default 导出
+ * @throws {@link Error} 导入失败或无 default 导出
+ */
+declare function importConfigModule(configPath: string): Promise<unknown>;
+//#endregion
+//#region src/scaffold/render-scaffold.renderer.d.ts
+/**
+ * lzi-issues 配置脚手架渲染（init 命令载体）
+ *
+ * 结构化渲染而非手拼字符串：create 模式生成完整 config 文件（defineConfig
+ * 范式 + 契约注释头）；append 模式在既有 scopes 数组内做括号配平插入，不动
+ * 其他节。序列化器与基线再生渲染共用（同构 TS 字面量输出）。
+ */
+/**
+ * scope 脚手架入参（init 命令旗标映射）
+ */
+type ScopeScaffoldInput = {
+  /**
+   * scope key（kebab-case）
+   */
+  key: string;
+  /**
+   * scope 人类可读名
+   */
+  title: string;
+  /**
+   * 覆盖路径 glob（缺省 ['.']——本目录树全部）
+   */
+  paths?: string[];
+  /**
+   * 注册表目录（缺省 docs/issues）
+   */
+  registryDir?: string;
+};
+/**
+ * 配置文件契约注释头（create 模式）
+ */
+declare const CONFIG_SCAFFOLD_HEADER: string;
+/**
+ * 序列化完整配置对象为 defineConfig 包裹的配置体文本（不含文件头注释）
+ *
+ * @param config - 配置对象（解析后或字面量输入形态）
+ * @returns 配置体文本（export default defineConfig({...});）
+ */
+declare function serializeConfigBody(config: Record<string, unknown>): string;
+/**
+ * 渲染完整配置文件文本（create 模式）
+ *
+ * @param config - 配置对象
+ * @param header - 文件头注释（缺省 init 契约头）
+ * @returns 完整文件文本
+ */
+declare function renderConfigFile(config: Record<string, unknown>, header?: string): string;
+/**
+ * 渲染 scope 条目字面量（4 空格基准缩进，append 模式插入单元）
+ *
+ * @param scope - scope 脚手架入参
+ * @returns scope 条目字面量文本
+ */
+declare function renderScopeEntry(scope: ScopeScaffoldInput): string;
+/**
+ * 渲染 init 生成的完整配置文件（单 scope 起步）
+ *
+ * @param scope - 首个 scope 入参
+ * @returns 完整配置文件文本
+ */
+declare function renderConfigScaffoldFile(scope: ScopeScaffoldInput): string;
+/**
+ * 在既有配置文本的 scopes 数组内追加 scope（append 模式，不动其他节）
+ *
+ * 仅依赖括号配平定位数组收口，在收口前插入条目；scope key 已存在时显式抛错。
+ * 插入缩进按本包渲染器规范（4 空格）——非规范缩进的文件插入后由 oxfmt 归一。
+ *
+ * @param configText - 既有配置文件全文
+ * @param scope - 待追加 scope 入参
+ * @returns 追加后的配置文件全文
+ * @throws {@link Error} key 已注册 / 无 scopes 数组 / 括号不配平
+ */
+declare function appendScopeToConfigText(configText: string, scope: ScopeScaffoldInput): string;
+//#endregion
+//#region src/validation/validate-cross-entries.d.ts
+/**
+ * 跨条目校验违规消息列表类型
+ */
+type CrossEntryViolations = string[];
+/**
+ * 跨条目语义校验
+ *
+ * 校验面：scope key 查重、保留号逐 scope 查重、基线 (file,rule) 查重（lint 与
+ * docs 各自为界）、allowlist 指向已登记 scope 且条目查重、全部 glob 形态与
+ * 查重、audit.roots 与 registryDir 相对路径形态。
+ *
+ * @param config - 解析后配置
+ * @returns 违规消息列表（空列表 = 合法）
+ */
+declare function validateCrossEntries(config: LziIssuesConfig): CrossEntryViolations;
+/**
+ * 校验配置并聚合抛错（加载链路统一入口）
+ *
+ * @param config - 解析后配置
+ * @returns 原样返回合法配置（链式便利）
+ * @throws {@link Error} 存在任何跨条目违规（消息聚合全部违规项）
+ */
+declare function validateLziIssuesConfig(config: LziIssuesConfig): LziIssuesConfig;
+//#endregion
+export { BaselineSection, CONFIG_SCAFFOLD_HEADER, CrossEntryViolations, DEFAULT_AUDIT_ROOTS, DEFAULT_NUMBERISH_PATTERN, DEFAULT_PENDING_WORDS, DEFAULT_REGISTRY_DIR, DEFAULT_SQLITE_PATH, EXTENSION_PATTERN, LintBaselineEntry, LoadLziIssuesConfigFailure, LoadLziIssuesConfigOptions, LoadLziIssuesConfigResult, LoadLziIssuesConfigSuccess, LziIssuesConfig, LziIssuesConfigInput, LziIssuesConfigSource, NUMBER_PATTERN, RATCHET_CONTRACT_HEADER, SCOPE_KEY_PATTERN, STORAGE_STRATEGIES, ScopeEntry, ScopeEntryInput, ScopeScaffoldInput, StorageStrategy, appendScopeToConfigText, baselineEntrySchema, defineConfig, deriveBaselineEntries, importConfigModule, loadLziIssuesConfig, lziIssuesConfigSchema, parseLziIssuesConfig, renderBaselineRegeneratedConfig, renderConfigFile, renderConfigScaffoldFile, renderScopeEntry, serializeConfigBody, validateCrossEntries, validateLziIssuesConfig };

package/dist/index.js

@@ -0,0 +1,6 @@
+import"./rolldown-runtime-BqT_7tdF.js";import*as e from"zod";import{loadUnifiedConfig as t}from"@longzai-intelligence-shared-config/core";import{existsSync as n}from"node:fs";import{resolve as r}from"node:path";import{pathToFileURL as i}from"node:url";const a=[`files`,`sqlite`,`postgres`,`mysql`,`memory`],o=[`待补跑`,`待复跑`,`待低负载`,`环境不具备`,`挂起`,`后补跑`],s=`^\\d{1,4}[-._]`,c=[`docs`],l=`docs/issues`,u=`.lzi/issues/issues.sqlite`,d=/^[a-z][a-z0-9-]*$/,f=/^\d+$/,p=/^\.[A-Za-z0-9]+$/,m=e.object({number:e.string().regex(f),reason:e.string().min(1)}),h=e.object({file:e.string().min(1),rule:e.string().min(1),issue:e.string().min(1)}),g=e.object({glob:e.string().min(1),reason:e.string().min(1)}),_=e.object({key:e.string().regex(d),title:e.string().min(1),paths:e.array(e.string().min(1)).min(1),registryDir:e.string().min(1),numbering:e.object({reserved:e.array(m)}).default({reserved:[]}),slugDigitPolicy:e.literal(`forbid`).optional()}),v=e.object({strategy:e.enum(a).default(`files`),sqlitePath:e.string().min(1).default(u)}),y=e.object({baseline:e.array(h).default([]),strictLegacy:e.boolean().default(!1),rulePacks:e.array(e.string().min(1)).default([])}),b=e.object({scopeKey:e.string().min(1),number:e.string().regex(f),files:e.array(e.string().min(1)).min(2),status:e.enum([`待清偿`,`维持现状`]),reason:e.string().min(1)}),x=e.object({allowlist:e.array(b).default([]),globalExclusions:e.array(g).default([]),audit:e.object({roots:e.array(e.string().min(1)).min(1).default([...c]),numberishPattern:e.string().min(1).default(s),pending:e.array(g).default([])}).default({roots:[...c],numberishPattern:s,pending:[]})}),S=e.object({scanRoots:e.array(e.string().min(1)).min(1),includeExtensions:e.array(e.string().regex(p)).default([`.md`]),exclusions:e.array(g).default([]),baseline:e.array(h).default([])}),C=e.object({pendingWords:e.array(e.string().min(1)).default([...o]),heavyPattern:e.string().min(1).optional(),fullPattern:e.string().min(1).optional(),blockingMustBeGreen:e.boolean().default(!0)}),w=e.object({builtin:e.boolean().default(!0),extraDir:e.string().min(1).optional()}),T=e.object({schemaVersion:e.literal(1),storage:v.default({strategy:`files`,sqlitePath:u}),scopes:e.array(_).min(1),lint:y.default({baseline:[],strictLegacy:!1,rulePacks:[]}),numbering:x.default({allowlist:[],globalExclusions:[],audit:{roots:[...c],numberishPattern:s,pending:[]}}),slugDigitAllowlist:e.array(g).default([]),docs:S.optional(),close:C.default({pendingWords:[...o],blockingMustBeGreen:!0}),prompts:w.default({builtin:!0})});function E(e){let t=T.safeParse(e);if(!t.success){let e=t.error.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`).join(`；`);throw Error(`lzi-issues 配置形态非法：${e}`)}return t.data}function D(e){return e}const O=[`/**`," * lzi-issues 配置（单一真源）——由 `lzi-issues init` 生成。",` *`,` * 引擎零仓库知识：一切仓库特有信息（scope 注册 / 扫描面 / 门禁参数）只在本文件登记。`,` * 存储默认 files（Local First）：issue 为注册表 markdown，派生数据统一 .lzi/issues/。`,` */`].join(`
+`);function k(e){return`'${e.replace(/\\/g,`\\\\`).replace(/'/g,`\\'`).replace(/\n/g,`\\n`)}'`}function A(e,t){if(e.length===0)return`[]`;let n=`  `.repeat(t+1),r=`  `.repeat(t);return e.every(e=>typeof e==`object`&&!!e)?`[\n${e.map(e=>`${n}${N(e,t+1)},`).join(`
+`)}\n${r}]`:`[${e.map(e=>N(e,t+1)).join(`, `)}]`}function j(e,t){let n=Object.keys(e).filter(t=>e[t]!==void 0);if(n.length===0)return`{}`;let r=`  `.repeat(t+1),i=`  `.repeat(t);return`{\n${n.map(n=>`${r}${n}: ${N(e[n],t+1)},`).join(`
+`)}\n${i}}`}function M(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function N(e,t){return typeof e==`string`?k(e):Array.isArray(e)?A(e,t):M(e)?j(e,t):String(e)}function P(e){return`export default defineConfig(${N(e,0)});\n`}function F(e,t=O){return`import { defineConfig } from '@longzai-intelligence-issues/config';\n\n${t}\n${P(e)}`}function I(e){return N({key:e.key,title:e.title,paths:e.paths??[`.`],registryDir:e.registryDir??`docs/issues`},2).trimStart()}function L(e){return F({schemaVersion:1,scopes:[{key:e.key,title:e.title,paths:e.paths??[`.`],registryDir:e.registryDir??`docs/issues`}]})}function R(e,t){let n=e[t]??``,r={"[":`]`,"{":`}`,"(":`)`}[n];if(r===void 0)throw Error(`扫描起点不是开括号：位置 ${t}`);let i=0;for(let a=t;a<e.length;a+=1){let t=e[a]??``,o=e[a+1]??``;if(t===`/`&&o===`/`){if(a=e.indexOf(`
+`,a),a===-1)break;continue}if(t===`/`&&o===`*`){if(a=e.indexOf(`*/`,a+2),a===-1)throw Error(`括号扫描遇未闭合块注释`);a+=1;continue}if(t===`'`||t===`"`||t==="`"){for(a+=1;a<e.length;){let n=e[a]??``;if(n===`\\`){a+=2;continue}if(n===t)break;a+=1}continue}if(t===n)i+=1;else if(t===r&&(--i,i===0))return a}throw Error(`括号不配平：scopes 数组未闭合`)}function z(e,t){if(RegExp(`key\\s*:\\s*'${t.key}'`).test(e))throw Error(`scope key「${t.key}」已注册，拒绝重复追加`);let n=/scopes\s*:\s*\[/.exec(e);if(n===null)throw Error(`配置文件缺少 scopes 数组，无法追加 scope`);let r=R(e,(n.index??0)+n[0].length-1),i=r-1;for(;i>=0&&/\s/.test(e[i]??``);)--i;let a=e[i]===`,`?`\n    ${I(t)}`:`,\n    ${I(t)}`;return`${e.slice(0,r)}${a}${e.slice(r)}`}const B=[`/**`," * lzi-issues 配置（单一真源）——由 `--write-baseline --issue <指针>` 再生。",` *`,` * 棘轮基线语义：基线按 (file, rule) 精确命中豁免存量违规；基线外新增违规仍红；`,` * 基线条目无对应现行违规计陈旧红——修复存量即须同步删除对应条目，棘轮只许缩短直至清零；`,` * 每条豁免必须携带 issue 收编指针（非空）。`,` *`,` * 注意：再生以解析值重建本文件，节内手工注释不保留——长篇说明请写入 docs/guides。`,` */`].join(`
+`);function V(e){let t=new Map;for(let n of e){let e=`${n.file}::${n.rule}`;t.has(e)||t.set(e,{...n})}return[...t.values()].sort((e,t)=>e.file===t.file?e.rule.localeCompare(t.rule):e.file.localeCompare(t.file))}function H(e,t,n){let r=V(n);if(t===`lint`)return F({schemaVersion:e.schemaVersion,storage:e.storage,scopes:e.scopes,lint:{...e.lint,baseline:r},numbering:e.numbering,slugDigitAllowlist:e.slugDigitAllowlist,docs:e.docs,close:e.close,prompts:e.prompts},B);if(e.docs===void 0)throw Error(`配置未登记 docs 节，无法再生 docs 基线`);return F({schemaVersion:e.schemaVersion,storage:e.storage,scopes:e.scopes,lint:e.lint,numbering:e.numbering,slugDigitAllowlist:e.slugDigitAllowlist,docs:{...e.docs,baseline:r},close:e.close,prompts:e.prompts},B)}function U(e,t,n){(t.startsWith(`/`)||t.startsWith(`\\`))&&n.push(`${e}「${t}」不得为绝对路径`),t.includes(`\\`)&&n.push(`${e}「${t}」不得包含反斜杠（须为 posix 相对路径）`),t.split(`/`).includes(`..`)&&n.push(`${e}「${t}」不得包含 .. 上溯段`)}function W(e,t,n){t.includes(`\\`)&&n.push(`${e}「${t}」不得包含反斜杠`),t.startsWith(`/`)&&n.push(`${e}「${t}」不得以 / 起首（须为仓库相对 glob）`)}function G(e,t,n){let r=new Set;for(let i of t)r.has(i)&&n.push(`${e} 存在重复 glob「${i}」`),r.add(i)}function K(e){let t=[],n=new Set;e.scopes.forEach((e,r)=>{let i=`scopes[${r}]（${e.key}）`;n.has(e.key)&&t.push(`scope key「${e.key}」重复注册`),n.add(e.key),U(`${i}.registryDir`,e.registryDir,t);let a=new Set;for(let n of e.numbering.reserved)a.has(n.number)&&t.push(`${i} 保留号「${n.number}」重复登记`),a.add(n.number)});let r=new Set;for(let n of e.lint.baseline){let e=`${n.file}::${n.rule}`;r.has(e)&&t.push(`lint.baseline 条目（${n.file}, ${n.rule}）重复`),r.add(e)}if(e.docs!==void 0){let n=new Set;for(let r of e.docs.baseline){let e=`${r.file}::${r.rule}`;n.has(e)&&t.push(`docs.baseline 条目（${r.file}, ${r.rule}）重复`),n.add(e)}for(let n of e.docs.exclusions)W(`docs.exclusions`,n.glob,t);G(`docs.exclusions`,e.docs.exclusions.map(e=>e.glob),t);for(let n of e.docs.scanRoots)U(`docs.scanRoots`,n,t)}let i=new Set;for(let r of e.numbering.allowlist){n.has(r.scopeKey)||t.push(`numbering.allowlist 条目指向未登记 scope「${r.scopeKey}」（编号 ${r.number}）`);let e=`${r.scopeKey}::${r.number}::${[...r.files].sort().join(`,`)}`;i.has(e)&&t.push(`numbering.allowlist 条目（${r.scopeKey} ${r.number}）重复`),i.add(e)}for(let n of e.numbering.globalExclusions)W(`numbering.globalExclusions`,n.glob,t);G(`numbering.globalExclusions`,e.numbering.globalExclusions.map(e=>e.glob),t);for(let n of e.numbering.audit.pending)W(`numbering.audit.pending`,n.glob,t);G(`numbering.audit.pending`,e.numbering.audit.pending.map(e=>e.glob),t);for(let n of e.numbering.audit.roots)U(`numbering.audit.roots`,n,t);for(let n of e.slugDigitAllowlist)W(`slugDigitAllowlist`,n.glob,t);return G(`slugDigitAllowlist`,e.slugDigitAllowlist.map(e=>e.glob),t),t}function q(e){let t=K(e);if(t.length>0)throw Error(`lzi-issues 配置跨条目校验失败：${t.join(`；`)}`);return e}function J(e,t){try{return q(E(e))}catch(e){let n=e instanceof Error?e.message:String(e);throw Error(`${n}（配置文件：${t}）`)}}async function Y(e={}){if(e.configPath!==void 0){let t=r(e.cwd??process.cwd(),e.configPath);return n(t)?{ok:!0,config:J(await X(t),t),configFilePath:t,source:`explicit`}:{ok:!1,reason:`未找到配置文件：${t}`}}let i=await t({standaloneFile:`lzi-issues.config.ts`,unifiedField:`issues`,cwd:e.cwd});return i.success?{ok:!0,config:J(i.config,i.configFilePath),configFilePath:i.configFilePath,source:i.source}:{ok:!1,reason:`未找到 lzi-issues.config.ts（且 lzi.config.ts 无 issues 字段）——可先执行 lzi-issues init`}}async function X(e){let t=await import(i(e).href);if(t.default===void 0)throw Error(`配置文件缺少 default 导出：${e}`);return t.default}export{O as CONFIG_SCAFFOLD_HEADER,c as DEFAULT_AUDIT_ROOTS,s as DEFAULT_NUMBERISH_PATTERN,o as DEFAULT_PENDING_WORDS,l as DEFAULT_REGISTRY_DIR,u as DEFAULT_SQLITE_PATH,p as EXTENSION_PATTERN,f as NUMBER_PATTERN,B as RATCHET_CONTRACT_HEADER,d as SCOPE_KEY_PATTERN,a as STORAGE_STRATEGIES,z as appendScopeToConfigText,h as baselineEntrySchema,D as defineConfig,V as deriveBaselineEntries,X as importConfigModule,Y as loadLziIssuesConfig,T as lziIssuesConfigSchema,E as parseLziIssuesConfig,H as renderBaselineRegeneratedConfig,F as renderConfigFile,L as renderConfigScaffoldFile,I as renderScopeEntry,P as serializeConfigBody,K as validateCrossEntries,q as validateLziIssuesConfig};

package/dist/rolldown-runtime-BqT_7tdF.js

@@ -0,0 +1 @@
+import"node:module";export{};

package/lzi-builder.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from '@longzai-intelligence-builder/esm';
+
+/**
+ * 配置包构建配置
+ *
+ * 单入口库包：schema/校验/加载/脚手架渲染/基线再生。加载器依赖
+ * node:fs / node:path / node:url（纯 Node 运行时），显式声明 platform: 'node'。
+ */
+export default defineConfig({
+  entry: {
+    index: 'src/index.ts',
+  },
+  platform: 'node',
+});

package/lzi-bun.config.ts

@@ -0,0 +1,8 @@
+import { definePackageCoreBunConfig } from '@longzai-intelligence-bun/config';
+
+/**
+ * 引擎包 bun 测试配置
+ *
+ * 按核心工具库阈值参与覆盖率门控；测试位于 src 内（test.ts 后缀）。
+ */
+export default definePackageCoreBunConfig();

package/oxlint.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from '@longzai-intelligence-oxlint/presets/library';
+
+export default defineConfig();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@longzai-intelligence-issues/config",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "lzi-builder",
+    "build:prod": "NODE_ENV=production bun run build",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "lzi-tsgo typecheck tsconfig/app.json",
+    "typecheck:node": "lzi-tsgo typecheck tsconfig/node.json",
+    "typecheck:test": "lzi-tsgo typecheck tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "lzi-bun-cli test",
+    "test:watch": "lzi-bun-cli test --watch",
+    "test:coverage": "lzi-bun-cli test --coverage",
+    "clean": "lzi-dev-cli clean"
+  },
+  "dependencies": {
+    "@longzai-intelligence-shared-config/core": "^0.0.5",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@longzai-intelligence-builder/cli": "^0.2.16",
+    "@longzai-intelligence-tsgo/cli": "^0.0.1",
+    "@types/bun": "latest",
+    "@typescript/native-preview": "beta",
+    "oxlint": "^1.77.0"
+  }
+}

package/src/__tests__/baseline/render-baseline.renderer.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import {
+  deriveBaselineEntries,
+  RATCHET_CONTRACT_HEADER,
+  renderBaselineRegeneratedConfig,
+} from '@/baseline/render-baseline.renderer';
+import { parseLziIssuesConfig } from '@/schema/lzi-issues-config.schema';
+
+/**
+ * 基线再生回环用的基准配置
+ */
+const BASE_CONFIG = parseLziIssuesConfig({
+  schemaVersion: 1,
+  scopes: [{ key: 'root', title: '全局', paths: ['.'], registryDir: 'docs/issues' }],
+  docs: { scanRoots: ['docs'] },
+});
+
+/**
+ * 动态导入序号（每次唯一文件名，规避 bun 模块 URL 缓存返回陈旧模块）
+ */
+let importSequence = 0;
+
+/**
+ * 动态导入再生文本并解析（包导入改写为包内别名）
+ *
+ * @param generated - 再生的配置文件全文
+ * @returns 解析后配置
+ */
+async function importAndParse(generated: string) {
+  /**
+   * 临时目录（包内）
+   */
+  const tmpDir = join(import.meta.dir, '__tmp-baseline__');
+
+  /**
+   * 临时文件路径（序号唯一化）
+   */
+  const tmpFile = join(tmpDir, `gen-${(importSequence += 1)}.config.ts`);
+
+  mkdirSync(tmpDir, { recursive: true });
+
+  try {
+    /**
+     * 可导入文本
+     */
+    const importable = generated.replace(
+      "'@longzai-intelligence-issues/config'",
+      "'@/schema/lzi-issues-config.schema'",
+    );
+
+    writeFileSync(tmpFile, importable);
+
+    /**
+     * 动态导入的配置模块
+     */
+    const module = (await import(pathToFileURL(tmpFile).href)) as { default: unknown };
+
+    return parseLziIssuesConfig(module.default);
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+describe('deriveBaselineEntries', () => {
+  test('按 (file, rule) 去重并按 file、rule 排序', () => {
+    const entries = deriveBaselineEntries([
+      { file: 'b.md', rule: 'y', issue: '0002' },
+      { file: 'a.md', rule: 'z', issue: '0001' },
+      { file: 'a.md', rule: 'z', issue: '0009' },
+      { file: 'a.md', rule: 'x', issue: '0003' },
+    ]);
+
+    expect(entries).toEqual([
+      { file: 'a.md', rule: 'x', issue: '0003' },
+      { file: 'a.md', rule: 'z', issue: '0001' },
+      { file: 'b.md', rule: 'y', issue: '0002' },
+    ]);
+  });
+
+  test('空入参产出空列表', () => {
+    expect(deriveBaselineEntries([])).toEqual([]);
+  });
+});
+
+describe('renderBaselineRegeneratedConfig', () => {
+  test('lint 节再生：契约头 + 条目在场 + 其余节保留 + 回环合法', async () => {
+    const text = renderBaselineRegeneratedConfig(BASE_CONFIG, 'lint', [
+      { file: 'docs/issues/0002-a.md', rule: 'yellow-no-pending-reason', issue: '0003' },
+    ]);
+
+    expect(text.includes('棘轮只许缩短')).toBe(true);
+    expect(text.includes(RATCHET_CONTRACT_HEADER)).toBe(true);
+    expect(text.includes("rule: 'yellow-no-pending-reason'")).toBe(true);
+    expect(text.includes("registryDir: 'docs/issues'")).toBe(true);
+
+    const config = await importAndParse(text);
+
+    expect(config.lint.baseline).toEqual([
+      { file: 'docs/issues/0002-a.md', rule: 'yellow-no-pending-reason', issue: '0003' },
+    ]);
+    expect(config.scopes[0]?.key).toBe('root');
+    expect(config.docs?.scanRoots).toEqual(['docs']);
+  });
+
+  test('docs 节再生：docs.baseline 替换且 lint 节不动', async () => {
+    const configWithLintBaseline = {
+      ...BASE_CONFIG,
+      lint: {
+        ...BASE_CONFIG.lint,
+        baseline: [{ file: 'x.md', rule: 'r', issue: '0001' }],
+      },
+    };
+
+    const text = renderBaselineRegeneratedConfig(configWithLintBaseline, 'docs', [
+      { file: 'README.md', rule: 'doc-ref-unknown', issue: '0004' },
+    ]);
+
+    const config = await importAndParse(text);
+
+    expect(config.docs?.baseline).toEqual([
+      { file: 'README.md', rule: 'doc-ref-unknown', issue: '0004' },
+    ]);
+    expect(config.lint.baseline).toEqual([{ file: 'x.md', rule: 'r', issue: '0001' }]);
+  });
+
+  test('未登记 docs 节时 docs 再生显式抛错', () => {
+    expect(() =>
+      renderBaselineRegeneratedConfig(
+        parseLziIssuesConfig({
+          schemaVersion: 1,
+          scopes: [{ key: 'root', title: '全局', paths: ['.'], registryDir: 'docs/issues' }],
+        }),
+        'docs',
+        [],
+      ),
+    ).toThrow('docs 节');
+  });
+});