@tq1086/urpf-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2267 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/pack.ts
+import path2 from "path";
+import fs3 from "fs/promises";
+
+// src/core/scanner/file-scanner.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/core/scanner/ignore/ignore-engine.ts
+var IgnoreEngine = class {
+  constructor(options) {
+    this.rules = [];
+    this.options = {
+      caseSensitive: false,
+      pathSeparator: "/",
+      gitignoreExtended: true
+    };
+    if (options) {
+      this.options = { ...this.options, ...options };
+    }
+  }
+  /**
+   * 添加忽略规则
+   * @param rule 忽略规则
+   */
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  /**
+   * 添加多个忽略规则
+   * @param rules 忽略规则列表
+   */
+  addRules(rules) {
+    this.rules.push(...rules);
+  }
+  /**
+   * 移除所有规则
+   */
+  clear() {
+    this.rules = [];
+  }
+  /**
+   * 获取所有规则
+   * @returns 规则列表
+   */
+  getRules() {
+    return [...this.rules];
+  }
+  /**
+   * 匹配文件路径
+   * @param filePath 文件路径
+   * @param isDirectory 是否为目录
+   * @returns 匹配结果
+   */
+  match(filePath, isDirectory = false) {
+    const normalizedPath = this.normalizePath(filePath);
+    let lastMatchedRuleIndex;
+    let lastMatchedRule;
+    for (let i = 0; i < this.rules.length; i++) {
+      const rule = this.rules[i];
+      if (rule.isDirectoryOnly && !isDirectory) {
+        continue;
+      }
+      if (this.matchRule(normalizedPath, rule, isDirectory)) {
+        lastMatchedRuleIndex = i;
+        lastMatchedRule = rule;
+      }
+    }
+    if (lastMatchedRule) {
+      return {
+        matched: !lastMatchedRule.isNegation,
+        ruleIndex: lastMatchedRuleIndex,
+        rule: lastMatchedRule
+      };
+    }
+    return { matched: false };
+  }
+  /**
+   * 批量匹配文件路径
+   * @param filePaths 文件路径列表
+   * @param isDirectory 是否为目录
+   * @returns 匹配结果列表
+   */
+  matchBatch(filePaths, isDirectory = false) {
+    return filePaths.map((filePath) => this.match(filePath, isDirectory));
+  }
+  /**
+   * 匹配单个规则
+   * @param filePath 文件路径
+   * @param rule 忽略规则
+   * @param isDirectory 是否为目录
+   * @returns 是否匹配
+   */
+  matchRule(filePath, rule, isDirectory) {
+    const pattern = rule.pattern;
+    if (rule.isAbsolute) {
+      return this.matchPattern(filePath, pattern, isDirectory, true);
+    }
+    const parts = filePath.split(this.options.pathSeparator);
+    for (let i = 0; i < parts.length; i++) {
+      const subPath = parts.slice(i).join(this.options.pathSeparator);
+      if (this.matchPattern(subPath, pattern, isDirectory, false)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 匹配通配符模式
+   * @param filePath 文件路径
+   * @param pattern 模式
+   * @param isDirectory 是否为目录
+   * @param fromStart 是否从开头匹配
+   * @returns 是否匹配
+   */
+  matchPattern(filePath, pattern, isDirectory, fromStart) {
+    const regex = this.patternToRegex(pattern, fromStart);
+    if (regex.test(filePath)) {
+      return true;
+    }
+    if (isDirectory && !filePath.endsWith(this.options.pathSeparator)) {
+      const dirPath = filePath + this.options.pathSeparator;
+      return regex.test(dirPath);
+    }
+    return false;
+  }
+  /**
+   * 将通配符模式转换为正则表达式
+   * @param pattern 通配符模式
+   * @param fromStart 是否从开头匹配
+   * @returns 正则表达式
+   */
+  patternToRegex(pattern, fromStart) {
+    let regexPattern = "";
+    const specialChars = /[.+?^${}()|[\]\\]/g;
+    regexPattern = pattern.replace(specialChars, "\\$&");
+    regexPattern = regexPattern.replace(/\*\*/g, ".*");
+    regexPattern = regexPattern.replace(/(?<!\.)\*(?!\*)/g, "[^/]*");
+    regexPattern = regexPattern.replace(/\?/g, "[^/]");
+    regexPattern = regexPattern.replace(/\[!\]/g, "\\[!\\]");
+    regexPattern = regexPattern.replace(/\[([^\]]+)\]/g, (match, content) => {
+      if (content.startsWith("!")) {
+        return `[^${content.substring(1)}]`;
+      }
+      return `[${content}]`;
+    });
+    if (fromStart) {
+      regexPattern = `^${regexPattern}$`;
+    } else {
+      regexPattern = `(^|/)${regexPattern}$`;
+    }
+    const flags = this.options.caseSensitive ? "" : "i";
+    return new RegExp(regexPattern, flags);
+  }
+  /**
+   * 规范化路径
+   * @param filePath 文件路径
+   * @returns 规范化后的路径
+   */
+  normalizePath(filePath) {
+    let normalized = filePath;
+    normalized = normalized.replace(/\\/g, this.options.pathSeparator);
+    if (normalized.startsWith(this.options.pathSeparator)) {
+      normalized = normalized.substring(1);
+    }
+    if (normalized.endsWith(this.options.pathSeparator)) {
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+  }
+};
+
+// src/core/scanner/file-scanner.ts
+var FileScanner = class {
+  /**
+   * 扫描目录
+   * @param rootPath 根目录路径
+   * @param options 扫描选项
+   * @returns 扫描结果
+   */
+  static async scanDirectory(rootPath, options = {}) {
+    const startTime = Date.now();
+    const files = [];
+    const directories = [];
+    const skippedFiles = [];
+    try {
+      const absoluteRootPath = path.resolve(rootPath);
+      const ignoreEngine = options.ignoreRules ? new IgnoreEngine() : void 0;
+      if (ignoreEngine && options.ignoreRules) {
+        ignoreEngine.addRules(options.ignoreRules);
+      }
+      await this.scanRecursive(
+        absoluteRootPath,
+        "",
+        0,
+        options,
+        files,
+        directories,
+        skippedFiles,
+        ignoreEngine
+      );
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+      return {
+        rootPath: absoluteRootPath,
+        files,
+        directories,
+        skippedFiles,
+        startTime,
+        endTime,
+        duration
+      };
+    } catch (error) {
+      throw new Error(`\u626B\u63CF\u76EE\u5F55\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * 递归扫描目录
+   * @param currentPath 当前路径
+   * @param relativePath 相对路径
+   * @param currentDepth 当前深度
+   * @param options 扫描选项
+   * @param files 文件列表
+   * @param directories 目录列表
+   * @param skippedFiles 被忽略的文件列表
+   */
+  static async scanRecursive(currentPath, relativePath, currentDepth, options, files, directories, skippedFiles, ignoreEngine) {
+    if (options.maxDepth !== void 0 && options.maxDepth > 0 && currentDepth >= options.maxDepth) {
+      return;
+    }
+    try {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryName = entry.name;
+        const entryPath = path.join(currentPath, entryName);
+        const entryRelativePath = relativePath ? path.join(relativePath, entryName) : entryName;
+        if (!options.includeHidden && entryName.startsWith(".")) {
+          skippedFiles.push(entryRelativePath);
+          continue;
+        }
+        try {
+          const stats = await fs.stat(entryPath);
+          const metadata = {
+            path: entryRelativePath,
+            name: entryName,
+            isDirectory: entry.isDirectory(),
+            isSymlink: entry.isSymbolicLink(),
+            size: stats.size,
+            permissions: this.modeToPermissions(stats.mode),
+            mtime: stats.mtimeMs,
+            ctime: stats.ctimeMs,
+            encoding: "utf-8",
+            newlineType: "lf",
+            isBinary: false
+          };
+          if (entry.isSymbolicLink()) {
+            if (!options.followSymlinks) {
+              skippedFiles.push(entryRelativePath);
+              continue;
+            }
+            const realStats = await fs.stat(entryPath);
+            metadata.isDirectory = realStats.isDirectory();
+            metadata.size = realStats.size;
+          }
+          if (ignoreEngine) {
+            const matchResult = ignoreEngine.match(entryRelativePath, metadata.isDirectory);
+            if (matchResult.matched) {
+              skippedFiles.push(entryRelativePath);
+              continue;
+            }
+          }
+          if (options.fileFilter && !options.fileFilter(metadata)) {
+            skippedFiles.push(entryRelativePath);
+            continue;
+          }
+          if (metadata.isDirectory) {
+            directories.push(metadata);
+            await this.scanRecursive(
+              entryPath,
+              entryRelativePath,
+              currentDepth + 1,
+              options,
+              files,
+              directories,
+              skippedFiles,
+              ignoreEngine
+            );
+          } else {
+            files.push(metadata);
+          }
+        } catch (error) {
+          skippedFiles.push(entryRelativePath);
+        }
+      }
+    } catch (error) {
+      throw new Error(`\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${currentPath} - ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * 将文件模式转换为权限字符串
+   * @param mode 文件模式
+   * @returns 权限字符串（如 "0644"）
+   */
+  static modeToPermissions(mode) {
+    return (mode & 511).toString(8).padStart(3, "0");
+  }
+  /**
+   * 计算扫描统计信息
+   * @param result 扫描结果
+   * @returns 统计信息
+   */
+  static calculateStatistics(result) {
+    const totalFiles = result.files.length;
+    const totalDirectories = result.directories.length;
+    const ignoredFiles = result.skippedFiles.length;
+    const symlinks = result.files.filter((f) => f.isSymlink).length + result.directories.filter((d) => d.isSymlink).length;
+    const totalSize = result.files.reduce((sum, f) => sum + f.size, 0);
+    return {
+      totalFiles,
+      totalDirectories,
+      ignoredFiles,
+      symlinks,
+      totalSize
+    };
+  }
+  /**
+   * 过滤文件列表
+   * @param files 文件列表
+   * @param rules 忽略规则
+   * @returns 过滤后的文件列表
+   */
+  static filterFiles(files, rules) {
+    if (rules.length === 0) {
+      return files;
+    }
+    return files;
+  }
+};
+
+// src/core/scanner/ignore/ignore-parser.ts
+var IgnoreRuleParser = class {
+  /**
+   * 解析忽略规则字符串
+   * @param pattern 规则模式字符串
+   * @param sourceFile 规则来源文件（可选）
+   * @returns 忽略规则
+   */
+  parse(pattern, sourceFile) {
+    const trimmedPattern = pattern.trim();
+    if (!trimmedPattern || trimmedPattern.startsWith("#")) {
+      throw new Error("\u65E0\u6548\u7684\u5FFD\u7565\u89C4\u5219\uFF1A\u7A7A\u884C\u6216\u6CE8\u91CA");
+    }
+    let rulePattern = trimmedPattern;
+    let isNegation = false;
+    let isDirectoryOnly = false;
+    let isAbsolute = false;
+    if (rulePattern.startsWith("!")) {
+      isNegation = true;
+      rulePattern = rulePattern.substring(1).trim();
+    }
+    if (rulePattern.endsWith("/")) {
+      isDirectoryOnly = true;
+      rulePattern = rulePattern.slice(0, -1);
+    }
+    if (rulePattern.startsWith("/")) {
+      isAbsolute = true;
+      rulePattern = rulePattern.substring(1);
+    }
+    return {
+      pattern: rulePattern,
+      isNegation,
+      isDirectoryOnly,
+      isAbsolute,
+      sourceFile
+    };
+  }
+  /**
+   * 解析忽略文件内容
+   * @param content 文件内容
+   * @param sourceFile 规则来源文件（可选）
+   * @returns 忽略规则列表
+   */
+  parseFile(content, sourceFile) {
+    const rules = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      try {
+        const rule = this.parse(line, sourceFile);
+        rules.push(rule);
+      } catch (error) {
+        console.warn(`\u7B2C ${i + 1} \u884C: \u65E0\u6548\u7684\u5FFD\u7565\u89C4\u5219 "${line}"`);
+      }
+    }
+    return rules;
+  }
+  /**
+   * 解析忽略文件（从文件系统）
+   * @param filePath 文件路径
+   * @returns 忽略规则列表
+   */
+  async parseFileFromPath(filePath) {
+    const fs7 = await import("fs/promises");
+    const content = await fs7.readFile(filePath, "utf-8");
+    return this.parseFile(content, filePath);
+  }
+  /**
+   * 从多个文件加载忽略规则
+   * @param filePaths 文件路径列表
+   * @returns 忽略规则列表
+   */
+  async parseMultipleFiles(filePaths) {
+    const allRules = [];
+    for (const filePath of filePaths) {
+      try {
+        const rules = await this.parseFileFromPath(filePath);
+        allRules.push(...rules);
+      } catch (error) {
+        console.warn(`\u65E0\u6CD5\u8BFB\u53D6\u5FFD\u7565\u6587\u4EF6: ${filePath}`);
+      }
+    }
+    return allRules;
+  }
+  /**
+   * 查找并解析项目根目录的忽略文件
+   * @param rootPath 项目根目录
+   * @param ignoreFileNames 忽略文件名列表
+   * @returns 忽略规则列表
+   */
+  async findAndParseIgnoreFiles(rootPath, ignoreFileNames = [".gitignore", ".iflowignore", ".npmignore"]) {
+    const fs7 = await import("fs/promises");
+    const path6 = await import("path");
+    const rules = [];
+    for (const fileName of ignoreFileNames) {
+      const filePath = path6.join(rootPath, fileName);
+      try {
+        await fs7.access(filePath);
+        const fileRules = await this.parseFileFromPath(filePath);
+        rules.push(...fileRules);
+      } catch {
+      }
+    }
+    return rules;
+  }
+};
+
+// src/core/generator/urpf-generator.ts
+import crypto from "crypto";
+var URPFGenerator = class {
+  constructor(options = {}) {
+    this.state = {
+      boundaryToken: options.boundaryToken || this.generateBoundaryToken(),
+      includeBoundaries: options.includeBoundaries !== false,
+      newlineType: options.newlineType || "lf"
+    };
+  }
+  /**
+   * 生成随机边界令牌（8位十六进制）
+   */
+  generateBoundaryToken() {
+    return crypto.randomBytes(4).toString("hex");
+  }
+  /**
+   * 获取换行符
+   */
+  getNewline() {
+    return this.state.newlineType === "lf" ? "\n" : "\r\n";
+  }
+  /**
+   * 生成开始边界
+   */
+  generateStartBoundary() {
+    return `--URPF-BOUNDARY-${this.state.boundaryToken}--`;
+  }
+  /**
+   * 生成结束边界
+   */
+  generateEndBoundary() {
+    return `--URPF-BOUNDARY-${this.state.boundaryToken}--`;
+  }
+  /**
+   * 生成分隔符
+   */
+  generateDelimiter() {
+    return `--URPF-BOUNDARY-${this.state.boundaryToken}--`;
+  }
+  /**
+   * 生成属性部分
+   */
+  generatePropertySection(properties) {
+    const newline = this.getNewline();
+    const lines = [];
+    for (const prop of properties) {
+      if (prop.name.includes(" ")) {
+        lines.push(`\${${prop.name}}=${prop.value}`);
+      } else {
+        lines.push(`$${prop.name}=${prop.value}`);
+      }
+    }
+    return lines.join(newline);
+  }
+  /**
+   * 生成资源头部
+   */
+  generateResourceHeader(resource) {
+    const header = `@${resource.header.udrsReference} ${resource.header.encoding} ${resource.header.permissions} ${resource.header.newlineType}`;
+    return header;
+  }
+  /**
+   * 生成资源部分
+   */
+  generateResourceSection(resource) {
+    const newline = this.getNewline();
+    const header = this.generateResourceHeader(resource);
+    const content = resource.content;
+    return `${header}${newline}${content}`;
+  }
+  /**
+   * 生成 URPF 文档
+   */
+  async generate(document) {
+    const startTime = Date.now();
+    const newline = this.getNewline();
+    const parts = [];
+    if (this.state.includeBoundaries) {
+      parts.push(this.generateStartBoundary());
+    }
+    if (document.properties && document.properties.length > 0) {
+      parts.push(this.generatePropertySection(document.properties));
+      parts.push(this.generateDelimiter());
+    }
+    for (const resource of document.resources) {
+      parts.push(this.generateResourceSection(resource));
+      parts.push(this.generateDelimiter());
+    }
+    if (this.state.includeBoundaries) {
+      parts.pop();
+      parts.push(this.generateEndBoundary());
+    } else {
+      parts.pop();
+    }
+    const content = parts.join(newline);
+    const duration = Date.now() - startTime;
+    return {
+      content,
+      size: Buffer.byteLength(content, "utf-8"),
+      resourceCount: document.resources.length,
+      duration
+    };
+  }
+  /**
+   * 获取当前边界令牌
+   */
+  getBoundaryToken() {
+    return this.state.boundaryToken;
+  }
+  /**
+   * 设置边界令牌
+   */
+  setBoundaryToken(token) {
+    if (!/^[0-9a-fA-F]{8}$/.test(token)) {
+      throw new Error("\u8FB9\u754C\u4EE4\u724C\u5FC5\u987B\u662F8\u4F4D\u5341\u516D\u8FDB\u5236\u6570\u5B57");
+    }
+    this.state.boundaryToken = token;
+  }
+};
+
+// src/core/generator/resource-serializer.ts
+import fs2 from "fs/promises";
+var ResourceSerializer = class {
+  constructor(options = {}) {
+    this.options = {
+      encoding: options.encoding || "utf-8",
+      detectEncoding: options.detectEncoding !== false,
+      detectNewline: options.detectNewline !== false
+    };
+  }
+  /**
+   * 检测文件编码
+   */
+  async detectFileEncoding(buffer) {
+    if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+      return "utf-8";
+    }
+    if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) {
+      return "utf-16le";
+    }
+    if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) {
+      return "utf-16be";
+    }
+    try {
+      Buffer.from(buffer.toString("utf-8"), "utf-8");
+      return "utf-8";
+    } catch {
+      try {
+        Buffer.from(buffer.toString("gbk"), "gbk");
+        return "gbk";
+      } catch {
+        return "binary";
+      }
+    }
+  }
+  /**
+   * 检测换行符类型
+   */
+  detectNewlineType(buffer) {
+    const content = buffer.toString("utf-8");
+    let crlfCount = 0;
+    let lfCount = 0;
+    let crCount = 0;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\r" && content[i + 1] === "\n") {
+        crlfCount++;
+        i++;
+      } else if (content[i] === "\n") {
+        lfCount++;
+      } else if (content[i] === "\r") {
+        crCount++;
+      }
+    }
+    if (crlfCount >= lfCount && crlfCount >= crCount) {
+      return "crlf";
+    } else if (lfCount >= crCount) {
+      return "lf";
+    } else {
+      return "cr";
+    }
+  }
+  /**
+   * 转换文件权限为八进制字符串
+   */
+  convertPermissions(mode) {
+    const permissions = mode & 511;
+    return permissions.toString(8).padStart(3, "0");
+  }
+  /**
+   * 读取文件内容
+   */
+  async readFile(filePath, encoding) {
+    if (encoding === "binary") {
+      const buffer = await fs2.readFile(filePath);
+      return buffer.toString("base64");
+    } else {
+      return await fs2.readFile(filePath, encoding);
+    }
+  }
+  /**
+   * 序列化文件为资源部分
+   */
+  async serializeFile(filePath, metadata, udrsReference) {
+    let encoding = this.options.encoding || "utf-8";
+    let newlineType = "lf";
+    if (this.options.detectEncoding) {
+      const buffer = await fs2.readFile(filePath);
+      encoding = await this.detectFileEncoding(buffer);
+    }
+    if (this.options.detectNewline && encoding !== "binary") {
+      const buffer = await fs2.readFile(filePath);
+      newlineType = this.detectNewlineType(buffer);
+    }
+    const content = await this.readFile(filePath, encoding);
+    const permissions = this.convertPermissions(metadata.permissions);
+    const header = {
+      udrsReference,
+      encoding,
+      permissions,
+      newlineType
+    };
+    return {
+      header,
+      content
+    };
+  }
+  /**
+   * 批量序列化文件
+   */
+  async serializeFiles(files) {
+    const resources = [];
+    for (const file of files) {
+      const resource = await this.serializeFile(file.filePath, file.metadata, file.udrsReference);
+      resources.push(resource);
+    }
+    return resources;
+  }
+};
+
+// src/commands/pack.ts
+var PackCommand = class {
+  /**
+   * 执行 pack 命令
+   */
+  async execute(inputPath, options = {}) {
+    const startTime = Date.now();
+    try {
+      const resolvedPath = path2.resolve(inputPath);
+      await this.validatePath(resolvedPath);
+      const outputPath = options.output || this.generateOutputPath(resolvedPath);
+      const scanResult = await this.scanFiles(resolvedPath, options);
+      const urpfDocument = await this.generateURPFDocument(scanResult, resolvedPath);
+      const urpfResult = await this.saveURPFDocument(urpfDocument, outputPath, options);
+      const duration = Date.now() - startTime;
+      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 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}`);
+    }
+  }
+  /**
+   * 生成输出路径
+   */
+  generateOutputPath(inputPath) {
+    return `${inputPath}.urpf`;
+  }
+  /**
+   * 扫描文件
+   */
+  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
+        }
+      };
+    }
+    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 {
+        }
+      }
+    }
+    const effectiveMaxDepth = options.noRecurse ? 1 : options.maxDepth;
+    return await FileScanner.scanDirectory(rootPath, {
+      ignoreRules,
+      followSymlinks: options.followSymlinks || false,
+      maxDepth: effectiveMaxDepth
+      // undefined 或 1
+    });
+  }
+  /**
+   * 收集文件元数据
+   */
+  async collectFileMetadata(filePath) {
+    const stats = await fs3.stat(filePath);
+    return {
+      path: filePath,
+      name: path2.basename(filePath),
+      size: stats.size,
+      permissions: stats.mode,
+      mtime: stats.mtime,
+      encoding: "utf-8",
+      newlineType: "lf"
+    };
+  }
+  /**
+  * 生成 URPF 文档
+  */
+  async generateURPFDocument(scanResult, rootPath) {
+    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;
+      return {
+        filePath,
+        metadata: file,
+        udrsReference: `file://${relativePath}`
+      };
+    });
+    const resources = await serializer.serializeFiles(files);
+    return {
+      boundaryToken: "",
+      // 将由生成器自动生成
+      properties: [],
+      resources
+    };
+  }
+  /**
+  * 保存 URPF 文件
+  */
+  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 });
+    try {
+      await fs3.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`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await fs3.writeFile(outputPath, result.content, "utf-8");
+    return result;
+  }
+  /**
+   * 输出详细日志
+   */
+  logVerbose(scanResult, urpfResult, outputPath, duration) {
+    console.log("URPF \u6253\u5305\u5B8C\u6210:");
+    console.log(`  \u8F93\u51FA\u6587\u4EF6: ${outputPath}`);
+    console.log(`  \u6587\u4EF6\u6570\u91CF: ${scanResult.files.length}`);
+    console.log(`  \u76EE\u5F55\u6570\u91CF: ${scanResult.directories.length}`);
+    console.log(`  \u8DF3\u8FC7\u6587\u4EF6: ${scanResult.skippedFiles.length}`);
+    console.log(`  URPF \u5927\u5C0F: ${urpfResult.size} \u5B57\u8282`);
+    console.log(`  \u8D44\u6E90\u6570\u91CF: ${urpfResult.resourceCount}`);
+    console.log(`  \u6267\u884C\u8017\u65F6: ${duration}ms`);
+  }
+};
+
+// src/commands/unpack.ts
+import path3 from "path";
+import fs4 from "fs/promises";
+
+// src/core/parser/types.ts
+var URPFParseError = class extends Error {
+  constructor(message, line, column) {
+    super(message);
+    this.line = line;
+    this.column = column;
+    this.name = "URPFParseError";
+  }
+};
+
+// src/core/parser/boundary-parser.ts
+var BoundaryParser = class _BoundaryParser {
+  static {
+    /** 边界前缀 */
+    this.BOUNDARY_PREFIX = "--URPF-BOUNDARY-";
+  }
+  static {
+    /** 边界后缀 */
+    this.BOUNDARY_SUFFIX = "--";
+  }
+  static {
+    /** 边界令牌正则表达式（8位十六进制） */
+    this.TOKEN_REGEX = /^[0-9a-fA-F]{8}$/;
+  }
+  static {
+    /** 完整边界正则表达式 */
+    this.BOUNDARY_REGEX = /^--URPF-BOUNDARY-([0-9a-fA-F]{8})--$/;
+  }
+  /**
+   * 验证边界令牌格式
+   * @param token 边界令牌
+   * @returns 是否有效
+   */
+  static isValidToken(token) {
+    return _BoundaryParser.TOKEN_REGEX.test(token);
+  }
+  /**
+   * 提取边界令牌
+   * @param line 边界行
+   * @returns 边界令牌，如果无效则返回 null
+   */
+  static extractToken(line) {
+    const match = line.match(_BoundaryParser.BOUNDARY_REGEX);
+    return match ? match[1].toLowerCase() : null;
+  }
+  /**
+   * 判断是否为边界行
+   * @param line 文本行
+   * @returns 是否为边界行
+   */
+  static isBoundaryLine(line) {
+    return _BoundaryParser.BOUNDARY_REGEX.test(line);
+  }
+  /**
+   * 生成边界行
+   * @param token 边界令牌
+   * @param type 边界类型
+   * @returns 边界行字符串
+   */
+  static generateBoundaryLine(token, type) {
+    return `${_BoundaryParser.BOUNDARY_PREFIX}${token}${_BoundaryParser.BOUNDARY_SUFFIX}`;
+  }
+  /**
+   * 生成随机边界令牌
+   * @returns 随机边界令牌
+   */
+  static generateRandomToken() {
+    let token = "";
+    const hexChars = "0123456789abcdef";
+    for (let i = 0; i < 8; i++) {
+      token += hexChars[Math.floor(Math.random() * 16)];
+    }
+    return token;
+  }
+  /**
+   * 查找所有边界行
+   * @param content 内容字符串
+   * @returns 边界匹配结果列表
+   */
+  static findBoundaries(content) {
+    const lines = content.split("\n");
+    const boundaries = [];
+    lines.forEach((line, index) => {
+      if (_BoundaryParser.isBoundaryLine(line)) {
+        const token = _BoundaryParser.extractToken(line);
+        if (token) {
+          const lineNumber = index + 1;
+          let type;
+          if (index === 0) {
+            type = "start" /* START */;
+          } else if (index === lines.length - 1) {
+            type = "end" /* END */;
+          } else {
+            type = "delimiter" /* DELIMITER */;
+          }
+          boundaries.push({ type, token, line: lineNumber });
+        }
+      }
+    });
+    return boundaries;
+  }
+  /**
+   * 验证边界一致性
+   * @param boundaries 边界列表
+   * @throws {URPFParseError} 如果边界不一致
+   */
+  static validateBoundaries(boundaries) {
+    if (boundaries.length < 2) {
+      throw new URPFParseError(
+        "URPF \u6587\u6863\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u5F00\u59CB\u8FB9\u754C\u548C\u7ED3\u675F\u8FB9\u754C"
+      );
+    }
+    if (boundaries[0].type !== "start" /* START */) {
+      throw new URPFParseError(
+        `\u7B2C ${boundaries[0].line} \u884C: \u6587\u6863\u5FC5\u987B\u4EE5\u5F00\u59CB\u8FB9\u754C\u5F00\u5934`,
+        boundaries[0].line
+      );
+    }
+    if (boundaries[boundaries.length - 1].type !== "end" /* END */) {
+      throw new URPFParseError(
+        `\u7B2C ${boundaries[boundaries.length - 1].line} \u884C: \u6587\u6863\u5FC5\u987B\u4EE5\u7ED3\u675F\u8FB9\u754C\u7ED3\u5C3E`,
+        boundaries[boundaries.length - 1].line
+      );
+    }
+    const token = boundaries[0].token;
+    for (let i = 1; i < boundaries.length; i++) {
+      if (boundaries[i].token !== token) {
+        throw new URPFParseError(
+          `\u7B2C ${boundaries[i].line} \u884C: \u8FB9\u754C\u4EE4\u724C\u4E0D\u4E00\u81F4\uFF0C\u671F\u671B "${token}"\uFF0C\u5B9E\u9645 "${boundaries[i].token}"`,
+          boundaries[i].line
+        );
+      }
+    }
+  }
+  /**
+   * 根据边界分割内容
+   * @param content 内容字符串
+   * @param boundaries 边界列表
+   * @returns 分割后的内容段列表
+   */
+  static splitByBoundaries(content, boundaries) {
+    const lines = content.split("\n");
+    const sections = [];
+    for (let i = 0; i < boundaries.length - 1; i++) {
+      const startLine = boundaries[i].line - 1;
+      const endLine = boundaries[i + 1].line - 1;
+      if (endLine > startLine + 1) {
+        const sectionLines = lines.slice(startLine + 1, endLine);
+        sections.push(sectionLines.join("\n"));
+      } else {
+        sections.push("");
+      }
+    }
+    return sections;
+  }
+};
+
+// src/core/parser/property-parser.ts
+var PropertyParser = class _PropertyParser {
+  static {
+    /** 简单变量名正则表达式（$name） */
+    this.SIMPLE_NAME_REGEX = /^\$([a-zA-Z0-9_]+)$/;
+  }
+  static {
+    /** 带空格变量名正则表达式（${full name}） */
+    this.EXTENDED_NAME_REGEX = /^\$\{([a-zA-Z0-9_ ]+)\}$/;
+  }
+  static {
+    /** 属性行正则表达式 */
+    this.PROPERTY_LINE_REGEX = /^(.+?)=(.*)$/;
+  }
+  /**
+   * 解析属性行
+   * @param line 属性行
+   * @param lineNo 行号
+   * @returns 属性项
+   * @throws {URPFParseError} 如果格式无效
+   */
+  static parsePropertyLine(line, lineNo) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      throw new URPFParseError(`\u7B2C ${lineNo} \u884C: \u7A7A\u884C\u6216\u6CE8\u91CA`, lineNo);
+    }
+    const match = trimmedLine.match(_PropertyParser.PROPERTY_LINE_REGEX);
+    if (!match) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684\u5C5E\u6027\u884C\u683C\u5F0F\uFF0C\u5E94\u4E3A "name=value"`,
+        lineNo
+      );
+    }
+    const namePart = match[1].trim();
+    const valuePart = match[2];
+    const simpleMatch = namePart.match(_PropertyParser.SIMPLE_NAME_REGEX);
+    const extendedMatch = namePart.match(_PropertyParser.EXTENDED_NAME_REGEX);
+    let name;
+    let isExtended = false;
+    if (simpleMatch) {
+      name = simpleMatch[1];
+      isExtended = false;
+    } else if (extendedMatch) {
+      name = extendedMatch[1];
+      isExtended = true;
+    } else {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684\u53D8\u91CF\u540D\u683C\u5F0F\uFF0C\u5E94\u4E3A "$name" \u6216 "\${name with space}"`,
+        lineNo
+      );
+    }
+    return {
+      name,
+      value: valuePart,
+      isExtended
+    };
+  }
+  /**
+   * 解析属性部分
+   * @param content 属性部分内容
+   * @param startLineNo 起始行号
+   * @returns 属性部分
+   * @throws {URPFParseError} 如果解析失败
+   */
+  static parsePropertySection(content, startLineNo = 1) {
+    const lines = content.split("\n");
+    const properties = [];
+    const nameSet = /* @__PURE__ */ new Set();
+    lines.forEach((line, index) => {
+      const lineNo = startLineNo + index;
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith("#")) {
+        return;
+      }
+      const property = _PropertyParser.parsePropertyLine(line, lineNo);
+      if (nameSet.has(property.name)) {
+        throw new URPFParseError(
+          `\u7B2C ${lineNo} \u884C: \u53D8\u91CF\u540D "${property.name}" \u91CD\u590D\u5B9A\u4E49`,
+          lineNo
+        );
+      }
+      nameSet.add(property.name);
+      properties.push(property);
+    });
+    return { properties };
+  }
+  /**
+   * 检查内容是否为属性部分
+   * @param content 内容
+   * @returns 是否为属性部分
+   */
+  static isPropertySection(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith("#")) {
+        continue;
+      }
+      return trimmedLine.startsWith("$") || trimmedLine.startsWith("${");
+    }
+    return false;
+  }
+  /**
+   * 生成属性行
+   * @param name 变量名
+   * @param value 变量值
+   * @param isExtended 是否为带空格格式
+   * @returns 属性行字符串
+   */
+  static generatePropertyLine(name, value, isExtended = false) {
+    const namePart = isExtended ? `\${${name}}` : `$${name}`;
+    return `${namePart}=${value}`;
+  }
+  /**
+   * 生成属性部分内容
+   * @param propertySection 属性部分
+   * @returns 属性部分内容字符串
+   */
+  static generatePropertySectionContent(propertySection) {
+    return propertySection.properties.map((p) => _PropertyParser.generatePropertyLine(p.name, p.value, p.isExtended)).join("\n");
+  }
+};
+
+// src/core/parser/resource-parser.ts
+var VALID_ENCODINGS = [
+  "utf-8",
+  "ascii",
+  "gbk",
+  "gb2312",
+  "iso-8859-1",
+  "binary"
+];
+var VALID_NEWLINES = ["lf", "cr", "crlf"];
+var ResourceParser = class _ResourceParser {
+  static {
+    /** 资源头部正则表达式 */
+    this.RESOURCE_HEADER_REGEX = /^@(\S+)\s+(\S+)\s+(\d{3})\s+(lf|cr|crlf)$/i;
+  }
+  /**
+   * 解析资源头部
+   * @param line 资源头部行
+   * @param lineNo 行号
+   * @returns 资源头部
+   * @throws {URPFParseError} 如果格式无效
+   */
+  static parseResourceHeader(line, lineNo) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith("@")) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u8D44\u6E90\u5934\u90E8\u5FC5\u987B\u4EE5 '@' \u5F00\u5934`,
+        lineNo
+      );
+    }
+    const match = trimmedLine.match(_ResourceParser.RESOURCE_HEADER_REGEX);
+    if (!match) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684\u8D44\u6E90\u5934\u90E8\u683C\u5F0F\uFF0C\u5E94\u4E3A "@<udrs-reference> <encoding> <permissions> <newline-type>"`,
+        lineNo
+      );
+    }
+    const udrsRefString = match[1];
+    const encoding = match[2].toLowerCase();
+    const permissions = match[3];
+    const newlineType = match[4].toLowerCase();
+    if (!VALID_ENCODINGS.includes(encoding)) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684\u7F16\u7801\u7C7B\u578B "${encoding}"\uFF0C\u6709\u6548\u503C\u4E3A: ${VALID_ENCODINGS.join(", ")}`,
+        lineNo
+      );
+    }
+    if (!VALID_NEWLINES.includes(newlineType)) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684\u6362\u884C\u7B26\u7C7B\u578B "${newlineType}"\uFF0C\u6709\u6548\u503C\u4E3A: ${VALID_NEWLINES.join(", ")}`,
+        lineNo
+      );
+    }
+    const udrsReference = _ResourceParser.parseUDRSReference(udrsRefString, lineNo);
+    return {
+      udrsReference,
+      encoding,
+      permissions,
+      newlineType
+    };
+  }
+  /**
+   * 解析 UDRS 引用
+   * @param udrsRefString UDRS 引用字符串
+   * @param lineNo 行号
+   * @returns UDRS 引用
+   * @throws {URPFParseError} 如果格式无效
+   */
+  static parseUDRSReference(udrsRefString, lineNo) {
+    const protocolMatch = udrsRefString.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/(.*)$/);
+    if (!protocolMatch) {
+      throw new URPFParseError(
+        `\u7B2C ${lineNo} \u884C: \u65E0\u6548\u7684 UDRS \u5F15\u7528\u683C\u5F0F "${udrsRefString}"\uFF0C\u5E94\u4E3A "<protocol>://<uri>[#<fragment>]"`,
+        lineNo
+      );
+    }
+    const protocol = protocolMatch[1].toLowerCase();
+    const uriAndFragment = protocolMatch[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
+    };
+  }
+  /**
+   * 解析资源内容
+   * @param content 资源内容字符串
+   * @param encoding 编码类型
+   * @param newlineType 换行符类型
+   * @returns 资源内容（Buffer 或 string）
+   */
+  static parseResourceContent(content, encoding, newlineType) {
+    if (encoding === "binary") {
+      return Buffer.from(content, "binary");
+    }
+    let normalizedContent = content;
+    switch (newlineType) {
+      case "lf":
+        break;
+      case "cr":
+        normalizedContent = content.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
+        break;
+      case "crlf":
+        normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\r\n");
+        break;
+    }
+    return normalizedContent;
+  }
+  /**
+   * 解析资源部分
+   * @param content 资源部分内容
+   * @param startLineNo 起始行号
+   * @returns 资源部分
+   * @throws {URPFParseError} 如果解析失败
+   */
+  static parseResourceSection(content, startLineNo = 1) {
+    const lines = content.split("\n");
+    if (lines.length === 0) {
+      throw new URPFParseError(
+        `\u7B2C ${startLineNo} \u884C: \u8D44\u6E90\u90E8\u5206\u4E0D\u80FD\u4E3A\u7A7A`,
+        startLineNo
+      );
+    }
+    const header = _ResourceParser.parseResourceHeader(lines[0], startLineNo);
+    const contentLines = lines.slice(1);
+    const contentString = contentLines.join("\n");
+    const parsedContent = _ResourceParser.parseResourceContent(
+      contentString,
+      header.encoding,
+      header.newlineType
+    );
+    return {
+      header,
+      content: parsedContent
+    };
+  }
+  /**
+   * 检查内容是否为资源部分
+   * @param content 内容
+   * @returns 是否为资源部分
+   */
+  static isResourceSection(content) {
+    const lines = content.split("\n");
+    if (lines.length === 0) {
+      return false;
+    }
+    return lines[0].trim().startsWith("@");
+  }
+  /**
+   * 生成资源头部行
+   * @param header 资源头部
+   * @returns 资源头部行字符串
+   */
+  static generateResourceHeaderLine(header) {
+    const udrsRefString = _ResourceParser.generateUDRSReferenceString(header.udrsReference);
+    return `@${udrsRefString} ${header.encoding} ${header.permissions} ${header.newlineType}`;
+  }
+  /**
+   * 生成 UDRS 引用字符串
+   * @param udrsReference UDRS 引用
+   * @returns UDRS 引用字符串
+   */
+  static generateUDRSReferenceString(udrsReference) {
+    let result = `${udrsReference.protocol}://${udrsReference.uri}`;
+    if (udrsReference.fragment) {
+      result += `#${udrsReference.fragment}`;
+    }
+    return result;
+  }
+  /**
+   * 生成资源部分内容
+   * @param resourceSection 资源部分
+   * @returns 资源部分内容字符串
+   */
+  static generateResourceSectionContent(resourceSection) {
+    const headerLine = _ResourceParser.generateResourceHeaderLine(resourceSection.header);
+    let content = "";
+    if (typeof resourceSection.content === "string") {
+      content = resourceSection.content;
+    } else {
+      content = resourceSection.content.toString("binary");
+    }
+    return `${headerLine}
+${content}`;
+  }
+};
+
+// src/core/parser/variable-replacer.ts
+var VariableReplacer = class _VariableReplacer {
+  static {
+    /** 变量引用正则表达式（${name} 或 ${full name}） */
+    this.VARIABLE_REF_REGEX = /\$\{([a-zA-Z0-9_ ]+)\}/g;
+  }
+  /**
+   * 创建变量上下文
+   * @param properties 属性列表
+   * @returns 变量上下文
+   */
+  static createContext(properties) {
+    const map = /* @__PURE__ */ new Map();
+    properties.forEach((p) => map.set(p.name, p.value));
+    return {
+      get(name) {
+        return map.get(name);
+      },
+      has(name) {
+        return map.has(name);
+      },
+      keys() {
+        return Array.from(map.keys());
+      }
+    };
+  }
+  /**
+   * 替换字符串中的变量引用
+   * @param input 输入字符串
+   * @param context 变量上下文
+   * @param lineNo 行号（用于错误报告）
+   * @returns 替换后的字符串
+   * @throws {URPFParseError} 如果变量未定义
+   */
+  static replace(input, context, lineNo) {
+    return input.replace(_VariableReplacer.VARIABLE_REF_REGEX, (match, name) => {
+      const trimmedName = name.trim();
+      if (!context.has(trimmedName)) {
+        const lineInfo = lineNo !== void 0 ? `\u7B2C ${lineNo} \u884C: ` : "";
+        throw new URPFParseError(
+          `${lineInfo}\u672A\u5B9A\u4E49\u7684\u53D8\u91CF: "${trimmedName}"`,
+          lineNo
+        );
+      }
+      const value = context.get(trimmedName);
+      return value || "";
+    });
+  }
+  /**
+   * 检查字符串中是否包含变量引用
+   * @param input 输入字符串
+   * @returns 是否包含变量引用
+   */
+  static hasVariableReferences(input) {
+    return _VariableReplacer.VARIABLE_REF_REGEX.test(input);
+  }
+  /**
+   * 提取字符串中的所有变量名
+   * @param input 输入字符串
+   * @returns 变量名列表
+   */
+  static extractVariableNames(input) {
+    const names = [];
+    let match;
+    while ((match = _VariableReplacer.VARIABLE_REF_REGEX.exec(input)) !== null) {
+      names.push(match[1].trim());
+    }
+    return [...new Set(names)];
+  }
+  /**
+   * 验证所有变量引用是否已定义
+   * @param input 输入字符串
+   * @param context 变量上下文
+   * @param lineNo 行号（用于错误报告）
+   * @returns 是否所有变量都已定义
+   */
+  static validateVariables(input, context, lineNo) {
+    const names = _VariableReplacer.extractVariableNames(input);
+    for (const name of names) {
+      if (!context.has(name)) {
+        const lineInfo = lineNo !== void 0 ? `\u7B2C ${lineNo} \u884C: ` : "";
+        throw new URPFParseError(
+          `${lineInfo}\u672A\u5B9A\u4E49\u7684\u53D8\u91CF: "${name}"`,
+          lineNo
+        );
+      }
+    }
+    return true;
+  }
+};
+
+// src/core/parser/urpf-parser.ts
+var URPFParser = class _URPFParser {
+  /**
+   * 解析 URPF 文档
+   * @param content URPF 文档内容
+   * @param options 解析选项
+   * @returns 解析结果
+   * @throws {URPFParseError} 如果解析失败
+   */
+  static parse(content, options = {}) {
+    const warnings = [];
+    const strict = options.strict !== false;
+    try {
+      const boundaries = BoundaryParser.findBoundaries(content);
+      if (strict) {
+        BoundaryParser.validateBoundaries(boundaries);
+      } else {
+        try {
+          BoundaryParser.validateBoundaries(boundaries);
+        } catch (error) {
+          if (error instanceof URPFParseError) {
+            warnings.push(error.message);
+          }
+        }
+      }
+      if (boundaries.length < 2) {
+        throw new URPFParseError("URPF \u6587\u6863\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u5F00\u59CB\u8FB9\u754C\u548C\u7ED3\u675F\u8FB9\u754C");
+      }
+      const boundaryToken = boundaries[0].token;
+      const sections = BoundaryParser.splitByBoundaries(content, boundaries);
+      if (sections.length === 0) {
+        throw new URPFParseError("URPF \u6587\u6863\u4E0D\u5305\u542B\u4EFB\u4F55\u90E8\u5206");
+      }
+      const document = {
+        boundaryToken,
+        resourceSections: []
+      };
+      let startSectionIndex = 0;
+      if (sections.length > 0 && PropertyParser.isPropertySection(sections[0])) {
+        try {
+          document.propertySection = PropertyParser.parsePropertySection(sections[0], boundaries[0].line + 1);
+          const variableContext = VariableReplacer.createContext(document.propertySection.properties);
+          for (let i = 1; i < sections.length; i++) {
+            try {
+              const resourceSection = ResourceParser.parseResourceSection(sections[i], boundaries[i].line + 1);
+              const udrsRefString = ResourceParser.generateUDRSReferenceString(resourceSection.header.udrsReference);
+              const replacedRefString = VariableReplacer.replace(udrsRefString, variableContext);
+              resourceSection.header.udrsReference = ResourceParser.parseUDRSReference(replacedRefString, boundaries[i].line + 1);
+              document.resourceSections.push(resourceSection);
+            } catch (error) {
+              if (strict) {
+                throw error;
+              } else if (error instanceof Error) {
+                warnings.push(`\u7B2C ${boundaries[i].line + 1} \u884C: ${error.message}`);
+              }
+            }
+          }
+          startSectionIndex = 1;
+        } catch (error) {
+          if (strict) {
+            throw error;
+          } else if (error instanceof Error) {
+            warnings.push(`\u7B2C ${boundaries[0].line + 1} \u884C: ${error.message}`);
+          }
+        }
+      }
+      if (startSectionIndex === 0) {
+        for (let i = startSectionIndex; i < sections.length; i++) {
+          try {
+            const resourceSection = ResourceParser.parseResourceSection(sections[i], boundaries[i].line + 1);
+            document.resourceSections.push(resourceSection);
+          } catch (error) {
+            if (strict) {
+              throw error;
+            } else if (error instanceof Error) {
+              warnings.push(`\u7B2C ${boundaries[i].line + 1} \u884C: ${error.message}`);
+            }
+          }
+        }
+      }
+      if (document.resourceSections.length === 0) {
+        warnings.push("URPF \u6587\u6863\u4E0D\u5305\u542B\u4EFB\u4F55\u8D44\u6E90\u90E8\u5206");
+      }
+      return {
+        document,
+        warnings
+      };
+    } catch (error) {
+      if (error instanceof URPFParseError) {
+        throw error;
+      }
+      throw new URPFParseError(`\u89E3\u6790\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * 解析 URPF 文档（从文件）
+   * @param filePath 文件路径
+   * @param options 解析选项
+   * @returns 解析结果
+   * @throws {URPFParseError} 如果解析失败
+   */
+  static async parseFile(filePath, options = {}) {
+    const fs7 = await import("fs/promises");
+    const content = await fs7.readFile(filePath, "utf-8");
+    return _URPFParser.parse(content, options);
+  }
+  /**
+   * 生成 URPF 文档
+   * @param document URPF 文档
+   * @returns URPF 文档字符串
+   */
+  static generate(document) {
+    const lines = [];
+    lines.push(BoundaryParser.generateBoundaryLine(document.boundaryToken, "start" /* START */));
+    if (document.propertySection) {
+      lines.push(PropertyParser.generatePropertySectionContent(document.propertySection));
+      lines.push(BoundaryParser.generateBoundaryLine(document.boundaryToken, "delimiter" /* DELIMITER */));
+    }
+    document.resourceSections.forEach((resourceSection, index) => {
+      lines.push(ResourceParser.generateResourceSectionContent(resourceSection));
+      if (index < document.resourceSections.length - 1) {
+        lines.push(BoundaryParser.generateBoundaryLine(document.boundaryToken, "delimiter" /* DELIMITER */));
+      }
+    });
+    lines.push(BoundaryParser.generateBoundaryLine(document.boundaryToken, "end" /* END */));
+    return lines.join("\n");
+  }
+  /**
+   * 验证 URPF 文档
+   * @param document URPF 文档
+   * @returns 验证结果
+   */
+  static validate(document) {
+    const errors = [];
+    if (!BoundaryParser.isValidToken(document.boundaryToken)) {
+      errors.push(`\u65E0\u6548\u7684\u8FB9\u754C\u4EE4\u724C: ${document.boundaryToken}`);
+    }
+    if (document.propertySection) {
+      const propertyNames = /* @__PURE__ */ new Set();
+      for (const property of document.propertySection.properties) {
+        if (propertyNames.has(property.name)) {
+          errors.push(`\u91CD\u590D\u7684\u53D8\u91CF\u540D: ${property.name}`);
+        }
+        propertyNames.add(property.name);
+      }
+    }
+    if (document.resourceSections.length === 0) {
+      errors.push("URPF \u6587\u6863\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u4E00\u4E2A\u8D44\u6E90\u90E8\u5206");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/commands/unpack.ts
+var UnpackCommand = class {
+  /**
+   * 执行 unpack 命令
+   */
+  async execute(urpfFilePath, options = {}) {
+    const startTime = Date.now();
+    try {
+      const resolvedPath = path3.resolve(urpfFilePath);
+      await this.validateURPFFile(resolvedPath);
+      const outputDir = options.output ? path3.resolve(options.output) : process.cwd();
+      await fs4.mkdir(outputDir, { recursive: true });
+      const parseResult = await URPFParser.parseFile(resolvedPath);
+      const results = [];
+      let totalBytes = 0;
+      for (const resource of parseResult.document.resourceSections) {
+        const result = await this.extractResource(
+          resource,
+          outputDir,
+          options
+        );
+        if (result.success && result.action !== "skipped") {
+          totalBytes += this.getFileSize(resource);
+        }
+        results.push(result);
+      }
+      const duration = Date.now() - startTime;
+      const createdCount = results.filter((r) => r.action === "created").length;
+      const overwrittenCount = results.filter((r) => r.action === "overwritten").length;
+      const skippedCount = results.filter((r) => r.action === "skipped").length;
+      const failedCount = results.filter((r) => r.action === "error").length;
+      if (options.verbose) {
+        this.logVerbose(results, outputDir, duration);
+      }
+      return {
+        success: failedCount === 0,
+        outputDir,
+        files: results,
+        createdCount,
+        overwrittenCount,
+        skippedCount,
+        failedCount,
+        totalBytes,
+        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,
+        outputDir: options.output ? path3.resolve(options.output) : process.cwd(),
+        files: [],
+        createdCount: 0,
+        overwrittenCount: 0,
+        skippedCount: 0,
+        failedCount: 0,
+        totalBytes: 0,
+        duration,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 验证 URPF 文件
+   */
+  async validateURPFFile(filePath) {
+    try {
+      const stats = await fs4.stat(filePath);
+      if (!stats.isFile()) {
+        throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${filePath}`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 提取资源到文件系统
+   */
+  async extractResource(resource, outputDir, options) {
+    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 fileExists = await this.fileExists(fullPath);
+      if (fileExists) {
+        if (options.force) {
+          await this.writeFile(resource, fullPath, options);
+          return {
+            path: filePath,
+            success: true,
+            action: "overwritten"
+          };
+        } else if (options.forceWhenNewer) {
+          const sourceMtime = this.extractMtime(resource);
+          const targetMtime = await this.getFileMtime(fullPath);
+          if (sourceMtime > targetMtime) {
+            await this.writeFile(resource, fullPath, options);
+            return {
+              path: filePath,
+              success: true,
+              action: "overwritten"
+            };
+          } else {
+            if (options.verbose) {
+              console.log(`\u8DF3\u8FC7\uFF08\u76EE\u6807\u6587\u4EF6\u66F4\u65B0\uFF09: ${filePath}`);
+            }
+            return {
+              path: filePath,
+              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`);
+        }
+      } else {
+        await this.writeFile(resource, fullPath, options);
+        return {
+          path: filePath,
+          success: true,
+          action: "created"
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        path: this.extractFilePath(resource.header.udrsReference.uri),
+        success: false,
+        action: "error",
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 从 UDRS 引用中提取文件路径
+   */
+  extractFilePath(uri) {
+    let filePath = uri.replace(/^file:\/\//, "");
+    if (filePath.startsWith("/")) {
+      filePath = filePath.substring(1);
+    }
+    if (/^[A-Za-z]:/.test(filePath)) {
+      filePath = filePath;
+    }
+    return filePath;
+  }
+  /**
+   * 检查文件是否存在
+   */
+  async fileExists(filePath) {
+    try {
+      await fs4.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 获取文件修改时间
+   */
+  async getFileMtime(filePath) {
+    const stats = await fs4.stat(filePath);
+    return stats.mtime;
+  }
+  /**
+   * 从资源中提取修改时间
+   * 注意：URPF 规范中不直接存储 mtime，这里我们使用一个合理的时间戳
+   * 在实际应用中，可能需要从 URPF 文件的属性部分读取
+   */
+  extractMtime(resource) {
+    return new Date(Date.now() - 36e5);
+  }
+  /**
+   * 获取文件大小
+   */
+  getFileSize(resource) {
+    if (Buffer.isBuffer(resource.content)) {
+      return resource.content.length;
+    }
+    return Buffer.byteLength(resource.content, "utf-8");
+  }
+  /**
+   * 写入文件
+   */
+  async writeFile(resource, filePath, options) {
+    let content;
+    if (Buffer.isBuffer(resource.content)) {
+      content = resource.content;
+    } else {
+      content = resource.content;
+    }
+    if (Buffer.isBuffer(content)) {
+      await fs4.writeFile(filePath, content);
+    } else {
+      await fs4.writeFile(filePath, content, {
+        encoding: resource.header.encoding
+      });
+    }
+    if (resource.header.permissions) {
+      const permissions = parseInt(resource.header.permissions, 8);
+      await fs4.chmod(filePath, permissions);
+    }
+    if (options.preserveMtime) {
+      const mtime = this.extractMtime(resource);
+      await fs4.utimes(filePath, mtime, mtime);
+    }
+    if (options.verbose) {
+      console.log(`\u5DF2${await this.fileExists(filePath) ? "\u8986\u76D6" : "\u521B\u5EFA"}: ${filePath}`);
+    }
+  }
+  /**
+   * 输出详细日志
+   */
+  logVerbose(results, outputDir, duration) {
+    console.log("URPF \u89E3\u5305\u5B8C\u6210:");
+    console.log(`  \u8F93\u51FA\u76EE\u5F55: ${outputDir}`);
+    console.log(`  \u6587\u4EF6\u603B\u6570: ${results.length}`);
+    const createdCount = results.filter((r) => r.action === "created").length;
+    const overwrittenCount = results.filter((r) => r.action === "overwritten").length;
+    const skippedCount = results.filter((r) => r.action === "skipped").length;
+    const failedCount = results.filter((r) => r.action === "error").length;
+    console.log(`  \u521B\u5EFA: ${createdCount}`);
+    console.log(`  \u8986\u76D6: ${overwrittenCount}`);
+    console.log(`  \u8DF3\u8FC7: ${skippedCount}`);
+    console.log(`  \u5931\u8D25: ${failedCount}`);
+    console.log(`  \u6267\u884C\u8017\u65F6: ${duration}ms`);
+    if (failedCount > 0) {
+      console.log("\n\u5931\u8D25\u7684\u6587\u4EF6:");
+      for (const result of results) {
+        if (result.action === "error") {
+          console.log(`  - ${result.path}: ${result.error}`);
+        }
+      }
+    }
+  }
+};
+
+// src/commands/pack-add.ts
+import path4 from "path";
+import fs5 from "fs/promises";
+var PackAddCommand = class {
+  /**
+   * 执行 pack-add 命令
+   */
+  async execute(urpfFilePath, targetPath, options = {}) {
+    const startTime = Date.now();
+    try {
+      const resolvedUrpfPath = path4.resolve(urpfFilePath);
+      await this.validatePath(resolvedUrpfPath);
+      const resolvedTargetPath = path4.resolve(targetPath);
+      await this.validatePath(resolvedTargetPath);
+      const urpfContent = await fs5.readFile(resolvedUrpfPath, "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 scanResult = await this.scanFiles(resolvedTargetPath, options, variableContext);
+      if (scanResult.files.length === 0) {
+        return {
+          success: true,
+          urpfFilePath: resolvedUrpfPath,
+          addedCount: 0,
+          skippedCount: scanResult.skippedFiles.length,
+          totalBytes: 0,
+          duration: Date.now() - startTime
+        };
+      }
+      const serializer = new ResourceSerializer();
+      const filesToAdd = scanResult.files.map((file) => {
+        const isAbsolutePath = path4.isAbsolute(file.path);
+        const filePath = isAbsolutePath ? file.path : path4.join(resolvedTargetPath, file.path);
+        const relativePath = isAbsolutePath ? path4.relative(resolvedTargetPath, file.path) : file.path;
+        return {
+          filePath,
+          metadata: file,
+          udrsReference: `file://${relativePath}`
+        };
+      });
+      const newResources = await serializer.serializeFiles(filesToAdd);
+      const generatorDoc = {
+        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
+        }))
+      };
+      generatorDoc.resources = [...generatorDoc.resources, ...newResources];
+      const generator = new URPFGenerator({
+        boundaryToken: generatorDoc.boundaryToken,
+        includeBoundaries: true
+      });
+      const result = await generator.generate(generatorDoc);
+      await fs5.writeFile(resolvedUrpfPath, result.content, "utf-8");
+      const duration = Date.now() - startTime;
+      if (options.verbose) {
+        console.log(`Successfully added ${newResources.length} files to URPF package: ${resolvedUrpfPath}`);
+        console.log(`  Added files: ${newResources.length}`);
+        console.log(`  Skipped files: ${scanResult.skippedFiles.length}`);
+        console.log(`  Total bytes: ${scanResult.files.reduce((sum, f) => sum + f.size, 0)}`);
+        console.log(`  Duration: ${duration}ms`);
+      }
+      return {
+        success: true,
+        urpfFilePath: resolvedUrpfPath,
+        addedCount: newResources.length,
+        skippedCount: scanResult.skippedFiles.length,
+        totalBytes: scanResult.files.reduce((sum, f) => sum + f.size, 0),
+        duration
+      };
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (options.verbose) {
+        console.error(`Error: ${errorMessage}`);
+      }
+      return {
+        success: false,
+        urpfFilePath: path4.resolve(urpfFilePath),
+        addedCount: 0,
+        skippedCount: 0,
+        totalBytes: 0,
+        duration,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 验证路径
+   */
+  async validatePath(filePath) {
+    try {
+      const stats = await fs5.stat(filePath);
+      if (!stats.isFile() && !stats.isDirectory()) {
+        throw new Error(`Path is not a file or directory: ${filePath}`);
+      }
+    } catch {
+      throw new Error(`Cannot access path: ${filePath}`);
+    }
+  }
+  /**
+   * 扫描文件
+   */
+  async scanFiles(rootPath, options, variableContext) {
+    const stats = await fs5.stat(rootPath);
+    if (stats.isFile()) {
+      const metadata = await this.collectFileMetadata(rootPath);
+      return {
+        files: [metadata],
+        directories: [],
+        skippedFiles: [],
+        statistics: {
+          totalFiles: 1,
+          totalDirectories: 0,
+          skippedFiles: 0
+        }
+      };
+    }
+    let ignoreRules = [];
+    if (options.ignoreFile) {
+      const parser = new IgnoreRuleParser();
+      const content = await fs5.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);
+        try {
+          await fs5.access(ignorePath);
+          const parser = new IgnoreRuleParser();
+          const content = await fs5.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
+    });
+  }
+  /**
+   * 收集文件元数据
+   */
+  async collectFileMetadata(filePath) {
+    const stats = await fs5.stat(filePath);
+    return {
+      path: filePath,
+      name: path4.basename(filePath),
+      size: stats.size,
+      permissions: stats.mode,
+      mtime: stats.mtime,
+      encoding: "utf-8",
+      newlineType: "lf"
+    };
+  }
+};
+
+// src/commands/pack-remove.ts
+import path5 from "path";
+import fs6 from "fs/promises";
+var PackRemoveCommand = class {
+  /**
+   * 执行 pack-remove 命令
+   */
+  async execute(urpfFilePath, filenamePattern, options = {}) {
+    const startTime = Date.now();
+    try {
+      const resolvedUrpfPath = path5.resolve(urpfFilePath);
+      await this.validateUrpfFile(resolvedUrpfPath);
+      const urpfContent = await fs6.readFile(resolvedUrpfPath, "utf-8");
+      const parseResult = URPFParser.parse(urpfContent, { strict: false });
+      const document = parseResult.document;
+      const variableContext = document.propertySection ? VariableReplacer.createContext(document.propertySection.properties) : void 0;
+      let processedPattern = filenamePattern;
+      if (options.applyVariables !== false && variableContext) {
+        try {
+          processedPattern = VariableReplacer.replace(filenamePattern, variableContext);
+          if (options.verbose) {
+            console.log(`Variable replacement: ${filenamePattern} -> ${processedPattern}`);
+          }
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(`Variable replacement failed: ${error.message}`);
+          }
+          throw error;
+        }
+      }
+      const generatorDoc = {
+        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
+        }))
+      };
+      const { removedResources, notFoundCount } = this.removeResources(generatorDoc, processedPattern);
+      if (removedResources.length === 0) {
+        return {
+          success: true,
+          urpfFilePath: resolvedUrpfPath,
+          removedCount: 0,
+          notFoundCount,
+          duration: Date.now() - startTime
+        };
+      }
+      const generator = new URPFGenerator({
+        boundaryToken: generatorDoc.boundaryToken,
+        includeBoundaries: true
+      });
+      const result = await generator.generate(generatorDoc);
+      await fs6.writeFile(resolvedUrpfPath, result.content, "utf-8");
+      const duration = Date.now() - startTime;
+      if (options.verbose) {
+        console.log(`Successfully removed ${removedResources.length} files: ${resolvedUrpfPath}`);
+        console.log(`  Removed files:`);
+        removedResources.forEach((resource) => {
+          console.log(`    - ${resource.header.udrsReference}`);
+        });
+        console.log(`  Not found count: ${notFoundCount}`);
+        console.log(`  Duration: ${duration}ms`);
+      }
+      return {
+        success: true,
+        urpfFilePath: resolvedUrpfPath,
+        removedCount: removedResources.length,
+        notFoundCount,
+        duration
+      };
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (options.verbose) {
+        console.error(`Error: ${errorMessage}`);
+      }
+      return {
+        success: false,
+        urpfFilePath: path5.resolve(urpfFilePath),
+        removedCount: 0,
+        notFoundCount: 0,
+        duration,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 验证 URPF 文件
+   */
+  async validateUrpfFile(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      if (!stats.isFile()) {
+        throw new Error(`Path is not a file: ${filePath}`);
+      }
+    } catch {
+      throw new Error(`Cannot access URPF file: ${filePath}`);
+    }
+  }
+  /**
+   * 从文档中移除匹配的资源
+   */
+  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;
+      if (this.matchResource(udrsRefString, normalizedPatternWithSlash)) {
+        removedResources.push(resource);
+        document.resources.splice(i, 1);
+      }
+    }
+    if (removedResources.length === 0) {
+      notFoundCount = 1;
+    }
+    return { removedResources, notFoundCount };
+  }
+  /**
+   * 检查资源是否匹配模式
+   */
+  matchResource(udrsRefString, pattern) {
+    const match = udrsRefString.match(/^file:\/\/(.+)$/);
+    if (!match) {
+      return false;
+    }
+    const resourcePath = match[1];
+    const normalizedResourcePath = resourcePath.replace(/\\/g, "/");
+    if (normalizedResourcePath === pattern) {
+      return true;
+    }
+    const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(normalizedResourcePath);
+  }
+};
+
+// src/index.ts
+var program = new Command();
+program.name("urpfcli").description("URPF CLI \u5DE5\u5177 - \u57FA\u4E8E URPF \u89C4\u8303\u7684\u547D\u4EE4\u884C\u6253\u5305\u5DE5\u5177").version("0.1.0");
+program.command("pack").description("\u5C06\u6587\u4EF6\u6216\u76EE\u5F55\u6253\u5305\u6210 URPF \u683C\u5F0F").argument("<file|dir>", "\u8981\u6253\u5305\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84").option("-o, --output <path>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4\uFF1A\u8F93\u5165\u8DEF\u5F84.urpf\uFF09").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("-i, --ignore <path>", "\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84").option("-f, --follow-symlinks", "\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5").option("-d, --max-depth <number>", "\u6700\u5927\u626B\u63CF\u6DF1\u5EA6\uFF080 \u8868\u793A\u65E0\u9650\u5236\uFF09").option("--no-recurse", "\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55").option("--force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u8F93\u51FA\u6587\u4EF6").action(async (file, options) => {
+  try {
+    const packCommand = new PackCommand();
+    const result = await packCommand.execute(file, options);
+    if (result.success) {
+      console.log(`\u2705 URPF \u6587\u4EF6\u5DF2\u751F\u6210: ${result.outputPath}`);
+      if (!options.verbose) {
+        console.log(`  \u6587\u4EF6\u6570\u91CF: ${result.fileCount}`);
+        console.log(`  \u76EE\u5F55\u6570\u91CF: ${result.directoryCount}`);
+        console.log(`  \u8DF3\u8FC7\u6587\u4EF6: ${result.skippedCount}`);
+        console.log(`  URPF \u5927\u5C0F: ${result.urpfSize} \u5B57\u8282`);
+        console.log(`  \u6267\u884C\u8017\u65F6: ${result.duration}ms`);
+      }
+    } else {
+      console.error(`\u274C \u6253\u5305\u5931\u8D25: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C \u9519\u8BEF: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.command("unpack").description("\u89E3\u5305 URPF \u6587\u4EF6\u5230\u6307\u5B9A\u76EE\u5F55").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").action(async (file, options) => {
+  try {
+    const unpackCommand = new UnpackCommand();
+    const result = await unpackCommand.execute(file, options);
+    if (result.success) {
+      console.log(`\u2705 URPF \u6587\u4EF6\u5DF2\u89E3\u5305\u5230: ${result.outputDir}`);
+      if (!options.verbose) {
+        console.log(`  \u521B\u5EFA: ${result.createdCount}`);
+        console.log(`  \u8986\u76D6: ${result.overwrittenCount}`);
+        console.log(`  \u8DF3\u8FC7: ${result.skippedCount}`);
+        console.log(`  \u603B\u5B57\u8282: ${result.totalBytes}`);
+        console.log(`  \u6267\u884C\u8017\u65F6: ${result.duration}ms`);
+      }
+    } else {
+      console.error(`\u274C \u89E3\u5305\u5931\u8D25: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C \u9519\u8BEF: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.command("pack-add").description("\u5411\u5DF2\u6709 URPF \u5305\u6DFB\u52A0\u6587\u4EF6\u6216\u76EE\u5F55").argument("<file.urpf>", "URPF \u6587\u4EF6\u8DEF\u5F84").argument("<file|dir>", "\u8981\u6DFB\u52A0\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("-i, --ignore <path>", "\u6307\u5B9A\u5FFD\u7565\u89C4\u5219\u6587\u4EF6\u8DEF\u5F84").option("-f, --follow-symlinks", "\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5").option("-d, --max-depth <number>", "\u6700\u5927\u626B\u63CF\u6DF1\u5EA6\uFF080 \u8868\u793A\u65E0\u9650\u5236\uFF09").option("--no-recurse", "\u4E0D\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55").action(async (urpfFile, target, options) => {
+  try {
+    const packAddCommand = new PackAddCommand();
+    const result = await packAddCommand.execute(urpfFile, target, options);
+    if (result.success) {
+      console.log(`\u2705 \u5DF2\u6210\u529F\u6DFB\u52A0\u6587\u4EF6\u5230 URPF \u5305: ${result.urpfFilePath}`);
+      if (!options.verbose) {
+        console.log(`  \u6DFB\u52A0\u6587\u4EF6: ${result.addedCount}`);
+        console.log(`  \u8DF3\u8FC7\u6587\u4EF6: ${result.skippedCount}`);
+        console.log(`  \u603B\u5B57\u8282: ${result.totalBytes}`);
+        console.log(`  \u6267\u884C\u8017\u65F6: ${result.duration}ms`);
+      }
+    } else {
+      console.error(`\u274C \u6DFB\u52A0\u5931\u8D25: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C \u9519\u8BEF: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.command("pack-remove").description("\u4ECE URPF \u5305\u4E2D\u79FB\u9664\u6587\u4EF6\uFF08\u652F\u6301\u53D8\u91CF\u66FF\u6362\uFF09").argument("<file.urpf>", "URPF \u6587\u4EF6\u8DEF\u5F84").argument("<filename>", "\u8981\u79FB\u9664\u7684\u6587\u4EF6\u540D\u6216\u6A21\u5F0F\uFF08\u652F\u6301\u901A\u914D\u7B26 * \u548C ?\uFF09").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("--no-apply-variables", "\u4E0D\u5E94\u7528\u53D8\u91CF\u66FF\u6362").action(async (urpfFile, filename, options) => {
+  try {
+    const packRemoveCommand = new PackRemoveCommand();
+    const result = await packRemoveCommand.execute(urpfFile, filename, options);
+    if (result.success) {
+      console.log(`\u2705 \u5DF2\u6210\u529F\u4ECE URPF \u5305\u79FB\u9664\u6587\u4EF6: ${result.urpfFilePath}`);
+      if (!options.verbose) {
+        console.log(`  \u79FB\u9664\u6587\u4EF6: ${result.removedCount}`);
+        console.log(`  \u672A\u627E\u5230: ${result.notFoundCount}`);
+        console.log(`  \u6267\u884C\u8017\u65F6: ${result.duration}ms`);
+      }
+    } else {
+      console.error(`\u274C \u79FB\u9664\u5931\u8D25: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C \u9519\u8BEF: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.parse();