je-cd 0.1.0

package/dist/index.js

@@ -0,0 +1,2251 @@
+#!/usr/bin/env node
+import {
+  getCpuManager,
+  getDiskManager,
+  getGpuManager,
+  getMemoryManager,
+  getNetworkManager,
+  getOsManager,
+  getProcessManager
+} from "./chunk-DZZGI7AU.js";
+
+// src/cli/router.ts
+import chalk2 from "chalk";
+
+// src/groups/claude/run.ts
+import { spawn } from "child_process";
+async function handler(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("claude", args, { stdio: "inherit", shell: true });
+    child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`claude exit code ${code}`)));
+    child.on("error", (e) => reject(e));
+  });
+}
+var commandDef = { name: "run", description: "\u542F\u52A8 Claude Code", handler, examples: ["jc claude"] };
+
+// src/groups/claude/bypass.ts
+import { spawn as spawn2 } from "child_process";
+async function handler2(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("claude", ["--permission-mode", "bypassPermissions"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef2 = { name: "b", description: "\u8DF3\u8FC7\u6743\u9650\u6A21\u5F0F", handler: handler2, examples: ["jc claude b"] };
+
+// src/groups/claude/resume.ts
+import { spawn as spawn3 } from "child_process";
+async function handler3(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3("claude", ["-r", "--dangerously-skip-permissions"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef3 = { name: "r", description: "\u6062\u590D\u4E0A\u6B21\u4F1A\u8BDD", handler: handler3, examples: ["jc claude r"] };
+
+// src/groups/claude/ultracode.ts
+import { spawn as spawn4 } from "child_process";
+async function handler4(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn4("claude", ["--dangerously-skip-permissions", "/effort ultracode"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef4 = { name: "e", description: "Ultracode \u6A21\u5F0F", handler: handler4, examples: ["jc claude e"] };
+
+// src/groups/claude/index.ts
+var claudeGroup = {
+  name: "claude",
+  alias: "c",
+  description: "Claude Code CLI \u5305\u88C5",
+  commands: [commandDef, commandDef2, commandDef3, commandDef4],
+  defaultHandler: handler
+};
+
+// src/groups/happy/run.ts
+import { spawn as spawn5 } from "child_process";
+async function handler5(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn5("happy", args, { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`happy exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef5 = { name: "run", description: "\u542F\u52A8 Happy", handler: handler5, examples: ["jc happy"] };
+
+// src/groups/happy/claude.ts
+import { spawn as spawn6 } from "child_process";
+async function handler6(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn6("happy", ["claude"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef6 = { name: "claude", description: "\u542F\u52A8 Happy + Claude", handler: handler6, examples: ["jc happy claude"] };
+
+// src/groups/happy/codex.ts
+import { spawn as spawn7 } from "child_process";
+async function handler7(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn7("happy", ["codex"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef7 = { name: "codex", description: "\u542F\u52A8 Happy + Codex", handler: handler7, examples: ["jc happy codex"] };
+
+// src/groups/happy/resume.ts
+import { spawn as spawn8 } from "child_process";
+async function handler8(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn8("happy", ["resume", ...args], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef8 = { name: "resume", description: "\u6062\u590D Happy \u4F1A\u8BDD", handler: handler8, examples: ["jc happy resume <session-id>"] };
+
+// src/groups/happy/daemon.ts
+import { spawn as spawn9 } from "child_process";
+async function handler9(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn9("happy", ["daemon"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef9 = { name: "daemon", description: "\u542F\u52A8 Happy \u5B88\u62A4\u8FDB\u7A0B", handler: handler9, examples: ["jc happy daemon"] };
+
+// src/groups/happy/doctor.ts
+import { spawn as spawn10 } from "child_process";
+async function handler10(_args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn10("happy", ["doctor"], { stdio: "inherit", shell: true });
+    child.on("close", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+    child.on("error", reject);
+  });
+}
+var commandDef10 = { name: "doctor", description: "Happy \u8BCA\u65AD\u68C0\u67E5", handler: handler10, examples: ["jc happy doctor"] };
+
+// src/groups/happy/stop.ts
+import { execSync } from "child_process";
+async function handler11(_args) {
+  if (process.platform === "win32") {
+    execSync(`powershell -NoProfile "Get-CimInstance Win32_Process -Filter \\"Name='node.exe'\\" | Where-Object { $_.CommandLine -match 'happy' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }"`);
+  } else {
+    execSync('pkill -f "happy"', { stdio: "ignore" });
+  }
+  console.log("Happy \u8FDB\u7A0B\u5DF2\u505C\u6B62");
+}
+var commandDef11 = { name: "x", description: "\u505C\u6B62\u6240\u6709 Happy \u8FDB\u7A0B", handler: handler11, examples: ["jc happy x"] };
+
+// src/groups/happy/index.ts
+var happyGroup = {
+  name: "happy",
+  alias: "hy",
+  description: "Happy mobile Claude \u5305\u88C5",
+  commands: [commandDef5, commandDef6, commandDef7, commandDef8, commandDef9, commandDef10, commandDef11],
+  defaultHandler: commandDef5.handler
+};
+
+// src/cli/output.ts
+import chalk from "chalk";
+var jc = chalk.red("jc");
+var groupName = chalk.yellow;
+var subCmd = chalk.blue;
+var error = chalk.red;
+var warning = chalk.yellow;
+var success = chalk.green;
+function padEnd(s, n) {
+  return s + " ".repeat(Math.max(0, n - s.length));
+}
+function printHeader(title) {
+  console.log(`===== ${chalk.yellow(title)} =====`);
+}
+function printCommands(commands) {
+  for (const cmd of commands) {
+    console.log(
+      `  ${chalk.red("jc")} ${chalk.yellow(padEnd(cmd.name, 14))} ${cmd.description}`
+    );
+  }
+}
+function printCommandHelp(cmd, group, category) {
+  const tag = category ? `  [${category}]` : "";
+  console.log(`${chalk.yellow(`[jc ${group} ${cmd.name}]`)} ${cmd.description} ${chalk.blue(tag)}`);
+  console.log();
+  if (cmd.helpText) {
+    console.log(`  ${cmd.helpText}`);
+    console.log();
+  }
+  if (cmd.examples && cmd.examples.length > 0) {
+    console.log(`  ${chalk.red("\u793A\u4F8B")}:`);
+    for (const ex of cmd.examples) {
+      console.log(`    ${ex}`);
+    }
+    console.log();
+  }
+  if (cmd.related && cmd.related.length > 0) {
+    console.log(`  ${chalk.red("\u76F8\u5173")}: ${cmd.related.join(" / ")}`);
+  }
+}
+function printGroupHelp(group) {
+  console.log();
+  printHeader(group.name);
+  console.log(`  ${group.description}`);
+  console.log();
+  printCommands(group.commands);
+  if (group.categories) {
+    for (const cat of group.categories) {
+      console.log();
+      console.log(`  ${chalk.blue(`[${cat.name}]`)} \u2014 ${cat.description}`);
+      printCommands(cat.commands);
+    }
+  }
+  console.log();
+  console.log(`\u7528\u6CD5: jc ${chalk.yellow(group.name)} ${chalk.blue("<\u547D\u4EE4>")} [\u53C2\u6570...]`);
+}
+function printCategoryHelp(cat) {
+  console.log();
+  printHeader(cat.name);
+  console.log(`  ${cat.description}`);
+  console.log();
+  printCommands(cat.commands);
+  console.log();
+}
+
+// src/groups/w/proc/port.ts
+async function handler12(args) {
+  const pm = getProcessManager();
+  if (args.length === 0) {
+    const ports = await pm.getListeningPorts();
+    console.log("\u76D1\u542C\u7AEF\u53E3\u5217\u8868:");
+    if (ports.length === 0) {
+      console.log("\u65E0\u76D1\u542C\u7684\u7AEF\u53E3");
+      return;
+    }
+    console.table(ports.map((p) => ({ PID: p.pid, Port: p.port, State: p.state })));
+    return;
+  }
+  const port = parseInt(args[0], 10);
+  if (isNaN(port)) {
+    console.error(error("\u274C \u7AEF\u53E3\u53F7\u5FC5\u987B\u662F\u6570\u5B57"));
+    process.exit(1);
+  }
+  const procs = await pm.getProcessByPort(port);
+  if (procs.length === 0) {
+    console.log(`\u7AEF\u53E3 ${port} \u65E0\u8FDB\u7A0B\u5360\u7528`);
+    return;
+  }
+  console.table(procs.map((p) => ({ PID: p.pid, \u8FDB\u7A0B\u540D: p.name, CPU: `${p.cpu}%`, \u5185\u5B58: `${p.memory}MB` })));
+}
+var commandDef12 = {
+  name: "p",
+  description: "\u67E5\u7AEF\u53E3\u5360\u7528\u7684\u8FDB\u7A0B",
+  handler: handler12,
+  helpText: "\u7528\u6CD5:\n  jc w p [\u65E0\u53C2]  - \u5217\u6240\u6709\u76D1\u542C\u7AEF\u53E3\n  jc w p <PORT>  - \u67E5\u6307\u5B9A\u7AEF\u53E3",
+  examples: ["jc w p", "jc w p 3306"],
+  related: ["jc w pk", "jc w k", "jc w portscan"]
+};
+
+// src/groups/w/proc/portkill.ts
+async function handler13(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "?") {
+    console.log(`\u7528\u6CD5: jc w pk <PORT> [--soft|--list]`);
+    return;
+  }
+  const port = parseInt(args[0], 10);
+  if (isNaN(port)) {
+    console.error(error("\u274C \u7AEF\u53E3\u53F7\u5FC5\u987B\u662F\u6570\u5B57"));
+    process.exit(1);
+  }
+  const pm = getProcessManager();
+  const procs = await pm.getProcessByPort(port);
+  if (procs.length === 0) {
+    console.log(`\u7AEF\u53E3 ${port} \u65E0\u8FDB\u7A0B\u5360\u7528`);
+    return;
+  }
+  const isListOnly = args.includes("--list");
+  const isSoft = args.includes("--soft");
+  console.log(`\u7AEF\u53E3 ${port} \u88AB\u4EE5\u4E0B\u8FDB\u7A0B\u5360\u7528:`);
+  procs.forEach((p) => console.log(`  PID: ${p.pid}, \u540D\u79F0: ${p.name}`));
+  if (isListOnly) return;
+  for (const p of procs) {
+    try {
+      if (isSoft) {
+        process.kill(p.pid, "SIGTERM");
+      } else {
+        process.kill(p.pid, "SIGKILL");
+      }
+      console.log(`\u2705 PID ${p.pid} (${p.name}) \u5DF2\u7EC8\u6B62`);
+    } catch (e) {
+      console.error(warning(`\u26A0\uFE0F PID ${p.pid} \u7EC8\u6B62\u5931\u8D25: ${e.message}`));
+    }
+  }
+}
+var commandDef13 = {
+  name: "pk",
+  description: "\u4E00\u952E\u67E5\u5E76\u6740\u7AEF\u53E3\u8FDB\u7A0B",
+  handler: handler13,
+  helpText: "\u7528\u6CD5:\n  jc w pk <PORT>     - \u5F3A\u5236\u6740\n  jc w pk <PORT> --list - \u53EA\u67E5\u4E0D\u6740\n  jc w pk <PORT> --soft - \u4F18\u96C5\u7EC8\u6B62",
+  examples: ["jc w pk 8080", "jc w pk 3000 --list"],
+  related: ["jc w p", "jc w k", "jc w kn"]
+};
+
+// src/groups/w/proc/kill.ts
+async function handler14(args) {
+  if (args.length === 0) {
+    console.error(error("\u274C \u8BF7\u6307\u5B9A PID"));
+    process.exit(1);
+  }
+  const pid = parseInt(args[0], 10);
+  if (isNaN(pid)) {
+    console.error(error("\u274C PID \u5FC5\u987B\u662F\u6570\u5B57"));
+    process.exit(1);
+  }
+  try {
+    await getProcessManager().killProcess(pid);
+    console.log(`\u2705 PID ${pid} \u5DF2\u7EC8\u6B62`);
+  } catch (e) {
+    console.error(error(`\u274C \u7EC8\u6B62\u5931\u8D25: ${e.message}`));
+    process.exit(2);
+  }
+}
+var commandDef14 = {
+  name: "k",
+  description: "\u6309 PID \u6740\u8FDB\u7A0B",
+  handler: handler14,
+  helpText: "\u7528\u6CD5:\n  jc w k <PID>  - \u5F3A\u5236\u7ED3\u675F\u6307\u5B9A PID",
+  examples: ["jc w k 1234"],
+  related: ["jc w p", "jc w pk", "jc w kn", "jc w ps"]
+};
+
+// src/groups/w/proc/killname.ts
+async function handler15(args) {
+  if (args.length === 0) {
+    console.error(error("\u274C \u8BF7\u6307\u5B9A\u8FDB\u7A0B\u540D"));
+    process.exit(1);
+  }
+  const name = args[0];
+  const pm = getProcessManager();
+  const procs = await pm.getProcessByName(name);
+  if (procs.length === 0) {
+    console.log(`\u672A\u627E\u5230\u8FDB\u7A0B: ${name}`);
+    return;
+  }
+  for (const p of procs) {
+    try {
+      await pm.killProcess(p.pid);
+      console.log(`\u2705 ${p.name} (PID: ${p.pid}) \u5DF2\u7EC8\u6B62`);
+    } catch (e) {
+      console.error(warning(`\u26A0\uFE0F ${p.name} (PID: ${p.pid}) \u7EC8\u6B62\u5931\u8D25: ${e.message}`));
+    }
+  }
+}
+var commandDef15 = {
+  name: "kn",
+  description: "\u6309\u8FDB\u7A0B\u540D\u6740\u8FDB\u7A0B",
+  handler: handler15,
+  helpText: "\u7528\u6CD5:\n  jc w kn <NAME>  - \u5982 chrome / node",
+  examples: ["jc w kn chrome", "jc w kn node"],
+  related: ["jc w k", "jc w ps", "jc w p"]
+};
+
+// src/groups/w/proc/ps.ts
+async function handler16(args) {
+  const pm = getProcessManager();
+  const filter = args.length > 0 ? args[0] : void 0;
+  const procs = await pm.listProcesses(filter);
+  if (procs.length === 0) {
+    console.log(filter ? `\u672A\u627E\u5230\u5339\u914D\u8FDB\u7A0B: ${filter}` : "\u65E0\u8FDB\u7A0B");
+    return;
+  }
+  console.table(procs.slice(0, 50).map((p) => ({
+    PID: p.pid,
+    \u540D\u79F0: p.name,
+    CPU: `${p.cpu}%`,
+    \u5185\u5B58: `${p.memory}MB`,
+    \u72B6\u6001: p.state || ""
+  })));
+  if (procs.length > 50) {
+    console.log(`... \u8FD8\u6709 ${procs.length - 50} \u4E2A\u8FDB\u7A0B`);
+  }
+}
+var commandDef16 = {
+  name: "ps",
+  description: "\u67E5\u8FDB\u7A0B",
+  handler: handler16,
+  helpText: "\u7528\u6CD5:\n  jc w ps [\u65E0\u53C2]  - \u5217\u51FA\u5168\u90E8\u8FDB\u7A0B\n  jc w ps <NAME>  - \u6309\u8FDB\u7A0B\u540D\u8FC7\u6EE4",
+  examples: ["jc w ps", "jc w ps chrome"],
+  related: ["jc w p", "jc w k", "jc w kn", "jc w top"]
+};
+
+// src/groups/w/proc/top.ts
+async function handler17(args) {
+  const pm = getProcessManager();
+  const limit = parseInt(args[0], 10) || 20;
+  const procs = await pm.getTopProcesses("cpu", limit);
+  console.table(procs.map((p) => ({
+    PID: p.pid,
+    \u540D\u79F0: p.name,
+    CPU: `${p.cpu}%`,
+    \u5185\u5B58: `${p.memory}MB`
+  })));
+}
+var commandDef17 = {
+  name: "top",
+  description: "CPU \u5360\u7528 Top20",
+  handler: handler17,
+  helpText: "\u7528\u6CD5:\n  jc w top [N]  - CPU \u964D\u5E8F\u524D N (\u9ED8\u8BA4 20)",
+  examples: ["jc w top"],
+  related: ["jc w mem", "jc w ps", "jc w psg"]
+};
+
+// src/groups/w/proc/mem.ts
+async function handler18(args) {
+  const { getProcessManager: getProcessManager2 } = await import("./adapter-DN3PLEN3.js");
+  const pm = getProcessManager2();
+  const limit = parseInt(args[0], 10) || 20;
+  const procs = await pm.getTopProcesses("memory", limit);
+  console.table(procs.map((p) => ({
+    PID: p.pid,
+    \u540D\u79F0: p.name,
+    \u5185\u5B58: `${p.memory}MB`,
+    CPU: `${p.cpu}%`
+  })));
+}
+var commandDef18 = {
+  name: "mem",
+  description: "\u5185\u5B58\u5360\u7528 Top20 (MB)",
+  handler: handler18,
+  helpText: "\u7528\u6CD5:\n  jc w mem [N]  - \u5185\u5B58\u964D\u5E8F\u524D N (\u9ED8\u8BA4 20)",
+  examples: ["jc w mem"],
+  related: ["jc w top", "jc w ps", "jc w psg"]
+};
+
+// src/groups/w/proc/psg.ts
+async function handler19(_args) {
+  const pm = getProcessManager();
+  const stats = await pm.getProcessStats();
+  console.log(`\u8FDB\u7A0B\u603B\u6570: ${stats.total}`);
+  console.log(`\u8FD0\u884C\u4E2D:   ${stats.running}`);
+  console.log(`CPU \u5360\u7528: ${stats.cpuPercent}%`);
+  console.log(`\u5185\u5B58\u5360\u7528: ${stats.memoryGB}GB`);
+}
+var commandDef19 = {
+  name: "psg",
+  description: "\u8FDB\u7A0B\u7EDF\u8BA1\u6982\u89C8",
+  handler: handler19,
+  helpText: "\u7528\u6CD5:\n  jc w psg [\u65E0\u53C2] - \u8FDB\u7A0B\u7EDF\u8BA1\u6982\u89C8",
+  examples: ["jc w psg"],
+  related: ["jc w ps", "jc w top", "jc w mem"]
+};
+
+// src/groups/w/sys/sysinfo.ts
+async function handler20(_args) {
+  const [os2, cpu, mem, disks, gpus] = await Promise.all([
+    getOsManager().getInfo(),
+    getCpuManager().getInfo(),
+    getMemoryManager().getInfo(),
+    getDiskManager().getInfo(),
+    getGpuManager().getInfo()
+  ]);
+  console.log(`\u4E3B\u673A\u540D:     ${os2.hostname}`);
+  console.log(`\u64CD\u4F5C\u7CFB\u7EDF:   ${os2.platform} ${os2.distro} ${os2.release}`);
+  console.log(`\u5185\u6838:       ${os2.kernel}`);
+  console.log(`CPU:        ${cpu.brand} (${cpu.physicalCores}\u7269\u7406\u6838 / ${cpu.logicalCores}\u903B\u8F91\u6838)`);
+  console.log(`CPU \u8D1F\u8F7D:   ${cpu.loadPercent}%`);
+  console.log(`\u5185\u5B58:       ${mem.totalGB}GB (\u5DF2\u7528 ${mem.usedGB}GB, \u5269\u4F59 ${mem.freeGB}GB)`);
+  console.log(`\u8FD0\u884C\u65F6\u957F:   ${await getOsManager().getUptime()}`);
+  console.log(`BIOS:       ${os2.biosVendor} ${os2.biosVersion} (${os2.biosDate})`);
+  if (disks.length > 0) {
+    const d = disks[0];
+    console.log(`\u7CFB\u7EDF\u76D8:     ${d.drive} ${d.usedGB}GB/${d.sizeGB}GB (${d.percentUsed}%)`);
+  }
+  if (gpus.length > 0) {
+    console.log(`GPU:        ${gpus[0].model} (${gpus[0].vramGB}GB)`);
+  }
+}
+var commandDef20 = {
+  name: "sysinfo",
+  description: "\u7CFB\u7EDF\u8BE6\u7EC6\u4FE1\u606F",
+  handler: handler20,
+  helpText: "\u7528\u6CD5:\n  jc w sysinfo - \u663E\u793A\u7CFB\u7EDF\u5B8C\u6574\u4FE1\u606F",
+  examples: ["jc w sysinfo"],
+  related: ["jc w host", "jc w cpu", "jc w meminfo", "jc w disk"]
+};
+
+// src/groups/w/sys/host.ts
+async function handler21(_args) {
+  console.log(await getOsManager().getHostname());
+}
+var commandDef21 = {
+  name: "host",
+  description: "\u672C\u673A\u4E3B\u673A\u540D",
+  handler: handler21,
+  examples: ["jc w host"],
+  related: ["jc w ip", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/uptime.ts
+async function handler22(_args) {
+  console.log(await getOsManager().getUptime());
+}
+var commandDef22 = {
+  name: "uptime",
+  description: "\u7CFB\u7EDF\u8FD0\u884C\u65F6\u957F",
+  handler: handler22,
+  examples: ["jc w uptime"],
+  related: ["jc w host", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/cpu.ts
+async function handler23(_args) {
+  const cpu = await getCpuManager().getInfo();
+  console.log(`\u578B\u53F7:     ${cpu.manufacturer} ${cpu.brand}`);
+  console.log(`\u7269\u7406\u6838:   ${cpu.physicalCores}`);
+  console.log(`\u903B\u8F91\u6838:   ${cpu.logicalCores}`);
+  console.log(`\u4E3B\u9891:     ${cpu.speedGHz}GHz`);
+  console.log(`\u5F53\u524D\u8D1F\u8F7D: ${cpu.loadPercent}%`);
+}
+var commandDef23 = {
+  name: "cpu",
+  description: "CPU \u4FE1\u606F",
+  handler: handler23,
+  examples: ["jc w cpu"],
+  related: ["jc w meminfo", "jc w gpu", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/meminfo.ts
+async function handler24(_args) {
+  const mem = await getMemoryManager().getInfo();
+  console.log(`\u603B\u8BA1: ${mem.totalGB}GB`);
+  console.log(`\u5DF2\u7528: ${mem.usedGB}GB (${mem.percentUsed}%)`);
+  console.log(`\u5269\u4F59: ${mem.freeGB}GB`);
+  if (mem.swapTotalGB > 0) {
+    console.log(`\u4EA4\u6362: ${mem.swapUsedGB}GB / ${mem.swapTotalGB}GB`);
+  }
+}
+var commandDef24 = {
+  name: "meminfo",
+  description: "\u5185\u5B58\u4FE1\u606F",
+  handler: handler24,
+  examples: ["jc w meminfo"],
+  related: ["jc w cpu", "jc w disk", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/disk.ts
+async function handler25(_args) {
+  const disks = await getDiskManager().getInfo();
+  if (disks.length === 0) {
+    console.log("\u672A\u627E\u5230\u78C1\u76D8\u5377");
+    return;
+  }
+  for (const d of disks) {
+    console.log(`\u5377: ${d.drive}`);
+    console.log(`  \u603B\u8BA1: ${d.sizeGB}GB`);
+    console.log(`  \u5DF2\u7528: ${d.usedGB}GB (${d.percentUsed}%)`);
+    console.log(`  \u5269\u4F59: ${d.freeGB}GB`);
+    console.log(`  \u6587\u4EF6\u7CFB\u7EDF: ${d.filesystem}`);
+    console.log("");
+  }
+}
+var commandDef25 = {
+  name: "disk",
+  description: "\u78C1\u76D8\u5377\u4FE1\u606F (Get-Volume \u98CE\u683C)",
+  handler: handler25,
+  examples: ["jc w disk"],
+  related: ["jc w diskfull", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/diskfull.ts
+async function handler26(_args) {
+  const disks = await getDiskManager().getFullInfo();
+  if (disks.length === 0) {
+    console.log("\u672A\u627E\u5230\u78C1\u76D8");
+    return;
+  }
+  console.log("\u6240\u6709\u78C1\u76D8\u4FE1\u606F (Get-PSDrive \u98CE\u683C):");
+  for (const d of disks) {
+    console.log(`${d.drive}`);
+    console.log(`  \u5DF2\u7528: ${d.usedGB}GB / ${d.sizeGB}GB (${d.percentUsed}%)`);
+    console.log(`  \u5269\u4F59: ${d.freeGB}GB`);
+    console.log(`  \u6587\u4EF6\u7CFB\u7EDF: ${d.filesystem}`);
+    console.log("");
+  }
+}
+var commandDef26 = {
+  name: "diskfull",
+  description: "\u5B8C\u6574\u78C1\u76D8\u4FE1\u606F (Get-PSDrive \u98CE\u683C)",
+  handler: handler26,
+  examples: ["jc w diskfull"],
+  related: ["jc w disk", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/gpu.ts
+async function handler27(_args) {
+  const gpus = await getGpuManager().getInfo();
+  if (gpus.length === 0) {
+    console.log("\u672A\u68C0\u6D4B\u5230 GPU");
+    return;
+  }
+  for (let i = 0; i < gpus.length; i++) {
+    const g = gpus[i];
+    console.log(`GPU #${i + 1}`);
+    console.log(`  \u578B\u53F7:   ${g.model}`);
+    console.log(`  \u9A71\u52A8:   ${g.driverVersion || "(\u672A\u77E5)"}`);
+    console.log(`  \u663E\u5B58:   ${g.vramGB}GB`);
+    console.log("");
+  }
+}
+var commandDef27 = {
+  name: "gpu",
+  description: "GPU \u4FE1\u606F",
+  handler: handler27,
+  examples: ["jc w gpu"],
+  related: ["jc w cpu", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/bios.ts
+async function handler28(_args) {
+  const os2 = await getOsManager().getInfo();
+  console.log(`BIOS \u5382\u5546:  ${os2.biosVendor || "(\u672A\u77E5)"}`);
+  console.log(`BIOS \u7248\u672C:  ${os2.biosVersion || "(\u672A\u77E5)"}`);
+  console.log(`BIOS \u65E5\u671F:  ${os2.biosDate || "(\u672A\u77E5)"}`);
+}
+var commandDef28 = {
+  name: "bios",
+  description: "BIOS \u4FE1\u606F",
+  handler: handler28,
+  examples: ["jc w bios"],
+  related: ["jc w sysinfo"]
+};
+
+// src/groups/w/sys/bat.ts
+import si from "systeminformation";
+async function handler29(_args) {
+  try {
+    const bat = await si.battery();
+    if (!bat.hasBattery) {
+      console.log("\u672A\u68C0\u6D4B\u5230\u7535\u6C60");
+      return;
+    }
+    console.log(`\u7535\u91CF:        ${bat.percent}%`);
+    console.log(`\u72B6\u6001:        ${bat.acConnected ? "\u7535\u6E90\u9002\u914D\u5668" : "\u4F7F\u7528\u7535\u6C60"}`);
+    if (bat.isCharging) console.log(`\u5145\u7535\u4E2D:      ${bat.percent}%`);
+    if (bat.timeRemaining > 0) {
+      const m = Math.floor(bat.timeRemaining / 60);
+      console.log(`\u5269\u4F59\u65F6\u95F4:    ${m} \u5206\u949F`);
+    }
+    if (bat.maxCapacity) console.log(`\u8BBE\u8BA1\u5BB9\u91CF:    ${(bat.maxCapacity / 1e3).toFixed(1)}Wh`);
+    if (bat.currentCapacity) console.log(`\u5F53\u524D\u5BB9\u91CF:    ${(bat.currentCapacity / 1e3).toFixed(1)}Wh`);
+  } catch {
+    console.error("\u65E0\u6CD5\u83B7\u53D6\u7535\u6C60\u4FE1\u606F\uFF08\u53EF\u80FD\u65E0\u7535\u6C60\u8BBE\u5907\uFF09");
+  }
+}
+var commandDef29 = {
+  name: "bat",
+  description: "\u7535\u6C60\u72B6\u6001",
+  handler: handler29,
+  examples: ["jc w bat"],
+  related: ["jc w sysinfo", "jc w powercfg"]
+};
+
+// src/groups/w/sys/mon.ts
+import si2 from "systeminformation";
+async function handler30(_args) {
+  try {
+    const graphics = await si2.graphics();
+    const displays = graphics.displays || [];
+    if (displays.length === 0) {
+      console.log("\u672A\u68C0\u6D4B\u5230\u663E\u793A\u5668");
+      return;
+    }
+    for (let i = 0; i < displays.length; i++) {
+      const d = displays[i];
+      console.log(`\u663E\u793A\u5668 #${i + 1}`);
+      console.log(`  \u578B\u53F7:   ${d.model || "(\u672A\u77E5)"}`);
+      if (d.main) console.log("  \u4E3B\u663E\u793A\u5668: \u662F");
+      console.log(`  \u5206\u8FA8\u7387: ${d.resolutionX}x${d.resolutionY}`);
+      if (d.currentResX && d.currentResY) console.log(`  \u5F53\u524D:   ${d.currentResX}x${d.currentResY}`);
+      if (d.pixelDepth) console.log(`  \u4F4D\u6DF1:   ${d.pixelDepth}bit`);
+      if (d.sizeX && d.sizeY) console.log(`  \u5C3A\u5BF8:   ${(d.sizeX / 25.4).toFixed(1)}" (${d.sizeX}x${d.sizeY}mm)`);
+      console.log("");
+    }
+  } catch {
+    console.error("\u65E0\u6CD5\u83B7\u53D6\u663E\u793A\u5668\u4FE1\u606F");
+  }
+}
+var commandDef30 = {
+  name: "mon",
+  description: "\u663E\u793A\u5668\u4FE1\u606F",
+  handler: handler30,
+  examples: ["jc w mon"],
+  related: ["jc w gpu", "jc w sysinfo"]
+};
+
+// src/groups/w/sys/powercfg.ts
+import { execSync as execSync2 } from "child_process";
+async function handler31(_args) {
+  if (process.platform !== "win32") {
+    console.log("powercfg \u4EC5\u652F\u6301 Windows");
+    return;
+  }
+  console.log("\u6B63\u5728\u751F\u6210\u7535\u6E90\u65B9\u6848\u62A5\u544A...\n");
+  try {
+    const schemes = execSync2("powercfg /list", { encoding: "utf8" });
+    console.log("\u7535\u6E90\u65B9\u6848:");
+    console.log(schemes);
+    const query = execSync2("powercfg /query", { encoding: "utf8", timeout: 15e3 });
+    console.log("\u7535\u6E90\u65B9\u6848\u8BE6\u7EC6\u8BBE\u7F6E:");
+    console.log(query);
+  } catch (e) {
+    console.error(error(`\u7535\u6E90\u62A5\u544A\u751F\u6210\u5931\u8D25: ${e.message}`));
+  }
+}
+var commandDef31 = {
+  name: "powercfg",
+  description: "\u7535\u6E90\u65B9\u6848\u4FE1\u606F",
+  handler: handler31,
+  examples: ["jc w powercfg"],
+  related: ["jc w bat", "jc w sysinfo"]
+};
+
+// src/groups/w/net/ip.ts
+async function handler32(_args) {
+  const net2 = await getNetworkManager().getNetworkInfo();
+  console.log(`\u4E3B\u673A\u540D: ${net2.hostname}`);
+  if (net2.defaultGateway) console.log(`\u9ED8\u8BA4\u7F51\u5173: ${net2.defaultGateway}`);
+  console.log("");
+  for (const iface of net2.interfaces) {
+    console.log(`${iface.name} [${iface.type}]`);
+    console.log(`  IPv4: ${iface.ip4 || "-"}`);
+    console.log(`  IPv6: ${iface.ip6 || "-"}`);
+    console.log(`  MAC:  ${iface.mac || "-"}`);
+    console.log("");
+  }
+}
+var commandDef32 = {
+  name: "ip",
+  description: "\u7F51\u7EDC\u63A5\u53E3\u4FE1\u606F (IP/MAC)",
+  handler: handler32,
+  examples: ["jc w ip"],
+  related: ["jc w ip4", "jc w mac", "jc w wifi"]
+};
+
+// src/groups/w/net/ip4.ts
+async function handler33(_args) {
+  const net2 = await getNetworkManager().getNetworkInfo();
+  for (const iface of net2.interfaces) {
+    if (iface.ip4) {
+      console.log(`${iface.name}: ${iface.ip4}`);
+    }
+  }
+}
+var commandDef33 = {
+  name: "ip4",
+  description: "IPv4 \u5730\u5740",
+  handler: handler33,
+  examples: ["jc w ip4"],
+  related: ["jc w ip", "jc w mac"]
+};
+
+// src/groups/w/net/dns.ts
+async function handler34(_args) {
+  try {
+    await getNetworkManager().flushDns();
+    console.log("DNS \u7F13\u5B58\u5DF2\u5237\u65B0");
+  } catch (e) {
+    console.error(`DNS \u5237\u65B0\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef34 = {
+  name: "dns",
+  description: "\u5237\u65B0 DNS \u7F13\u5B58",
+  handler: handler34,
+  examples: ["jc w dns"],
+  related: ["jc w ns", "jc w proxy"]
+};
+
+// src/groups/w/net/ns.ts
+import { execSync as execSync3 } from "child_process";
+async function handler35(args) {
+  const host = args[0];
+  if (!host) {
+    console.log("\u7528\u6CD5: jc w ns <hostname>");
+    return;
+  }
+  try {
+    const output = execSync3(`nslookup ${host}`, { encoding: "utf8", timeout: 1e4 });
+    console.log(output);
+  } catch (e) {
+    console.error(`DNS \u67E5\u8BE2\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef35 = {
+  name: "ns",
+  description: "DNS \u67E5\u8BE2 (nslookup)",
+  handler: handler35,
+  examples: ["jc w ns google.com"],
+  related: ["jc w dns", "jc w ping"]
+};
+
+// src/groups/w/net/ping.ts
+async function handler36(args) {
+  const host = args[0] || "127.0.0.1";
+  console.log(`Pinging ${host}...`);
+  const result = await getNetworkManager().ping(host);
+  if (result.alive) {
+    console.log(`\u54CD\u5E94: ${result.time}ms`);
+  } else {
+    console.log("\u8D85\u65F6\u6216\u65E0\u54CD\u5E94");
+  }
+}
+var commandDef36 = {
+  name: "ping",
+  description: "Ping \u4E3B\u673A",
+  handler: handler36,
+  examples: ["jc w ping google.com", "jc w ping 8.8.8.8"],
+  related: ["jc w ns", "jc w trace"]
+};
+
+// src/groups/w/net/trace.ts
+async function handler37(args) {
+  const host = args[0];
+  if (!host) {
+    console.log("\u7528\u6CD5: jc w trace <host>");
+    return;
+  }
+  console.log(`\u8DEF\u7531\u8FFD\u8E2A\u5230 ${host}...`);
+  const hops = await getNetworkManager().traceRoute(host);
+  if (hops.length === 0) {
+    console.log("\u65E0\u54CD\u5E94");
+    return;
+  }
+  for (let i = 0; i < hops.length; i++) {
+    console.log(` ${i + 1}. ${hops[i]}`);
+  }
+}
+var commandDef37 = {
+  name: "trace",
+  description: "\u8DEF\u7531\u8FFD\u8E2A",
+  handler: handler37,
+  examples: ["jc w trace google.com"],
+  related: ["jc w ping", "jc w route"]
+};
+
+// src/groups/w/net/route.ts
+import { execSync as execSync4 } from "child_process";
+async function handler38(_args) {
+  try {
+    const cmd = process.platform === "win32" ? "route print" : "netstat -rn";
+    const output = execSync4(cmd, { encoding: "utf8" });
+    console.log(output);
+  } catch (e) {
+    console.error(`\u83B7\u53D6\u8DEF\u7531\u8868\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef38 = {
+  name: "route",
+  description: "\u8DEF\u7531\u8868",
+  handler: handler38,
+  examples: ["jc w route"],
+  related: ["jc w trace", "jc w ip"]
+};
+
+// src/groups/w/net/conn.ts
+async function handler39(_args) {
+  const conns = await getNetworkManager().getConnections();
+  if (conns.length === 0) {
+    console.log("\u65E0 TCP \u8FDE\u63A5");
+    return;
+  }
+  const listening = conns.filter((c) => c.state === "listen");
+  const established = conns.filter((c) => c.state === "established");
+  console.log(`TCP \u8FDE\u63A5\u603B\u6570: ${conns.length}`);
+  console.log(`  \u76D1\u542C\u4E2D:     ${listening.length}`);
+  console.log(`  \u5DF2\u5EFA\u7ACB:     ${established.length}`);
+  console.log("");
+  if (listening.length > 0) {
+    console.log("\u76D1\u542C\u7AEF\u53E3:");
+    for (const c of listening.slice(0, 20)) {
+      console.log(`  :${c.localPort} (PID: ${c.pid})`);
+    }
+    if (listening.length > 20) console.log(`  ... \u8FD8\u6709 ${listening.length - 20} \u4E2A`);
+  }
+}
+var commandDef39 = {
+  name: "conn",
+  description: "TCP \u8FDE\u63A5\u4FE1\u606F",
+  handler: handler39,
+  examples: ["jc w conn"],
+  related: ["jc w p", "jc w portscan"]
+};
+
+// src/groups/w/net/wifi.ts
+async function handler40(_args) {
+  const networks = await getNetworkManager().getWiFiInfo();
+  if (networks.length === 0) {
+    console.log("\u672A\u8FDE\u63A5 WiFi \u6216\u65E0 WiFi \u9002\u914D\u5668");
+    return;
+  }
+  for (const n of networks) {
+    console.log(`SSID:       ${n.ssid}`);
+    console.log(`\u4FE1\u53F7:       ${n.signal}%`);
+    console.log(`\u9891\u7387:       ${n.frequency}`);
+    console.log(`\u4FE1\u9053:       ${n.channel}`);
+    console.log(`\u5B89\u5168\u7C7B\u578B:   ${n.security}`);
+    console.log("");
+  }
+}
+var commandDef40 = {
+  name: "wifi",
+  description: "WiFi \u8FDE\u63A5\u4FE1\u606F",
+  handler: handler40,
+  examples: ["jc w wifi"],
+  related: ["jc w wifipwd", "jc w ip"]
+};
+
+// src/groups/w/net/wifipwd.ts
+async function handler41(_args) {
+  try {
+    const profiles = await getNetworkManager().getWiFiPasswords();
+    if (profiles.length === 0) {
+      console.log("\u672A\u627E\u5230 WiFi \u914D\u7F6E\u6587\u4EF6");
+      return;
+    }
+    for (const p of profiles) {
+      console.log(`${p.ssid}: ${p.password}`);
+    }
+  } catch (e) {
+    console.error(`\u83B7\u53D6 WiFi \u5BC6\u7801\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef41 = {
+  name: "wifipwd",
+  description: "WiFi \u5BC6\u7801 (\u4EC5 Windows)",
+  handler: handler41,
+  platform: "win32",
+  examples: ["jc w wifipwd"],
+  related: ["jc w wifi", "jc w wifiexp"]
+};
+
+// src/groups/w/net/wifiexp.ts
+import { execSync as execSync5 } from "child_process";
+async function handler42(_args) {
+  if (process.platform !== "win32") {
+    console.error(error("\u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows"));
+    return;
+  }
+  try {
+    const output = execSync5("netsh wlan export profile folder=. key=clear", { encoding: "utf8" });
+    console.log("WiFi \u914D\u7F6E\u6587\u4EF6\u5DF2\u5BFC\u51FA\u5230\u5F53\u524D\u76EE\u5F55");
+    console.log(output);
+  } catch (e) {
+    console.error(error(`\u5BFC\u51FA WiFi \u914D\u7F6E\u5931\u8D25: ${e.message}`));
+  }
+}
+var commandDef42 = {
+  name: "wifiexp",
+  description: "\u5BFC\u51FA WiFi \u914D\u7F6E (\u4EC5 Windows)",
+  handler: handler42,
+  platform: "win32",
+  examples: ["jc w wifiexp"],
+  related: ["jc w wifi", "jc w wifipwd"]
+};
+
+// src/groups/w/net/proxy.ts
+async function handler43(_args) {
+  const proxy = await getNetworkManager().getProxySettings();
+  console.log(`\u4EE3\u7406\u72B6\u6001:   ${proxy.enabled ? "\u5DF2\u542F\u7528" : "\u5DF2\u7981\u7528"}`);
+  console.log(`HTTP \u4EE3\u7406:  ${proxy.httpProxy || "(\u65E0)"}`);
+  console.log(`HTTPS \u4EE3\u7406: ${proxy.httpsProxy || "(\u65E0)"}`);
+}
+var commandDef43 = {
+  name: "proxy",
+  description: "\u4EE3\u7406\u8BBE\u7F6E",
+  handler: handler43,
+  examples: ["jc w proxy"],
+  related: ["jc w dns", "jc w ip"]
+};
+
+// src/groups/w/net/portscan.ts
+import net from "net";
+async function checkPort(host, port, timeout = 3e3) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(timeout);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, host);
+  });
+}
+async function handler44(args) {
+  const host = args[0] || "127.0.0.1";
+  const portsArg = args[1] || "22,80,443,3306,5432,6379,8080,8443";
+  const ports = portsArg.split(",").map((p) => parseInt(p.trim(), 10)).filter((p) => !isNaN(p));
+  console.log(`\u626B\u63CF ${host} \u7AEF\u53E3: ${ports.join(", ")}`);
+  console.log("");
+  for (const port of ports) {
+    const open15 = await checkPort(host, port);
+    console.log(`  Port ${port}: ${open15 ? "\u5F00\u653E" : "\u5173\u95ED"}`);
+  }
+}
+var commandDef44 = {
+  name: "portscan",
+  description: "\u7AEF\u53E3\u626B\u63CF",
+  handler: handler44,
+  examples: ["jc w portscan", "jc w portscan 192.168.1.1 22,80,443"],
+  related: ["jc w p", "jc w conn"]
+};
+
+// src/groups/w/net/mac.ts
+async function handler45(_args) {
+  const macs = await getNetworkManager().getMacAddresses();
+  if (macs.length === 0) {
+    console.log("\u672A\u627E\u5230\u7F51\u7EDC\u63A5\u53E3");
+    return;
+  }
+  for (const m of macs) {
+    console.log(`${m.name}: ${m.mac || "-"}`);
+  }
+}
+var commandDef45 = {
+  name: "mac",
+  description: "MAC \u5730\u5740",
+  handler: handler45,
+  examples: ["jc w mac"],
+  related: ["jc w ip", "jc w ip4"]
+};
+
+// src/groups/w/net/share.ts
+import { execSync as execSync6 } from "child_process";
+async function handler46(_args) {
+  try {
+    let output;
+    if (process.platform === "win32") {
+      output = execSync6("net share", { encoding: "utf8" });
+    } else {
+      output = execSync6("share", { encoding: "utf8" }).replace(/^.*\n/, "");
+    }
+    console.log(output);
+  } catch (e) {
+    console.error(`\u83B7\u53D6\u7F51\u7EDC\u5171\u4EAB\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef46 = {
+  name: "share",
+  description: "\u7F51\u7EDC\u5171\u4EAB",
+  handler: handler46,
+  examples: ["jc w share"],
+  related: ["jc w ip", "jc w proxy"]
+};
+
+// src/groups/w/file/ls.ts
+import fs from "fs";
+import path from "path";
+async function handler47(args) {
+  const dir = args[0] || ".";
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+      let stat = null;
+      try {
+        stat = fs.statSync(fullPath);
+      } catch {
+      }
+      if (item.isDirectory()) {
+        console.log(`[DIR]  ${item.name}${stat ? `  (${stat.size} bytes)` : ""}`);
+      } else if (item.isSymbolicLink()) {
+        const target = fs.readlinkSync(fullPath);
+        console.log(`[LNK]  ${item.name} -> ${target}`);
+      } else {
+        console.log(`[FILE] ${item.name}${stat ? `  (${stat.size} bytes)` : ""}`);
+      }
+    }
+  } catch (e) {
+    console.error(`\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef47 = {
+  name: "ls",
+  description: "\u5217\u51FA\u76EE\u5F55\u5185\u5BB9",
+  handler: handler47,
+  examples: ["jc w ls", "jc w ls C:\\"],
+  related: ["jc w pwd", "jc w dtree", "jc w find"]
+};
+
+// src/groups/w/file/pwd.ts
+async function handler48(_args) {
+  console.log(process.cwd());
+}
+var commandDef48 = {
+  name: "pwd",
+  description: "\u663E\u793A\u5F53\u524D\u76EE\u5F55",
+  handler: handler48,
+  examples: ["jc w pwd"],
+  related: ["jc w ls", "jc w cd"]
+};
+
+// src/groups/w/file/cd.ts
+async function handler49(args) {
+  const dir = args[0];
+  if (!dir) {
+    console.log(`\u5F53\u524D\u76EE\u5F55: ${process.cwd()}`);
+    return;
+  }
+  try {
+    process.chdir(dir);
+    console.log(`\u5DF2\u5207\u6362\u5230: ${process.cwd()}`);
+  } catch (e) {
+    console.error(`\u5207\u6362\u76EE\u5F55\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef49 = {
+  name: "cd",
+  description: "\u5207\u6362\u76EE\u5F55 (\u4EC5\u5F53\u524D\u4F1A\u8BDD)",
+  handler: handler49,
+  examples: ["jc w cd C:\\", "jc w cd .."],
+  related: ["jc w pwd", "jc w ls"]
+};
+
+// src/groups/w/file/rm.ts
+import fs2 from "fs";
+import readline from "readline";
+function confirm(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+async function handler50(args) {
+  const dir = args[0];
+  if (!dir) {
+    console.log("\u7528\u6CD5: jc w rm <directory>");
+    return;
+  }
+  try {
+    if (!fs2.existsSync(dir)) {
+      console.error(`\u76EE\u5F55\u4E0D\u5B58\u5728: ${dir}`);
+      return;
+    }
+    const ok = await confirm(`\u786E\u8BA4\u5220\u9664\u76EE\u5F55 "${dir}"? (y/N) `);
+    if (!ok) {
+      console.log("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    fs2.rmSync(dir, { recursive: true, force: true });
+    console.log(`\u5DF2\u5220\u9664\u76EE\u5F55: ${dir}`);
+  } catch (e) {
+    console.error(`\u5220\u9664\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef50 = {
+  name: "rm",
+  description: "\u5220\u9664\u76EE\u5F55 (\u542B\u786E\u8BA4\u63D0\u793A)",
+  handler: handler50,
+  examples: ["jc w rm ./node_modules"],
+  related: ["jc w del", "jc w mkdir"]
+};
+
+// src/groups/w/file/del.ts
+import fs3 from "fs";
+async function handler51(args) {
+  const file = args[0];
+  if (!file) {
+    console.log("\u7528\u6CD5: jc w del <file>");
+    return;
+  }
+  try {
+    fs3.unlinkSync(file);
+    console.log(`\u5DF2\u5220\u9664: ${file}`);
+  } catch (e) {
+    console.error(`\u5220\u9664\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef51 = {
+  name: "del",
+  description: "\u5220\u9664\u6587\u4EF6",
+  handler: handler51,
+  examples: ["jc w del ./temp.txt"],
+  related: ["jc w rm", "jc w cp", "jc w mv"]
+};
+
+// src/groups/w/file/mkdir.ts
+import fs4 from "fs";
+async function handler52(args) {
+  const dir = args[0];
+  if (!dir) {
+    console.log("\u7528\u6CD5: jc w mkdir <directory>");
+    return;
+  }
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+    console.log(`\u5DF2\u521B\u5EFA\u76EE\u5F55: ${dir}`);
+  } catch (e) {
+    console.error(`\u521B\u5EFA\u76EE\u5F55\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef52 = {
+  name: "mkdir",
+  description: "\u521B\u5EFA\u76EE\u5F55",
+  handler: handler52,
+  examples: ["jc w mkdir ./newdir", "jc w mkdir ./a/b/c"],
+  related: ["jc w rm", "jc w touch"]
+};
+
+// src/groups/w/file/touch.ts
+import fs5 from "fs";
+import path2 from "path";
+async function handler53(args) {
+  const file = args[0];
+  if (!file) {
+    console.log("\u7528\u6CD5: jc w touch <file>");
+    return;
+  }
+  try {
+    if (fs5.existsSync(file)) {
+      const now = /* @__PURE__ */ new Date();
+      fs5.utimesSync(file, now, now);
+      console.log(`\u5DF2\u66F4\u65B0: ${file}`);
+    } else {
+      const dir = path2.dirname(file);
+      if (dir && !fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
+      }
+      fs5.writeFileSync(file, "", "utf8");
+      console.log(`\u5DF2\u521B\u5EFA: ${file}`);
+    }
+  } catch (e) {
+    console.error(`\u64CD\u4F5C\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef53 = {
+  name: "touch",
+  description: "\u521B\u5EFA\u7A7A\u6587\u4EF6\u6216\u66F4\u65B0\u6587\u4EF6\u65F6\u95F4\u6233",
+  handler: handler53,
+  examples: ["jc w touch ./newfile.txt"],
+  related: ["jc w mkdir", "jc w del"]
+};
+
+// src/groups/w/file/cp.ts
+import fs6 from "fs";
+import path3 from "path";
+async function handler54(args) {
+  const src = args[0];
+  const dest = args[1];
+  if (!src || !dest) {
+    console.log("\u7528\u6CD5: jc w cp <source> <destination>");
+    return;
+  }
+  try {
+    const srcStat = fs6.statSync(src);
+    if (srcStat.isDirectory()) {
+      cpDir(src, dest);
+    } else {
+      const destDir = path3.dirname(dest);
+      if (destDir && !fs6.existsSync(destDir)) {
+        fs6.mkdirSync(destDir, { recursive: true });
+      }
+      fs6.copyFileSync(src, dest);
+    }
+    console.log(`\u5DF2\u590D\u5236: ${src} -> ${dest}`);
+  } catch (e) {
+    console.error(`\u590D\u5236\u5931\u8D25: ${e.message}`);
+  }
+}
+function cpDir(src, dest) {
+  fs6.mkdirSync(dest, { recursive: true });
+  const items = fs6.readdirSync(src);
+  for (const item of items) {
+    const srcPath = path3.join(src, item);
+    const destPath = path3.join(dest, item);
+    if (fs6.statSync(srcPath).isDirectory()) {
+      cpDir(srcPath, destPath);
+    } else {
+      fs6.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+var commandDef54 = {
+  name: "cp",
+  description: "\u590D\u5236\u6587\u4EF6\u6216\u76EE\u5F55",
+  handler: handler54,
+  examples: ["jc w cp file.txt backup.txt", "jc w cp dir1 dir2"],
+  related: ["jc w mv", "jc w del", "jc w ls"]
+};
+
+// src/groups/w/file/mv.ts
+import fs7 from "fs";
+import path4 from "path";
+async function handler55(args) {
+  const src = args[0];
+  const dest = args[1];
+  if (!src || !dest) {
+    console.log("\u7528\u6CD5: jc w mv <source> <destination>");
+    return;
+  }
+  try {
+    const destDir = path4.dirname(dest);
+    if (destDir && !fs7.existsSync(destDir)) {
+      fs7.mkdirSync(destDir, { recursive: true });
+    }
+    fs7.renameSync(src, dest);
+    console.log(`\u5DF2\u79FB\u52A8/\u91CD\u547D\u540D: ${src} -> ${dest}`);
+  } catch (e) {
+    console.error(`\u79FB\u52A8\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef55 = {
+  name: "mv",
+  description: "\u79FB\u52A8\u6216\u91CD\u547D\u540D\u6587\u4EF6/\u76EE\u5F55",
+  handler: handler55,
+  examples: ["jc w mv old.txt new.txt", "jc w mv file.txt ./backup/"],
+  related: ["jc w cp", "jc w del", "jc w ls"]
+};
+
+// src/groups/w/file/find.ts
+import fs8 from "fs";
+import path5 from "path";
+function searchDir(dir, pattern, results) {
+  try {
+    const items = fs8.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path5.join(dir, item);
+      try {
+        const stat = fs8.statSync(fullPath);
+        if (item.toLowerCase().includes(pattern.toLowerCase())) {
+          results.push(fullPath);
+        }
+        if (stat.isDirectory()) {
+          searchDir(fullPath, pattern, results);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function handler56(args) {
+  const pattern = args[0];
+  const rootDir = args[1] || ".";
+  if (!pattern) {
+    console.log("\u7528\u6CD5: jc w find <pattern> [rootDir]");
+    return;
+  }
+  console.log(`\u5728 ${rootDir} \u4E2D\u641C\u7D22 "${pattern}"...`);
+  const results = [];
+  searchDir(rootDir, pattern, results);
+  if (results.length === 0) {
+    console.log("\u672A\u627E\u5230\u5339\u914D\u9879");
+    return;
+  }
+  for (const r of results) {
+    console.log(r);
+  }
+  console.log(`
+\u5171 ${results.length} \u4E2A\u5339\u914D`);
+}
+var commandDef56 = {
+  name: "find",
+  description: "\u9012\u5F52\u641C\u7D22\u6587\u4EF6",
+  handler: handler56,
+  examples: ["jc w find .ts", "jc w find node_modules C:\\project"],
+  related: ["jc w ls", "jc w dtree"]
+};
+
+// src/groups/w/file/size.ts
+import fs9 from "fs";
+import path6 from "path";
+function getDirSize(dir) {
+  let total = 0;
+  try {
+    const items = fs9.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path6.join(dir, item);
+      try {
+        const stat = fs9.statSync(fullPath);
+        if (stat.isDirectory()) {
+          total += getDirSize(fullPath);
+        } else {
+          total += stat.size;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return total;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+async function handler57(args) {
+  const target = args[0] || ".";
+  try {
+    const stat = fs9.statSync(target);
+    if (stat.isDirectory()) {
+      console.log(`\u6B63\u5728\u8BA1\u7B97 "${target}" \u7684\u5927\u5C0F...`);
+      const size = getDirSize(target);
+      console.log(`\u76EE\u5F55\u5927\u5C0F: ${formatBytes(size)}`);
+    } else {
+      console.log(`${target}: ${formatBytes(stat.size)}`);
+    }
+  } catch (e) {
+    console.error(`\u83B7\u53D6\u5927\u5C0F\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef57 = {
+  name: "size",
+  description: "\u76EE\u5F55\u6216\u6587\u4EF6\u5927\u5C0F",
+  handler: handler57,
+  examples: ["jc w size .", "jc w size ./node_modules"],
+  related: ["jc w disk", "jc w ls", "jc w dtree"]
+};
+
+// src/groups/w/file/dtree.ts
+import fs10 from "fs";
+import path7 from "path";
+function printTree(dir, prefix = "") {
+  let items = [];
+  try {
+    items = fs10.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const fullPath = path7.join(dir, item);
+    const isLast = i === items.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    console.log(prefix + connector + item);
+    try {
+      if (fs10.statSync(fullPath).isDirectory()) {
+        const ext = isLast ? "    " : "\u2502   ";
+        printTree(fullPath, prefix + ext);
+      }
+    } catch {
+    }
+  }
+}
+async function handler58(args) {
+  const dir = args[0] || ".";
+  console.log(dir);
+  printTree(dir);
+}
+var commandDef58 = {
+  name: "dtree",
+  description: "\u76EE\u5F55\u6811",
+  handler: handler58,
+  examples: ["jc w dtree", "jc w dtree C:\\project"],
+  related: ["jc w ls", "jc w find", "jc w size"]
+};
+
+// src/groups/w/file/ln.ts
+import fs11 from "fs";
+import path8 from "path";
+async function handler59(args) {
+  const target = args[0];
+  const linkPath = args[1];
+  if (!target || !linkPath) {
+    console.log("\u7528\u6CD5: jc w ln <target> <link>");
+    return;
+  }
+  try {
+    const absTarget = path8.resolve(target);
+    const absLink = path8.resolve(linkPath);
+    const isDir = fs11.statSync(absTarget).isDirectory();
+    if (process.platform === "win32" && isDir) {
+      fs11.symlinkSync(absTarget, absLink, "junction");
+    } else {
+      fs11.symlinkSync(absTarget, absLink);
+    }
+    console.log(`\u5DF2\u521B\u5EFA\u94FE\u63A5: ${absLink} -> ${absTarget}`);
+  } catch (e) {
+    console.error(`\u521B\u5EFA\u94FE\u63A5\u5931\u8D25: ${e.message}`);
+  }
+}
+var commandDef59 = {
+  name: "ln",
+  description: "\u521B\u5EFA\u7B26\u53F7\u94FE\u63A5",
+  handler: handler59,
+  examples: ["jc w ln /real/path /link/path"],
+  related: ["jc w cp", "jc w mv", "jc w ls"]
+};
+
+// src/groups/w/svc/svc.ts
+import si3 from "systeminformation";
+async function handler60(args) {
+  const services = await si3.services("*");
+  const filter = args[0]?.toLowerCase();
+  const filtered = filter ? services.filter((s) => s.name.toLowerCase().includes(filter)) : services;
+  console.table(filtered.slice(0, 50).map((s) => ({ \u540D\u79F0: s.name, \u72B6\u6001: s.running ? "\u8FD0\u884C\u4E2D" : "\u5DF2\u505C\u6B62" })));
+}
+var commandDef60 = {
+  name: "svc",
+  description: "\u67E5\u670D\u52A1",
+  handler: handler60,
+  examples: ["jc w svc", "jc w svc w32time"],
+  related: ["jc w svcstart", "jc w svcstop"]
+};
+
+// src/groups/w/svc/svcstart.ts
+import { execSync as execSync7 } from "child_process";
+async function handler61(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u670D\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync7(`net start "${name}"`, { stdio: "inherit" });
+}
+var commandDef61 = {
+  name: "svcstart",
+  description: "\u542F\u52A8\u670D\u52A1",
+  handler: handler61,
+  examples: ["jc w svcstart w32time"],
+  related: ["jc w svc", "jc w svcstop"]
+};
+
+// src/groups/w/svc/svcstop.ts
+import { execSync as execSync8 } from "child_process";
+async function handler62(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u670D\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync8(`net stop "${name}"`, { stdio: "inherit" });
+}
+var commandDef62 = {
+  name: "svcstop",
+  description: "\u505C\u6B62\u670D\u52A1",
+  handler: handler62,
+  examples: ["jc w svcstop w32time"],
+  related: ["jc w svc", "jc w svcstart"]
+};
+
+// src/groups/w/svc/svcrestart.ts
+import { execSync as execSync9 } from "child_process";
+async function handler63(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u670D\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync9(`net stop "${name}"`, { stdio: "inherit" });
+  execSync9(`net start "${name}"`, { stdio: "inherit" });
+}
+var commandDef63 = {
+  name: "svcrestart",
+  description: "\u91CD\u542F\u670D\u52A1",
+  handler: handler63,
+  examples: ["jc w svcrestart w32time"]
+};
+
+// src/groups/w/svc/svcdelayed.ts
+import { execSync as execSync10 } from "child_process";
+async function handler64(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u670D\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync10(`sc config "${name}" start=delayed-auto`, { stdio: "inherit" });
+}
+var commandDef64 = {
+  name: "svcdelayed",
+  description: "\u8BBE\u7F6E\u670D\u52A1\u4E3A\u5EF6\u8FDF\u81EA\u542F",
+  handler: handler64,
+  examples: ["jc w svcdelayed w32time"]
+};
+
+// src/groups/w/pwr/off.ts
+import { execSync as execSync11 } from "child_process";
+async function handler65(_args) {
+  const cmd = process.platform === "win32" ? "shutdown /s /t 5" : "shutdown -h now";
+  execSync11(cmd, { stdio: "inherit" });
+}
+var commandDef65 = {
+  name: "off",
+  description: "\u5173\u673A (5s \u7F13\u51B2)",
+  handler: handler65,
+  examples: ["jc w off"],
+  related: ["jc w reboot", "jc w cancel"]
+};
+
+// src/groups/w/pwr/reboot.ts
+import { execSync as execSync12 } from "child_process";
+async function handler66(_args) {
+  const cmd = process.platform === "win32" ? "shutdown /r /t 5" : "shutdown -r now";
+  execSync12(cmd, { stdio: "inherit" });
+}
+var commandDef66 = {
+  name: "reboot",
+  description: "\u91CD\u542F (5s \u7F13\u51B2)",
+  handler: handler66,
+  examples: ["jc w reboot"],
+  related: ["jc w off", "jc w cancel"]
+};
+
+// src/groups/w/pwr/logout.ts
+import { execSync as execSync13 } from "child_process";
+async function handler67(_args) {
+  const cmd = process.platform === "win32" ? "shutdown /l" : "pkill -KILL -u $USER";
+  execSync13(cmd, { stdio: "inherit" });
+}
+var commandDef67 = {
+  name: "logout",
+  description: "\u6CE8\u9500\u5F53\u524D\u7528\u6237",
+  handler: handler67,
+  examples: ["jc w logout"]
+};
+
+// src/groups/w/pwr/lock.ts
+import { execSync as execSync14 } from "child_process";
+async function handler68(_args) {
+  const cmd = process.platform === "win32" ? "rundll32.exe user32.dll,LockWorkStation" : "loginctl lock-session";
+  execSync14(cmd, { stdio: "inherit" });
+}
+var commandDef68 = {
+  name: "lock",
+  description: "\u9501\u5B9A\u5C4F\u5E55",
+  handler: handler68,
+  examples: ["jc w lock"]
+};
+
+// src/groups/w/pwr/sleep.ts
+import { execSync as execSync15 } from "child_process";
+async function handler69(_args) {
+  const cmd = process.platform === "win32" ? "shutdown /h" : "systemctl suspend";
+  execSync15(cmd, { stdio: "inherit" });
+}
+var commandDef69 = {
+  name: "sleep",
+  description: "\u4F11\u7720",
+  handler: handler69,
+  examples: ["jc w sleep"]
+};
+
+// src/groups/w/pwr/cancel.ts
+import { execSync as execSync16 } from "child_process";
+async function handler70(_args) {
+  const cmd = process.platform === "win32" ? "shutdown /a" : "shutdown -c";
+  execSync16(cmd, { stdio: "inherit" });
+}
+var commandDef70 = {
+  name: "cancel",
+  description: "\u53D6\u6D88\u5173\u673A/\u91CD\u542F",
+  handler: handler70,
+  examples: ["jc w cancel"],
+  related: ["jc w off", "jc w reboot"]
+};
+
+// src/groups/w/reg/reg.ts
+import { execSync as execSync17 } from "child_process";
+function requireWin() {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+}
+async function handler71(args) {
+  requireWin();
+  const path9 = args[0] || "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+  try {
+    console.log(execSync17(`reg query "${path9}"`, { encoding: "utf8" }));
+  } catch {
+    console.log(`\u8DEF\u5F84\u4E0D\u5B58\u5728: ${path9}`);
+  }
+}
+var commandDef71 = {
+  name: "reg",
+  description: "\u67E5\u6CE8\u518C\u8868\u9879",
+  handler: handler71,
+  platform: "win32",
+  examples: ['jc w reg "HKCU\\Software\\..."'],
+  related: ["jc w regset", "jc w regdel"]
+};
+
+// src/groups/w/reg/regset.ts
+import { execSync as execSync18 } from "child_process";
+function requireWin2() {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+}
+async function handler72(args) {
+  requireWin2();
+  const path9 = args[0];
+  const name = args[1];
+  const value = args.slice(2).join(" ");
+  if (!path9 || !name) {
+    console.error("\u274C \u7528\u6CD5: jc w regset <path> <name> <value>");
+    process.exit(1);
+  }
+  execSync18(`reg add "${path9}" /v "${name}" /d "${value}" /f`, { stdio: "inherit" });
+}
+var commandDef72 = {
+  name: "regset",
+  description: "\u5199\u6CE8\u518C\u8868\u503C",
+  handler: handler72,
+  platform: "win32"
+};
+
+// src/groups/w/reg/regdel.ts
+import { execSync as execSync19 } from "child_process";
+function requireWin3() {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+}
+async function handler73(args) {
+  requireWin3();
+  const path9 = args[0];
+  if (!path9) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u6CE8\u518C\u8868\u8DEF\u5F84");
+    process.exit(1);
+  }
+  console.log(`\u786E\u8BA4\u5220\u9664 ${path9}? (y/N)`);
+  const answer = await new Promise((resolve) => process.stdin.once("data", (d) => resolve(d.toString().trim().toLowerCase())));
+  if (answer === "y") {
+    execSync19(`reg delete "${path9}" /f`, { stdio: "inherit" });
+  } else {
+    console.log("\u5DF2\u53D6\u6D88");
+  }
+}
+var commandDef73 = {
+  name: "regdel",
+  description: "\u5220\u6CE8\u518C\u8868\u9879",
+  handler: handler73,
+  platform: "win32"
+};
+
+// src/groups/w/reg/regfind.ts
+import { execSync as execSync20 } from "child_process";
+function requireWin4() {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+}
+async function handler74(args) {
+  requireWin4();
+  execSync20(`reg query HKCU /s /f "${args[0] || ""}"`, { stdio: "inherit" });
+}
+var commandDef74 = {
+  name: "regfind",
+  description: "\u641C\u6CE8\u518C\u8868\u503C\u540D",
+  handler: handler74,
+  platform: "win32"
+};
+
+// src/groups/w/task/task.ts
+import { execSync as execSync21 } from "child_process";
+async function handler75(_args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  execSync21("schtasks /query /fo TABLE /nh", { stdio: "inherit" });
+}
+var commandDef75 = {
+  name: "task",
+  description: "\u5217\u51FA\u8BA1\u5212\u4EFB\u52A1",
+  handler: handler75,
+  platform: "win32"
+};
+
+// src/groups/w/task/taskrun.ts
+import { execSync as execSync22 } from "child_process";
+async function handler76(args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u4EFB\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync22(`powershell -NoProfile "Start-ScheduledTask -TaskPath '\\' -TaskName '${name}'"`, { stdio: "inherit" });
+}
+var commandDef76 = {
+  name: "taskrun",
+  description: "\u8FD0\u884C\u8BA1\u5212\u4EFB\u52A1",
+  handler: handler76,
+  platform: "win32"
+};
+
+// src/groups/w/task/taskstop.ts
+import { execSync as execSync23 } from "child_process";
+async function handler77(args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  const name = args[0];
+  if (!name) {
+    console.error("\u274C \u8BF7\u6307\u5B9A\u4EFB\u52A1\u540D");
+    process.exit(1);
+  }
+  execSync23(`powershell -NoProfile "Stop-ScheduledTask -TaskPath '\\' -TaskName '${name}'"`, { stdio: "inherit" });
+}
+var commandDef77 = {
+  name: "taskstop",
+  description: "\u505C\u6B62\u8BA1\u5212\u4EFB\u52A1",
+  handler: handler77,
+  platform: "win32"
+};
+
+// src/groups/w/tools/taskmgr.ts
+import open from "open";
+async function handler78(_args) {
+  await open("taskmgr");
+}
+var commandDef78 = {
+  name: "taskmgr",
+  description: "\u4EFB\u52A1\u7BA1\u7406\u5668",
+  handler: handler78,
+  examples: ["jc w taskmgr"]
+};
+
+// src/groups/w/tools/resmon.ts
+import open2 from "open";
+async function handler79(_args) {
+  await open2("resmon");
+}
+var commandDef79 = {
+  name: "resmon",
+  description: "\u8D44\u6E90\u76D1\u89C6\u5668",
+  handler: handler79,
+  examples: ["jc w resmon"]
+};
+
+// src/groups/w/tools/perfmon.ts
+import open3 from "open";
+async function handler80(_args) {
+  await open3("perfmon /report");
+}
+var commandDef80 = {
+  name: "perfmon",
+  description: "\u6027\u80FD\u76D1\u89C6\u5668",
+  handler: handler80,
+  examples: ["jc w perfmon"]
+};
+
+// src/groups/w/tools/eventvwr.ts
+import open4 from "open";
+async function handler81(_args) {
+  await open4("eventvwr.msc");
+}
+var commandDef81 = {
+  name: "eventvwr",
+  description: "\u4E8B\u4EF6\u67E5\u770B\u5668",
+  handler: handler81,
+  examples: ["jc w eventvwr"]
+};
+
+// src/groups/w/tools/devmgmt.ts
+import open5 from "open";
+async function handler82(_args) {
+  await open5("devmgmt.msc");
+}
+var commandDef82 = {
+  name: "devmgmt",
+  description: "\u8BBE\u5907\u7BA1\u7406\u5668",
+  handler: handler82,
+  examples: ["jc w devmgmt"]
+};
+
+// src/groups/w/tools/diskmgmt.ts
+import open6 from "open";
+async function handler83(_args) {
+  await open6("diskmgmt.msc");
+}
+var commandDef83 = {
+  name: "diskmgmt",
+  description: "\u78C1\u76D8\u7BA1\u7406",
+  handler: handler83,
+  examples: ["jc w diskmgmt"]
+};
+
+// src/groups/w/tools/msconfig.ts
+import open7 from "open";
+async function handler84(_args) {
+  await open7("msconfig");
+}
+var commandDef84 = {
+  name: "msconfig",
+  description: "\u7CFB\u7EDF\u914D\u7F6E",
+  handler: handler84,
+  examples: ["jc w msconfig"]
+};
+
+// src/groups/w/tools/reged.ts
+import open8 from "open";
+async function handler85(_args) {
+  await open8("regedit");
+}
+var commandDef85 = {
+  name: "reged",
+  description: "\u6CE8\u518C\u8868\u7F16\u8F91\u5668",
+  handler: handler85,
+  examples: ["jc w reged"]
+};
+
+// src/groups/w/tools/gpedit.ts
+import open9 from "open";
+async function handler86(_args) {
+  await open9("gpedit.msc");
+}
+var commandDef86 = {
+  name: "gpedit",
+  description: "\u7EC4\u7B56\u7565\u7F16\u8F91\u5668",
+  handler: handler86,
+  examples: ["jc w gpedit"]
+};
+
+// src/groups/w/tools/control.ts
+import open10 from "open";
+async function handler87(_args) {
+  await open10("control");
+}
+var commandDef87 = {
+  name: "control",
+  description: "\u63A7\u5236\u9762\u677F",
+  handler: handler87,
+  examples: ["jc w control"]
+};
+
+// src/groups/w/tools/services.ts
+import open11 from "open";
+async function handler88(_args) {
+  await open11("services.msc");
+}
+var commandDef88 = {
+  name: "services",
+  description: "\u670D\u52A1\u7BA1\u7406\u5668",
+  handler: handler88,
+  examples: ["jc w services"]
+};
+
+// src/groups/w/tools/here.ts
+import open12 from "open";
+async function handler89(_args) {
+  await open12(".");
+}
+var commandDef89 = {
+  name: "here",
+  description: "\u6253\u5F00\u5F53\u524D\u76EE\u5F55",
+  handler: handler89,
+  examples: ["jc w here"]
+};
+
+// src/groups/w/tools/wt.ts
+import open13 from "open";
+async function handler90(_args) {
+  await open13("wt");
+}
+var commandDef90 = {
+  name: "wt",
+  description: "\u6253\u5F00 Windows Terminal",
+  handler: handler90,
+  examples: ["jc w wt"]
+};
+
+// src/groups/w/tools/code.ts
+import open14 from "open";
+async function handler91(_args) {
+  await open14("code .");
+}
+var commandDef91 = {
+  name: "code",
+  description: "\u6253\u5F00 VS Code (\u5F53\u524D\u76EE\u5F55)",
+  handler: handler91,
+  examples: ["jc w code"]
+};
+
+// src/groups/w/user/who.ts
+import os from "os";
+async function handler92(_args) {
+  const info = os.userInfo();
+  console.log(`\u7528\u6237\u540D: ${info.username}`);
+  console.log(`\u7528\u6237\u76EE\u5F55: ${info.homedir}`);
+  console.log(`Shell: ${info.shell}`);
+}
+var commandDef92 = {
+  name: "who",
+  description: "\u5F53\u524D\u7528\u6237\u4FE1\u606F",
+  handler: handler92,
+  examples: ["jc w who"]
+};
+
+// src/groups/w/user/users.ts
+import { execSync as execSync24 } from "child_process";
+async function handler93(_args) {
+  if (process.platform === "win32") {
+    execSync24("net user", { stdio: "inherit" });
+  } else {
+    execSync24("cat /etc/passwd | cut -d: -f1,3,6,7", { stdio: "inherit" });
+  }
+}
+var commandDef93 = {
+  name: "users",
+  description: "\u5217\u51FA\u7CFB\u7EDF\u7528\u6237",
+  handler: handler93,
+  examples: ["jc w users"]
+};
+
+// src/groups/w/user/admin.ts
+import { execSync as execSync25 } from "child_process";
+async function handler94(_args) {
+  if (process.platform === "win32") {
+    try {
+      execSync25("net session", { stdio: "ignore" });
+      console.log("\u2705 \u4EE5\u7BA1\u7406\u5458\u8EAB\u4EFD\u8FD0\u884C");
+    } catch {
+      console.log("\u26A0\uFE0F \u975E\u7BA1\u7406\u5458\u8EAB\u4EFD\u8FD0\u884C");
+    }
+  } else {
+    console.log(process.getuid?.() === 0 ? "\u2705 \u4EE5 root \u8EAB\u4EFD\u8FD0\u884C" : "\u26A0\uFE0F \u4EE5\u666E\u901A\u7528\u6237\u8EAB\u4EFD\u8FD0\u884C");
+  }
+}
+var commandDef94 = {
+  name: "admin",
+  description: "\u68C0\u67E5\u662F\u5426\u7BA1\u7406\u5458/root",
+  handler: handler94,
+  examples: ["jc w admin"]
+};
+
+// src/groups/w/user/runas.ts
+import { execSync as execSync26 } from "child_process";
+async function handler95(_args) {
+  if (process.platform === "win32") {
+    execSync26('powershell -NoProfile "Start-Process cmd -Verb RunAs"', { stdio: "inherit" });
+  } else {
+    execSync26("sudo -i", { stdio: "inherit" });
+  }
+}
+var commandDef95 = {
+  name: "runas",
+  description: "\u4EE5\u7BA1\u7406\u5458/root \u8EAB\u4EFD\u8FD0\u884C",
+  handler: handler95,
+  examples: ["jc w runas"]
+};
+
+// src/groups/w/wsl/wsl.ts
+import { execSync as execSync27 } from "child_process";
+async function handler96(_args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  execSync27("wsl --list --verbose", { stdio: "inherit" });
+}
+var commandDef96 = {
+  name: "wsl",
+  description: "\u5217\u51FA WSL \u53D1\u884C\u7248",
+  handler: handler96,
+  platform: "win32"
+};
+
+// src/groups/w/wsl/wslkill.ts
+import { execSync as execSync28 } from "child_process";
+async function handler97(_args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  execSync28("wsl --shutdown", { stdio: "inherit" });
+}
+var commandDef97 = {
+  name: "wslkill",
+  description: "\u5173\u95ED\u6240\u6709 WSL \u5B9E\u4F8B",
+  handler: handler97,
+  platform: "win32"
+};
+
+// src/groups/w/wsl/docker.ts
+import { execSync as execSync29 } from "child_process";
+async function handler98(_args) {
+  if (process.platform !== "win32") {
+    console.error("\u274C \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    process.exit(3);
+  }
+  execSync29("docker ps -a", { stdio: "inherit" });
+}
+var commandDef98 = {
+  name: "docker",
+  description: "\u5217\u51FA Docker \u5BB9\u5668",
+  handler: handler98,
+  platform: "win32"
+};
+
+// src/groups/w/index.ts
+var procCategory = {
+  name: "proc",
+  description: "\u8FDB\u7A0B (8)",
+  commands: [commandDef12, commandDef13, commandDef14, commandDef15, commandDef16, commandDef17, commandDef18, commandDef19]
+};
+var sysCategory = {
+  name: "sys",
+  description: "\u7CFB\u7EDF\u4FE1\u606F (12)",
+  commands: [commandDef20, commandDef21, commandDef22, commandDef23, commandDef24, commandDef25, commandDef26, commandDef27, commandDef28, commandDef29, commandDef30, commandDef31]
+};
+var netCategory = {
+  name: "net",
+  description: "\u7F51\u7EDC (15)",
+  commands: [commandDef32, commandDef33, commandDef34, commandDef35, commandDef36, commandDef37, commandDef38, commandDef39, commandDef40, commandDef41, commandDef42, commandDef43, commandDef44, commandDef45, commandDef46]
+};
+var fileCategory = {
+  name: "file",
+  description: "\u6587\u4EF6/\u76EE\u5F55 (13)",
+  commands: [commandDef47, commandDef48, commandDef49, commandDef50, commandDef51, commandDef52, commandDef53, commandDef54, commandDef55, commandDef56, commandDef57, commandDef58, commandDef59]
+};
+var svcCategory = {
+  name: "svc",
+  description: "\u670D\u52A1 (5)",
+  commands: [commandDef60, commandDef61, commandDef62, commandDef63, commandDef64]
+};
+var pwrCategory = {
+  name: "pwr",
+  description: "\u7535\u6E90 (6)",
+  commands: [commandDef65, commandDef66, commandDef67, commandDef68, commandDef69, commandDef70]
+};
+var regCategory = {
+  name: "reg",
+  description: "\u6CE8\u518C\u8868 (4)",
+  commands: [commandDef71, commandDef72, commandDef73, commandDef74]
+};
+var taskCategory = {
+  name: "task",
+  description: "\u8BA1\u5212\u4EFB\u52A1 (3)",
+  commands: [commandDef75, commandDef76, commandDef77]
+};
+var toolsCategory = {
+  name: "tools",
+  description: "\u7CFB\u7EDF\u5DE5\u5177 (14)",
+  commands: [commandDef78, commandDef79, commandDef80, commandDef81, commandDef82, commandDef83, commandDef84, commandDef85, commandDef86, commandDef87, commandDef88, commandDef89, commandDef90, commandDef91]
+};
+var userCategory = {
+  name: "user",
+  description: "\u7528\u6237 (4)",
+  commands: [commandDef92, commandDef93, commandDef94, commandDef95]
+};
+var wslCategory = {
+  name: "wsl",
+  description: "WSL/Docker (3)",
+  commands: [commandDef96, commandDef97, commandDef98]
+};
+var wGroup = {
+  name: "w",
+  alias: "w",
+  description: "Windows \u5FEB\u6377\u547D\u4EE4\u96C6 / \u7CFB\u7EDF\u5DE5\u5177",
+  commands: [],
+  categories: [procCategory, sysCategory, netCategory, fileCategory, svcCategory, pwrCategory, regCategory, taskCategory, toolsCategory, userCategory, wslCategory]
+};
+
+// src/cli/router.ts
+function parseArgs(argv) {
+  if (argv.length === 0) return null;
+  if (argv.length === 1) return { group: argv[0], command: "", args: [] };
+  if (argv.length === 2 && argv[1] === "l") return { group: argv[0], command: "l", args: [] };
+  return { group: argv[0], command: argv[1], args: argv.slice(2) };
+}
+var groups = {};
+function registerGroup(group) {
+  groups[group.name] = group;
+  groups[group.alias] = group;
+}
+registerGroup(claudeGroup);
+registerGroup(happyGroup);
+registerGroup(wGroup);
+async function route(argv) {
+  const parsed = parseArgs(argv);
+  if (!parsed) {
+    console.log(`${jc} \u2014 j \u547D\u4EE4\u5957\u4EF6`);
+    console.log();
+    for (const [key, g] of Object.entries(groups)) {
+      if (key === g.name) {
+        console.log(`  ${jc} ${chalk2.yellow(g.name.padEnd(14))} ${g.description}`);
+      }
+    }
+    console.log();
+    console.log(`\u7528\u6CD5: ${jc} ${chalk2.yellow("<\u7EC4>")} ${chalk2.blue("<\u547D\u4EE4>")} [\u53C2\u6570...]`);
+    console.log(`\u67E5\u770B\u7EC4\u8BE6\u60C5: ${jc} ${chalk2.yellow("<\u7EC4>")} l`);
+    return;
+  }
+  const group = groups[parsed.group];
+  if (!group) {
+    console.error(`\u9519\u8BEF: \u672A\u77E5\u547D\u4EE4: ${parsed.group}`);
+    process.exit(1);
+  }
+  if (parsed.command === "l") {
+    printGroupHelp(group);
+    return;
+  }
+  if (parsed.command === "" || !parsed.command) {
+    if (group.defaultHandler) {
+      await group.defaultHandler(parsed.args);
+    } else {
+      printGroupHelp(group);
+    }
+    return;
+  }
+  const allCmds = group.categories ? group.categories.flatMap((c) => c.commands).concat(group.commands) : group.commands;
+  const cmd = allCmds.find((c) => c.name === parsed.command || c.alias?.includes(parsed.command));
+  if (cmd) {
+    if (parsed.args[0] === "?" || parsed.args[0] === "-h" || parsed.args[0] === "--help") {
+      printCommandHelp(cmd, parsed.group);
+      return;
+    }
+    if (cmd.platform === "win32" && process.platform !== "win32") {
+      console.error("\u9519\u8BEF: \u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+      process.exit(3);
+    }
+    await cmd.handler(parsed.args);
+    return;
+  }
+  if (group.categories) {
+    const cat = group.categories.find((c) => c.name === parsed.command);
+    if (cat) {
+      printCategoryHelp(cat);
+      return;
+    }
+  }
+  console.error(`\u9519\u8BEF: \u672A\u77E5\u547D\u4EE4: ${parsed.group} ${parsed.command}`);
+  process.exit(1);
+}
+
+// src/index.ts
+async function main() {
+  const args = process.argv.slice(2);
+  await route(args);
+}
+main().catch((err) => {
+  console.error("\u274C", err.message);
+  process.exit(1);
+});