hypercore-cli 1.1.0

package/dist/chunk-ZSBHUGWR.js

@@ -0,0 +1,262 @@
+// src/admin/quality.ts
+import { execSync } from "child_process";
+import { join } from "path";
+import { readFile, stat, readdir } from "fs/promises";
+import { existsSync } from "fs";
+function toText(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("utf-8");
+  return "";
+}
+function getExecErrorOutput(err) {
+  if (err && typeof err === "object") {
+    const stdout = toText(err.stdout);
+    const stderr = toText(err.stderr);
+    const merged = [stdout, stderr].filter(Boolean).join("\n").trim();
+    if (merged) return merged;
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+async function walkFiles(dir, accept, out = []) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiles(fullPath, accept, out);
+      continue;
+    }
+    if (entry.isFile() && accept(fullPath)) {
+      out.push(fullPath);
+    }
+  }
+  return out;
+}
+async function checkTests(projectRoot) {
+  try {
+    const output = execSync("npm test -- --reporter=verbose", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const passMatch = output.match(/(\d+)\s+passed/);
+    const failMatch = output.match(/(\d+)\s+failed/);
+    const passed = passMatch ? parseInt(passMatch[1]) : 0;
+    const failed = failMatch ? parseInt(failMatch[1]) : 0;
+    const total = passed + failed;
+    return {
+      name: "\u6D4B\u8BD5\u901A\u8FC7\u7387",
+      ok: failed === 0 && passed > 0,
+      detail: `${passed}/${total} \u901A\u8FC7${failed > 0 ? `\uFF0C${failed} \u5931\u8D25` : ""}`,
+      value: total > 0 ? Math.round(passed / total * 100) : 0,
+      unit: "%"
+    };
+  } catch (err) {
+    const output = getExecErrorOutput(err);
+    const passMatch = output.match(/(\d+)\s+passed/);
+    const failMatch = output.match(/(\d+)\s+failed/);
+    if (passMatch || failMatch) {
+      const passed = passMatch ? parseInt(passMatch[1]) : 0;
+      const failed = failMatch ? parseInt(failMatch[1]) : 0;
+      return {
+        name: "\u6D4B\u8BD5\u901A\u8FC7\u7387",
+        ok: false,
+        detail: `${passed}/${passed + failed} \u901A\u8FC7\uFF0C${failed} \u5931\u8D25`,
+        value: passed + failed > 0 ? Math.round(passed / (passed + failed) * 100) : 0,
+        unit: "%"
+      };
+    }
+    return {
+      name: "\u6D4B\u8BD5\u901A\u8FC7\u7387",
+      ok: false,
+      detail: `\u6D4B\u8BD5\u8FD0\u884C\u5931\u8D25: ${output.slice(0, 100)}`
+    };
+  }
+}
+async function checkTodos(projectRoot) {
+  try {
+    const srcDir = join(projectRoot, "src");
+    if (!existsSync(srcDir)) {
+      return { name: "TODO \u626B\u63CF", ok: true, detail: "src \u76EE\u5F55\u4E0D\u5B58\u5728", value: 0, unit: "\u4E2A" };
+    }
+    const todos = [];
+    const files = await walkFiles(srcDir, (file) => file.endsWith(".ts") || file.endsWith(".js"));
+    for (const file of files) {
+      const content = await readFile(file, "utf-8");
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const text = lines[i];
+        const typeMatch = text.match(/(TODO|FIXME|HACK|XXX)/i);
+        if (!typeMatch) continue;
+        todos.push({
+          file: file.replace(`${projectRoot}/`, ""),
+          line: i + 1,
+          text: text.trim().slice(0, 80),
+          type: typeMatch[1].toUpperCase()
+        });
+      }
+    }
+    const byType = {};
+    for (const t of todos) {
+      byType[t.type] = (byType[t.type] || 0) + 1;
+    }
+    const typeSummary = Object.entries(byType).map(([t, c]) => `${t}:${c}`).join(" ");
+    return {
+      name: "TODO \u626B\u63CF",
+      ok: todos.length <= 10,
+      detail: todos.length === 0 ? "\u65E0\u672A\u5904\u7406\u6807\u8BB0" : `${todos.length} \u4E2A\u6807\u8BB0 (${typeSummary})`,
+      value: todos.length,
+      unit: "\u4E2A"
+    };
+  } catch {
+    return { name: "TODO \u626B\u63CF", ok: true, detail: "\u626B\u63CF\u5931\u8D25\uFF0C\u8DF3\u8FC7", value: 0, unit: "\u4E2A" };
+  }
+}
+async function checkDeps(projectRoot) {
+  try {
+    let auditIssues = 0;
+    try {
+      execSync("npm audit --json", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        timeout: 3e4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      const msg = getExecErrorOutput(err);
+      if (msg) {
+        try {
+          const audit = JSON.parse(msg);
+          auditIssues = audit?.metadata?.vulnerabilities?.total || 0;
+        } catch {
+        }
+      }
+    }
+    let outdated = 0;
+    try {
+      execSync("npm outdated --json", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        timeout: 3e4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      const msg = getExecErrorOutput(err);
+      if (msg) {
+        try {
+          const pkgs = JSON.parse(msg);
+          outdated = Object.keys(pkgs).length;
+        } catch {
+        }
+      }
+    }
+    const parts = [];
+    if (auditIssues > 0) parts.push(`${auditIssues} \u5B89\u5168\u6F0F\u6D1E`);
+    if (outdated > 0) parts.push(`${outdated} \u8FC7\u671F\u4F9D\u8D56`);
+    if (parts.length === 0) parts.push("\u4F9D\u8D56\u5065\u5EB7");
+    return {
+      name: "\u4F9D\u8D56\u68C0\u67E5",
+      ok: auditIssues === 0,
+      detail: parts.join(", "),
+      value: auditIssues,
+      unit: "\u6F0F\u6D1E"
+    };
+  } catch {
+    return { name: "\u4F9D\u8D56\u68C0\u67E5", ok: true, detail: "\u68C0\u67E5\u5931\u8D25\uFF0C\u8DF3\u8FC7" };
+  }
+}
+async function checkPackageSize(projectRoot) {
+  const distDir = join(projectRoot, "dist");
+  if (!existsSync(distDir)) {
+    return { name: "\u5305\u4F53\u79EF", ok: false, detail: "dist/ \u4E0D\u5B58\u5728\uFF0C\u5148\u8FD0\u884C build" };
+  }
+  try {
+    const files = await walkFiles(
+      distDir,
+      (file) => file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs")
+    );
+    let totalBytes = 0;
+    for (const file of files) {
+      const fileStat = await stat(file);
+      totalBytes += fileStat.size;
+    }
+    const sizeMB = (totalBytes / 1024 / 1024).toFixed(2);
+    return {
+      name: "\u5305\u4F53\u79EF",
+      ok: totalBytes < 5 * 1024 * 1024,
+      // < 5MB
+      detail: `${sizeMB} MB`,
+      value: totalBytes,
+      unit: "bytes"
+    };
+  } catch {
+    return { name: "\u5305\u4F53\u79EF", ok: true, detail: "\u4F53\u79EF\u8BA1\u7B97\u5931\u8D25\uFF0C\u8DF3\u8FC7" };
+  }
+}
+async function checkBuild(projectRoot) {
+  try {
+    execSync("npm run build", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { name: "Build", ok: true, detail: "\u7F16\u8BD1\u6210\u529F" };
+  } catch (err) {
+    const msg = getExecErrorOutput(err);
+    return { name: "Build", ok: false, detail: `\u7F16\u8BD1\u5931\u8D25: ${msg.slice(0, 100)}` };
+  }
+}
+async function runQualityReport(projectRoot, options) {
+  const checks = [];
+  const [todoResult, depResult, sizeResult] = await Promise.all([
+    checkTodos(projectRoot),
+    checkDeps(projectRoot),
+    checkPackageSize(projectRoot)
+  ]);
+  checks.push(todoResult, depResult, sizeResult);
+  if (!options?.skipBuild) {
+    checks.push(await checkBuild(projectRoot));
+  }
+  if (!options?.skipTests) {
+    checks.push(await checkTests(projectRoot));
+  }
+  const score = calculateScore(checks);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot,
+    checks,
+    score
+  };
+}
+function calculateScore(checks) {
+  if (checks.length === 0) return 0;
+  const weights = {
+    "\u6D4B\u8BD5\u901A\u8FC7\u7387": 30,
+    "Build": 25,
+    "\u4F9D\u8D56\u68C0\u67E5": 20,
+    "TODO \u626B\u63CF": 15,
+    "\u5305\u4F53\u79EF": 10
+  };
+  let totalWeight = 0;
+  let weightedScore = 0;
+  for (const c of checks) {
+    const w = weights[c.name] || 10;
+    totalWeight += w;
+    if (c.ok) {
+      weightedScore += w;
+    } else if (c.value !== void 0 && c.unit === "%") {
+      weightedScore += w * (c.value / 100);
+    }
+  }
+  return totalWeight > 0 ? Math.round(weightedScore / totalWeight * 100) : 0;
+}
+
+export {
+  checkTests,
+  checkTodos,
+  checkDeps,
+  checkPackageSize,
+  checkBuild,
+  runQualityReport
+};

package/dist/claude-NSQ442XD.js

@@ -0,0 +1,12 @@
+import {
+  callLLM,
+  createLLMClient,
+  streamCallLLM
+} from "./chunk-43OLRXM5.js";
+import "./chunk-B6A2AKLN.js";
+import "./chunk-V5UHPPSY.js";
+export {
+  callLLM,
+  createLLMClient,
+  streamCallLLM
+};

package/dist/commands-CK3WFAGI.js

@@ -0,0 +1,128 @@
+import {
+  loadLocalToken
+} from "./chunk-XDRCBMZZ.js";
+import {
+  showError,
+  showTaskList,
+  showTeamStatus
+} from "./chunk-R3GPQC7I.js";
+import "./chunk-BE46C7JW.js";
+import "./chunk-RNG3K465.js";
+import "./chunk-V5UHPPSY.js";
+
+// src/team/commands.ts
+import chalk from "chalk";
+function createTeamSlashCommands() {
+  return [
+    {
+      name: "team",
+      description: "\u67E5\u770B\u56E2\u961F\u72B6\u6001",
+      category: "team",
+      handler: async (_args, _ctx) => {
+        const token = await loadLocalToken();
+        if (!token) {
+          console.log(chalk.dim("\n  \u672A\u52A0\u5165\u56E2\u961F\u3002\u8BF7\u4F7F\u7528 hyper team create \u6216 hyper team join\n"));
+          return;
+        }
+        try {
+          const resp = await fetch(`${token.serverUrl}/api/team/${token.teamId}/status`, {
+            headers: { "Authorization": `Bearer ${token.token}` }
+          });
+          if (!resp.ok) {
+            showError("\u65E0\u6CD5\u83B7\u53D6\u56E2\u961F\u72B6\u6001");
+            return;
+          }
+          const data = await resp.json();
+          showTeamStatus(data.team, data.members, token);
+        } catch (err) {
+          showError(`\u8FDE\u63A5\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+          console.log(chalk.dim("  \u8BF7\u786E\u4FDD\u56E2\u961F\u670D\u52A1\u5668\u5DF2\u542F\u52A8\uFF08hypercore web\uFF09"));
+        }
+      }
+    },
+    {
+      name: "task",
+      aliases: ["tasks"],
+      description: "\u56E2\u961F\u4EFB\u52A1 (add/list/done)",
+      category: "team",
+      handler: async (args, _ctx) => {
+        const token = await loadLocalToken();
+        if (!token) {
+          console.log(chalk.dim("\n  \u672A\u52A0\u5165\u56E2\u961F\n"));
+          return;
+        }
+        const sub = args[0] || "list";
+        const baseUrl = `${token.serverUrl}/api/team/${token.teamId}`;
+        const headers = {
+          "Authorization": `Bearer ${token.token}`,
+          "Content-Type": "application/json"
+        };
+        try {
+          if (sub === "list" || sub === "ls") {
+            const resp = await fetch(`${baseUrl}/tasks`, { headers });
+            const data = await resp.json();
+            showTaskList(data.tasks);
+          } else if (sub === "add") {
+            const title = args.slice(1).join(" ");
+            if (!title) {
+              console.log(chalk.dim("\n  \u7528\u6CD5: /task add <\u6807\u9898>\n"));
+              return;
+            }
+            const resp = await fetch(`${baseUrl}/tasks`, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({ title })
+            });
+            const data = await resp.json();
+            console.log(chalk.green(`
+  \u2705 \u4EFB\u52A1 #${data.task.id} \u5DF2\u521B\u5EFA: ${data.task.title}
+`));
+          } else if (sub === "done") {
+            const taskId = args[1];
+            if (!taskId) {
+              console.log(chalk.dim("\n  \u7528\u6CD5: /task done <id>\n"));
+              return;
+            }
+            await fetch(`${baseUrl}/tasks/${taskId}`, {
+              method: "PUT",
+              headers,
+              body: JSON.stringify({ status: "done" })
+            });
+            console.log(chalk.green(`
+  \u2705 \u4EFB\u52A1 #${taskId} \u5DF2\u5B8C\u6210
+`));
+          } else if (sub === "assign") {
+            const taskId = args[1];
+            const memberName = args[2];
+            if (!taskId || !memberName) {
+              console.log(chalk.dim("\n  \u7528\u6CD5: /task assign <id> <\u6210\u5458>\n"));
+              return;
+            }
+            const statusResp = await fetch(`${token.serverUrl}/api/team/${token.teamId}/status`, { headers });
+            const statusData = await statusResp.json();
+            const target = statusData.members.find((m) => m.name === memberName || m.id === memberName);
+            if (!target) {
+              showError(`\u672A\u627E\u5230\u6210\u5458: ${memberName}`);
+              return;
+            }
+            await fetch(`${baseUrl}/tasks/${taskId}`, {
+              method: "PUT",
+              headers,
+              body: JSON.stringify({ assignee: target.id, status: "doing" })
+            });
+            console.log(chalk.green(`
+  \u2705 \u4EFB\u52A1 #${taskId} \u5DF2\u5206\u914D\u7ED9 ${target.name}
+`));
+          } else {
+            console.log(chalk.dim("\n  \u7528\u6CD5: /task [list|add|done|assign]\n"));
+          }
+        } catch (err) {
+          showError(`\u8BF7\u6C42\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  ];
+}
+export {
+  createTeamSlashCommands
+};