@tq1086/urpf-cli 2.0.0 → 2.1.0

package/dist/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/pack.ts
-import path2 from "path";
-import fs3 from "fs/promises";
+import path3 from "path";
+import fs4 from "fs/promises";
 
 // src/core/scanner/file-scanner.ts
 import * as fs from "fs/promises";
@@ -554,8 +554,8 @@ var IgnoreRuleParser = class {
    * @returns 忽略规则列表
    */
   async parseFileFromPath(filePath) {
-    const fs14 = await import("fs/promises");
-    const content = await fs14.readFile(filePath, "utf-8");
+    const fs15 = await import("fs/promises");
+    const content = await fs15.readFile(filePath, "utf-8");
     return this.parseFile(content, filePath);
   }
   /**
@@ -582,13 +582,13 @@ var IgnoreRuleParser = class {
    * @returns 忽略规则列表
    */
   async findAndParseIgnoreFiles(rootPath, ignoreFileNames = [".gitignore", ".iflowignore", ".npmignore"]) {
-    const fs14 = await import("fs/promises");
-    const path7 = await import("path");
+    const fs15 = await import("fs/promises");
+    const path8 = await import("path");
     const rules = [];
     for (const fileName of ignoreFileNames) {
-      const filePath = path7.join(rootPath, fileName);
+      const filePath = path8.join(rootPath, fileName);
       try {
-        await fs14.access(filePath);
+        await fs15.access(filePath);
         const fileRules = await this.parseFileFromPath(filePath);
         rules.push(...fileRules);
       } catch {
@@ -602,11 +602,11 @@ var IgnoreRuleParser = class {
    * @returns 白名单规则列表，如果文件不存在则返回空数组
    */
   async parseWhiteList(rootPath) {
-    const fs14 = await import("fs/promises");
-    const path7 = await import("path");
-    const whiteListPath = path7.join(rootPath, ".urpfallow");
+    const fs15 = await import("fs/promises");
+    const path8 = await import("path");
+    const whiteListPath = path8.join(rootPath, ".urpfallow");
     try {
-      await fs14.access(whiteListPath);
+      await fs15.access(whiteListPath);
       return await this.parseFileFromPath(whiteListPath);
     } catch {
       return [];
@@ -618,11 +618,11 @@ var IgnoreRuleParser = class {
    * @returns 黑名单规则列表，如果文件不存在则返回空数组
    */
   async parseBlackList(rootPath) {
-    const fs14 = await import("fs/promises");
-    const path7 = await import("path");
-    const blackListPath = path7.join(rootPath, ".urpfforbid");
+    const fs15 = await import("fs/promises");
+    const path8 = await import("path");
+    const blackListPath = path8.join(rootPath, ".urpfforbid");
     try {
-      await fs14.access(blackListPath);
+      await fs15.access(blackListPath);
       return await this.parseFileFromPath(blackListPath);
     } catch {
       return [];
@@ -634,11 +634,11 @@ var IgnoreRuleParser = class {
    * @returns 是否存在白名单文件
    */
   async hasWhiteList(rootPath) {
-    const fs14 = await import("fs/promises");
-    const path7 = await import("path");
-    const whiteListPath = path7.join(rootPath, ".urpfallow");
+    const fs15 = await import("fs/promises");
+    const path8 = await import("path");
+    const whiteListPath = path8.join(rootPath, ".urpfallow");
     try {
-      await fs14.access(whiteListPath);
+      await fs15.access(whiteListPath);
       return true;
     } catch {
       return false;
@@ -689,14 +689,14 @@ var URPFGenerator = class {
   /**
    * 生成属性部分
    */
-  generatePropertySection(properties) {
+  generatePropertySection(properties2) {
     const newline = this.getNewline();
     const lines = [];
-    for (const prop of properties) {
+    for (const prop of properties2) {
       if (prop.name.includes(" ")) {
-        lines.push(`\${${prop.name}}=${prop.value}`);
+        lines.push(`${prop.name}=${prop.value}`);
       } else {
-        lines.push(`$${prop.name}=${prop.value}`);
+        lines.push(`${prop.name}=${prop.value}`);
       }
     }
     return lines.join(newline);
@@ -705,7 +705,19 @@ var URPFGenerator = class {
    * 生成资源头部
    */
   generateResourceHeader(resource) {
-    const header = `@${resource.header.udrsReference} ${resource.header.encoding} ${resource.header.permissions} ${resource.header.newlineType}`;
+    const udrsRef = resource.header.udrsReference;
+    let udrsRefString;
+    if (typeof udrsRef === "string") {
+      udrsRefString = udrsRef;
+    } else if (udrsRef.protocol && udrsRef.uri) {
+      udrsRefString = `${udrsRef.protocol}://${udrsRef.uri}`;
+      if (udrsRef.fragment) {
+        udrsRefString += `#${udrsRef.fragment}`;
+      }
+    } else {
+      throw new Error(`Invalid UDRS reference: ${JSON.stringify(udrsRef)}`);
+    }
+    const header = `@${udrsRefString} ${resource.header.encoding} ${resource.header.permissions} ${resource.header.newlineType}`;
     return header;
   }
   /**
@@ -727,9 +739,9 @@ var URPFGenerator = class {
     if (this.state.includeBoundaries) {
       parts.push(this.generateStartBoundary());
     }
-    const properties = "propertySection" in document ? document.propertySection?.properties : "properties" in document ? document.properties : void 0;
-    if (properties && properties.length > 0) {
-      parts.push(this.generatePropertySection(properties));
+    const properties2 = "propertySection" in document ? document.propertySection?.properties : "properties" in document ? document.properties : void 0;
+    if (properties2 && properties2.length > 0) {
+      parts.push(this.generatePropertySection(properties2));
       parts.push(this.generateDelimiter());
     }
     const resources = "resourceSections" in document ? document.resourceSections : "resources" in document ? document.resources : [];
@@ -745,10 +757,11 @@ var URPFGenerator = class {
     }
     const content = parts.join(newline);
     const duration = Date.now() - startTime;
+    const resourcesForCount = "resourceSections" in document ? document.resourceSections : "resources" in document ? document.resources : [];
     return {
       content,
       size: Buffer.byteLength(content, "utf-8"),
-      resourceCount: document.resources.length,
+      resourceCount: resourcesForCount.length,
       duration
     };
   }
@@ -796,12 +809,7 @@ var ResourceSerializer = class {
       Buffer.from(buffer.toString("utf-8"), "utf-8");
       return "utf-8";
     } catch {
-      try {
-        Buffer.from(buffer.toString("gbk"), "gbk");
-        return "gbk";
-      } catch {
-        return "binary";
-      }
+      return "binary";
     }
   }
   /**
@@ -837,6 +845,36 @@ var ResourceSerializer = class {
     const permissions = mode & 511;
     return permissions.toString(8).padStart(3, "0");
   }
+  /**
+   * 解析 UDRS 引用字符串为 UDRSReference 对象
+   */
+  parseUDRSReference(udrsRefString) {
+    const match = udrsRefString.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/(.*)$/);
+    if (!match) {
+      throw new Error(`\u65E0\u6548\u7684 UDRS \u5F15\u7528\u683C\u5F0F: ${udrsRefString}`);
+    }
+    const protocol = match[1];
+    const uriAndFragment = match[2];
+    const fragmentIndex = uriAndFragment.indexOf("#");
+    const uri = fragmentIndex !== -1 ? uriAndFragment.substring(0, fragmentIndex) : uriAndFragment;
+    const fragment = fragmentIndex !== -1 ? uriAndFragment.substring(fragmentIndex + 1) : void 0;
+    let fragmentType;
+    if (fragment) {
+      if (fragment.startsWith("::line=")) {
+        fragmentType = "raw-line";
+      } else if (fragment.startsWith("::byte=")) {
+        fragmentType = "raw-byte";
+      } else {
+        fragmentType = "structured";
+      }
+    }
+    return {
+      protocol,
+      uri,
+      fragment,
+      fragmentType
+    };
+  }
   /**
    * 读取文件内容
    */
@@ -864,8 +902,9 @@ var ResourceSerializer = class {
     }
     const content = await this.readFile(filePath, encoding);
     const permissions = this.convertPermissions(metadata.permissions);
+    const udrsRef = this.parseUDRSReference(udrsReference);
     const header = {
-      udrsReference,
+      udrsReference: udrsRef,
       encoding,
       permissions,
       newlineType
@@ -1175,6 +1214,9 @@ var LineOperations = class {
    */
   static applyCLILineRange(content, range) {
     const normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (normalizedContent === "") {
+      throw new Error(`\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u63D0\u53D6\u884C`);
+    }
     const lines = normalizedContent.split("\n");
     const totalLines = lines.length;
     const { start, end } = range;
@@ -1385,184 +1427,1527 @@ var LineOperations = class {
   }
 };
 
-// src/commands/pack.ts
-import clipboardy from "clipboardy";
-
-// src/commands/types.ts
-function normalizeURPFPath(filePath) {
-  if (filePath.endsWith(".urpf.txt") || filePath.endsWith(".urpf")) {
-    return filePath;
+// src/core/engine/key-extractor.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+import * as yaml from "js-yaml";
+import * as toml from "toml";
+import * as xml2js from "xml2js";
+import * as ini from "ini";
+var KeyExtractor = class {
+  constructor(options = {}) {
+    this.options = {
+      preserveFormat: options.preserveFormat ?? true,
+      onError: options.onError ?? ((error) => {
+        throw error;
+      })
+    };
   }
-  return `${filePath}.urpf.txt`;
-}
-async function findURPFFile(filePath) {
-  const fs14 = await import("fs/promises");
-  try {
-    const stats = await fs14.stat(filePath);
-    if (stats.isFile()) {
-      return filePath;
+  /**
+   * 从文件中提取指定 key 的值
+   *
+   * @param filePath - 文件路径
+   * @param keyPath - key 路径（如 "config.server.port"）
+   * @returns 提取结果
+   */
+  async extractFromFile(filePath, keyPath) {
+    if (!fs3.existsSync(filePath)) {
+      const error = new Error(`File not found: ${filePath}`);
+      this.options.onError(error);
+      throw error;
+    }
+    const format = this.detectFormat(filePath);
+    const content = fs3.readFileSync(filePath, "utf-8");
+    let value;
+    switch (format) {
+      case "json" /* JSON */:
+        value = await this.extractFromJSON(content, keyPath);
+        break;
+      case "yaml" /* YAML */:
+        value = await this.extractFromYAML(content, keyPath);
+        break;
+      case "toml" /* TOML */:
+        value = await this.extractFromTOML(content, keyPath);
+        break;
+      case "xml" /* XML */:
+        value = await this.extractFromXML(content, keyPath);
+        break;
+      case "properties" /* PROPERTIES */:
+        value = await this.extractFromProperties(content, keyPath);
+        break;
+      case "ini" /* INI */:
+        value = await this.extractFromINI(content, keyPath);
+        break;
+      default: {
+        const error = new Error(`Unsupported file format: ${format}`);
+        this.options.onError(error);
+        throw error;
+      }
     }
-  } catch {
+    return {
+      value,
+      type: this.getValueType(value),
+      format,
+      keyPath
+    };
   }
-  if (!filePath.endsWith(".urpf.txt") && !filePath.endsWith(".urpf")) {
-    const newPath = `${filePath}.urpf.txt`;
+  /**
+   * 从 JSON 内容中提取指定 key 的值
+   *
+   * @param content - JSON 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromJSON(content, keyPath) {
+    const data = this.parseJSON(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 从 YAML 内容中提取指定 key 的值
+   *
+   * @param content - YAML 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromYAML(content, keyPath) {
+    const data = this.parseYAML(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 从 TOML 内容中提取指定 key 的值
+   *
+   * @param content - TOML 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromTOML(content, keyPath) {
+    const data = this.parseTOML(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 从 XML 内容中提取指定 key 的值
+   *
+   * @param content - XML 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromXML(content, keyPath) {
+    const data = await this.parseXML(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 从 Properties 内容中提取指定 key 的值
+   *
+   * @param content - Properties 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromProperties(content, keyPath) {
+    const data = this.parseProperties(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 从 INI 内容中提取指定 key 的值
+   *
+   * @param content - INI 内容
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  async extractFromINI(content, keyPath) {
+    const data = this.parseINI(content);
+    return this.extractByPath(data, keyPath);
+  }
+  /**
+   * 解析 JSON 内容
+   *
+   * @param content - JSON 内容
+   * @returns 解析后的对象
+   */
+  parseJSON(content) {
     try {
-      const stats = await fs14.stat(newPath);
-      if (stats.isFile()) {
-        return newPath;
-      }
-    } catch {
+      return JSON.parse(content);
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
     }
-    const oldPath = `${filePath}.urpf`;
+  }
+  /**
+   * 解析 YAML 内容
+   *
+   * @param content - YAML 内容
+   * @returns 解析后的对象
+   */
+  parseYAML(content) {
     try {
-      const stats = await fs14.stat(oldPath);
-      if (stats.isFile()) {
-        return oldPath;
-      }
-    } catch {
+      return yaml.load(content);
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
     }
   }
-  return null;
-}
-
-// src/commands/pack.ts
-var PackCommand = class {
   /**
-   * 执行 pack 命令
+   * 解析 TOML 内容
+   *
+   * @param content - TOML 内容
+   * @returns 解析后的对象
    */
-  async execute(inputPath, options = {}) {
-    const startTime = Date.now();
+  parseTOML(content) {
     try {
-      const resolvedPath = path2.resolve(inputPath);
-      await this.validatePath(resolvedPath);
-      this.validateSliceOptions(options);
-      const outputPath = options.output || this.generateOutputPath(resolvedPath);
-      const scanResult = await this.scanFiles(resolvedPath, options);
-      const urpfDocument = await this.generateURPFDocument(scanResult, resolvedPath, options);
-      const urpfResult = await this.saveURPFDocument(urpfDocument, outputPath, options);
-      const duration = Date.now() - startTime;
-      await this.handleOutputOptions(urpfResult.content, outputPath, options);
-      if (options.verbose) {
-        this.logVerbose(scanResult, urpfResult, outputPath, duration);
-      }
-      return {
-        success: true,
-        outputPath,
-        fileCount: scanResult.files.length,
-        directoryCount: scanResult.directories.length,
-        skippedCount: scanResult.skippedFiles.length,
-        urpfSize: urpfResult.size,
-        duration
-      };
-    } catch (err) {
-      const duration = Date.now() - startTime;
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      if (options.verbose) {
-        console.error(`\u9519\u8BEF: ${errorMessage}`);
-      }
-      return {
-        success: false,
-        outputPath: "",
-        fileCount: 0,
-        directoryCount: 0,
-        skippedCount: 0,
-        urpfSize: 0,
-        duration,
-        error: errorMessage
-      };
+      return toml.parse(content);
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse TOML: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
     }
   }
   /**
-   * 验证输入路径
+   * 解析 XML 内容
+   *
+   * @param content - XML 内容
+   * @returns 解析后的对象
    */
-  async validatePath(filePath) {
+  async parseXML(content) {
     try {
-      const stats = await fs3.stat(filePath);
-      if (!stats.isFile() && !stats.isDirectory()) {
-        throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6\u6216\u76EE\u5F55: ${filePath}`);
-      }
-    } catch {
-      throw new Error(`\u65E0\u6CD5\u8BBF\u95EE\u8DEF\u5F84: ${filePath}`);
+      const parser = new xml2js.Parser();
+      return await parser.parseStringPromise(content);
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse XML: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
     }
   }
   /**
-   * 验证切片选项
+   * 解析 Properties 内容
+   *
+   * @param content - Properties 内容
+   * @returns 解析后的对象（包含 section）
    */
-  validateSliceOptions(options) {
-    if ((options.byteStart !== void 0 || options.byteEnd !== void 0) && (options.lineStart !== void 0 || options.lineEnd !== void 0)) {
-      throw new Error("\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528 --byte \u548C --line \u5207\u7247\u9009\u9879");
-    }
-    if (options.byteEnd !== void 0 && options.byteStart === void 0) {
-      throw new Error("--byte \u9009\u9879\u5FC5\u987B\u6307\u5B9A\u8D77\u59CB\u4F4D\u7F6E");
-    }
-    if (options.lineEnd !== void 0 && options.lineStart === void 0) {
-      throw new Error("--line \u9009\u9879\u5FC5\u987B\u6307\u5B9A\u8D77\u59CB\u884C\u53F7");
+  parseProperties(content) {
+    try {
+      const result = {};
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith("#") || trimmedLine.startsWith("!")) {
+          continue;
+        }
+        const processedLine = trimmedLine.replace(/\\:/g, ":").replace(/\\=/g, "=").replace(/\\#/g, "#").replace(/\\!/g, "!");
+        let separatorIndex = -1;
+        for (let i = 0; i < processedLine.length; i++) {
+          if (processedLine[i] === "=" || processedLine[i] === ":") {
+            separatorIndex = i;
+            break;
+          }
+        }
+        if (separatorIndex === -1) {
+          result[processedLine] = "";
+          continue;
+        }
+        const key = processedLine.substring(0, separatorIndex).trim();
+        let value = processedLine.substring(separatorIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.substring(1, value.length - 1);
+        }
+        result[key] = value;
+      }
+      const nestedResult = {};
+      for (const [key, value] of Object.entries(result)) {
+        const parts = key.split(".");
+        if (parts.length > 1) {
+          const section = parts[0];
+          const sectionKey = parts.slice(1).join(".");
+          if (!(nestedResult[section] && typeof nestedResult[section] === "object")) {
+            nestedResult[section] = {};
+          }
+          const sectionObj = nestedResult[section];
+          sectionObj[sectionKey] = value;
+        } else {
+          nestedResult[key] = value;
+        }
+      }
+      return nestedResult;
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse Properties: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
     }
   }
   /**
-   * 生成输出路径
+   * 解析 INI 内容
+   *
+   * @param content - INI 内容
+   * @returns 解析后的对象（包含 section）
    */
-  generateOutputPath(inputPath) {
-    return normalizeURPFPath(inputPath);
+  parseINI(content) {
+    try {
+      return ini.parse(content);
+    } catch (error) {
+      const parsedError = new Error(`Failed to parse INI: ${error instanceof Error ? error.message : String(error)}`);
+      this.options.onError(parsedError);
+      throw parsedError;
+    }
   }
   /**
-   * 扫描文件
-   */
-  async scanFiles(rootPath, options) {
-    const stats = await fs3.stat(rootPath);
-    if (stats.isFile()) {
-      const metadata = await this.collectFileMetadata(rootPath);
-      return {
-        files: [metadata],
-        directories: [],
-        skippedFiles: [],
-        statistics: {
-          totalFiles: 1,
-          totalDirectories: 0,
-          skippedFiles: 0
+   * 根据路径从对象中提取值
+   *
+   * @param data - 数据对象
+   * @param keyPath - key 路径
+   * @returns 提取的值
+   */
+  extractByPath(data, keyPath) {
+    const pathSegments = this.parseKeyPath(keyPath);
+    let current = data;
+    for (const segment of pathSegments) {
+      if (current == null) {
+        const error = new Error(`Key path "${keyPath}" not found: cannot access property "${segment}" of ${current}`);
+        this.options.onError(error);
+        throw error;
+      }
+      if (typeof segment === "number") {
+        if (Array.isArray(current)) {
+          if (segment >= current.length) {
+            const error = new Error(`Array index ${segment} out of bounds (length: ${current.length})`);
+            this.options.onError(error);
+            throw error;
+          }
+          current = current[segment];
+        } else {
+          const error = new Error(`Cannot access array index ${segment} on non-array value`);
+          this.options.onError(error);
+          throw error;
         }
-      };
+      } else {
+        if (typeof current === "object" && current !== null) {
+          if (!(segment in current)) {
+            const error = new Error(`Key "${segment}" not found in path "${keyPath}"`);
+            this.options.onError(error);
+            throw error;
+          }
+          current = current[segment];
+        } else {
+          const error = new Error(`Cannot access property "${segment}" on non-object value`);
+          this.options.onError(error);
+          throw error;
+        }
+      }
     }
-    let ignoreRules = [];
-    if (options.ignoreFile) {
-      const parser = new IgnoreRuleParser();
-      const content = await fs3.readFile(options.ignoreFile, "utf-8");
-      ignoreRules = parser.parseFile(content);
-    } else {
-      const defaultIgnoreFiles = [".gitignore", ".iflowignore"];
-      for (const ignoreFile of defaultIgnoreFiles) {
-        const ignorePath = path2.join(rootPath, ignoreFile);
-        try {
-          await fs3.access(ignorePath);
-          const parser = new IgnoreRuleParser();
-          const content = await fs3.readFile(ignorePath, "utf-8");
-          ignoreRules = [...ignoreRules, ...parser.parseFile(content)];
-          break;
-        } catch {
+    return current;
+  }
+  /**
+   * 解析 key 路径，支持点分隔符和数组索引
+   *
+   * @param keyPath - key 路径（如 "config.server.port" 或 "items[0].name"）
+   * @returns 解析后的路径段数组
+   */
+  parseKeyPath(keyPath) {
+    const segments = [];
+    let current = "";
+    let inBrackets = false;
+    let bracketContent = "";
+    for (let i = 0; i < keyPath.length; i++) {
+      const char = keyPath[i];
+      if (char === "[") {
+        if (inBrackets) {
+          const error = new Error(`Invalid key path: nested brackets at position ${i}`);
+          this.options.onError(error);
+          throw error;
+        }
+        if (current.trim()) {
+          segments.push(current.trim());
+        }
+        inBrackets = true;
+        bracketContent = "";
+        current = "";
+      } else if (char === "]") {
+        if (!inBrackets) {
+          const error = new Error(`Invalid key path: closing bracket without opening bracket at position ${i}`);
+          this.options.onError(error);
+          throw error;
+        }
+        inBrackets = false;
+        const index = parseInt(bracketContent.trim(), 10);
+        if (isNaN(index)) {
+          const error = new Error(`Invalid array index: "${bracketContent}" is not a number`);
+          this.options.onError(error);
+          throw error;
+        }
+        segments.push(index);
+        current = "";
+      } else if (char === "." && !inBrackets) {
+        if (current.trim()) {
+          const trimmed = current.trim();
+          const numIndex = parseInt(trimmed, 10);
+          if (!isNaN(numIndex) && trimmed === numIndex.toString()) {
+            segments.push(numIndex);
+          } else {
+            segments.push(trimmed);
+          }
+        }
+        current = "";
+      } else {
+        if (inBrackets) {
+          bracketContent += char;
+        } else {
+          current += char;
         }
       }
     }
-    const effectiveMaxDepth = options.noRecurse ? 1 : options.maxDepth;
-    return await FileScanner.scanDirectory(rootPath, {
-      ignoreRules,
-      followSymlinks: options.followSymlinks || false,
-      maxDepth: effectiveMaxDepth
-      // undefined 或 1
-    });
+    if (inBrackets) {
+      const error = new Error("Invalid key path: unclosed bracket");
+      this.options.onError(error);
+      throw error;
+    }
+    if (current.trim()) {
+      const trimmed = current.trim();
+      const numIndex = parseInt(trimmed, 10);
+      if (!isNaN(numIndex) && trimmed === numIndex.toString()) {
+        segments.push(numIndex);
+      } else {
+        segments.push(trimmed);
+      }
+    }
+    return segments;
   }
   /**
-   * 收集文件元数据
-   */
-  async collectFileMetadata(filePath) {
-    const stats = await fs3.stat(filePath);
-    return {
-      path: filePath,
-      name: path2.basename(filePath),
+   * 根据文件扩展名检测文件格式
+   *
+   * @param filePath - 文件路径
+   * @returns 文件格式
+   */
+  detectFormat(filePath) {
+    const ext = path2.extname(filePath).toLowerCase();
+    switch (ext) {
+      case ".json":
+        return "json" /* JSON */;
+      case ".yaml":
+      case ".yml":
+        return "yaml" /* YAML */;
+      case ".toml":
+        return "toml" /* TOML */;
+      case ".xml":
+        return "xml" /* XML */;
+      case ".properties":
+        return "properties" /* PROPERTIES */;
+      case ".ini":
+        return "ini" /* INI */;
+      default: {
+        const error = new Error(`Unsupported file extension: ${ext}`);
+        this.options.onError(error);
+        throw error;
+      }
+    }
+  }
+  /**
+   * 获取值的类型
+   *
+   * @param value - 值
+   * @returns 类型字符串
+   */
+  getValueType(value) {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "array";
+    return typeof value;
+  }
+};
+
+// src/core/engine/wildcard-matcher.ts
+var WildcardMatcher = class {
+  constructor(options = {}) {
+    this.options = {
+      caseSensitive: options.caseSensitive ?? false
+    };
+  }
+  /**
+   * 检查单个 key 是否匹配通配符模式
+   *
+   * @param pattern - 通配符模式（如 "config.*.port" 或 "data.**.value"）
+   * @param key - 要检查的 key 路径
+   * @returns 是否匹配
+   */
+  matches(pattern, key) {
+    const patternSegments = this.splitPattern(pattern);
+    const keySegments = this.splitKeyPath(key);
+    return this.matchSegments(patternSegments, keySegments, 0, 0);
+  }
+  /**
+   * 分割通配符模式为段数组
+   */
+  splitPattern(pattern) {
+    const segments = [];
+    let current = "";
+    let i = 0;
+    let inBrackets = false;
+    while (i < pattern.length) {
+      const char = pattern[i];
+      if (char === "[") {
+        if (current) {
+          segments.push(current);
+          current = "";
+        }
+        inBrackets = true;
+        current = "[";
+        i += 1;
+      } else if (char === "]") {
+        current += char;
+        inBrackets = false;
+        segments.push(current);
+        current = "";
+        i += 1;
+      } else if (char === "*" && pattern[i + 1] === "*" && !inBrackets) {
+        if (current) {
+          segments.push(current);
+          current = "";
+        }
+        segments.push("**");
+        i += 2;
+      } else if (char === "*" && !inBrackets) {
+        current += char;
+        i += 1;
+      } else if (char === "." && !inBrackets) {
+        if (current) {
+          segments.push(current);
+          current = "";
+        }
+        i += 1;
+      } else {
+        current += char;
+        i += 1;
+      }
+    }
+    if (current) {
+      segments.push(current);
+    }
+    return segments;
+  }
+  /**
+   * 分割 key 路径为段数组
+   */
+  splitKeyPath(key) {
+    const segments = [];
+    let current = "";
+    let inBrackets = false;
+    for (let i = 0; i < key.length; i++) {
+      const char = key[i];
+      if (char === "[") {
+        if (current) {
+          segments.push(current);
+          current = "";
+        }
+        inBrackets = true;
+        current = "[";
+      } else if (char === "]") {
+        current += char;
+        inBrackets = false;
+        segments.push(current);
+        current = "";
+      } else if (char === "." && !inBrackets) {
+        if (current) {
+          segments.push(current);
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current) {
+      segments.push(current);
+    }
+    return segments;
+  }
+  /**
+   * 递归匹配段
+   */
+  matchSegments(patternSegments, keySegments, patternIndex, keyIndex) {
+    if (patternIndex >= patternSegments.length && keyIndex >= keySegments.length) {
+      return true;
+    }
+    if (patternIndex >= patternSegments.length) {
+      return false;
+    }
+    const patternSegment = patternSegments[patternIndex];
+    if (patternSegment === "**") {
+      if (this.matchSegments(patternSegments, keySegments, patternIndex + 1, keyIndex)) {
+        return true;
+      }
+      if (keyIndex < keySegments.length) {
+        if (this.matchSegments(patternSegments, keySegments, patternIndex, keyIndex + 1)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    if (keyIndex >= keySegments.length) {
+      for (let i = patternIndex; i < patternSegments.length; i++) {
+        if (patternSegments[i] !== "**") {
+          return false;
+        }
+      }
+      return true;
+    }
+    const keySegment = keySegments[keyIndex];
+    if (patternSegment === "*") {
+      return this.matchSegments(patternSegments, keySegments, patternIndex + 1, keyIndex + 1);
+    }
+    if (this.matchPatternSegment(patternSegment, keySegment)) {
+      return this.matchSegments(patternSegments, keySegments, patternIndex + 1, keyIndex + 1);
+    }
+    return false;
+  }
+  /**
+   * 匹配单个模式段和 key 段
+   */
+  matchPatternSegment(patternSegment, keySegment) {
+    if (patternSegment.includes("*") || patternSegment.includes("?")) {
+      return this.matchWildcardPattern(patternSegment, keySegment);
+    }
+    if (this.options.caseSensitive) {
+      return patternSegment === keySegment;
+    } else {
+      return patternSegment.toLowerCase() === keySegment.toLowerCase();
+    }
+  }
+  /**
+   * 匹配通配符模式（不包含 globstar）
+   */
+  matchWildcardPattern(pattern, text) {
+    const pLen = pattern.length;
+    const tLen = text.length;
+    let pIndex = 0;
+    let tIndex = 0;
+    let starIndex = -1;
+    let matchIndex = -1;
+    while (tIndex < tLen) {
+      if (pIndex < pLen && pattern[pIndex] === "*") {
+        starIndex = pIndex;
+        matchIndex = tIndex;
+        pIndex++;
+      } else if (pIndex < pLen && this.matchChar(pattern[pIndex], text[tIndex])) {
+        pIndex++;
+        tIndex++;
+      } else if (starIndex !== -1) {
+        pIndex = starIndex + 1;
+        matchIndex++;
+        tIndex = matchIndex;
+      } else {
+        return false;
+      }
+    }
+    while (pIndex < pLen && pattern[pIndex] === "*") {
+      pIndex++;
+    }
+    return pIndex === pLen;
+  }
+  /**
+   * 匹配单个字符
+   */
+  matchChar(patternChar, textChar) {
+    if (patternChar === "?") {
+      return true;
+    }
+    if (this.options.caseSensitive) {
+      return patternChar === textChar;
+    } else {
+      return patternChar.toLowerCase() === textChar.toLowerCase();
+    }
+  }
+  /**
+   * 从 key 列表中找出所有匹配通配符模式的 key
+   *
+   * @param pattern - 通配符模式
+   * @param keys - key 列表
+   * @returns 匹配结果
+   */
+  matchKeys(pattern, keys) {
+    const matches = [];
+    for (const key of keys) {
+      if (this.matches(pattern, key)) {
+        matches.push(key);
+      }
+    }
+    return {
+      matched: matches.length > 0,
+      matches,
+      stats: {
+        total: keys.length,
+        matched: matches.length
+      }
+    };
+  }
+  /**
+   * 从对象中提取所有匹配通配符模式的 key 路径
+   *
+   * @param pattern - 通配符模式
+   * @param obj - 要搜索的对象
+   * @param prefix - 当前路径前缀（内部使用）
+   * @returns 匹配结果
+   */
+  extractMatchingKeys(pattern, obj, prefix = "") {
+    const matches = [];
+    const allKeys = [];
+    this.collectKeys(obj, prefix, allKeys);
+    for (const key of allKeys) {
+      if (this.matches(pattern, key)) {
+        matches.push(key);
+      }
+    }
+    return {
+      matched: matches.length > 0,
+      matches,
+      stats: {
+        total: allKeys.length,
+        matched: matches.length
+      }
+    };
+  }
+  /**
+   * 从对象中提取匹配通配符模式的 key 值对
+   *
+   * @param pattern - 通配符模式
+   * @param obj - 要搜索的对象
+   * @returns 匹配的 key 值对
+   */
+  extractMatchingValues(pattern, obj) {
+    const result = {};
+    const matchResult = this.extractMatchingKeys(pattern, obj);
+    for (const key of matchResult.matches) {
+      try {
+        const value = this.getValueByPath(obj, key);
+        result[key] = value;
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * 递归收集对象中的所有 key 路径
+   *
+   * @param obj - 对象
+   * @param prefix - 路径前缀
+   * @param keys - 收集的 key 列表
+   */
+  collectKeys(obj, prefix, keys) {
+    if (obj == null || typeof obj !== "object") {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        const key = prefix ? `${prefix}[${i}]` : `[${i}]`;
+        keys.push(key);
+        this.collectKeys(obj[i], key, keys);
+      }
+    } else {
+      for (const [prop, value] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${prop}` : prop;
+        keys.push(key);
+        this.collectKeys(value, key, keys);
+      }
+    }
+  }
+  /**
+   * 根据路径从对象中获取值
+   *
+   * @param obj - 对象
+   * @param path - 路径
+   * @returns 值
+   */
+  getValueByPath(obj, path8) {
+    const segments = [];
+    let current = "";
+    let inBrackets = false;
+    let bracketContent = "";
+    for (let i = 0; i < path8.length; i++) {
+      const char = path8[i];
+      if (char === "[") {
+        if (inBrackets) {
+          throw new Error(`Invalid path: nested brackets at position ${i}`);
+        }
+        if (current.trim()) {
+          segments.push(current.trim());
+        }
+        inBrackets = true;
+        bracketContent = "";
+        current = "";
+      } else if (char === "]") {
+        if (!inBrackets) {
+          throw new Error(`Invalid path: closing bracket without opening bracket at position ${i}`);
+        }
+        inBrackets = false;
+        const index = parseInt(bracketContent.trim(), 10);
+        if (isNaN(index)) {
+          throw new Error(`Invalid array index: "${bracketContent}" is not a number`);
+        }
+        segments.push(index);
+        current = "";
+      } else if (char === "." && !inBrackets) {
+        if (current.trim()) {
+          segments.push(current.trim());
+        }
+        current = "";
+      } else {
+        if (inBrackets) {
+          bracketContent += char;
+        } else {
+          current += char;
+        }
+      }
+    }
+    if (inBrackets) {
+      throw new Error("Invalid path: unclosed bracket");
+    }
+    if (current.trim()) {
+      segments.push(current.trim());
+    }
+    let value = obj;
+    for (const segment of segments) {
+      if (value == null) {
+        throw new Error(`Path "${path8}" not found`);
+      }
+      if (typeof segment === "number") {
+        if (Array.isArray(value)) {
+          if (segment >= value.length) {
+            throw new Error(`Array index ${segment} out of bounds`);
+          }
+          value = value[segment];
+        } else {
+          throw new Error(`Cannot access array index ${segment} on non-array value`);
+        }
+      } else {
+        if (typeof value === "object" && value !== null) {
+          if (!(segment in value)) {
+            throw new Error(`Key "${segment}" not found`);
+          }
+          value = value[segment];
+        } else {
+          throw new Error(`Cannot access property "${segment}" on non-object value`);
+        }
+      }
+    }
+    return value;
+  }
+  /**
+   * 检查模式是否包含通配符
+   *
+   * @param pattern - 模式
+   * @returns 是否包含通配符
+   */
+  hasWildcard(pattern) {
+    return /[*?]/.test(pattern);
+  }
+  /**
+   * 检查模式是否包含多层级通配符
+   *
+   * @param pattern - 模式
+   * @returns 是否包含多层级通配符
+   */
+  hasGlobstar(pattern) {
+    return pattern.includes("**");
+  }
+};
+var defaultWildcardMatcher = new WildcardMatcher({
+  caseSensitive: false
+});
+
+// src/core/engine/batch-key-extractor.ts
+var BatchKeyExtractor = class {
+  constructor(options = {}) {
+    this.options = {
+      preserveFormat: options.preserveFormat ?? true,
+      onError: options.onError ?? ((error) => {
+        throw error;
+      }),
+      enableWildcard: options.enableWildcard ?? true,
+      warnOnNoMatch: options.warnOnNoMatch ?? true,
+      outputFormat: options.outputFormat ?? "array"
+    };
+    this.keyExtractor = new KeyExtractor({
+      preserveFormat: this.options.preserveFormat,
+      onError: this.options.onError
+    });
+    this.wildcardMatcher = new WildcardMatcher({
+      caseSensitive: false
+    });
+  }
+  /**
+   * 从文件中批量提取多个 key 的值
+   *
+   * @param filePath - 文件路径
+   * @param keyPaths - key 路径列表（支持逗号分隔）
+   * @returns 批量提取结果
+   */
+  async extractFromFile(filePath, keyPaths) {
+    const keys = this.parseKeyPaths(keyPaths);
+    const results = [];
+    const errors = [];
+    for (const keyPath of keys) {
+      try {
+        if (this.options.enableWildcard && this.wildcardMatcher.hasWildcard(keyPath)) {
+          const wildcardResults = await this.extractWithWildcard(filePath, keyPath);
+          results.push(...wildcardResults.results);
+          if (wildcardResults.errors.length > 0) {
+            errors.push(...wildcardResults.errors);
+          }
+        } else {
+          const result = await this.keyExtractor.extractFromFile(filePath, keyPath);
+          results.push(result);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({ key: keyPath, error: errorMessage });
+      }
+    }
+    return {
+      results,
+      success: errors.length === 0,
+      successCount: results.length,
+      failureCount: errors.length,
+      errors
+    };
+  }
+  /**
+   * 使用通配符模式提取 key
+   *
+   * @param filePath - 文件路径
+   * @param pattern - 通配符模式
+   * @returns 批量提取结果
+   */
+  async extractWithWildcard(filePath, pattern) {
+    const fs15 = await import("fs");
+    const content = fs15.readFileSync(filePath, "utf-8");
+    let obj;
+    const format = this.keyExtractor.detectFormat(filePath);
+    switch (format) {
+      case "json":
+        obj = this.keyExtractor.parseJSON(content);
+        break;
+      case "yaml":
+        obj = this.keyExtractor.parseYAML(content);
+        break;
+      case "toml":
+        obj = this.keyExtractor.parseTOML(content);
+        break;
+      case "xml":
+        obj = await this.keyExtractor.parseXML(content);
+        break;
+      case "properties":
+        obj = this.keyExtractor.parseProperties(content);
+        break;
+      case "ini":
+        obj = this.keyExtractor.parseINI(content);
+        break;
+      default:
+        throw new Error(`Unsupported file format: ${format}`);
+    }
+    const matchedValues = this.wildcardMatcher.extractMatchingValues(pattern, obj);
+    const results = [];
+    const errors = [];
+    for (const [key, value] of Object.entries(matchedValues)) {
+      results.push({
+        value,
+        type: this.getValueType(value),
+        format,
+        keyPath: key
+      });
+    }
+    if (results.length === 0 && this.options.warnOnNoMatch) {
+      console.warn(`\u26A0\uFE0F  \u8B66\u544A: \u901A\u914D\u7B26\u6A21\u5F0F "${pattern}" \u672A\u5339\u914D\u5230\u4EFB\u4F55 key`);
+    }
+    return {
+      results,
+      success: errors.length === 0,
+      successCount: results.length,
+      failureCount: errors.length,
+      errors
+    };
+  }
+  /**
+   * 解析 key 路径列表（支持逗号分隔）
+   *
+   * @param keyPaths - key 路径（字符串或字符串数组）
+   * @returns 解析后的 key 路径数组
+   */
+  parseKeyPaths(keyPaths) {
+    if (Array.isArray(keyPaths)) {
+      const result = [];
+      for (const kp of keyPaths) {
+        const parts = kp.split(",").map((s) => s.trim()).filter((s) => s);
+        result.push(...parts);
+      }
+      return result;
+    } else {
+      return keyPaths.split(",").map((s) => s.trim()).filter((s) => s);
+    }
+  }
+  /**
+   * 获取值的类型
+   *
+   * @param value - 值
+   * @returns 类型字符串
+   */
+  getValueType(value) {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "array";
+    return typeof value;
+  }
+  /**
+   * 格式化输出结果
+   *
+   * @param result - 批量提取结果
+   * @returns 格式化后的输出
+   */
+  formatOutput(result) {
+    if (this.options.outputFormat === "object") {
+      const obj = {};
+      for (const r of result.results) {
+        obj[r.keyPath] = r.value;
+      }
+      return JSON.stringify(obj, null, 2);
+    } else {
+      return JSON.stringify(result.results.map((r) => ({
+        key: r.keyPath,
+        value: r.value,
+        type: r.type
+      })), null, 2);
+    }
+  }
+  /**
+   * 打印批量提取结果的摘要
+   *
+   * @param result - 批量提取结果
+   */
+  printSummary(result) {
+    console.log(`\u2705 \u6210\u529F\u63D0\u53D6: ${result.successCount} \u4E2A key`);
+    if (result.failureCount > 0) {
+      console.log(`\u274C \u5931\u8D25: ${result.failureCount} \u4E2A key`);
+      for (const err of result.errors) {
+        console.log(`  - ${err.key}: ${err.error}`);
+      }
+    }
+  }
+};
+var defaultBatchKeyExtractor = new BatchKeyExtractor();
+
+// src/core/formatter/output-formatter.ts
+import yaml2 from "js-yaml";
+import TOML from "toml";
+import xml2js2 from "xml2js";
+var OutputFormatter = class {
+  /**
+   * 格式化数据为指定格式
+   * @param data 要格式化的数据
+   * @param options 格式化选项
+   * @returns 格式化后的字符串
+   */
+  format(data, options) {
+    const { format } = options;
+    switch (format) {
+      case "json":
+        return this.formatJSON(data, options);
+      case "yaml":
+      case "yml":
+        return this.formatYAML(data, options);
+      case "toml":
+        return this.formatTOML(data, options);
+      case "xml":
+        return this.formatXML(data, options);
+      case "properties":
+        return this.formatProperties(data, options);
+      case "ini":
+        return this.formatINI(data, options);
+      case "raw":
+        return this.formatRaw(data, options);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * 格式化为 JSON
+   */
+  formatJSON(data, options) {
+    const indent = options.indent ?? 2;
+    return JSON.stringify(data, null, indent);
+  }
+  /**
+   * 格式化为 YAML
+   */
+  formatYAML(data, options) {
+    const indent = options.indent ?? 2;
+    return yaml2.dump(data, {
+      indent,
+      lineWidth: -1,
+      // 不限制行宽
+      noRefs: true,
+      // 不支持引用
+      sortKeys: false
+      // 不排序键
+    });
+  }
+  /**
+  * 格式化为 TOML
+  */
+  formatTOML(data, _options) {
+    return TOML.stringify(data);
+  }
+  /**
+   * 格式化为 XML
+   */
+  formatXML(data, options) {
+    const rootName = options.xmlRootName ?? "root";
+    const indent = options.indent ?? 2;
+    const builder = new xml2js2.Builder({
+      rootName,
+      xmldec: { version: "1.0", encoding: "UTF-8" },
+      renderOpts: { pretty: true, indent: " ".repeat(indent) }
+    });
+    return builder.buildObject(data);
+  }
+  /**
+   * 格式化为 Properties 格式
+   */
+  formatProperties(data, options) {
+    const prefix = options.keyPrefix ?? "";
+    const lines = [];
+    const flatten = (obj, currentPrefix) => {
+      for (const [key, value] of Object.entries(obj)) {
+        const fullKey = currentPrefix ? `${currentPrefix}.${key}` : key;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          flatten(value, fullKey);
+        } else {
+          const stringValue = this.escapePropertiesValue(String(value));
+          lines.push(`${prefix}${fullKey}=${stringValue}`);
+        }
+      }
+    };
+    if (typeof data === "object" && data !== null) {
+      flatten(data, "");
+    } else {
+      const stringValue = this.escapePropertiesValue(String(data));
+      lines.push(`${prefix}value=${stringValue}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * 转义 Properties 值中的特殊字符
+   */
+  escapePropertiesValue(value) {
+    return value.replace(/\\/g, "").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f");
+  }
+  /**
+    * 格式化为 INI 格式
+  */
+  formatINI(data, _options) {
+    const lines = [];
+    const flatten = (obj, section) => {
+      for (const [key, value] of Object.entries(obj)) {
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          flatten(value, key);
+        } else {
+          const stringValue = this.escapeINIValue(String(value));
+          if (section) {
+            lines.push(`[${section}]`);
+            lines.push(`${key}=${stringValue}`);
+            section = null;
+          } else {
+            lines.push(`${key}=${stringValue}`);
+          }
+        }
+      }
+    };
+    if (typeof data === "object" && data !== null) {
+      flatten(data, null);
+    } else {
+      const stringValue = this.escapeINIValue(String(data));
+      lines.push(`value=${stringValue}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * 转义 INI 值中的特殊字符
+   */
+  escapeINIValue(value) {
+    return value.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  }
+  /**
+   * 格式化为原始格式（直接输出值）
+   */
+  formatRaw(data, _options) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (typeof data === "number" || typeof data === "boolean") {
+      return String(data);
+    }
+    if (data === null) {
+      return "";
+    }
+    if (typeof data === "object") {
+      return JSON.stringify(data);
+    }
+    return String(data);
+  }
+  /**
+   * 验证格式字符串是否有效
+   */
+  static isValidFormat(format) {
+    const validFormats = ["json", "yaml", "yml", "toml", "xml", "properties", "ini", "raw"];
+    return validFormats.includes(format);
+  }
+  /**
+   * 获取所有支持的格式列表
+   */
+  static getSupportedFormats() {
+    return ["json", "yaml", "yml", "toml", "xml", "properties", "ini", "raw"];
+  }
+};
+
+// src/core/validator/key-validator.ts
+var KeyValidator = class {
+  constructor() {
+    this.keyExtractor = new KeyExtractor();
+    this.batchKeyExtractor = new BatchKeyExtractor();
+  }
+  /**
+  * 验证单个 key 是否存在
+  * @param data 配置数据对象
+  * @param keyPath key 路径
+  * @returns 验证结果
+  */
+  validate(data, keyPath) {
+    try {
+      const value = this.extractValueFromData(data, keyPath);
+      if (value !== void 0) {
+        return {
+          key: keyPath,
+          exists: true,
+          value
+        };
+      } else {
+        return {
+          key: keyPath,
+          exists: false
+        };
+      }
+    } catch (error) {
+      return {
+        key: keyPath,
+        exists: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * 从数据对象中提取值（辅助方法）
+   */
+  extractValueFromData(data, keyPath) {
+    if (!keyPath) {
+      throw new Error("Key path cannot be empty");
+    }
+    const parts = keyPath.split(".");
+    let current = data;
+    for (const part of parts) {
+      if (current === null || current === void 0) {
+        return void 0;
+      }
+      if (typeof current !== "object") {
+        return void 0;
+      }
+      if (part.includes("[") && part.includes("]")) {
+        const [arrayKey, indexStr] = part.split("[");
+        const index = parseInt(indexStr.replace("]", ""), 10);
+        const obj = current;
+        current = obj[arrayKey];
+        if (Array.isArray(current)) {
+          current = current[index];
+        }
+      } else {
+        const obj = current;
+        current = obj[part];
+      }
+    }
+    return current;
+  }
+  /**
+  * 批量验证多个 key 是否存在
+  * @param data 配置数据对象
+  * @param keyPaths key 路径数组（可能包含逗号分隔的字符串）
+  * @returns 批量验证结果
+  */
+  validateBatch(data, keyPaths) {
+    const results = [];
+    const allKeys = [];
+    for (const kp of keyPaths) {
+      const parts = kp.split(",").map((s) => s.trim()).filter((s) => s);
+      allKeys.push(...parts);
+    }
+    for (const keyPath of allKeys) {
+      const result = this.validate(data, keyPath);
+      results.push(result);
+    }
+    const existsCount = results.filter((r) => r.exists).length;
+    const notExistsCount = results.length - existsCount;
+    return {
+      allExists: notExistsCount === 0,
+      results,
+      existsCount,
+      notExistsCount
+    };
+  }
+  /**
+   * 格式化验证结果为人类可读的字符串
+   * @param result 验证结果
+   * @returns 格式化后的字符串
+   */
+  formatResult(result) {
+    if (result.exists) {
+      const valueStr = this.formatValue(result.value);
+      return `\u2705 Key '${result.key}' exists${valueStr ? `: ${valueStr}` : ""}`;
+    } else {
+      if (result.error) {
+        return `\u274C Key '${result.key}' error: ${result.error}`;
+      }
+      return `\u274C Key '${result.key}' not found`;
+    }
+  }
+  /**
+   * 格式化批量验证结果为人类可读的字符串
+   * @param result 批量验证结果
+   * @returns 格式化后的字符串
+   */
+  formatBatchResult(result) {
+    const lines = [];
+    for (const r of result.results) {
+      lines.push(this.formatResult(r));
+    }
+    lines.push("");
+    lines.push(`\u{1F4CA} Summary:`);
+    lines.push(`  \u2705 Exists: ${result.existsCount}`);
+    lines.push(`  \u274C Not found: ${result.notExistsCount}`);
+    lines.push(`  \u{1F4C8} Total: ${result.results.length}`);
+    return lines.join("\n");
+  }
+  /**
+   * 格式化值为字符串
+   */
+  formatValue(value) {
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      return `"${value}"`;
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  /**
+   * 根据验证结果确定退出码
+   * @param result 验证结果
+   * @returns 退出码（0 表示全部存在，1 表示有不存在或错误）
+   */
+  getExitCode(result) {
+    if ("allExists" in result) {
+      return result.allExists ? 0 : 1;
+    } else {
+      return result.exists ? 0 : 1;
+    }
+  }
+};
+
+// src/commands/pack.ts
+import clipboardy from "clipboardy";
+
+// src/commands/types.ts
+function normalizeURPFPath(filePath) {
+  if (filePath.endsWith(".urpf.txt") || filePath.endsWith(".urpf")) {
+    return filePath;
+  }
+  return `${filePath}.urpf.txt`;
+}
+async function findURPFFile(filePath) {
+  const fs15 = await import("fs/promises");
+  try {
+    const stats = await fs15.stat(filePath);
+    if (stats.isFile()) {
+      return filePath;
+    }
+  } catch {
+  }
+  if (!filePath.endsWith(".urpf.txt") && !filePath.endsWith(".urpf")) {
+    const newPath = `${filePath}.urpf.txt`;
+    try {
+      const stats = await fs15.stat(newPath);
+      if (stats.isFile()) {
+        return newPath;
+      }
+    } catch {
+    }
+    const oldPath = `${filePath}.urpf`;
+    try {
+      const stats = await fs15.stat(oldPath);
+      if (stats.isFile()) {
+        return oldPath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/pack.ts
+var PackCommand = class {
+  /**
+   * 执行 pack 命令
+   */
+  async execute(inputPath, options = {}) {
+    const startTime = Date.now();
+    try {
+      const resolvedPath = path3.resolve(inputPath);
+      await this.validatePath(resolvedPath);
+      this.validateSliceOptions(options);
+      const outputPath = options.output || this.generateOutputPath(resolvedPath);
+      const scanResult = await this.scanFiles(resolvedPath, options);
+      const urpfDocument = await this.generateURPFDocument(scanResult, resolvedPath, options);
+      const urpfResult = await this.saveURPFDocument(urpfDocument, outputPath, options);
+      const duration = Date.now() - startTime;
+      await this.handleOutputOptions(urpfResult.content, outputPath, options);
+      if (options.verbose) {
+        this.logVerbose(scanResult, urpfResult, outputPath, duration);
+      }
+      return {
+        success: true,
+        outputPath,
+        fileCount: scanResult.files.length,
+        directoryCount: scanResult.directories.length,
+        skippedCount: scanResult.skippedFiles.length,
+        urpfSize: urpfResult.size,
+        duration
+      };
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (options.verbose) {
+        console.error(`\u9519\u8BEF: ${errorMessage}`);
+      }
+      return {
+        success: false,
+        outputPath: "",
+        fileCount: 0,
+        directoryCount: 0,
+        skippedCount: 0,
+        urpfSize: 0,
+        duration,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 验证输入路径
+   */
+  async validatePath(filePath) {
+    try {
+      const stats = await fs4.stat(filePath);
+      if (!stats.isFile() && !stats.isDirectory()) {
+        throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6\u6216\u76EE\u5F55: ${filePath}`);
+      }
+    } catch {
+      throw new Error(`\u65E0\u6CD5\u8BBF\u95EE\u8DEF\u5F84: ${filePath}`);
+    }
+  }
+  /**
+   * 验证切片选项
+   */
+  validateSliceOptions(options) {
+    if ((options.byteStart !== void 0 || options.byteEnd !== void 0) && (options.lineStart !== void 0 || options.lineEnd !== void 0)) {
+      throw new Error("\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528 --byte \u548C --line \u5207\u7247\u9009\u9879");
+    }
+    if (options.byteEnd !== void 0 && options.byteStart === void 0) {
+      throw new Error("--byte \u9009\u9879\u5FC5\u987B\u6307\u5B9A\u8D77\u59CB\u4F4D\u7F6E");
+    }
+    if (options.lineEnd !== void 0 && options.lineStart === void 0) {
+      throw new Error("--line \u9009\u9879\u5FC5\u987B\u6307\u5B9A\u8D77\u59CB\u884C\u53F7");
+    }
+    if (options.key !== void 0 && (options.byteStart !== void 0 || options.byteEnd !== void 0)) {
+      throw new Error("\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528 --key \u548C --byte \u9009\u9879");
+    }
+    if (options.key !== void 0 && (options.lineStart !== void 0 || options.lineEnd !== void 0)) {
+      throw new Error("\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528 --key \u548C --line \u9009\u9879");
+    }
+  }
+  /**
+   * 生成输出路径
+   */
+  generateOutputPath(inputPath) {
+    return normalizeURPFPath(inputPath);
+  }
+  /**
+   * 扫描文件
+   */
+  async scanFiles(rootPath, options) {
+    const stats = await fs4.stat(rootPath);
+    if (stats.isFile()) {
+      const basePath = path3.dirname(rootPath);
+      const metadata = await this.collectFileMetadata(rootPath, basePath);
+      return {
+        rootPath: basePath,
+        // 设置正确的 rootPath
+        files: [metadata],
+        directories: [],
+        skippedFiles: [],
+        startTime: Date.now(),
+        endTime: Date.now(),
+        duration: 0
+      };
+    }
+    let ignoreRules = [];
+    if (options.ignoreFile) {
+      const parser = new IgnoreRuleParser();
+      const content = await fs4.readFile(options.ignoreFile, "utf-8");
+      ignoreRules = parser.parseFile(content);
+    } else {
+      const defaultIgnoreFiles = [".gitignore", ".iflowignore"];
+      for (const ignoreFile of defaultIgnoreFiles) {
+        const ignorePath = path3.join(rootPath, ignoreFile);
+        try {
+          await fs4.access(ignorePath);
+          const parser = new IgnoreRuleParser();
+          const content = await fs4.readFile(ignorePath, "utf-8");
+          ignoreRules = [...ignoreRules, ...parser.parseFile(content)];
+          break;
+        } catch {
+        }
+      }
+    }
+    const effectiveMaxDepth = options.noRecurse ? 1 : options.maxDepth;
+    return await FileScanner.scanDirectory(rootPath, {
+      ignoreRules,
+      followSymlinks: options.followSymlinks || false,
+      maxDepth: effectiveMaxDepth
+      // undefined 或 1
+    });
+  }
+  /**
+   * 收集文件元数据
+   */
+  async collectFileMetadata(filePath, rootPath) {
+    const stats = await fs4.stat(filePath);
+    const relativePath = path3.relative(rootPath, filePath);
+    return {
+      path: relativePath,
+      name: path3.basename(filePath),
+      isDirectory: false,
+      isSymlink: false,
       size: stats.size,
-      permissions: stats.mode,
-      mtime: stats.mtime,
+      permissions: stats.mode.toString(8).padStart(3, "0"),
+      mtime: stats.mtime.getTime(),
+      ctime: stats.ctime.getTime(),
       encoding: "utf-8",
-      newlineType: "lf"
+      newlineType: "lf",
+      isBinary: false
     };
   }
   /**
@@ -1571,22 +2956,28 @@ var PackCommand = class {
   async generateURPFDocument(scanResult, rootPath, options) {
     const serializer = new ResourceSerializer();
     const files = scanResult.files.map((file) => {
-      const isAbsolutePath = path2.isAbsolute(file.path);
-      const filePath = isAbsolutePath ? file.path : path2.join(rootPath, file.path);
-      const relativePath = isAbsolutePath ? path2.relative(rootPath, file.path) : file.path;
+      const relativePath = file.path;
+      const basePath = scanResult.rootPath || rootPath;
+      const filePath = path3.join(basePath, relativePath);
+      const udrsRef = `file://${relativePath}`;
       return {
         filePath,
         metadata: file,
-        udrsReference: `file://${relativePath}`
+        udrsReference: udrsRef
       };
     });
     const resources = await serializer.serializeFiles(files);
-    const processedResources = await this.applySliceToResources(resources, options);
-    const properties = this.buildProperties(options);
+    let processedResources = resources;
+    if (options.key !== void 0) {
+      processedResources = await this.handleKeyExtraction(resources, files, options);
+    } else {
+      processedResources = await this.applySliceToResources(resources, options);
+    }
+    const properties2 = this.buildProperties(options);
     return {
       boundaryToken: "",
       // 将由生成器自动生成
-      properties,
+      properties: properties2,
       resources: processedResources
     };
   }
@@ -1599,7 +2990,6 @@ var PackCommand = class {
     }
     if (options.byteStart !== void 0) {
       return resources.map((resource) => {
-        const { start, end } = options;
         const byteRange = { start: options.byteStart, end: options.byteEnd };
         let content;
         if (Buffer.isBuffer(resource.content)) {
@@ -1636,22 +3026,150 @@ var PackCommand = class {
     }
     return resources;
   }
+  /**
+    * 处理 Key 提取逻辑
+  */
+  async handleKeyExtraction(resources, files, options) {
+    if (!options.key) {
+      return resources;
+    }
+    if (options.validate) {
+      return this.handleKeyValidation(resources, files, options);
+    }
+    const isBatch = Array.isArray(options.key) || typeof options.key === "string" && options.key.includes(",");
+    const processedResources = [];
+    const formatter = options.format ? new OutputFormatter() : null;
+    if (isBatch) {
+      const batchExtractor = new BatchKeyExtractor({
+        outputFormat: "array",
+        enableWildcard: true
+      });
+      for (let i = 0; i < resources.length; i++) {
+        const resource = resources[i];
+        const file = files[i];
+        const absolutePath = file.filePath;
+        try {
+          const result = await batchExtractor.extractFromFile(absolutePath, options.key);
+          const extractedData = result.results.map((r) => r.value);
+          let extractedContent;
+          if (formatter && options.format) {
+            extractedContent = formatter.format(extractedData, { format: options.format });
+          } else {
+            extractedContent = batchExtractor.formatOutput(result);
+          }
+          processedResources.push({
+            ...resource,
+            content: extractedContent
+          });
+          if (options.verbose) {
+            batchExtractor.printSummary(result);
+            console.log(`  \u2713 \u4ECE ${absolutePath} \u6279\u91CF\u63D0\u53D6 ${result.successCount} \u4E2A key`);
+          }
+          if (result.errors.length > 0) {
+            throw new Error(`\u6279\u91CF\u63D0\u53D6\u5931\u8D25: ${result.errors[0].error}`);
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(`\u65E0\u6CD5\u4ECE\u6587\u4EF6 ${absolutePath} \u6279\u91CF\u63D0\u53D6 key: ${errorMessage}`);
+        }
+      }
+    } else {
+      const keyExtractor = new KeyExtractor({
+        onError: (error) => {
+          throw error;
+        }
+      });
+      for (let i = 0; i < resources.length; i++) {
+        const resource = resources[i];
+        const file = files[i];
+        const absolutePath = file.filePath;
+        try {
+          const result = await keyExtractor.extractFromFile(absolutePath, options.key);
+          const extractedValue = result.value;
+          let extractedContent;
+          if (formatter && options.format) {
+            extractedContent = formatter.format(extractedValue, { format: options.format });
+          } else if (typeof extractedValue === "object" && extractedValue !== null) {
+            extractedContent = JSON.stringify(extractedValue, null, 2);
+          } else if (typeof extractedValue === "string") {
+            extractedContent = extractedValue;
+          } else if (extractedValue === null) {
+            extractedContent = "null";
+          } else if (extractedValue === void 0) {
+            extractedContent = "undefined";
+          } else {
+            extractedContent = String(extractedValue);
+          }
+          processedResources.push({
+            ...resource,
+            content: extractedContent
+          });
+          if (options.verbose) {
+            console.log(`  \u2713 \u4ECE ${absolutePath} \u63D0\u53D6 key "${options.key}": ${result.type} \u7C7B\u578B`);
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(`\u65E0\u6CD5\u4ECE\u6587\u4EF6 ${absolutePath} \u63D0\u53D6 key "${options.key}": ${errorMessage}`);
+        }
+      }
+    }
+    return processedResources;
+  }
+  /**
+    * 处理 Key 验证逻辑
+  */
+  async handleKeyValidation(resources, files, options) {
+    const validator = new KeyValidator();
+    for (let i = 0; i < resources.length; i++) {
+      const file = files[i];
+      const absolutePath = file.filePath;
+      try {
+        const fileContent = await fs4.readFile(absolutePath, "utf-8");
+        const data = JSON.parse(fileContent);
+        const keyPaths = Array.isArray(options.key) ? options.key : [options.key];
+        const isBatch = keyPaths.length > 1 || typeof options.key === "string" && options.key.includes(",");
+        let result;
+        if (isBatch) {
+          const batchResult = validator.validateBatch(data, keyPaths);
+          console.log(validator.formatBatchResult(batchResult));
+          result = { allExists: batchResult.allExists };
+        } else {
+          const singleResult = validator.validate(data, options.key);
+          console.log(validator.formatResult(singleResult));
+          result = { allExists: singleResult.exists };
+        }
+        if (!result.allExists) {
+          process.exit(1);
+        }
+        return [];
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C \u9A8C\u8BC1\u5931\u8D25: ${errorMessage}`);
+        process.exit(1);
+      }
+    }
+    return [];
+  }
   /**
    * 构建属性列表（包括环境变量）
    */
   buildProperties(options) {
-    const properties = [];
+    const properties2 = [];
+    properties2.push({
+      name: "version",
+      value: "1.0"
+    });
     if (options.envVars && Object.keys(options.envVars).length > 0) {
       for (const [name, value] of Object.entries(options.envVars)) {
         const envValue = value !== void 0 ? value : process.env[name] || "";
-        properties.push({
+        properties2.push({
           name,
           value: envValue,
           isExtended: true
         });
       }
     }
-    return properties.length > 0 ? properties : void 0;
+    return properties2;
   }
   /**
   * 保存 URPF 文件
@@ -1659,10 +3177,10 @@ var PackCommand = class {
   async saveURPFDocument(document, outputPath, options) {
     const generator = new URPFGenerator();
     const result = await generator.generate(document);
-    const outputDir = path2.dirname(outputPath);
-    await fs3.mkdir(outputDir, { recursive: true });
+    const outputDir = path3.dirname(outputPath);
+    await fs4.mkdir(outputDir, { recursive: true });
     try {
-      await fs3.access(outputPath);
+      await fs4.access(outputPath);
       if (!options.force) {
         throw new Error(`\u8F93\u51FA\u6587\u4EF6\u5DF2\u5B58\u5728: ${outputPath}\u3002\u8BF7\u4F7F\u7528 --force \u9009\u9879\u5F3A\u5236\u8986\u76D6\uFF0C\u6216\u6307\u5B9A\u4E0D\u540C\u7684\u8F93\u51FA\u8DEF\u5F84\u3002`);
       }
@@ -1671,7 +3189,7 @@ var PackCommand = class {
         throw error;
       }
     }
-    await fs3.writeFile(outputPath, result.content, "utf-8");
+    await fs4.writeFile(outputPath, result.content, "utf-8");
     return result;
   }
   /**
@@ -1690,7 +3208,7 @@ var PackCommand = class {
   /**
    * 处理输出选项（stdout 和 clipboard）
    */
-  async handleOutputOptions(content, outputPath, options) {
+  async handleOutputOptions(content, _outputPath, options) {
     if (options.stdout) {
       console.log(content);
     }
@@ -1708,9 +3226,9 @@ var PackCommand = class {
   }
 };
 
-// src/commands/unpack.ts
-import path3 from "path";
-import fs4 from "fs/promises";
+// src/commands/unpack.ts
+import path4 from "path";
+import fs5 from "fs/promises";
 
 // src/core/parser/types.ts
 var URPFParseError = class extends Error {
@@ -1766,12 +3284,11 @@ var BoundaryParser = class _BoundaryParser {
     return _BoundaryParser.BOUNDARY_REGEX.test(line);
   }
   /**
-   * 生成边界行
    * @param token 边界令牌
    * @param type 边界类型
    * @returns 边界行字符串
    */
-  static generateBoundaryLine(token, type) {
+  static generateBoundaryLine(token, _type) {
     return `${_BoundaryParser.BOUNDARY_PREFIX}${token}${_BoundaryParser.BOUNDARY_SUFFIX}`;
   }
   /**
@@ -1873,11 +3390,11 @@ var BoundaryParser = class _BoundaryParser {
 var PropertyParser = class _PropertyParser {
   static {
     /** 简单变量名正则表达式（$name 或 $env:name） */
-    this.SIMPLE_NAME_REGEX = /^\$(?:([a-zA-Z0-9_]+)|(env:)([a-zA-Z0-9_]+))$/;
+    this.SIMPLE_NAME_REGEX = /^\$(?:([a-zA-Z0-9_-]+)|(env:)([a-zA-Z0-9_-]+))$/;
   }
   static {
     /** 带空格变量名正则表达式（${full name} 或 ${env:full name}） */
-    this.EXTENDED_NAME_REGEX = /^\$\{(?:([a-zA-Z0-9_ ]+)|(env:)([a-zA-Z0-9_ ]+))\}$/;
+    this.EXTENDED_NAME_REGEX = /^\$\{(?:([a-zA-Z0-9_ -]+)|(env:)([a-zA-Z0-9_ -]+))\}$/;
   }
   static {
     /** 属性行正则表达式 */
@@ -1943,7 +3460,7 @@ var PropertyParser = class _PropertyParser {
    */
   static parsePropertySection(content, startLineNo = 1) {
     const lines = content.split("\n");
-    const properties = [];
+    const properties2 = [];
     const nameSet = /* @__PURE__ */ new Set();
     lines.forEach((line, index) => {
       const lineNo = startLineNo + index;
@@ -1959,9 +3476,9 @@ var PropertyParser = class _PropertyParser {
         );
       }
       nameSet.add(property.name);
-      properties.push(property);
+      properties2.push(property);
     });
-    return { properties };
+    return { properties: properties2 };
   }
   /**
    * 检查内容是否为属性部分
@@ -2212,9 +3729,9 @@ var VariableReplacer = class _VariableReplacer {
    * @param properties 属性列表
    * @returns 变量上下文
    */
-  static createContext(properties) {
+  static createContext(properties2) {
     const map = /* @__PURE__ */ new Map();
-    properties.forEach((p) => map.set(p.name, p.value));
+    properties2.forEach((p) => map.set(p.name, p.value));
     return {
       get(name) {
         return map.get(name);
@@ -2394,8 +3911,8 @@ var URPFParser = class _URPFParser {
    * @throws {URPFParseError} 如果解析失败
    */
   static async parseFile(filePath, options = {}) {
-    const fs14 = await import("fs/promises");
-    const content = await fs14.readFile(filePath, "utf-8");
+    const fs15 = await import("fs/promises");
+    const content = await fs15.readFile(filePath, "utf-8");
     return _URPFParser.parse(content, options);
   }
   /**
@@ -2463,7 +3980,7 @@ function matchesAnyPattern(filePath, patterns) {
     if (filePath.startsWith(pattern + "/")) {
       return true;
     }
-    const dirMatch = regex.test(path3.dirname(filePath));
+    const dirMatch = regex.test(path4.dirname(filePath));
     if (dirMatch) {
       return true;
     }
@@ -2508,14 +4025,14 @@ var UnpackCommand = class {
   async execute(urpfFilePath, options = {}) {
     const startTime = Date.now();
     try {
-      const resolvedPath = path3.resolve(urpfFilePath);
+      const resolvedPath = path4.resolve(urpfFilePath);
       await this.validateURPFFile(resolvedPath);
       const actualPath = await findURPFFile(resolvedPath);
       if (actualPath === null) {
         throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${resolvedPath}`);
       }
-      const outputDir = options.output ? path3.resolve(options.output) : process.cwd();
-      await fs4.mkdir(outputDir, { recursive: true });
+      const outputDir = options.output ? path4.resolve(options.output) : process.cwd();
+      await fs5.mkdir(outputDir, { recursive: true });
       const parseResult = await URPFParser.parseFile(actualPath);
       const envVars = parseResult.document.propertySection ? extractEnvironmentVariables(parseResult.document.propertySection) : [];
       const vars = parseResult.document.propertySection ? extractVariables(parseResult.document.propertySection) : [];
@@ -2574,7 +4091,7 @@ var UnpackCommand = class {
       }
       return {
         success: false,
-        outputDir: options.output ? path3.resolve(options.output) : process.cwd(),
+        outputDir: options.output ? path4.resolve(options.output) : process.cwd(),
         files: [],
         createdCount: 0,
         overwrittenCount: 0,
@@ -2674,7 +4191,7 @@ var UnpackCommand = class {
       }
       throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
     }
-    const stats = await fs4.stat(actualPath);
+    const stats = await fs5.stat(actualPath);
     if (!stats.isFile()) {
       throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${actualPath}`);
     }
@@ -2685,15 +4202,16 @@ var UnpackCommand = class {
   async extractResource(resource, outputDir, options, variableContext) {
     try {
       const filePath = this.extractFilePath(resource.header.udrsReference.uri);
-      const fullPath = path3.join(outputDir, filePath);
-      const parentDir = path3.dirname(fullPath);
-      await fs4.mkdir(parentDir, { recursive: true });
+      const actualFilePath = filePath || `resource-${Date.now()}.txt`;
+      const fullPath = path4.join(outputDir, actualFilePath);
+      const parentDir = path4.dirname(fullPath);
+      await fs5.mkdir(parentDir, { recursive: true });
       const fileExists = await this.fileExists(fullPath);
       if (fileExists) {
         if (options.force) {
           await this.writeFile(resource, fullPath, options, variableContext);
           return {
-            path: filePath,
+            path: actualFilePath,
             success: true,
             action: "overwritten"
           };
@@ -2703,27 +4221,27 @@ var UnpackCommand = class {
           if (sourceMtime > targetMtime) {
             await this.writeFile(resource, fullPath, options, variableContext);
             return {
-              path: filePath,
+              path: actualFilePath,
               success: true,
               action: "overwritten"
             };
           } else {
             if (options.verbose) {
-              console.log(`\u8DF3\u8FC7\uFF08\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\uFF09: ${filePath}`);
+              console.log(`\u8DF3\u8FC7\uFF08\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\uFF09: ${actualFilePath}`);
             }
             return {
-              path: filePath,
+              path: actualFilePath,
               success: true,
               action: "skipped"
             };
           }
         } else {
-          throw new Error(`\u6587\u4EF6\u5DF2\u5B58\u5728: ${filePath}\u3002\u8BF7\u4F7F\u7528 --force \u9009\u9879\u5F3A\u5236\u8986\u76D6\uFF0C\u6216\u4F7F\u7528 --force-when-newer \u9009\u9879\u4EC5\u8986\u76D6\u66F4\u65B0\u7684\u6587\u4EF6\u3002`);
+          throw new Error(`\u6587\u4EF6\u5DF2\u5B58\u5728: ${actualFilePath}\u3002\u8BF7\u4F7F\u7528 --force \u9009\u9879\u5F3A\u5236\u8986\u76D6\uFF0C\u6216\u4F7F\u7528 --force-when-newer \u9009\u9879\u4EC5\u8986\u76D6\u66F4\u65B0\u7684\u6587\u4EF6\u3002`);
         }
       } else {
         await this.writeFile(resource, fullPath, options, variableContext);
         return {
-          path: filePath,
+          path: actualFilePath,
           success: true,
           action: "created"
         };
@@ -2731,7 +4249,7 @@ var UnpackCommand = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       return {
-        path: this.extractFilePath(resource.header.udrsReference.uri),
+        path: this.extractFilePath(resource.header.udrsReference.uri) || `resource-${Date.now()}.txt`,
         success: false,
         action: "error",
         error: errorMessage
@@ -2747,7 +4265,6 @@ var UnpackCommand = class {
       filePath = filePath.substring(1);
     }
     if (/^[A-Za-z]:/.test(filePath)) {
-      filePath = filePath;
     }
     return filePath;
   }
@@ -2756,7 +4273,7 @@ var UnpackCommand = class {
    */
   async fileExists(filePath) {
     try {
-      await fs4.access(filePath);
+      await fs5.access(filePath);
       return true;
     } catch {
       return false;
@@ -2766,7 +4283,7 @@ var UnpackCommand = class {
    * 获取文件修改时间
    */
   async getFileMtime(filePath) {
-    const stats = await fs4.stat(filePath);
+    const stats = await fs5.stat(filePath);
     return stats.mtime;
   }
   /**
@@ -2774,7 +4291,7 @@ var UnpackCommand = class {
    * 注意：URPF 规范中不直接存储 mtime，这里我们使用一个合理的时间戳
    * 在实际应用中，可能需要从 URPF 文件的属性部分读取
    */
-  extractMtime(resource) {
+  extractMtime(_resource) {
     return new Date(Date.now() - 36e5);
   }
   /**
@@ -2795,7 +4312,21 @@ var UnpackCommand = class {
       content = resource.content;
     } else {
       content = resource.content;
-      if (options.applyVariables && variableContext) {
+      if (options.key) {
+        try {
+          const extractedContent = await this.applyKeyExtraction(
+            content,
+            filePath,
+            options.key,
+            options.verbose ?? false
+          );
+          content = extractedContent;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(`\u65E0\u6CD5\u4ECE\u6587\u4EF6 ${filePath} \u63D0\u53D6 key "${options.key}": ${errorMessage}`);
+        }
+      }
+      if (options.applyVariables === true && variableContext) {
         try {
           const originalContent = content;
           content = VariableReplacer.replace(originalContent, variableContext);
@@ -2813,24 +4344,176 @@ var UnpackCommand = class {
       }
     }
     if (Buffer.isBuffer(content)) {
-      await fs4.writeFile(filePath, content);
+      await fs5.writeFile(filePath, content);
     } else {
-      await fs4.writeFile(filePath, content, {
+      await fs5.writeFile(filePath, content, {
         encoding: resource.header.encoding
       });
     }
     if (resource.header.permissions) {
       const permissions = parseInt(resource.header.permissions, 8);
-      await fs4.chmod(filePath, permissions);
+      await fs5.chmod(filePath, permissions);
     }
     if (options.preserveMtime) {
       const mtime = this.extractMtime(resource);
-      await fs4.utimes(filePath, mtime, mtime);
+      await fs5.utimes(filePath, mtime, mtime);
     }
     if (options.verbose) {
       console.log(`\u5DF2${await this.fileExists(filePath) ? "\u8986\u76D6" : "\u521B\u5EFA"}: ${filePath}`);
     }
   }
+  /**
+   * 应用 key 提取到文件内容
+   * @param content - 文件内容
+   * @param filePath - 文件路径
+   * @param keyPath - key 路径（可以是字符串或字符串数组，支持通配符和逗号分隔）
+   * @param verbose - 是否显示详细日志
+   * @param format - 输出格式（可选）
+   * @param validate - 是否仅验证（可选）
+   * @returns 提取后的内容
+   */
+  async applyKeyExtraction(content, filePath, keyPath, verbose, format, validate) {
+    let fileFormat = this.detectFileFormat(filePath);
+    if (!fileFormat) {
+      fileFormat = this.detectFormatFromContent(content);
+    }
+    if (!fileFormat) {
+      console.warn(`\u26A0\uFE0F  \u8B66\u544A: \u6587\u4EF6 ${filePath} \u4E0D\u662F\u652F\u6301\u7684\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\uFF0C\u8DF3\u8FC7 key \u63D0\u53D6`);
+      return content;
+    }
+    const tempDir = path4.join(process.cwd(), ".urpf-temp");
+    await fs5.mkdir(tempDir, { recursive: true });
+    const tempFilePath = path4.join(tempDir, `temp.${fileFormat}`);
+    try {
+      await fs5.writeFile(tempFilePath, content, "utf-8");
+      if (validate) {
+        return this.applyKeyValidation(tempFilePath, filePath, keyPath, verbose);
+      }
+      const formatter = format ? new OutputFormatter() : null;
+      const isBatch = Array.isArray(keyPath) || typeof keyPath === "string" && keyPath.includes(",");
+      let extractedContent;
+      if (isBatch) {
+        const batchExtractor = new BatchKeyExtractor({
+          outputFormat: "array",
+          enableWildcard: true
+        });
+        const result = await batchExtractor.extractFromFile(tempFilePath, keyPath);
+        const extractedData = result.results.map((r) => r.value);
+        if (formatter && format) {
+          extractedContent = formatter.format(extractedData, { format });
+        } else {
+          extractedContent = batchExtractor.formatOutput(result);
+        }
+        if (verbose) {
+          batchExtractor.printSummary(result);
+          console.log(`  \u2713 \u4ECE ${filePath} \u6279\u91CF\u63D0\u53D6 ${result.successCount} \u4E2A key`);
+        }
+        if (result.errors.length > 0) {
+          throw new Error(`\u6279\u91CF\u63D0\u53D6\u5931\u8D25: ${result.errors[0].error}`);
+        }
+      } else {
+        const keyExtractor = new KeyExtractor({
+          onError: (error) => {
+            throw error;
+          }
+        });
+        const result = await keyExtractor.extractFromFile(tempFilePath, keyPath);
+        const extractedValue = result.value;
+        if (formatter && format) {
+          extractedContent = formatter.format(extractedValue, { format });
+        } else if (typeof extractedValue === "object" && extractedValue !== null) {
+          extractedContent = JSON.stringify(extractedValue, null, 2);
+        } else if (typeof extractedValue === "string") {
+          extractedContent = extractedValue;
+        } else if (extractedValue === null) {
+          extractedContent = "null";
+        } else if (extractedValue === void 0) {
+          extractedContent = "undefined";
+        } else {
+          extractedContent = String(extractedValue);
+        }
+        if (verbose) {
+          console.log(`  \u2713 \u4ECE ${filePath} \u63D0\u53D6 key "${keyPath}": ${result.type} \u7C7B\u578B`);
+        }
+      }
+      return extractedContent;
+    } finally {
+      try {
+        await fs5.unlink(tempFilePath);
+      } catch {
+      }
+    }
+  }
+  /**
+    * 应用 Key 验证逻辑
+  */
+  async applyKeyValidation(tempFilePath, _filePath, keyPath, _verbose) {
+    const validator = new KeyValidator();
+    try {
+      const fileContent = await fs5.readFile(tempFilePath, "utf-8");
+      const data = JSON.parse(fileContent);
+      const keyPaths = Array.isArray(keyPath) ? keyPath : [keyPath];
+      const isBatch = keyPaths.length > 1 || typeof keyPath === "string" && keyPath.includes(",");
+      if (isBatch) {
+        const batchResult = validator.validateBatch(data, keyPaths);
+        console.log(validator.formatBatchResult(batchResult));
+      } else {
+        const singleResult = validator.validate(data, keyPath);
+        console.log(validator.formatResult(singleResult));
+      }
+      return fileContent;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C \u9A8C\u8BC1\u5931\u8D25: ${errorMessage}`);
+      throw error;
+    }
+  }
+  /**
+   * 检测文件格式
+   * @param filePath - 文件路径
+   * @returns 文件格式，如果不支持则返回 null
+   */
+  detectFileFormat(filePath) {
+    const ext = path4.extname(filePath).toLowerCase();
+    const supportedFormats = [
+      ".json",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".properties",
+      ".ini"
+    ];
+    if (supportedFormats.includes(ext)) {
+      return ext.substring(1);
+    }
+    return null;
+  }
+  /**
+   * 从内容检测文件格式
+   * @param content - 文件内容
+   * @returns 文件格式，如果不支持则返回 null
+   */
+  detectFormatFromContent(content) {
+    const trimmedContent = content.trim();
+    if (trimmedContent.startsWith("{") || trimmedContent.startsWith("[")) {
+      try {
+        JSON.parse(trimmedContent);
+        return "json";
+      } catch {
+      }
+    }
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*\s*:/.test(trimmedContent)) {
+      return "yaml";
+    }
+    if (trimmedContent.startsWith("<?xml") || trimmedContent.startsWith("<")) {
+      return "xml";
+    }
+    if (/^[a-zA-Z0-9_-]+\s*=\s*/.test(trimmedContent)) {
+      return "properties";
+    }
+    return null;
+  }
   /**
    * 输出详细日志
    */
@@ -2859,8 +4542,8 @@ var UnpackCommand = class {
 };
 
 // src/commands/pack-add.ts
-import path4 from "path";
-import fs5 from "fs/promises";
+import path5 from "path";
+import fs6 from "fs/promises";
 var PackAddCommand = class {
   /**
    * 执行 pack add 命令（支持多文件/目录添加）
@@ -2871,7 +4554,7 @@ var PackAddCommand = class {
   async execute(urpfFilePath, targetPaths, options = {}) {
     const startTime = Date.now();
     try {
-      const resolvedUrpfPath = path4.resolve(urpfFilePath);
+      const resolvedUrpfPath = path5.resolve(urpfFilePath);
       await this.validateUrpfFile(resolvedUrpfPath);
       const actualUrpfPath = await findURPFFile(resolvedUrpfPath);
       if (actualUrpfPath === null) {
@@ -2881,7 +4564,7 @@ var PackAddCommand = class {
       if (paths.length === 0) {
         throw new Error("\u81F3\u5C11\u9700\u8981\u6307\u5B9A\u4E00\u4E2A\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84");
       }
-      const urpfContent = await fs5.readFile(actualUrpfPath, "utf-8");
+      const urpfContent = await fs6.readFile(actualUrpfPath, "utf-8");
       const parseResult = URPFParser.parse(urpfContent, { strict: false });
       const document = parseResult.document;
       const variableContext = document.propertySection ? VariableReplacer.createContext(document.propertySection.properties) : void 0;
@@ -2889,14 +4572,14 @@ var PackAddCommand = class {
       const allSkippedFiles = [];
       const allDirectories = [];
       for (const targetPath of paths) {
-        const resolvedTargetPath = path4.resolve(targetPath);
+        const resolvedTargetPath = path5.resolve(targetPath);
         await this.validatePath(resolvedTargetPath);
         const scanResult = await this.scanFiles(resolvedTargetPath, options, variableContext);
         const filesWithBasePath = scanResult.files.map((file) => {
-          const isAbsolutePath = path4.isAbsolute(file.path);
+          const isAbsolutePath = path5.isAbsolute(file.path);
           return {
             ...file,
-            basePath: isAbsolutePath ? path4.dirname(file.path) : resolvedTargetPath,
+            basePath: isAbsolutePath ? path5.dirname(file.path) : resolvedTargetPath,
             isAbsolutePath
           };
         });
@@ -2919,44 +4602,33 @@ var PackAddCommand = class {
       }
       const serializer = new ResourceSerializer();
       const filesToAdd = allFiles.map((file) => {
+        const fileWithBase = file;
         let absoluteFilePath;
-        if (file.isAbsolutePath) {
-          absoluteFilePath = file.path;
+        if (fileWithBase.isAbsolutePath) {
+          absoluteFilePath = fileWithBase.path;
         } else {
-          absoluteFilePath = path4.join(file.basePath, file.path);
+          absoluteFilePath = path5.join(fileWithBase.basePath, fileWithBase.path);
         }
-        const relativePath = path4.relative(process.cwd(), absoluteFilePath);
+        const relativePath = path5.relative(process.cwd(), absoluteFilePath);
         return {
           filePath: absoluteFilePath,
-          metadata: file,
+          metadata: fileWithBase,
           udrsReference: `file://${relativePath}`
         };
       });
       const newResources = await serializer.serializeFiles(filesToAdd);
-      const generatorDoc = {
+      const updatedDocument = {
         boundaryToken: document.boundaryToken,
-        properties: document.propertySection?.properties.map((p) => ({
-          name: p.name,
-          value: p.value,
-          isExtended: p.isExtended
-        })),
-        resources: document.resourceSections.map((rs) => ({
-          header: {
-            udrsReference: rs.header.udrsReference.protocol + "://" + rs.header.udrsReference.uri + (rs.header.udrsReference.fragment ? "#" + rs.header.udrsReference.fragment : ""),
-            encoding: rs.header.encoding,
-            permissions: rs.header.permissions,
-            newlineType: rs.header.newlineType
-          },
-          content: rs.content
-        }))
+        propertySection: document.propertySection,
+        resourceSections: [...document.resourceSections]
       };
-      generatorDoc.resources = [...generatorDoc.resources, ...newResources];
+      updatedDocument.resourceSections = [...updatedDocument.resourceSections, ...newResources];
       const generator = new URPFGenerator({
-        boundaryToken: generatorDoc.boundaryToken,
+        boundaryToken: document.boundaryToken,
         includeBoundaries: true
       });
-      const result = await generator.generate(generatorDoc);
-      await fs5.writeFile(actualUrpfPath, result.content, "utf-8");
+      const result = await generator.generate(updatedDocument);
+      await fs6.writeFile(actualUrpfPath, result.content, "utf-8");
       const duration = Date.now() - startTime;
       const totalBytes = allFiles.reduce((sum, f) => sum + f.size, 0);
       if (options.verbose) {
@@ -2982,7 +4654,7 @@ var PackAddCommand = class {
       }
       return {
         success: false,
-        urpfFilePath: path4.resolve(urpfFilePath),
+        urpfFilePath: path5.resolve(urpfFilePath),
         addedCount: 0,
         skippedCount: 0,
         totalBytes: 0,
@@ -2996,7 +4668,7 @@ var PackAddCommand = class {
    */
   async validatePath(filePath) {
     try {
-      const stats = await fs5.stat(filePath);
+      const stats = await fs6.stat(filePath);
       if (!stats.isFile() && !stats.isDirectory()) {
         throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6\u6216\u76EE\u5F55: ${filePath}`);
       }
@@ -3018,7 +4690,7 @@ var PackAddCommand = class {
       }
       throw new Error(`\u65E0\u6CD5\u8BBF\u95EE URPF \u6587\u4EF6: ${filePath}`);
     }
-    const stats = await fs5.stat(actualPath);
+    const stats = await fs6.stat(actualPath);
     if (!stats.isFile()) {
       throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${actualPath}`);
     }
@@ -3027,33 +4699,32 @@ var PackAddCommand = class {
    * 扫描文件
    */
   async scanFiles(rootPath, options, _variableContext) {
-    const stats = await fs5.stat(rootPath);
+    const stats = await fs6.stat(rootPath);
     if (stats.isFile()) {
       const metadata = await this.collectFileMetadata(rootPath);
       return {
+        rootPath: path5.dirname(rootPath),
         files: [metadata],
         directories: [],
         skippedFiles: [],
-        statistics: {
-          totalFiles: 1,
-          totalDirectories: 0,
-          skippedFiles: 0
-        }
+        startTime: Date.now(),
+        endTime: Date.now(),
+        duration: 0
       };
     }
     let ignoreRules = [];
     if (options.ignoreFile) {
       const parser = new IgnoreRuleParser();
-      const content = await fs5.readFile(options.ignoreFile, "utf-8");
+      const content = await fs6.readFile(options.ignoreFile, "utf-8");
       ignoreRules = parser.parseFile(content);
     } else {
       const defaultIgnoreFiles = [".gitignore", ".iflowignore"];
       for (const ignoreFile of defaultIgnoreFiles) {
-        const ignorePath = path4.join(rootPath, ignoreFile);
+        const ignorePath = path5.join(rootPath, ignoreFile);
         try {
-          await fs5.access(ignorePath);
+          await fs6.access(ignorePath);
           const parser = new IgnoreRuleParser();
-          const content = await fs5.readFile(ignorePath, "utf-8");
+          const content = await fs6.readFile(ignorePath, "utf-8");
           ignoreRules = [...ignoreRules, ...parser.parseFile(content)];
           break;
         } catch {
@@ -3071,22 +4742,26 @@ var PackAddCommand = class {
    * 收集文件元数据
    */
   async collectFileMetadata(filePath) {
-    const stats = await fs5.stat(filePath);
+    const stats = await fs6.stat(filePath);
     return {
       path: filePath,
-      name: path4.basename(filePath),
+      name: path5.basename(filePath),
+      isDirectory: false,
+      isSymlink: false,
       size: stats.size,
-      permissions: stats.mode,
-      mtime: stats.mtime,
+      permissions: stats.mode.toString(8).padStart(3, "0"),
+      mtime: stats.mtime.getTime(),
+      ctime: stats.ctime.getTime(),
       encoding: "utf-8",
-      newlineType: "lf"
+      newlineType: "lf",
+      isBinary: false
     };
   }
 };
 
 // src/commands/pack-remove.ts
-import path5 from "path";
-import fs6 from "fs/promises";
+import path6 from "path";
+import fs7 from "fs/promises";
 var PackRemoveCommand = class {
   /**
    * 执行 pack remove 命令（支持多文件移除）
@@ -3097,7 +4772,7 @@ var PackRemoveCommand = class {
   async execute(urpfFilePath, filenamePatterns, options = {}) {
     const startTime = Date.now();
     try {
-      const resolvedUrpfPath = path5.resolve(urpfFilePath);
+      const resolvedUrpfPath = path6.resolve(urpfFilePath);
       await this.validateUrpfFile(resolvedUrpfPath);
       const actualUrpfPath = await findURPFFile(resolvedUrpfPath);
       if (actualUrpfPath === null) {
@@ -3107,26 +4782,14 @@ var PackRemoveCommand = class {
       if (patterns.length === 0) {
         throw new Error("\u81F3\u5C11\u9700\u8981\u6307\u5B9A\u4E00\u4E2A\u6587\u4EF6\u540D\u6216\u6A21\u5F0F");
       }
-      const urpfContent = await fs6.readFile(actualUrpfPath, "utf-8");
+      const urpfContent = await fs7.readFile(actualUrpfPath, "utf-8");
       const parseResult = URPFParser.parse(urpfContent, { strict: false });
       const document = parseResult.document;
       const variableContext = document.propertySection ? VariableReplacer.createContext(document.propertySection.properties) : void 0;
-      const generatorDoc = {
+      const updatedDocument = {
         boundaryToken: document.boundaryToken,
-        properties: document.propertySection?.properties.map((p) => ({
-          name: p.name,
-          value: p.value,
-          isExtended: p.isExtended
-        })),
-        resources: document.resourceSections.map((rs) => ({
-          header: {
-            udrsReference: rs.header.udrsReference.protocol + "://" + rs.header.udrsReference.uri + (rs.header.udrsReference.fragment ? "#" + rs.header.udrsReference.fragment : ""),
-            encoding: rs.header.encoding,
-            permissions: rs.header.permissions,
-            newlineType: rs.header.newlineType
-          },
-          content: rs.content
-        }))
+        propertySection: document.propertySection,
+        resourceSections: [...document.resourceSections]
       };
       const removedResources = [];
       let notFoundCount = 0;
@@ -3145,7 +4808,7 @@ var PackRemoveCommand = class {
             throw error;
           }
         }
-        const { removedResources: removed, notFoundCount: notFound } = this.removeResources(generatorDoc, processedPattern);
+        const { removedResources: removed, notFoundCount: notFound } = this.removeResources(updatedDocument, processedPattern);
         removedResources.push(...removed);
         notFoundCount += notFound;
         if (options.verbose) {
@@ -3162,11 +4825,11 @@ var PackRemoveCommand = class {
         };
       }
       const generator = new URPFGenerator({
-        boundaryToken: generatorDoc.boundaryToken,
+        boundaryToken: document.boundaryToken,
         includeBoundaries: true
       });
-      const result = await generator.generate(generatorDoc);
-      await fs6.writeFile(actualUrpfPath, result.content, "utf-8");
+      const result = await generator.generate(updatedDocument);
+      await fs7.writeFile(actualUrpfPath, result.content, "utf-8");
       const duration = Date.now() - startTime;
       if (options.verbose) {
         console.log(`Successfully removed ${removedResources.length} files: ${actualUrpfPath}`);
@@ -3192,7 +4855,7 @@ var PackRemoveCommand = class {
       }
       return {
         success: false,
-        urpfFilePath: path5.resolve(urpfFilePath),
+        urpfFilePath: path6.resolve(urpfFilePath),
         removedCount: 0,
         notFoundCount: 0,
         duration,
@@ -3214,25 +4877,25 @@ var PackRemoveCommand = class {
       }
       throw new Error(`\u65E0\u6CD5\u8BBF\u95EE URPF \u6587\u4EF6: ${filePath}`);
     }
-    const stats = await fs6.stat(actualPath);
+    const stats = await fs7.stat(actualPath);
     if (!stats.isFile()) {
       throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${actualPath}`);
     }
   }
   /**
-   * 从文档中移除匹配的资源
-   */
+  * 从文档中移除匹配的资源
+  */
   removeResources(document, pattern) {
     const removedResources = [];
     let notFoundCount = 0;
     const normalizedPattern = pattern.startsWith("/") || pattern.startsWith("\\") ? pattern.slice(1) : pattern;
     const normalizedPatternWithSlash = normalizedPattern.replace(/\\/g, "/");
-    for (let i = document.resources.length - 1; i >= 0; i--) {
-      const resource = document.resources[i];
-      const udrsRefString = resource.header.udrsReference;
+    for (let i = document.resourceSections.length - 1; i >= 0; i--) {
+      const resource = document.resourceSections[i];
+      const udrsRefString = resource.header.udrsReference.protocol + "://" + resource.header.udrsReference.uri + (resource.header.udrsReference.fragment ? "#" + resource.header.udrsReference.fragment : "");
       if (this.matchResource(udrsRefString, normalizedPatternWithSlash)) {
         removedResources.push(resource);
-        document.resources.splice(i, 1);
+        document.resourceSections.splice(i, 1);
       }
     }
     if (removedResources.length === 0) {
@@ -3260,7 +4923,7 @@ var PackRemoveCommand = class {
 };
 
 // src/commands/list.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 function wildcardToRegex2(pattern) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
   const regexPattern = "^" + escaped.replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
@@ -3334,7 +4997,7 @@ var ListCommand = class {
           error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
         };
       }
-      const content = await fs7.readFile(actualFilePath, "utf-8");
+      const content = await fs8.readFile(actualFilePath, "utf-8");
       let parseResult;
       try {
         parseResult = URPFParser.parse(content, { strict: false });
@@ -3443,7 +5106,7 @@ var ListCommand = class {
 };
 
 // src/commands/info.ts
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 function formatFileSize2(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -3513,7 +5176,7 @@ var InfoCommand = class {
           error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
         };
       }
-      const content = await fs8.readFile(actualFilePath, "utf-8");
+      const content = await fs9.readFile(actualFilePath, "utf-8");
       let parseResult;
       try {
         parseResult = URPFParser.parse(content, { strict: false });
@@ -3534,21 +5197,23 @@ var InfoCommand = class {
           error: `\u89E3\u6790\u5931\u8D25: ${errorMessage}`
         };
       }
+      const versionProp = parseResult.document.propertySection?.properties?.find((p) => p.name === "version");
+      const version = versionProp ? versionProp.value : "1.0";
       const info = {
         fileCount: parseResult.document.resourceSections.length,
         totalSize: parseResult.document.resourceSections.reduce((sum, section) => sum + section.content.length, 0),
-        version: parseResult.document.propertySection?.properties.version || "1.0",
+        version,
         boundaryToken: parseResult.document.boundaryToken,
-        propertyCount: parseResult.document.propertySection?.properties ? Object.keys(parseResult.document.propertySection.properties).length : 0,
+        propertyCount: parseResult.document.propertySection?.properties?.length || 0,
         resourceCount: parseResult.document.resourceSections.length
       };
       if (options.verbose) {
         if (parseResult.document.propertySection?.properties) {
-          const properties = {};
+          const properties2 = {};
           for (const prop of parseResult.document.propertySection.properties) {
-            properties[prop.name] = prop.value;
+            properties2[prop.name] = prop.value;
           }
-          info.properties = properties;
+          info.properties = properties2;
         }
         const textFiles = parseResult.document.resourceSections.filter((s) => s.header.encoding !== "binary").length;
         const binaryFiles = parseResult.document.resourceSections.filter((s) => s.header.encoding === "binary").length;
@@ -3608,7 +5273,7 @@ var InfoCommand = class {
 };
 
 // src/commands/verify.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 var URPFVerifier = class {
   constructor() {
     this.issues = [];
@@ -3697,7 +5362,7 @@ var URPFVerifier = class {
   /**
    * 验证属性部分
    */
-  verifyProperties(content, boundaryToken) {
+  verifyProperties(content, _boundaryToken) {
     try {
       const boundaries = BoundaryParser.findBoundaries(content);
       const sections = BoundaryParser.splitByBoundaries(content, boundaries);
@@ -3716,13 +5381,12 @@ var URPFVerifier = class {
       try {
         const propertySection = PropertyParser.parsePropertySection(sections[0], boundaries[0].line + 1);
         const propertyNames = /* @__PURE__ */ new Set();
-        for (const property of propertySection.properties) {
+        for (const property of properties) {
           if (propertyNames.has(property.name)) {
             this.addIssue({
               type: "property_duplicate",
               message: `\u91CD\u590D\u7684\u5C5E\u6027\u540D: ${property.name}`,
-              severity: "error",
-              line: property.line
+              severity: "error"
             }, false);
           }
           propertyNames.add(property.name);
@@ -3782,18 +5446,6 @@ var URPFVerifier = class {
               line: boundaries[i].line + 1
             });
           }
-          const expectedSize = parseInt(resourceSection.header.udrsReference.attributes.size || "0", 10);
-          const actualSize = resourceSection.content.length;
-          if (expectedSize > 0 && actualSize !== expectedSize) {
-            this.addIssue({
-              type: "resource_size_mismatch",
-              message: `\u6587\u4EF6\u5927\u5C0F\u4E0D\u5339\u914D: ${resourceSection.header.udrsReference.uri}`,
-              severity: "warning",
-              filePath: resourceSection.header.udrsReference.uri,
-              expected: expectedSize.toString(),
-              actual: actualSize.toString()
-            }, true);
-          }
           const encoding = resourceSection.header.encoding;
           if (!encoding) {
             this.addIssue({
@@ -3824,38 +5476,8 @@ var URPFVerifier = class {
   /**
    * 尝试修复问题
    */
-  async tryFix(content, issues) {
-    let fixedContent = content;
-    for (const issue of issues) {
-      if (!issue.fixable) {
-        continue;
-      }
-      if (issue.type === "resource_size_mismatch" && issue.filePath) {
-        try {
-          const boundaries = BoundaryParser.findBoundaries(fixedContent);
-          const sections = BoundaryParser.splitByBoundaries(fixedContent, boundaries);
-          let startSectionIndex = 0;
-          if (sections.length > 0 && PropertyParser.isPropertySection(sections[0])) {
-            startSectionIndex = 1;
-          }
-          for (let i = startSectionIndex; i < sections.length; i++) {
-            try {
-              const resourceSection = ResourceParser.parseResourceSection(sections[i], boundaries[i].line + 1);
-              if (resourceSection.header.udrsReference.uri === issue.filePath) {
-                const actualSize = resourceSection.content.length;
-                const sizePattern = new RegExp(`(size=${issue.expected})`, "g");
-                fixedContent = fixedContent.replace(sizePattern, `size=${actualSize}`);
-                this.fixedCount++;
-                break;
-              }
-            } catch {
-            }
-          }
-        } catch {
-        }
-      }
-    }
-    return fixedContent;
+  async tryFix(content, _issues) {
+    return content;
   }
   /**
    * 执行验证
@@ -3967,11 +5589,11 @@ var VerifyCommand = class {
           error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
         };
       }
-      let content = await fs9.readFile(actualFilePath, "utf-8");
+      const content = await fs10.readFile(actualFilePath, "utf-8");
       const verifier = new URPFVerifier();
       const verifyResult = await verifier.verify(content, options);
       if (options.fix && verifyResult.fixedContent && verifyResult.fixedCount > 0) {
-        await fs9.writeFile(actualFilePath, verifyResult.fixedContent, "utf-8");
+        await fs10.writeFile(actualFilePath, verifyResult.fixedContent, "utf-8");
       }
       let totalFiles = 0;
       let validFiles = 0;
@@ -4031,13 +5653,13 @@ var VerifyCommand = class {
 };
 
 // src/commands/diff.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 async function extractFileInfo(filePath) {
-  const content = await fs10.readFile(filePath, "utf-8");
+  const content = await fs11.readFile(filePath, "utf-8");
   let parseResult;
   try {
     parseResult = URPFParser.parse(content, { strict: false });
-  } catch (parseError) {
+  } catch {
     return [];
   }
   if (!parseResult.document.resourceSections || parseResult.document.resourceSections.length === 0) {
@@ -4068,19 +5690,19 @@ function compareFileLists(files1, files2) {
   const removed = [];
   const modified = [];
   const unchanged = [];
-  for (const path7 of allPaths) {
-    const file1 = fileMap1.get(path7);
-    const file2 = fileMap2.get(path7);
+  for (const path8 of allPaths) {
+    const file1 = fileMap1.get(path8);
+    const file2 = fileMap2.get(path8);
     if (!file1 && file2) {
       added.push({
-        path: path7,
+        path: path8,
         changeType: "added",
         size2: file2.size,
         encoding2: file2.encoding
       });
     } else if (file1 && !file2) {
       removed.push({
-        path: path7,
+        path: path8,
         changeType: "removed",
         size1: file1.size,
         encoding1: file1.encoding
@@ -4088,7 +5710,7 @@ function compareFileLists(files1, files2) {
     } else if (file1 && file2) {
       if (file1.size !== file2.size || file1.encoding !== file2.encoding) {
         modified.push({
-          path: path7,
+          path: path8,
           changeType: "modified",
           size1: file1.size,
           size2: file2.size,
@@ -4098,7 +5720,7 @@ function compareFileLists(files1, files2) {
         });
       } else {
         unchanged.push({
-          path: path7,
+          path: path8,
           changeType: "unchanged",
           size1: file1.size,
           size2: file2.size,
@@ -4280,8 +5902,8 @@ var DiffCommand = class {
 };
 
 // src/commands/merge.ts
-import path6 from "path";
-import fs11 from "fs/promises";
+import path7 from "path";
+import fs12 from "fs/promises";
 var MergeCommand = class {
   /**
    * 执行 merge 命令
@@ -4302,10 +5924,10 @@ var MergeCommand = class {
         parsedDocuments,
         options.verbose
       );
-      const resolvedOutputPath = path6.resolve(options.output);
-      await fs11.mkdir(path6.dirname(resolvedOutputPath), { recursive: true });
-      await fs11.writeFile(resolvedOutputPath, outputContent, "utf-8");
-      const outputStats = await fs11.stat(resolvedOutputPath);
+      const resolvedOutputPath = path7.resolve(options.output);
+      await fs12.mkdir(path7.dirname(resolvedOutputPath), { recursive: true });
+      await fs12.writeFile(resolvedOutputPath, outputContent, "utf-8");
+      const outputStats = await fs12.stat(resolvedOutputPath);
       const duration = Date.now() - startTime;
       const result = {
         success: true,
@@ -4364,7 +5986,7 @@ var MergeCommand = class {
   async resolveInputFiles(inputPaths) {
     const resolvedFiles = [];
     for (const inputPath of inputPaths) {
-      const resolvedPath = path6.resolve(inputPath);
+      const resolvedPath = path7.resolve(inputPath);
       const actualPath = await findURPFFile(resolvedPath);
       if (!actualPath) {
         throw new Error(`\u627E\u4E0D\u5230 URPF \u6587\u4EF6: ${inputPath}`);
@@ -4380,7 +6002,7 @@ var MergeCommand = class {
     const documents = [];
     for (const filePath of filePaths) {
       try {
-        const content = await fs11.readFile(filePath, "utf-8");
+        const content = await fs12.readFile(filePath, "utf-8");
         const parseResult = URPFParser.parse(content);
         documents.push({
           filePath,
@@ -4412,7 +6034,7 @@ var MergeCommand = class {
       const resourceSections = document.resourceSections || [];
       if (verbose) {
         console.log(`
-\u5904\u7406\u6587\u4EF6: ${path6.basename(filePath)} (${resourceSections.length} \u4E2A\u8D44\u6E90)`);
+\u5904\u7406\u6587\u4EF6: ${path7.basename(filePath)} (${resourceSections.length} \u4E2A\u8D44\u6E90)`);
       }
       for (const section of resourceSections) {
         const udrsRef = section.header.udrsReference;
@@ -4463,9 +6085,9 @@ var MergeCommand = class {
               let counter = 1;
               let newPath;
               do {
-                const ext = path6.extname(udrsReference);
-                const baseName = path6.basename(udrsReference, ext);
-                const dirName = path6.dirname(udrsReference);
+                const ext = path7.extname(udrsReference);
+                const baseName = path7.basename(udrsReference, ext);
+                const dirName = path7.dirname(udrsReference);
                 const newBaseName = `${baseName}-${counter}`;
                 newPath = dirName === "." ? `${newBaseName}${ext}` : `${dirName}/${newBaseName}${ext}`;
                 counter++;
@@ -4496,11 +6118,14 @@ var MergeCommand = class {
    */
   async generateMergedURPF(mergedResources, sourceDocuments, verbose) {
     const propertySection = sourceDocuments[0]?.document?.propertySection;
-    const properties = propertySection?.properties || [];
+    const properties2 = propertySection?.properties || [];
     const generatorResources = mergedResources.map((resource) => {
       return {
         header: {
-          udrsReference: resource.udrsReference,
+          udrsReference: {
+            protocol: "file",
+            uri: resource.udrsReference
+          },
           encoding: resource.encoding,
           permissions: resource.permissions,
           newlineType: resource.newlineType
@@ -4510,18 +6135,23 @@ var MergeCommand = class {
     });
     const generator = new URPFGenerator();
     const document = {
-      properties: properties.map((prop) => ({
-        name: prop.name,
-        value: prop.value
-      })),
-      resources: generatorResources
+      boundaryToken: "",
+      // 将由生成器自动生成
+      propertySection: {
+        properties: properties2.map((prop) => ({
+          name: prop.name,
+          value: prop.value,
+          isExtended: false
+        }))
+      },
+      resourceSections: generatorResources
     };
     const result = await generator.generate(document);
     if (verbose) {
       console.log(`
 \u751F\u6210\u5B8C\u6210:`);
       console.log(`  \u8FB9\u754C\u4EE4\u724C: ${generator.getBoundaryToken()}`);
-      console.log(`  \u5C5E\u6027\u6570\u91CF: ${properties.length}`);
+      console.log(`  \u5C5E\u6027\u6570\u91CF: ${properties2.length}`);
       console.log(`  \u8D44\u6E90\u6570\u91CF: ${generatorResources.length}`);
     }
     return result.content;
@@ -4544,17 +6174,17 @@ var MergeCommand = class {
 };
 
 // src/commands/var.ts
-import * as fs12 from "fs/promises";
+import * as fs13 from "fs/promises";
 function parseResultToDocument(parseResult) {
-  const properties = {};
+  const properties2 = {};
   if (parseResult.document.propertySection) {
     for (const prop of parseResult.document.propertySection.properties) {
-      properties[prop.name] = prop.value;
+      properties2[prop.name] = prop.value;
     }
   }
   return {
     boundaryToken: parseResult.document.boundaryToken,
-    properties,
+    properties: properties2,
     resources: parseResult.document.resourceSections
   };
 }
@@ -4585,7 +6215,7 @@ async function executeVarCommand(options) {
         error: `URPF \u6587\u4EF6\u4E0D\u5B58\u5728: ${options.filePath}`
       };
     }
-    const urpfContent = await fs12.readFile(filePath, "utf-8");
+    const urpfContent = await fs13.readFile(filePath, "utf-8");
     const parseResult = URPFParser.parse(urpfContent);
     const urpf = parseResultToDocument(parseResult);
     let result;
@@ -4664,7 +6294,7 @@ async function varAdd(urpf, filePath, options) {
   const urpfDocument = documentToURPFDocument(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs12.writeFile(filePath, newURPFContent, "utf-8");
+  await fs13.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "add",
@@ -4677,8 +6307,9 @@ async function varAdd(urpf, filePath, options) {
 async function varList(urpf, filePath, _options) {
   const startTime = Date.now();
   const variables = {};
+  const systemProperties = ["version", "boundary", "encoding", "line-ending"];
   for (const [key, value] of Object.entries(urpf.properties)) {
-    if (!key.startsWith("env:")) {
+    if (!key.startsWith("env:") && !systemProperties.includes(key)) {
       variables[key] = value;
     }
   }
@@ -4716,7 +6347,7 @@ async function varRemove(urpf, filePath, options) {
   const urpfDocument = documentToURPFDocument(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs12.writeFile(filePath, newURPFContent, "utf-8");
+  await fs13.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "remove",
@@ -4747,7 +6378,7 @@ async function varClear(urpf, filePath, _options) {
   const urpfDocument = documentToURPFDocument(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs12.writeFile(filePath, newURPFContent, "utf-8");
+  await fs13.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "clear",
@@ -4758,17 +6389,17 @@ async function varClear(urpf, filePath, _options) {
 }
 
 // src/commands/env.ts
-import * as fs13 from "fs/promises";
+import * as fs14 from "fs/promises";
 function parseResultToDocument2(parseResult) {
-  const properties = {};
+  const properties2 = {};
   if (parseResult.document.propertySection) {
     for (const prop of parseResult.document.propertySection.properties) {
-      properties[prop.name] = prop.value;
+      properties2[prop.name] = prop.value;
     }
   }
   return {
     boundaryToken: parseResult.document.boundaryToken,
-    properties,
+    properties: properties2,
     resources: parseResult.document.resourceSections
   };
 }
@@ -4799,7 +6430,7 @@ async function executeEnvCommand(options) {
         error: `URPF \u6587\u4EF6\u4E0D\u5B58\u5728: ${options.filePath}`
       };
     }
-    const urpfContent = await fs13.readFile(filePath, "utf-8");
+    const urpfContent = await fs14.readFile(filePath, "utf-8");
     const parseResult = URPFParser.parse(urpfContent);
     const urpf = parseResultToDocument2(parseResult);
     let result;
@@ -4873,7 +6504,7 @@ async function envAdd(urpf, filePath, options) {
   const urpfDocument = documentToURPFDocument2(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs13.writeFile(filePath, newURPFContent, "utf-8");
+  await fs14.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "add",
@@ -4928,7 +6559,7 @@ async function envRemove(urpf, filePath, options) {
   const urpfDocument = documentToURPFDocument2(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs13.writeFile(filePath, newURPFContent, "utf-8");
+  await fs14.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "remove",
@@ -4959,7 +6590,7 @@ async function envClear(urpf, filePath, _options) {
   const urpfDocument = documentToURPFDocument2(urpf);
   const generateResult = await generator.generate(urpfDocument);
   const newURPFContent = generateResult.content;
-  await fs13.writeFile(filePath, newURPFContent, "utf-8");
+  await fs14.writeFile(filePath, newURPFContent, "utf-8");
   return {
     success: true,
     action: "clear",
@@ -4969,6 +6600,682 @@ async function envClear(urpf, filePath, _options) {
   };
 }
 
+// src/commands/completion.ts
+function generateBashCompletion() {
+  const script = `#!/usr/bin/env bash
+
+###-begin-urpf-cli-completions-###
+#
+# urpf-cli command completion script
+#
+# Installation: urpf-cli completion bash >> ~/.bashrc
+#    or: urpf-cli completion bash >> ~/.bash_profile on macOS
+#
+
+_urpf_cli_completion() {
+    local cur words cword
+    _init_completion || return
+
+    # urpf-cli \u4E3B\u547D\u4EE4
+    if [[ $cword -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "pack unpack list info verify diff merge var env help --help --version" -- "$cur"))
+        return
+    fi
+
+    # pack \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "pack" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            COMPREPLY=($(compgen -W "create add remove help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "create" ]]; then
+            # pack create \u5B50\u547D\u4EE4
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            # pack create \u9009\u9879\u8865\u5168
+            COMPREPLY=($(compgen -W "-o --output -v --verbose -i --ignore -f --follow-symlinks -d --max-depth --no-recurse --force --byte --line -s --stdout -c --clipboard -e --env --key --format --validate --help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "add" ]]; then
+            # pack add \u5B50\u547D\u4EE4
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            if [[ $cword -ge 4 ]]; then
+                _filedir
+                return
+            fi
+            # pack add \u9009\u9879\u8865\u5168
+            COMPREPLY=($(compgen -W "-v --verbose -i --ignore -f --follow-symlinks -d --max-depth --no-recurse --help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "remove" ]]; then
+            # pack remove \u5B50\u547D\u4EE4
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            if [[ $cword -ge 4 ]]; then
+                _filedir
+                return
+            fi
+            # pack remove \u9009\u9879\u8865\u5168
+            COMPREPLY=($(compgen -W "-v --verbose --no-apply-variables --help" -- "$cur"))
+            return
+        fi
+    fi
+
+    # unpack \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "unpack" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            _filedir
+            return
+        fi
+        # unpack \u9009\u9879\u8865\u5168
+        COMPREPLY=($(compgen -W "-o --output -v --verbose --force --force-when-newer --preserve-mtime --unpack-env --apply-variables --packed-path --key --format --validate --help" -- "$cur"))
+        return
+    fi
+
+    # list \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "list" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            _filedir
+            return
+        fi
+        COMPREPLY=($(compgen -W "-v --verbose -p --pattern -j --json --help" -- "$cur"))
+        return
+    fi
+
+    # info \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "info" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            _filedir
+            return
+        fi
+        COMPREPLY=($(compgen -W "-v --verbose -j --json --help" -- "$cur"))
+        return
+    fi
+
+    # verify \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "verify" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            _filedir
+            return
+        fi
+        COMPREPLY=($(compgen -W "-f --fix -v --verbose -j --json --help" -- "$cur"))
+        return
+    fi
+
+    # diff \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "diff" ]]; then
+        if [[ $cword -eq 2 || $cword -eq 3 ]]; then
+            _filedir
+            return
+        fi
+        COMPREPLY=($(compgen -W "-v --verbose -j --json --help" -- "$cur"))
+        return
+    fi
+
+    # merge \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "merge" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            _filedir
+            return
+        fi
+        if [[ $cword -ge 3 ]]; then
+            _filedir
+            return
+        fi
+        COMPREPLY=($(compgen -W "-s --strategy -v --verbose --help" -- "$cur"))
+        return
+    fi
+
+    # var \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "var" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            COMPREPLY=($(compgen -W "add list remove clear help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "add" || "$words[2]" == "remove" ]]; then
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            COMPREPLY=($(compgen -W "-v --verbose --force --help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "list" || "$words[2]" == "clear" ]]; then
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            COMPREPLY=($(compgen -W "-v --verbose --help" -- "$cur"))
+            return
+        fi
+    fi
+
+    # env \u5B50\u547D\u4EE4
+    if [[ "$words[1]" == "env" ]]; then
+        if [[ $cword -eq 2 ]]; then
+            COMPREPLY=($(compgen -W "add list remove clear help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "add" || "$words[2]" == "remove" ]]; then
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            COMPREPLY=($(compgen -W "-v --verbose --force --help" -- "$cur"))
+            return
+        fi
+
+        if [[ "$words[2]" == "list" || "$words[2]" == "clear" ]]; then
+            if [[ $cword -eq 3 ]]; then
+                _filedir
+                return
+            fi
+            COMPREPLY=($(compgen -W "-v --verbose --help" -- "$cur"))
+            return
+        fi
+    fi
+}
+
+complete -F _urpf_cli_completion urpf-cli
+###-end-urpf-cli-completions-###
+`;
+  return script;
+}
+function generateZshCompletion() {
+  const script = `#compdef urpf-cli
+
+# urpf-cli zsh completion script
+# Installation: urpf-cli completion zsh >> ~/.zshrc
+
+_urpf_cli() {
+    local -a commands subcommands
+
+    commands=(
+        'pack:URPF \u5305\u7BA1\u7406\u547D\u4EE4'
+        'unpack:\u89E3\u5305 URPF \u6587\u4EF6\u5230\u6307\u5B9A\u76EE\u5F55'
+        'list:\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u6587\u4EF6\u53CA\u5176\u5143\u6570\u636E'
+        'info:\u663E\u793A URPF \u5305\u7684\u6458\u8981\u4FE1\u606F'
+        'verify:\u9A8C\u8BC1 URPF \u5305\u7684\u6587\u4EF6\u5B8C\u6574\u6027'
+        'diff:\u6BD4\u8F83\u4E24\u4E2A URPF \u5305\u4E4B\u95F4\u7684\u5DEE\u5F02'
+        'merge:\u5408\u5E76\u591A\u4E2A URPF \u5305\u5230\u4E00\u4E2A\u8F93\u51FA\u6587\u4EF6'
+        'var:URPF \u5305\u53D8\u91CF\u7BA1\u7406\u547D\u4EE4'
+        'env:URPF \u5305\u73AF\u5883\u53D8\u91CF\u7BA1\u7406\u547D\u4EE4'
+        'help:\u663E\u793A\u5E2E\u52A9\u4FE1\u606F'
+    )
+
+    if (( CURRENT == 2 )); then
+        _describe 'command' commands
+    else
+        case $words[2] in
+            pack)
+                subcommands=(
+                    'create:\u521B\u5EFA\u65B0\u7684 URPF \u5305'
+                    'add:\u5411\u5DF2\u6709 URPF \u5305\u6DFB\u52A0\u591A\u4E2A\u6587\u4EF6\u6216\u76EE\u5F55'
+                    'remove:\u4ECE URPF \u5305\u4E2D\u79FB\u9664\u591A\u4E2A\u6587\u4EF6'
+                )
+                if (( CURRENT == 3 )); then
+                    _describe 'subcommand' subcommands
+                else
+                    case $words[3] in
+                        create)
+                            _arguments -S \\
+                                '(-o --output)'{-o,--output}'[\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84]' \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(-i --ignore)'{-i,--ignore}'[\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84]' \\
+                                '(-f --follow-symlinks)'{-f,--follow-symlinks}'[\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5]' \\
+                                '(-d --max-depth)'{-d,--max-depth}'[\u6700\u5927\u626B\u63CF\u6DF1\u5EA6]' \\
+                                '(--no-recurse)--no-recurse[\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55]' \\
+                                '(--force)--force[\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u8F93\u51FA\u6587\u4EF6]' \\
+                                '(--byte)--byte[\u6309\u5B57\u8282\u504F\u79FB\u91CF\u5207\u7247]' \\
+                                '(--line)--line[\u6309\u884C\u53F7\u5207\u7247]' \\
+                                '(-s --stdout)'{-s,--stdout}'[\u8F93\u51FA URPF \u5185\u5BB9\u5230\u5C4F\u5E55]' \\
+                                '(-c --clipboard)'{-c,--clipboard}'[\u590D\u5236 URPF \u5185\u5BB9\u5230\u526A\u8D34\u677F]' \\
+                                '(-e --env)'{-e,--env}'[\u6253\u5305\u73AF\u5883\u53D8\u91CF]' \\
+                                '(--key)--key[\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C]' \\
+                                '(--format)--format[\u8F93\u51FA\u683C\u5F0F(json/yaml/toml/xml/properties/ini/raw)]' \\
+                                '(--validate)--validate[\u9A8C\u8BC1\u6A21\u5F0F(\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728)]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                        add)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(-i --ignore)'{-i,--ignore}'[\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84]' \\
+                                '(-f --follow-symlinks)'{-f,--follow-symlinks}'[\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5]' \\
+                                '(-d --max-depth)'{-d,--max-depth}'[\u6700\u5927\u626B\u63CF\u6DF1\u5EA6]' \\
+                                '(--no-recurse)--no-recurse[\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                        remove)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(--no-apply-variables)--no-apply-variables[\u4E0D\u5E94\u7528\u53D8\u91CF\u66FF\u6362]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                    esac
+                fi
+                ;;
+            unpack)
+                _arguments -S \\
+                    '(-o --output)'{-o,--output}'[\u8F93\u51FA\u76EE\u5F55\u8DEF\u5F84]' \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                    '(--force)--force[\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6]' \\
+                    '(--force-when-newer)--force-when-newer[\u4EC5\u5F53\u6E90\u6587\u4EF6\u6BD4\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\u65F6\u624D\u8986\u76D6]' \\
+                    '(--preserve-mtime)--preserve-mtime[\u4FDD\u7559\u539F\u59CB\u4FEE\u6539\u65F6\u95F4]' \\
+                    '(--unpack-env)--unpack-env[\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E]' \\
+                    '(--apply-variables)--apply-variables[\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9]' \\
+                    '(--packed-path)--packed-path[\u53EA\u89E3\u538B\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55]' \\
+                    '(--key)--key[\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C]' \\
+                    '(--format)--format[\u8F93\u51FA\u683C\u5F0F(json/yaml/toml/xml/properties/ini/raw)]' \\
+                    '(--validate)--validate[\u9A8C\u8BC1\u6A21\u5F0F(\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728)]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            list)
+                _arguments -S \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                    '(-p --pattern)'{-p,--pattern}'[\u6309\u6A21\u5F0F\u8FC7\u6EE4\u6587\u4EF6]' \\
+                    '(-j --json)'{-j,--json}'[\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            info)
+                _arguments -S \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u4FE1\u606F]' \\
+                    '(-j --json)'{-j,--json}'[\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            verify)
+                _arguments -S \\
+                    '(-f --fix)'{-f,--fix}'[\u5C1D\u8BD5\u4FEE\u590D\u5E38\u89C1\u95EE\u9898]' \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                    '(-j --json)'{-j,--json}'[\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            diff)
+                _arguments -S \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                    '(-j --json)'{-j,--json}'[\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            merge)
+                _arguments -S \\
+                    '(-s --strategy)'{-s,--strategy}'[\u5408\u5E76\u7B56\u7565(skip/overwrite/rename)]' \\
+                    '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                    '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                ;;
+            var)
+                subcommands=(
+                    'add:\u6DFB\u52A0\u53D8\u91CF\u5230 URPF \u5305'
+                    'list:\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u53D8\u91CF'
+                    'remove:\u4ECE URPF \u5305\u4E2D\u5220\u9664\u53D8\u91CF'
+                    'clear:\u6E05\u9664 URPF \u5305\u4E2D\u7684\u6240\u6709\u53D8\u91CF'
+                )
+                if (( CURRENT == 3 )); then
+                    _describe 'subcommand' subcommands
+                else
+                    case $words[3] in
+                        add|remove)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(--force)--force[\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u53D8\u91CF]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                        list|clear)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                    esac
+                fi
+                ;;
+            env)
+                subcommands=(
+                    'add:\u6DFB\u52A0\u73AF\u5883\u53D8\u91CF\u5230 URPF \u5305'
+                    'list:\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u73AF\u5883\u53D8\u91CF'
+                    'remove:\u4ECE URPF \u5305\u4E2D\u5220\u9664\u73AF\u5883\u53D8\u91CF'
+                    'clear:\u6E05\u9664 URPF \u5305\u4E2D\u7684\u6240\u6709\u73AF\u5883\u53D8\u91CF'
+                )
+                if (( CURRENT == 3 )); then
+                    _describe 'subcommand' subcommands
+                else
+                    case $words[3] in
+                        add|remove)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(--force)--force[\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u73AF\u5883\u53D8\u91CF]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                        list|clear)
+                            _arguments -S \\
+                                '(-v --verbose)'{-v,--verbose}'[\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7]' \\
+                                '(-h --help)'{-h,--help}'[\u663E\u793A\u5E2E\u52A9\u4FE1\u606F]'
+                            ;;
+                    esac
+                fi
+                ;;
+        esac
+    fi
+}
+
+_urpf_cli
+`;
+  return script;
+}
+function generateFishCompletion() {
+  const script = `#!/usr/bin/env fish
+
+# urpf-cli fish completion script
+# Installation: urpf-cli completion fish > ~/.config/fish/completions/urpf-cli.fish
+
+# Main commands
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a pack -d 'URPF \u5305\u7BA1\u7406\u547D\u4EE4'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a unpack -d '\u89E3\u5305 URPF \u6587\u4EF6\u5230\u6307\u5B9A\u76EE\u5F55'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a list -d '\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u6587\u4EF6\u53CA\u5176\u5143\u6570\u636E'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a info -d '\u663E\u793A URPF \u5305\u7684\u6458\u8981\u4FE1\u606F'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a verify -d '\u9A8C\u8BC1 URPF \u5305\u7684\u6587\u4EF6\u5B8C\u6574\u6027'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a diff -d '\u6BD4\u8F83\u4E24\u4E2A URPF \u5305\u4E4B\u95F4\u7684\u5DEE\u5F02'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a merge -d '\u5408\u5E76\u591A\u4E2A URPF \u5305\u5230\u4E00\u4E2A\u8F93\u51FA\u6587\u4EF6'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a var -d 'URPF \u5305\u53D8\u91CF\u7BA1\u7406\u547D\u4EE4'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a env -d 'URPF \u5305\u73AF\u5883\u53D8\u91CF\u7BA1\u7406\u547D\u4EE4'
+complete -c urpf-cli -f -n "__fish_use_subcommand" -a help -d '\u663E\u793A\u5E2E\u52A9\u4FE1\u606F'
+
+# pack subcommands
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack" -a create -d '\u521B\u5EFA\u65B0\u7684 URPF \u5305'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack" -a add -d '\u5411\u5DF2\u6709 URPF \u5305\u6DFB\u52A0\u591A\u4E2A\u6587\u4EF6\u6216\u76EE\u5F55'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack" -a remove -d '\u4ECE URPF \u5305\u4E2D\u79FB\u9664\u591A\u4E2A\u6587\u4EF6'
+
+# pack create options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l output -s o -d '\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l ignore -s i -d '\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l follow-symlinks -s f -d '\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l max-depth -s d -d '\u6700\u5927\u626B\u63CF\u6DF1\u5EA6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l no-recurse -d '\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l force -d '\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u8F93\u51FA\u6587\u4EF6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l byte -d '\u6309\u5B57\u8282\u504F\u79FB\u91CF\u5207\u7247'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l line -d '\u6309\u884C\u53F7\u5207\u7247'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l stdout -s s -d '\u8F93\u51FA URPF \u5185\u5BB9\u5230\u5C4F\u5E55'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l clipboard -s c -d '\u590D\u5236 URPF \u5185\u5BB9\u5230\u526A\u8D34\u677F'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l env -s e -d '\u6253\u5305\u73AF\u5883\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l key -d '\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l format -d '\u8F93\u51FA\u683C\u5F0F(json/yaml/toml/xml/properties/ini/raw)'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from create" -l validate -d '\u9A8C\u8BC1\u6A21\u5F0F(\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728)'
+
+# pack add options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from add" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from add" -l ignore -s i -d '\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from add" -l follow-symlinks -s f -d '\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from add" -l max-depth -s d -d '\u6700\u5927\u626B\u63CF\u6DF1\u5EA6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from add" -l no-recurse -d '\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55'
+
+# pack remove options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from remove" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from pack; and __fish_seen_subcommand_from remove" -l no-apply-variables -d '\u4E0D\u5E94\u7528\u53D8\u91CF\u66FF\u6362'
+
+# unpack options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l output -s o -d '\u8F93\u51FA\u76EE\u5F55\u8DEF\u5F84'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l force -d '\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l force-when-newer -d '\u4EC5\u5F53\u6E90\u6587\u4EF6\u6BD4\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\u65F6\u624D\u8986\u76D6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l preserve-mtime -d '\u4FDD\u7559\u539F\u59CB\u4FEE\u6539\u65F6\u95F4'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l unpack-env -d '\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l apply-variables -d '\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l packed-path -d '\u53EA\u89E3\u538B\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l key -d '\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l format -d '\u8F93\u51FA\u683C\u5F0F(json/yaml/toml/xml/properties/ini/raw)'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from unpack" -l validate -d '\u9A8C\u8BC1\u6A21\u5F0F(\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728)'
+
+# list options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from list" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from list" -l pattern -s p -d '\u6309\u6A21\u5F0F\u8FC7\u6EE4\u6587\u4EF6'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from list" -l json -s j -d '\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA'
+
+# info options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from info" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u4FE1\u606F'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from info" -l json -s j -d '\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA'
+
+# verify options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from verify" -l fix -s f -d '\u5C1D\u8BD5\u4FEE\u590D\u5E38\u89C1\u95EE\u9898'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from verify" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from verify" -l json -s j -d '\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA'
+
+# diff options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from diff" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from diff" -l json -s j -d '\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA'
+
+# merge options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from merge" -l strategy -s s -d '\u5408\u5E76\u7B56\u7565(skip/overwrite/rename)'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from merge" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+
+# var subcommands
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var" -a add -d '\u6DFB\u52A0\u53D8\u91CF\u5230 URPF \u5305'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var" -a list -d '\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var" -a remove -d '\u4ECE URPF \u5305\u4E2D\u5220\u9664\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var" -a clear -d '\u6E05\u9664 URPF \u5305\u4E2D\u7684\u6240\u6709\u53D8\u91CF'
+
+# var add/remove options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var; and __fish_seen_subcommand_from add" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var; and __fish_seen_subcommand_from add" -l force -d '\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var; and __fish_seen_subcommand_from remove" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+
+# var list/clear options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var; and __fish_seen_subcommand_from list" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from var; and __fish_seen_subcommand_from clear" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+
+# env subcommands
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env" -a add -d '\u6DFB\u52A0\u73AF\u5883\u53D8\u91CF\u5230 URPF \u5305'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env" -a list -d '\u5217\u51FA URPF \u5305\u4E2D\u7684\u6240\u6709\u73AF\u5883\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env" -a remove -d '\u4ECE URPF \u5305\u4E2D\u5220\u9664\u73AF\u5883\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env" -a clear -d '\u6E05\u9664 URPF \u5305\u4E2D\u7684\u6240\u6709\u73AF\u5883\u53D8\u91CF'
+
+# env add/remove options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env; and __fish_seen_subcommand_from add" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env; and __fish_seen_subcommand_from add" -l force -d '\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u73AF\u5883\u53D8\u91CF'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env; and __fish_seen_subcommand_from remove" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+
+# env list/clear options
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env; and __fish_seen_subcommand_from list" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+complete -c urpf-cli -f -n "__fish_seen_subcommand_from env; and __fish_seen_subcommand_from clear" -l verbose -s v -d '\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7'
+`;
+  return script;
+}
+function generatePowerShellCompletion() {
+  const script = `# urpf-cli PowerShell completion script
+# Installation: urpf-cli completion powershell >> $PROFILE
+
+Register-ArgumentCompleter -Native -CommandName urpf-cli -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $commands = @('pack', 'unpack', 'list', 'info', 'verify', 'diff', 'merge', 'var', 'env', 'help')
+
+    # Get the current command
+    $commandElements = $commandAst.CommandElements
+    $currentCommand = if ($commandElements.Count -gt 1) { $commandElements[1].Value } else { '' }
+
+    # Main command completion
+    if ($commandElements.Count -eq 2) {
+        $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # pack subcommand completion
+    if ($currentCommand -eq 'pack' -and $commandElements.Count -eq 3) {
+        $subcommands = @('create', 'add', 'remove')
+        $subcommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # pack create options
+    if ($currentCommand -eq 'pack' -and $commandElements.Count -gt 3 -and $commandElements[2].Value -eq 'create') {
+        $options = @('-o', '--output', '-v', '--verbose', '-i', '--ignore', '-f', '--follow-symlinks', '-d', '--max-depth', '--no-recurse', '--force', '--byte', '--line', '-s', '--stdout', '-c', '--clipboard', '-e', '--env', '--key', '--format', '--validate')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # pack add options
+    if ($currentCommand -eq 'pack' -and $commandElements.Count -gt 3 -and $commandElements[2].Value -eq 'add') {
+        $options = @('-v', '--verbose', '-i', '--ignore', '-f', '--follow-symlinks', '-d', '--max-depth', '--no-recurse')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # pack remove options
+    if ($currentCommand -eq 'pack' -and $commandElements.Count -gt 3 -and $commandElements[2].Value -eq 'remove') {
+        $options = @('-v', '--verbose', '--no-apply-variables')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # unpack options
+    if ($currentCommand -eq 'unpack' -and $commandElements.Count -gt 2) {
+        $options = @('-o', '--output', '-v', '--verbose', '--force', '--force-when-newer', '--preserve-mtime', '--unpack-env', '--apply-variables', '--packed-path', '--key', '--format', '--validate')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # list options
+    if ($currentCommand -eq 'list' -and $commandElements.Count -gt 2) {
+        $options = @('-v', '--verbose', '-p', '--pattern', '-j', '--json')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # info options
+    if ($currentCommand -eq 'info' -and $commandElements.Count -gt 2) {
+        $options = @('-v', '--verbose', '-j', '--json')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # verify options
+    if ($currentCommand -eq 'verify' -and $commandElements.Count -gt 2) {
+        $options = @('-f', '--fix', '-v', '--verbose', '-j', '--json')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # diff options
+    if ($currentCommand -eq 'diff' -and $commandElements.Count -gt 2) {
+        $options = @('-v', '--verbose', '-j', '--json')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # merge options
+    if ($currentCommand -eq 'merge' -and $commandElements.Count -gt 2) {
+        $options = @('-s', '--strategy', '-v', '--verbose')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # var subcommand completion
+    if ($currentCommand -eq 'var' -and $commandElements.Count -eq 3) {
+        $subcommands = @('add', 'list', 'remove', 'clear')
+        $subcommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # var add/remove options
+    if ($currentCommand -eq 'var' -and $commandElements.Count -gt 3 -and ($commandElements[2].Value -eq 'add' -or $commandElements[2].Value -eq 'remove')) {
+        $options = @('-v', '--verbose', '--force')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # var list/clear options
+    if ($currentCommand -eq 'var' -and $commandElements.Count -gt 3 -and ($commandElements[2].Value -eq 'list' -or $commandElements[2].Value -eq 'clear')) {
+        $options = @('-v', '--verbose')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # env subcommand completion
+    if ($currentCommand -eq 'env' -and $commandElements.Count -eq 3) {
+        $subcommands = @('add', 'list', 'remove', 'clear')
+        $subcommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # env add/remove options
+    if ($currentCommand -eq 'env' -and $commandElements.Count -gt 3 -and ($commandElements[2].Value -eq 'add' -or $commandElements[2].Value -eq 'remove')) {
+        $options = @('-v', '--verbose', '--force')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # env list/clear options
+    if ($currentCommand -eq 'env' -and $commandElements.Count -gt 3 -and ($commandElements[2].Value -eq 'list' -or $commandElements[2].Value -eq 'clear')) {
+        $options = @('-v', '--verbose')
+        $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+}
+`;
+  return script;
+}
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return generateBashCompletion();
+    case "zsh":
+      return generateZshCompletion();
+    case "fish":
+      return generateFishCompletion();
+    case "powershell":
+      return generatePowerShellCompletion();
+    default:
+      throw new Error(`Unsupported shell: ${shell}`);
+  }
+}
+function getSupportedShells() {
+  return ["bash", "zsh", "fish", "powershell"];
+}
+
 // src/index.ts
 var program = new Command();
 program.name("urpf-cli").description("URPF CLI \u5DE5\u5177 - \u57FA\u4E8E URPF \u89C4\u8303\u7684\u547D\u4EE4\u884C\u6253\u5305\u5DE5\u5177").version("0.1.0");
@@ -4985,7 +7292,10 @@ packCommand.command("create").description("\u5C06\u6587\u4EF6\u6216\u76EE\u5F55\
     previous[name] = void 0;
   }
   return previous;
-}, {}).action(async (file, options) => {
+}, {}).option("--key <key-path>", '\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C\uFF08\u652F\u6301\u5D4C\u5957\u548C\u6570\u7EC4\u8BBF\u95EE\uFF0C\u5982 "config.server.port" \u6216 "items[0].name"\uFF1B\u652F\u6301\u901A\u914D\u7B26 * \u548C **\uFF1B\u652F\u6301\u9017\u53F7\u5206\u9694\u591A\u4E2A key\uFF1B\u53EF\u591A\u6B21\u6307\u5B9A\uFF09', (value, previous = []) => {
+  previous.push(value);
+  return previous;
+}).option("--format <format>", "\u8F93\u51FA\u683C\u5F0F\uFF08json\u3001yaml\u3001toml\u3001xml\u3001properties\u3001ini\u3001raw\uFF09", "json").option("--validate", "\u9A8C\u8BC1\u6A21\u5F0F\uFF08\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728\uFF0C\u4E0D\u6267\u884C\u5B9E\u9645\u63D0\u53D6\uFF09").action(async (file, options) => {
   try {
     const envVars = options.env;
     const packOptions = {
@@ -5006,7 +7316,12 @@ packCommand.command("create").description("\u5C06\u6587\u4EF6\u6216\u76EE\u5F55\
       stdout: options.stdout,
       clipboard: options.clipboard,
       // 环境变量
-      envVars: Object.keys(envVars).length > 0 ? envVars : void 0
+      envVars: Object.keys(envVars).length > 0 ? envVars : void 0,
+      // key 提取
+      key: options.key,
+      // 格式化和验证
+      format: options.format,
+      validate: options.validate
     };
     const command = new PackCommand();
     const result = await command.execute(file, packOptions);
@@ -5074,15 +7389,20 @@ packCommand.command("remove").description("\u4ECE URPF \u5305\u4E2D\u79FB\u9664\
     process.exit(1);
   }
 });
-program.command("unpack").description("\u89E3\u5305 URPF \u6587\u4EF6\u5230\u6307\u5B9A\u76EE\u5F55\n\n\u73AF\u5883\u53D8\u91CF\u652F\u6301:\n  \u5982\u679C URPF \u5305\u5305\u542B\u73AF\u5883\u53D8\u91CF\uFF0C\u89E3\u5305\u65F6\u4F1A\u63D0\u793A\u7528\u6237\u662F\u5426\u8BBE\u7F6E\n  \u4F7F\u7528 --unpack-env \u9009\u9879\u53EF\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E\uFF08\u65E0\u9700\u7528\u6237\u4EA4\u4E92\uFF09\n  \u4F7F\u7528 --apply-variables \u9009\u9879\u53EF\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9").argument("<file.urpf>", "\u8981\u89E3\u5305\u7684 URPF \u6587\u4EF6\u8DEF\u5F84").option("-o, --output <path>", "\u8F93\u51FA\u76EE\u5F55\u8DEF\u5F84\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("--force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6").option("--force-when-newer", "\u4EC5\u5F53\u6E90\u6587\u4EF6\u6BD4\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\u65F6\u624D\u8986\u76D6").option("--preserve-mtime", "\u4FDD\u7559\u539F\u59CB\u4FEE\u6539\u65F6\u95F4").option("--unpack-env", "\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E\uFF08\u65E0\u9700\u7528\u6237\u4EA4\u4E92\uFF09").option("--apply-variables", "\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9").option("--packed-path <path>", "\u53EA\u89E3\u538B\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u652F\u6301\u901A\u914D\u7B26 * \u548C ?\uFF0C\u53EF\u591A\u6B21\u4F7F\u7528\uFF09", (value, previous = []) => {
+program.command("unpack").description('\u89E3\u5305 URPF \u6587\u4EF6\u5230\u6307\u5B9A\u76EE\u5F55\n\n\u73AF\u5883\u53D8\u91CF\u652F\u6301:\n  \u5982\u679C URPF \u5305\u5305\u542B\u73AF\u5883\u53D8\u91CF\uFF0C\u89E3\u5305\u65F6\u4F1A\u63D0\u793A\u7528\u6237\u662F\u5426\u8BBE\u7F6E\n  \u4F7F\u7528 --unpack-env \u9009\u9879\u53EF\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E\uFF08\u65E0\u9700\u7528\u6237\u4EA4\u4E92\uFF09\n  \u4F7F\u7528 --apply-variables \u9009\u9879\u53EF\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9\n\nKey \u63D0\u53D6\u652F\u6301:\n  \u4F7F\u7528 --key \u9009\u9879\u4ECE\u89E3\u5305\u540E\u7684\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C\n  \u652F\u6301\u5D4C\u5957\u952E\u8BBF\u95EE\uFF08\u5982 "config.server.port"\uFF09\n  \u652F\u6301\u6570\u7EC4\u7D22\u5F15\u8BBF\u95EE\uFF08\u5982 "items[0].name"\uFF09').argument("<file.urpf>", "\u8981\u89E3\u5305\u7684 URPF \u6587\u4EF6\u8DEF\u5F84").option("-o, --output <path>", "\u8F93\u51FA\u76EE\u5F55\u8DEF\u5F84\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("--force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6").option("--force-when-newer", "\u4EC5\u5F53\u6E90\u6587\u4EF6\u6BD4\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\u65F6\u624D\u8986\u76D6").option("--preserve-mtime", "\u4FDD\u7559\u539F\u59CB\u4FEE\u6539\u65F6\u95F4").option("--unpack-env", "\u81EA\u52A8\u786E\u8BA4\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E\uFF08\u65E0\u9700\u7528\u6237\u4EA4\u4E92\uFF09").option("--apply-variables", "\u5E94\u7528\u53D8\u91CF\u66FF\u6362\u5230\u6587\u4EF6\u5185\u5BB9").option("--packed-path <path>", "\u53EA\u89E3\u538B\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u652F\u6301\u901A\u914D\u7B26 * \u548C ?\uFF0C\u53EF\u591A\u6B21\u4F7F\u7528\uFF09", (value, previous = []) => {
+  previous.push(value);
+  return previous;
+}).option("--key <key-path>", '\u4ECE\u914D\u7F6E\u6587\u4EF6\u4E2D\u63D0\u53D6\u6307\u5B9A\u7684\u952E\u503C\uFF08\u652F\u6301\u5D4C\u5957\u548C\u6570\u7EC4\u8BBF\u95EE\uFF0C\u5982 "config.server.port" \u6216 "items[0].name"\uFF1B\u652F\u6301\u901A\u914D\u7B26 * \u548C **\uFF1B\u652F\u6301\u9017\u53F7\u5206\u9694\u591A\u4E2A key\uFF1B\u53EF\u591A\u6B21\u6307\u5B9A\uFF09', (value, previous = []) => {
   previous.push(value);
   return previous;
-}).action(async (file, options) => {
+}).option("--format <format>", "\u8F93\u51FA\u683C\u5F0F\uFF08json\u3001yaml\u3001toml\u3001xml\u3001properties\u3001ini\u3001raw\uFF09", "json").option("--validate", "\u9A8C\u8BC1\u6A21\u5F0F\uFF08\u4EC5\u9A8C\u8BC1 key \u662F\u5426\u5B58\u5728\uFF0C\u4E0D\u6267\u884C\u5B9E\u9645\u63D0\u53D6\uFF09").action(async (file, options) => {
   try {
     const unpackCommand = new UnpackCommand();
     const result = await unpackCommand.execute(file, {
       ...options,
-      packedPaths: options.packedPath
+      packedPaths: options.packedPath,
+      format: options.format,
+      validate: options.validate
     });
     if (result.success) {
       console.log(`\u2705 URPF \u6587\u4EF6\u5DF2\u89E3\u5305\u5230: ${result.outputDir}`);
@@ -5426,4 +7746,21 @@ envCommand.command("clear").description("\u6E05\u9664 URPF \u5305\u4E2D\u7684\u6
     process.exit(1);
   }
 });
+program.command("completion").description("\u751F\u6210 Shell \u81EA\u52A8\u8865\u5168\u811A\u672C\n\n\u652F\u6301\u7684 Shell:\n  bash   - Bash shell\n  zsh    - Zsh shell\n  fish   - Fish shell\n  powershell - PowerShell\n\n\u4F7F\u7528\u793A\u4F8B:\n  urpf-cli completion bash >> ~/.bashrc\n  urpf-cli completion zsh >> ~/.zshrc\n  urpf-cli completion fish > ~/.config/fish/completions/urpf-cli.fish\n  urpf-cli completion powershell >> $PROFILE").argument("<shell>", "Shell \u7C7B\u578B\uFF08bash\u3001zsh\u3001fish\u3001powershell\uFF09").action(async (shell) => {
+  try {
+    const shellType = shell.toLowerCase();
+    const supportedShells = getSupportedShells();
+    if (!supportedShells.includes(shellType)) {
+      console.error(`\u274C \u4E0D\u652F\u6301\u7684 Shell \u7C7B\u578B: ${shell}`);
+      console.error(`\u652F\u6301\u7684 Shell \u7C7B\u578B: ${supportedShells.join(", ")}`);
+      process.exit(1);
+    }
+    const completionScript = generateCompletion(shellType);
+    console.log(completionScript);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C \u751F\u6210\u8865\u5168\u811A\u672C\u5931\u8D25: ${errorMessage}`);
+    process.exit(1);
+  }
+});
 program.parse();