@deepstorm/cli 0.10.2 → 0.11.0

package/dist/cli.js

@@ -1187,13 +1187,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path24) {
-          return /^\.|this\b/.test(path24.original);
+        scopedId: function scopedId(path26) {
+          return /^\.|this\b/.test(path26.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path24) {
-          return path24.parts.length === 1 && !AST.helpers.scopedId(path24) && !path24.depth;
+        simpleId: function simpleId(path26) {
+          return path26.parts.length === 1 && !AST.helpers.scopedId(path26) && !path26.depth;
         }
       }
     };
@@ -2263,12 +2263,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path24, params, hash, open, strip, locInfo) {
+    function prepareMustache(path26, params, hash, open, strip, locInfo) {
       var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
       var decorator = /\*/.test(open);
       return {
         type: decorator ? "Decorator" : "MustacheStatement",
-        path: path24,
+        path: path26,
         params,
         hash,
         escaped,
@@ -2586,9 +2586,9 @@ var require_compiler = __commonJS({
       },
       DecoratorBlock: function DecoratorBlock(decorator) {
         var program2 = decorator.program && this.compileProgram(decorator.program);
-        var params = this.setupFullMustacheParams(decorator, program2, void 0), path24 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program2, void 0), path26 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path24.original);
+        this.opcode("registerDecorator", params.length, path26.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -2652,46 +2652,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program2, inverse) {
-        var path24 = sexpr.path, name = path24.parts[0], isBlock = program2 != null || inverse != null;
-        this.opcode("getContext", path24.depth);
+        var path26 = sexpr.path, name = path26.parts[0], isBlock = program2 != null || inverse != null;
+        this.opcode("getContext", path26.depth);
         this.opcode("pushProgram", program2);
         this.opcode("pushProgram", inverse);
-        path24.strict = true;
-        this.accept(path24);
+        path26.strict = true;
+        this.accept(path26);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path24 = sexpr.path;
-        path24.strict = true;
-        this.accept(path24);
+        var path26 = sexpr.path;
+        path26.strict = true;
+        this.accept(path26);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program2, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path24 = sexpr.path, name = path24.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path26 = sexpr.path, name = path26.parts[0];
         if (this.options.knownHelpers[name]) {
           this.opcode("invokeKnownHelper", params.length, name);
         } else if (this.options.knownHelpersOnly) {
           throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
         } else {
-          path24.strict = true;
-          path24.falsy = true;
-          this.accept(path24);
-          this.opcode("invokeHelper", params.length, path24.original, _ast2["default"].helpers.simpleId(path24));
+          path26.strict = true;
+          path26.falsy = true;
+          this.accept(path26);
+          this.opcode("invokeHelper", params.length, path26.original, _ast2["default"].helpers.simpleId(path26));
         }
       },
-      PathExpression: function PathExpression(path24) {
-        this.addDepth(path24.depth);
-        this.opcode("getContext", path24.depth);
-        var name = path24.parts[0], scoped = _ast2["default"].helpers.scopedId(path24), blockParamId = !path24.depth && !scoped && this.blockParamIndex(name);
+      PathExpression: function PathExpression(path26) {
+        this.addDepth(path26.depth);
+        this.opcode("getContext", path26.depth);
+        var name = path26.parts[0], scoped = _ast2["default"].helpers.scopedId(path26), blockParamId = !path26.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path24.parts);
+          this.opcode("lookupBlockParam", blockParamId, path26.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path24.data) {
+        } else if (path26.data) {
           this.options.data = true;
-          this.opcode("lookupData", path24.depth, path24.parts, path24.strict);
+          this.opcode("lookupData", path26.depth, path26.parts, path26.strict);
         } else {
-          this.opcode("lookupOnContext", path24.parts, path24.falsy, path24.strict, scoped);
+          this.opcode("lookupOnContext", path26.parts, path26.falsy, path26.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3041,16 +3041,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path24 = aPath;
+      var path26 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path24 = url.path;
+        path26 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path24);
-      var parts = path24.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path26);
+      var parts = path26.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -3067,18 +3067,18 @@ var require_util = __commonJS({
           }
         }
       }
-      path24 = parts.join("/");
-      if (path24 === "") {
-        path24 = isAbsolute ? "/" : ".";
+      path26 = parts.join("/");
+      if (path26 === "") {
+        path26 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path24;
+        url.path = path26;
         return urlGenerate(url);
       }
-      return path24;
+      return path26;
     }
     exports2.normalize = normalize;
-    function join22(aRoot, aPath) {
+    function join24(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3110,7 +3110,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join22;
+    exports2.join = join24;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -3283,7 +3283,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join22(urlGenerate(parsed), sourceURL);
+        sourceURL = join24(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -5858,8 +5858,8 @@ var require_printer = __commonJS({
       return this.accept(sexpr.path) + " " + params + hash;
     };
     PrintVisitor.prototype.PathExpression = function(id) {
-      var path24 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path24;
+      var path26 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path26;
     };
     PrintVisitor.prototype.StringLiteral = function(string) {
       return '"' + string.value + '"';
@@ -5898,8 +5898,8 @@ var require_lib = __commonJS({
     handlebars.print = printer.print;
     module2.exports = handlebars;
     function extension(module3, filename) {
-      var fs28 = require("fs");
-      var templateString = fs28.readFileSync(filename, "utf8");
+      var fs30 = require("fs");
+      var templateString = fs30.readFileSync(filename, "utf8");
       module3.exports = handlebars.compile(templateString);
     }
     if (typeof require !== "undefined" && require.extensions) {
@@ -5911,8 +5911,8 @@ var require_lib = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var fs27 = __toESM(require("node:fs"));
-var path23 = __toESM(require("node:path"));
+var fs29 = __toESM(require("node:fs"));
+var path25 = __toESM(require("node:path"));
 
 // src/commands/setup.ts
 var path9 = __toESM(require("node:path"));
@@ -10507,13 +10507,380 @@ function registerPilotCommands(program2) {
   (0, import_pilot.registerPilotCommands)(program2);
 }
 
-// src/commands/doctor.ts
-var fs25 = __toESM(require("node:fs"));
+// src/record/browser-recorder.ts
+var path22 = __toESM(require("node:path"));
+var fs26 = __toESM(require("node:fs"));
+var import_playwright = require("playwright");
+
+// src/record/recorder.ts
 var path21 = __toESM(require("node:path"));
+var fs25 = __toESM(require("node:fs"));
+function filterNoiseEvents(events) {
+  const noiseTypes = [];
+  const noiseSet = new Set(noiseTypes);
+  return events.filter((e) => !noiseSet.has(e.type));
+}
+function eventGroupKey(e) {
+  const selector = e.data?.cssSelector || "";
+  return { cssSelector: selector, type: e.type };
+}
+function dedupEvents(events) {
+  if (events.length === 0) return [];
+  const result = [];
+  const inputElements = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const current = events[i];
+    if (current.type === "input" || current.type === "select") {
+      const key = eventGroupKey(current);
+      const dedupKey = `${key.cssSelector}|${key.type}`;
+      inputElements.set(dedupKey, current);
+      continue;
+    }
+    if (current.type === "click") {
+      const lastEvent = result.length > 0 ? result[result.length - 1] : null;
+      if (lastEvent && lastEvent.type === "click") {
+        const currentKey = eventGroupKey(current);
+        const lastKey = eventGroupKey(lastEvent);
+        const sameElement = currentKey.cssSelector === lastKey.cssSelector;
+        const withinThreshold = current.ts - lastEvent.ts <= 500;
+        if (sameElement && withinThreshold) {
+          continue;
+        }
+      }
+    }
+    result.push(current);
+  }
+  inputElements.forEach((event) => {
+    result.push(event);
+  });
+  result.sort((a, b) => a.ts - b.ts);
+  return result;
+}
+function serializeRecording(data) {
+  return JSON.stringify(data, null, 2);
+}
+function buildRecordingFileName(seq = 1) {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const dateTime = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const seqStr = seq > 1 ? `-${seq}` : "";
+  return `${dateTime}${seqStr}.recording.json`;
+}
+function recordingsDir() {
+  return path21.join(process.cwd(), ".deepstorm", "recordings");
+}
+function getNextSeq(datePrefix) {
+  const dir = recordingsDir();
+  if (!fs25.existsSync(dir)) return 1;
+  const files = fs25.readdirSync(dir).filter((f) => f.startsWith(datePrefix));
+  if (files.length === 0) return 1;
+  let maxSeq = 0;
+  for (const f of files) {
+    const match = f.match(/(?:-(\d+))?\.recording\.json$/);
+    if (match) {
+      const s = match[1] ? parseInt(match[1], 10) : 1;
+      maxSeq = Math.max(maxSeq, s);
+    }
+  }
+  return maxSeq + 1;
+}
+
+// src/record/browser-recorder.ts
+async function recordBrowserSession(url) {
+  let targetUrl;
+  try {
+    targetUrl = new URL(url);
+  } catch {
+    throw new Error(`\u65E0\u6548\u7684 URL: ${url}`);
+  }
+  if (!await isPlaywrightAvailable()) {
+    console.error("Playwright \u6D4F\u89C8\u5668\u672A\u5B89\u88C5\uFF0C\u8BF7\u6267\u884C npx playwright install");
+    process.exit(1);
+  }
+  const startTime = Date.now();
+  const browser = await import_playwright.chromium.launch({ headless: false });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const events = [];
+  const requestMethods = /* @__PURE__ */ new Map();
+  const cdpSession = await context.newCDPSession(page);
+  cdpSession.on("Network.requestWillBeSent", (params) => {
+    const { request, type, requestId } = params;
+    requestMethods.set(requestId, request.method);
+    if (type === "XHR" || type === "Fetch") {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "network",
+        data: {
+          url: request.url,
+          method: request.method,
+          type: "request"
+        }
+      });
+    }
+  });
+  cdpSession.on("Network.responseReceived", (params) => {
+    const { response, type, requestId } = params;
+    const method = requestMethods.get(requestId) ?? "GET";
+    if (type === "XHR" || type === "Fetch") {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "network",
+        data: {
+          url: response.url,
+          method,
+          statusCode: response.status,
+          type: "response"
+        }
+      });
+    }
+  });
+  cdpSession.on("Page.frameNavigated", (params) => {
+    const { frame } = params;
+    if (frame.parentId === void 0 || frame.parentId === null) {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "navigation",
+        data: {
+          url: frame.url,
+          title: frame.name || frame.url,
+          type: "full"
+        }
+      });
+    }
+  });
+  cdpSession.on("Page.navigatedWithinDocument", (params) => {
+    events.push({
+      ts: Date.now() - startTime,
+      type: "navigation",
+      data: {
+        url: params.url,
+        type: "spa"
+      }
+    });
+  });
+  await page.exposeFunction("__deepstorm_recordEvent", (type, data) => {
+    events.push({
+      ts: Date.now() - startTime,
+      type,
+      data
+    });
+  });
+  await page.goto(targetUrl.href);
+  await page.evaluate(`(function() {
+    var send = window.__deepstorm_recordEvent;
+
+    // Click listener (capture phase)
+    document.addEventListener('click', function(e) {
+      var target = e.target;
+      if (!target || target === document.body || target === document.documentElement) return;
+
+      var info = {
+        tagName: target.tagName.toLowerCase(),
+        id: target.id || undefined,
+        className: (target.className || '').toString().slice(0, 100) || undefined,
+        textContent: (target.textContent || '').trim().slice(0, 100) || undefined
+      };
+
+      var role = target.getAttribute('role');
+      if (role) info.role = role;
+      var ariaLabel = target.getAttribute('aria-label');
+      if (ariaLabel) info.ariaLabel = ariaLabel;
+      var placeholder = target.getAttribute('placeholder');
+      if (placeholder) info.placeholder = placeholder;
+      var dataTestId = target.getAttribute('data-testid');
+      if (dataTestId) info.dataTestId = dataTestId;
+
+      info.cssSelector = buildSimpleSelector(target);
+      send('click', info);
+    }, true);
+
+    // Input listener (change event for final value)
+    document.addEventListener('change', function(e) {
+      var target = e.target;
+      if (!target) return;
+
+      if (target.tagName === 'SELECT') {
+        send('select', {
+          tagName: 'select',
+          value: target.value,
+          name: target.name || undefined,
+          cssSelector: buildSimpleSelector(target)
+        });
+        return;
+      }
+
+      if (target.type === 'password') {
+        send('input', {
+          tagName: target.tagName.toLowerCase(),
+          type: 'password',
+          value: '****',
+          name: target.name || undefined,
+          placeholder: target.placeholder || undefined,
+          cssSelector: buildSimpleSelector(target)
+        });
+        return;
+      }
+
+      send('input', {
+        tagName: target.tagName.toLowerCase(),
+        type: target.type || undefined,
+        value: target.value,
+        name: target.name || undefined,
+        placeholder: target.placeholder || undefined,
+        cssSelector: buildSimpleSelector(target)
+      });
+    }, true);
+
+    // Submit listener
+    document.addEventListener('submit', function(e) {
+      var form = e.target;
+      if (!form) return;
+      send('submit', {
+        cssSelector: buildSimpleSelector(form),
+        id: form.id || undefined,
+        action: form.action || undefined
+      });
+    }, true);
+
+    // Helper: build simple CSS selector
+    function buildSimpleSelector(el) {
+      if (el.id) return '#' + CSS.escape(el.id);
+      var testId = el.getAttribute('data-testid');
+      if (testId) return '[data-testid="' + CSS.escape(testId) + '"]';
+      var tag = el.tagName.toLowerCase();
+      var cls = '';
+      for (var i = 0; i < el.classList.length; i++) {
+        cls += '.' + CSS.escape(el.classList[i]);
+      }
+      if (cls) return tag + cls;
+      var parent = el.parentElement;
+      if (parent) {
+        var siblings = Array.from(parent.children).filter(function(s) {
+          return s.tagName === el.tagName;
+        });
+        if (siblings.length > 1) {
+          var idx = siblings.indexOf(el) + 1;
+          return tag + ':nth-child(' + idx + ')';
+        }
+      }
+      return tag;
+    }
+  })();`);
+  console.log("\u{1F3A5} \u5F55\u5236\u4E2D... \u6309 Ctrl+D \u505C\u6B62");
+  const stopPromise = new Promise((resolve4) => {
+    const wasRaw = process.stdin.isRaw;
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      if (chunk.length === 1 && chunk[0] === 4) {
+        cleanup();
+        resolve4();
+      }
+    });
+    process.stdin.on("end", () => {
+      cleanup();
+      resolve4();
+    });
+    function cleanup() {
+      process.stdin.setRawMode?.(wasRaw ?? false);
+      process.stdin.pause();
+    }
+  });
+  const crashPromise = new Promise((_resolve, reject) => {
+    browser.on("disconnected", () => {
+      reject(new Error("\u6D4F\u89C8\u5668\u8FDE\u63A5\u65AD\u5F00"));
+    });
+  });
+  try {
+    await Promise.race([stopPromise, crashPromise]);
+  } catch (err) {
+    console.error("\n\u6D4F\u89C8\u5668\u8FDE\u63A5\u65AD\u5F00\uFF0C\u5F55\u5236\u5DF2\u7EC8\u6B62");
+    throw err;
+  } finally {
+    process.stdin.setRawMode?.(false);
+    process.stdin.pause();
+  }
+  const duration = Date.now() - startTime;
+  try {
+    const screenshotBuffer = await page.screenshot({ type: "jpeg", quality: 70 });
+    events.push({
+      ts: Date.now() - startTime,
+      type: "screenshot",
+      data: {
+        label: "final",
+        data: screenshotBuffer.toString("base64")
+      }
+    });
+  } catch {
+  }
+  await browser.close();
+  const filteredEvents = dedupEvents(filterNoiseEvents(events));
+  const recordingData = {
+    meta: {
+      url: targetUrl.href,
+      recordedAt: new Date(startTime).toISOString(),
+      duration,
+      browser: `Playwright Chromium ${browser.version()}`
+    },
+    events: filteredEvents
+  };
+  const dir = recordingsDir();
+  fs26.mkdirSync(dir, { recursive: true });
+  const datePrefix = buildRecordingFileName().replace(".recording.json", "");
+  const seq = getNextSeq(datePrefix);
+  const fileName = buildRecordingFileName(seq);
+  const filePath = path22.join(dir, fileName);
+  fs26.writeFileSync(filePath, serializeRecording(recordingData), "utf-8");
+  console.log(`
+\u2705 \u5F55\u5236\u5B8C\u6210`);
+  console.log(`   \u6301\u7EED\u65F6\u95F4: ${(duration / 1e3).toFixed(1)} \u79D2`);
+  console.log(`   \u4E8B\u4EF6\u603B\u6570: ${filteredEvents.length}`);
+  console.log(`   \u6587\u4EF6\u8DEF\u5F84: ${filePath}`);
+  return filePath;
+}
+async function isPlaywrightAvailable() {
+  try {
+    const { execSync: execSync3 } = await import("node:child_process");
+    execSync3(
+      "npx playwright install --dry-run 2>/dev/null || npx playwright --version 2>/dev/null",
+      { stdio: "ignore" }
+    );
+    const browser = await import_playwright.chromium.launch({ headless: true });
+    await browser.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/record.ts
+function registerRecordCommand(program2) {
+  const recordCmd = program2.command("record").description("\u6D4F\u89C8\u5668\u64CD\u4F5C\u5F55\u5236 \u2014 \u542F\u52A8 headed \u6D4F\u89C8\u5668\u5F55\u5236\u7528\u6237\u64CD\u4F5C\uFF0C\u8F93\u51FA .recording.json");
+  recordCmd.command("start").description("\u5F00\u59CB\u5F55\u5236 \u2014 \u542F\u52A8 headed \u6D4F\u89C8\u5668\u5E76\u6253\u5F00\u6307\u5B9A URL").option("-u, --url <url>", "\u76EE\u6807 URL").action(async (options) => {
+    if (!options.url) {
+      console.error("\u8BF7\u4F7F\u7528 -u <url> \u6307\u5B9A\u76EE\u6807 URL");
+      process.exit(1);
+    }
+    try {
+      await recordBrowserSession(options.url);
+    } catch (err) {
+      console.error("\u5F55\u5236\u5931\u8D25:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+  recordCmd.command("stop").description("\u505C\u6B62\u5F55\u5236 \u2014 \u505C\u6B62\u5F53\u524D\u5F55\u5236\u5E76\u5199\u5165\u6587\u4EF6").action(() => {
+    console.log("\u8BF7\u5728\u5F55\u5236\u7EC8\u7AEF\u6309 Ctrl+D \u505C\u6B62\u5F55\u5236");
+  });
+}
+
+// src/commands/doctor.ts
+var fs27 = __toESM(require("node:fs"));
+var path23 = __toESM(require("node:path"));
 function getInstalledSkills(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   try {
-    const settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
     return settings.installedSkills || [];
   } catch {
     return [];
@@ -10530,7 +10897,7 @@ function runDoctor(targetDir) {
     message: `v${version}\uFF08\u8FD0\u884C deepstorm update \u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF09`
   });
   let hasDeepStorm = false;
-  if (!fs25.existsSync(settingsPath)) {
+  if (!fs27.existsSync(settingsPath)) {
     checks.push({
       name: "\u914D\u7F6E\u6587\u4EF6",
       status: "warn",
@@ -10538,7 +10905,7 @@ function runDoctor(targetDir) {
     });
   } else {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       if (config && Object.keys(config).length > 0) {
         hasDeepStorm = true;
         checks.push({
@@ -10561,20 +10928,20 @@ function runDoctor(targetDir) {
       });
     }
   }
-  const skillsDir = path21.join(targetDir, ".claude", "skills");
-  if (fs25.existsSync(skillsDir)) {
-    const skillDirs = fs25.readdirSync(skillsDir).filter(
-      (n) => fs25.statSync(path21.join(skillsDir, n)).isDirectory()
+  const skillsDir = path23.join(targetDir, ".claude", "skills");
+  if (fs27.existsSync(skillsDir)) {
+    const skillDirs = fs27.readdirSync(skillsDir).filter(
+      (n) => fs27.statSync(path23.join(skillsDir, n)).isDirectory()
     );
     let validCount = 0;
     let invalidCount = 0;
     for (const skillName of skillDirs) {
-      const skillMd = path21.join(skillsDir, skillName, "SKILL.md");
-      if (!fs25.existsSync(skillMd)) {
+      const skillMd = path23.join(skillsDir, skillName, "SKILL.md");
+      if (!fs27.existsSync(skillMd)) {
         invalidCount++;
         continue;
       }
-      const content = fs25.readFileSync(skillMd, "utf-8");
+      const content = fs27.readFileSync(skillMd, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter && frontmatter.name) {
         validCount++;
@@ -10604,7 +10971,7 @@ function runDoctor(targetDir) {
     const installedSkills = getInstalledSkills(targetDir);
     const missingSkills = [];
     for (const skillId of installedSkills) {
-      if (!fs25.existsSync(path21.join(skillsDir, skillId))) {
+      if (!fs27.existsSync(path23.join(skillsDir, skillId))) {
         missingSkills.push(skillId);
       }
     }
@@ -10628,10 +10995,10 @@ function runDoctor(targetDir) {
       message: ".claude/skills/ \u4E0D\u5B58\u5728"
     });
   }
-  const mcpPath = path21.join(targetDir, ".mcp.json");
-  if (fs25.existsSync(mcpPath)) {
+  const mcpPath = path23.join(targetDir, ".mcp.json");
+  if (fs27.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
+      const mcp = JSON.parse(fs27.readFileSync(mcpPath, "utf-8"));
       const hasServers = mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0;
       checks.push({
         name: "MCP \u670D\u52A1\u5668",
@@ -10652,12 +11019,12 @@ function runDoctor(targetDir) {
       message: ".mcp.json \u4E0D\u5B58\u5728"
     });
   }
-  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs27.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       const installedMcp = config.installedMcpServers;
       if (installedMcp && installedMcp.length > 0) {
-        const mcpExists = fs25.existsSync(mcpPath);
+        const mcpExists = fs27.existsSync(mcpPath);
         if (!mcpExists) {
           checks.push({
             name: "MCP \u4E00\u81F4\u6027",
@@ -10666,7 +11033,7 @@ function runDoctor(targetDir) {
           });
         } else {
           try {
-            const mcpConfig = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
+            const mcpConfig = JSON.parse(fs27.readFileSync(mcpPath, "utf-8"));
             const servers = mcpConfig.mcpServers || {};
             const missing = [];
             for (const toolName of installedMcp) {
@@ -10694,9 +11061,9 @@ function runDoctor(targetDir) {
     } catch {
     }
   }
-  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs27.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       const validKeys = loadValidConfigKeys();
       if (validKeys.size > 0 && config) {
         const configKeys = [];
@@ -10749,18 +11116,18 @@ function printDoctorReport(report) {
 }
 
 // src/commands/uninstall.ts
-var fs26 = __toESM(require("node:fs"));
-var path22 = __toESM(require("node:path"));
+var fs28 = __toESM(require("node:fs"));
+var path24 = __toESM(require("node:path"));
 var import_prompts4 = require("@clack/prompts");
 async function uninstallDeepStorm(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs26.existsSync(settingsPath)) {
+  if (!fs28.existsSync(settingsPath)) {
     console.log("DeepStorm \u5C1A\u672A\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D");
     return;
   }
   let hasDeepStorm = false;
   try {
-    const settings = JSON.parse(fs26.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs28.readFileSync(settingsPath, "utf-8"));
     hasDeepStorm = !!settings && Object.keys(settings).length > 0;
   } catch {
   }
@@ -10770,14 +11137,14 @@ async function uninstallDeepStorm(targetDir) {
   }
   cleanInstalled(targetDir);
   resetConfig(targetDir);
-  const templatesDir = path22.join(targetDir, ".deepstorm", "templates");
-  if (fs26.existsSync(templatesDir)) {
+  const templatesDir = path24.join(targetDir, ".deepstorm", "templates");
+  if (fs28.existsSync(templatesDir)) {
     const shouldDelete = await (0, import_prompts4.confirm)({
       message: "\u662F\u5426\u5220\u9664 .deepstorm/templates/ \u76EE\u5F55\uFF1F",
       initialValue: false
     });
     if (shouldDelete) {
-      fs26.rmSync(templatesDir, { recursive: true, force: true });
+      fs28.rmSync(templatesDir, { recursive: true, force: true });
       console.log("\u2714 .deepstorm/templates/ \u5DF2\u5220\u9664");
     } else {
       console.log("\u4FDD\u7559 .deepstorm/templates/");
@@ -10790,9 +11157,9 @@ async function uninstallDeepStorm(targetDir) {
 var program = new import_commander.Command();
 program.name("deepstorm").description("DeepStorm CLI \u2014 \u4E00\u952E\u914D\u7F6E\u9879\u76EE\u5F00\u53D1\u73AF\u5883").version(getCliVersion(), "-v, --version", "\u8F93\u51FA\u7248\u672C\u53F7");
 function loadRegistry() {
-  const registryPath = path23.join(__dirname, "registry.json");
+  const registryPath = path25.join(__dirname, "registry.json");
   try {
-    const raw = fs27.readFileSync(registryPath, "utf-8");
+    const raw = fs29.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: "1", tools: {}, wizards: {}, skills: {} };
@@ -10806,6 +11173,7 @@ registerConfigCommand(program, registry);
 registerTemplateCommand(program, registry);
 registerUpdateCommand(program);
 registerPilotCommands(program);
+registerRecordCommand(program);
 program.command("doctor").description("\u8BCA\u65AD\u9879\u76EE DeepStorm \u914D\u7F6E\u72B6\u6001").action(() => {
   const report = runDoctor(process.cwd());
   printDoctorReport(report);