hypercore-cli 1.1.0

package/dist/chunk-GOOTEPBK.js

@@ -0,0 +1,271 @@
+import {
+  hookManager
+} from "./chunk-B6A2AKLN.js";
+
+// src/llm/openai-compat.ts
+import OpenAI from "openai";
+function createOpenAIClient(config) {
+  return new OpenAI({
+    apiKey: config.apiKey,
+    baseURL: config.baseURL
+  });
+}
+async function triggerToolHook(event, context) {
+  try {
+    return await hookManager.trigger(event, context);
+  } catch {
+    return { intercepted: false };
+  }
+}
+async function callOpenAILLM(client, options) {
+  const {
+    systemPrompt,
+    userPrompt,
+    tools,
+    model = "gemini-2.5-flash",
+    maxTokens = 8192,
+    onText,
+    onToolCall,
+    onThinking,
+    onToolCallDone
+  } = options;
+  const toolDefinitions = tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.definition.name,
+      description: t.definition.description,
+      parameters: t.definition.input_schema
+    }
+  }));
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+  let totalOutput = "";
+  let currentRoundText = "";
+  const allToolCalls = [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let maxIterations = 10;
+  while (maxIterations-- > 0) {
+    currentRoundText = "";
+    const response = await client.chat.completions.create({
+      model,
+      max_tokens: maxTokens,
+      messages,
+      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0
+    });
+    if (response.usage) {
+      totalInputTokens += response.usage.prompt_tokens || 0;
+      totalOutputTokens += response.usage.completion_tokens || 0;
+    }
+    const choice = response.choices[0];
+    if (!choice) break;
+    const message = choice.message;
+    if (message.content) {
+      totalOutput += message.content;
+      currentRoundText += message.content;
+      onText?.(message.content);
+    }
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      if (currentRoundText.trim()) {
+        onThinking?.(currentRoundText.trim());
+      }
+      messages.push(message);
+      for (const toolCall of message.tool_calls) {
+        const fn = toolCall.function;
+        const fnName = fn.name;
+        let fnArgs = {};
+        try {
+          fnArgs = JSON.parse(fn.arguments || "{}");
+        } catch {
+        }
+        const toolInputText = JSON.stringify(fnArgs);
+        onToolCall?.(fnName, fnArgs);
+        const tool = tools.find((t) => t.definition.name === fnName);
+        let result;
+        const toolStart = Date.now();
+        const hookResult = await triggerToolHook("onToolCall", {
+          model,
+          toolName: fnName,
+          toolInput: toolInputText
+        });
+        if (hookResult.intercepted) {
+          result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
+        } else if (tool) {
+          try {
+            result = await tool.handler(fnArgs);
+          } catch (err) {
+            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        } else {
+          result = `Error: Tool "${fnName}" not found`;
+        }
+        const toolDuration = Date.now() - toolStart;
+        onToolCallDone?.(fnName, toolDuration);
+        await triggerToolHook("onToolResult", {
+          model,
+          toolName: fnName,
+          toolInput: toolInputText,
+          toolResult: result
+        });
+        allToolCalls.push({
+          toolName: fnName,
+          input: fnArgs,
+          output: result
+        });
+        messages.push({
+          role: "tool",
+          tool_call_id: toolCall.id,
+          content: result
+        });
+      }
+      continue;
+    }
+    break;
+  }
+  return {
+    output: totalOutput,
+    responseText: allToolCalls.length > 0 ? currentRoundText : totalOutput,
+    toolCalls: allToolCalls,
+    tokenUsage: {
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    }
+  };
+}
+async function streamOpenAIChat(client, messages, options) {
+  const { model, tools = [], onChunk, onToolCall, onThinking, onToolCallDone } = options;
+  const toolDefinitions = tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.definition.name,
+      description: t.definition.description,
+      parameters: t.definition.input_schema
+    }
+  }));
+  let totalContent = "";
+  let currentRoundContent = "";
+  let hasCalledTools = false;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let maxIterations = 10;
+  while (maxIterations-- > 0) {
+    currentRoundContent = "";
+    let stream;
+    let lastError;
+    for (let retry = 0; retry < 5; retry++) {
+      try {
+        stream = await client.chat.completions.create({
+          model,
+          max_tokens: 4096,
+          messages,
+          tools: toolDefinitions.length > 0 ? toolDefinitions : void 0,
+          stream: true
+        });
+        lastError = null;
+        break;
+      } catch (err) {
+        lastError = err;
+        const status = err.status;
+        if (status === 429) {
+          const wait = (retry + 1) * 5e3;
+          process.stdout.write(`\x1B[2m  \u23F3 API \u9650\u6D41\uFF0C${wait / 1e3}s \u540E\u91CD\u8BD5...\x1B[0m
+`);
+          await new Promise((r) => setTimeout(r, wait));
+          continue;
+        }
+        throw err;
+      }
+    }
+    if (lastError) throw lastError;
+    let chunkContent = "";
+    const toolCalls = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        chunkContent += delta.content;
+        totalContent += delta.content;
+        currentRoundContent += delta.content;
+        onChunk?.(delta.content);
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const existing = toolCalls.get(tc.index) || { id: "", name: "", args: "" };
+          if (tc.id) existing.id = tc.id;
+          if (tc.function?.name) existing.name = tc.function.name;
+          if (tc.function?.arguments) existing.args += tc.function.arguments;
+          toolCalls.set(tc.index, existing);
+        }
+      }
+      if (chunk.usage) {
+        totalInputTokens += chunk.usage.prompt_tokens || 0;
+        totalOutputTokens += chunk.usage.completion_tokens || 0;
+      }
+    }
+    if (toolCalls.size === 0) break;
+    hasCalledTools = true;
+    if (chunkContent.trim()) {
+      onThinking?.(chunkContent.trim());
+    }
+    const assistantMessage = {
+      role: "assistant",
+      content: chunkContent || null,
+      tool_calls: Array.from(toolCalls.values()).map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.args }
+      }))
+    };
+    messages.push(assistantMessage);
+    for (const [, tc] of toolCalls) {
+      let fnArgs = {};
+      try {
+        fnArgs = JSON.parse(tc.args || "{}");
+      } catch {
+      }
+      onToolCall?.(tc.name, fnArgs);
+      const toolInputText = JSON.stringify(fnArgs);
+      const tool = tools.find((t) => t.definition.name === tc.name);
+      let result;
+      const toolStart = Date.now();
+      const hookResult = await triggerToolHook("onToolCall", {
+        model,
+        toolName: tc.name,
+        toolInput: toolInputText
+      });
+      if (hookResult.intercepted) {
+        result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
+      } else if (tool) {
+        try {
+          result = await tool.handler(fnArgs);
+        } catch (err) {
+          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      } else {
+        result = `Error: Tool "${tc.name}" not found`;
+      }
+      const toolDuration = Date.now() - toolStart;
+      onToolCallDone?.(tc.name, toolDuration);
+      await triggerToolHook("onToolResult", {
+        model,
+        toolName: tc.name,
+        toolInput: toolInputText,
+        toolResult: result
+      });
+      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+    }
+  }
+  return {
+    content: totalContent,
+    responseContent: hasCalledTools ? currentRoundContent : totalContent,
+    tokenUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
+  };
+}
+
+export {
+  createOpenAIClient,
+  callOpenAILLM,
+  streamOpenAIChat
+};

package/dist/chunk-GPPMJYSM.js

@@ -0,0 +1,133 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/core/instance-registry.ts
+import { readFile, writeFile, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+var REGISTRY_PATH = join(HYPERCORE_DIR, "instances.json");
+var LOCK_PATH = join(HYPERCORE_DIR, "instances.lock");
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withLock(fn) {
+  const maxRetries = 5;
+  const baseDelay = 50;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      await writeFile(LOCK_PATH, String(process.pid), { flag: "wx" });
+      try {
+        return await fn();
+      } finally {
+        await unlink(LOCK_PATH).catch(() => {
+        });
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code === "EEXIST") {
+        try {
+          const lockPid = parseInt(await readFile(LOCK_PATH, "utf-8"), 10);
+          if (!isPidAlive(lockPid)) {
+            await unlink(LOCK_PATH).catch(() => {
+            });
+          } else {
+            await new Promise((r) => setTimeout(r, baseDelay * (i + 1)));
+          }
+        } catch {
+          await unlink(LOCK_PATH).catch(() => {
+          });
+        }
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Failed to acquire instance registry lock after " + maxRetries + " retries");
+}
+async function readRegistry() {
+  try {
+    if (!existsSync(REGISTRY_PATH)) {
+      return { instances: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    const data = JSON.parse(await readFile(REGISTRY_PATH, "utf-8"));
+    return data;
+  } catch {
+    return { instances: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeRegistry(registry) {
+  registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
+}
+async function registerInstance(instance) {
+  await withLock(async () => {
+    const registry = await readRegistry();
+    registry.instances = registry.instances.filter(
+      (inst) => inst.pid !== instance.pid && isPidAlive(inst.pid)
+    );
+    registry.instances.push(instance);
+    await writeRegistry(registry);
+  });
+}
+async function updateInstanceRuntime(pid, patch) {
+  if (Object.keys(patch).length === 0) return;
+  await withLock(async () => {
+    const registry = await readRegistry();
+    let changed = false;
+    const aliveInstances = registry.instances.filter((inst) => isPidAlive(inst.pid));
+    if (aliveInstances.length !== registry.instances.length) {
+      changed = true;
+    }
+    registry.instances = aliveInstances.map((inst) => {
+      if (inst.pid !== pid) return inst;
+      changed = true;
+      return { ...inst, ...patch };
+    });
+    if (changed) {
+      await writeRegistry(registry);
+    }
+  });
+}
+async function unregisterInstance(pid) {
+  await withLock(async () => {
+    const registry = await readRegistry();
+    registry.instances = registry.instances.filter((inst) => inst.pid !== pid);
+    await writeRegistry(registry);
+  });
+}
+async function listInstances() {
+  const registry = await readRegistry();
+  const alive = registry.instances.filter((inst) => isPidAlive(inst.pid));
+  if (alive.length !== registry.instances.length) {
+    withLock(async () => {
+      const fresh = await readRegistry();
+      fresh.instances = fresh.instances.filter((inst) => isPidAlive(inst.pid));
+      await writeRegistry(fresh);
+    }).catch(() => {
+    });
+  }
+  return alive;
+}
+async function getCanonicalDashboardPort(fallbackPort = 3210) {
+  try {
+    const instances = await listInstances();
+    if (instances.length === 0) return fallbackPort;
+    return Math.min(...instances.map((i) => i.port));
+  } catch {
+    return fallbackPort;
+  }
+}
+
+export {
+  registerInstance,
+  updateInstanceRuntime,
+  unregisterInstance,
+  listInstances,
+  getCanonicalDashboardPort
+};

package/dist/chunk-GU2FZQ6A.js

@@ -0,0 +1,69 @@
+// src/core/permissions.ts
+import chalk from "chalk";
+import { confirm } from "@inquirer/prompts";
+var TOOL_PERMISSIONS = {
+  // safe — 只读操作
+  file_read: "safe",
+  glob: "safe",
+  grep: "safe",
+  web_fetch: "safe",
+  web_search: "safe",
+  memory_search: "safe",
+  notebook_read: "safe",
+  task_output: "safe",
+  sub_agent: "safe",
+  // write — 文件修改操作
+  file_write: "write",
+  file_edit: "write",
+  memory_save: "write",
+  notebook_edit: "write",
+  // dangerous — 系统级操作
+  bash: "dangerous"
+};
+function getToolPermission(toolName) {
+  if (TOOL_PERMISSIONS[toolName]) return TOOL_PERMISSIONS[toolName];
+  if (toolName.startsWith("mcp_")) return "write";
+  return "write";
+}
+function wrapToolWithPermission(tool, config) {
+  const level = getToolPermission(tool.definition.name);
+  if (level === "safe") return tool;
+  const originalHandler = tool.handler;
+  return {
+    definition: tool.definition,
+    handler: async (input) => {
+      const mode = config.permissionMode || "full";
+      if (mode === "full") return originalHandler(input);
+      if (mode === "safe") {
+        return `\u26D4 \u6743\u9650\u62D2\u7EDD: \u5F53\u524D\u4E3A safe \u6A21\u5F0F\uFF0C\u5DE5\u5177 "${tool.definition.name}" (${level}) \u4E0D\u53EF\u7528\u3002\u4F7F\u7528 /permissions full \u5207\u6362\u6A21\u5F0F\u3002`;
+      }
+      if (mode === "ask") {
+        const inputPreview = JSON.stringify(input).slice(0, 200);
+        console.log(chalk.yellow(`
+  \u26A0\uFE0F \u6743\u9650\u786E\u8BA4: ${tool.definition.name} [${level}]`));
+        console.log(chalk.dim(`  \u8F93\u5165: ${inputPreview}`));
+        try {
+          const yes = await confirm({
+            message: `\u5141\u8BB8\u6267\u884C ${tool.definition.name}?`,
+            default: true
+          });
+          if (!yes) {
+            return `\u26D4 \u7528\u6237\u62D2\u7EDD\u6267\u884C "${tool.definition.name}"`;
+          }
+        } catch {
+          return `\u26D4 \u7528\u6237\u53D6\u6D88\u6267\u884C "${tool.definition.name}"`;
+        }
+      }
+      return originalHandler(input);
+    }
+  };
+}
+function applyPermissions(tools, config) {
+  return tools.map((t) => wrapToolWithPermission(t, config));
+}
+
+export {
+  getToolPermission,
+  wrapToolWithPermission,
+  applyPermissions
+};

package/dist/chunk-IOPKN5GD.js

@@ -0,0 +1,190 @@
+import {
+  getEventsSummary
+} from "./chunk-2CMSCWQW.js";
+import {
+  getItem,
+  listItems,
+  updateItemMetrics
+} from "./chunk-MGLJ53QN.js";
+
+// src/admin/verify.ts
+function inferBaselineKey(item) {
+  const titleLower = item.title.toLowerCase();
+  const descLower = item.description.toLowerCase();
+  const text = titleLower + " " + descLower;
+  if (text.includes("\u5931\u8D25\u7387") || text.includes("fail")) {
+    const cmdMatch = text.match(/(\/\w+)\s+失败/) || text.match(/(\/\w+).*fail/);
+    if (cmdMatch) return `cmd_fail_rate:${cmdMatch[1]}`;
+    return "cmd_fail_rate:all";
+  }
+  if (text.includes("\u9519\u8BEF") || text.includes("error")) {
+    return "error_count";
+  }
+  if (text.includes("\u8017\u65F6") || text.includes("\u6027\u80FD") || text.includes("perf") || text.includes("duration")) {
+    return "avg_session_rounds";
+  }
+  if (text.includes("\u4F1A\u8BDD") || text.includes("session") || text.includes("\u8F6E\u6B21")) {
+    return "avg_session_rounds";
+  }
+  if (text.includes("test") || text.includes("\u6D4B\u8BD5")) {
+    return "test_pass_rate";
+  }
+  if (text.includes("todo") || text.includes("fixme") || text.includes("\u6280\u672F\u503A")) {
+    return "todo_count";
+  }
+  if (text.includes("\u4F53\u79EF") || text.includes("size") || text.includes("bundle")) {
+    return "package_size";
+  }
+  if (item.type === "bugfix") return "error_count";
+  if (item.type === "improvement") return "avg_session_rounds";
+  return null;
+}
+async function getMetricValue(key, days = 7) {
+  if (key.startsWith("cmd_fail_rate:")) {
+    const cmd = key.replace("cmd_fail_rate:", "");
+    const summary = await getEventsSummary(days);
+    if (cmd === "all") {
+      let total = 0, fail = 0;
+      for (const stats2 of Object.values(summary.cmdCounts)) {
+        total += stats2.total;
+        fail += stats2.fail;
+      }
+      return total > 0 ? Math.round(fail / total * 1e3) / 10 : 0;
+    }
+    const stats = summary.cmdCounts[cmd];
+    if (!stats || stats.total === 0) return 0;
+    return Math.round(stats.fail / stats.total * 1e3) / 10;
+  }
+  if (key === "error_count") {
+    const summary = await getEventsSummary(days);
+    return summary.errors.reduce((s, e) => s + e.count, 0);
+  }
+  if (key === "avg_session_rounds") {
+    const summary = await getEventsSummary(days);
+    return summary.avgSessionRounds;
+  }
+  if (key === "test_pass_rate") {
+    const { checkTests } = await import("./quality-ST7PPNFR.js");
+    const result = await checkTests(process.cwd());
+    return result.value ?? null;
+  }
+  if (key === "todo_count") {
+    const { checkTodos } = await import("./quality-ST7PPNFR.js");
+    const result = await checkTodos(process.cwd());
+    return result.value ?? null;
+  }
+  if (key === "package_size") {
+    const { checkPackageSize } = await import("./quality-ST7PPNFR.js");
+    const result = await checkPackageSize(process.cwd());
+    return result.value ?? null;
+  }
+  return null;
+}
+async function recordBaseline(itemId) {
+  const item = await getItem(itemId);
+  if (!item) return null;
+  if (item.metrics.baselineKey && item.metrics.baselineValue !== null) {
+    return { key: item.metrics.baselineKey, value: item.metrics.baselineValue };
+  }
+  const key = inferBaselineKey(item);
+  if (!key) return null;
+  const value = await getMetricValue(key);
+  if (value === null) return null;
+  const metrics = {
+    ...item.metrics,
+    baselineKey: key,
+    baselineValue: value,
+    baselineDate: (/* @__PURE__ */ new Date()).toISOString(),
+    verified: false
+  };
+  const updated = await updateItemMetrics(itemId, metrics);
+  if (!updated) return null;
+  return { key, value };
+}
+async function verifyCompletedItems() {
+  const items = await listItems({ status: "done" });
+  const results = [];
+  for (const item of items) {
+    if (!item.metrics.baselineKey || item.metrics.baselineValue === null) continue;
+    if (item.metrics.verified) continue;
+    const currentValue = await getMetricValue(item.metrics.baselineKey);
+    let changePercent = null;
+    let verdict = "no-data";
+    let detail = "";
+    if (currentValue === null) {
+      verdict = "no-data";
+      detail = `\u65E0\u6CD5\u83B7\u53D6 ${item.metrics.baselineKey} \u7684\u5F53\u524D\u503C`;
+    } else {
+      const baseline = item.metrics.baselineValue;
+      if (baseline === 0) {
+        changePercent = currentValue === 0 ? 0 : 100;
+        verdict = currentValue <= 0 ? "effective" : "pending";
+        detail = `\u57FA\u7EBF: 0 \u2192 \u5F53\u524D: ${currentValue}`;
+      } else {
+        changePercent = Math.round((currentValue - baseline) / Math.abs(baseline) * 1e3) / 10;
+        const lowerIsBetter = isLowerBetter(item.metrics.baselineKey);
+        if (lowerIsBetter) {
+          if (changePercent <= -50) {
+            verdict = "effective";
+            detail = `\u4E0B\u964D ${Math.abs(changePercent)}% (${baseline} \u2192 ${currentValue})`;
+          } else if (changePercent <= -20) {
+            verdict = "pending";
+            detail = `\u4E0B\u964D ${Math.abs(changePercent)}%\uFF0C\u5F85\u8FDB\u4E00\u6B65\u89C2\u5BDF (${baseline} \u2192 ${currentValue})`;
+          } else {
+            verdict = "ineffective";
+            detail = changePercent >= 0 ? `\u672A\u6539\u5584\uFF0C\u53CD\u5347 ${changePercent}% (${baseline} \u2192 ${currentValue})` : `\u4EC5\u4E0B\u964D ${Math.abs(changePercent)}% (${baseline} \u2192 ${currentValue})`;
+          }
+        } else {
+          if (changePercent >= 50) {
+            verdict = "effective";
+            detail = `\u4E0A\u5347 ${changePercent}% (${baseline} \u2192 ${currentValue})`;
+          } else if (changePercent >= 20) {
+            verdict = "pending";
+            detail = `\u4E0A\u5347 ${changePercent}%\uFF0C\u5F85\u8FDB\u4E00\u6B65\u89C2\u5BDF (${baseline} \u2192 ${currentValue})`;
+          } else {
+            verdict = "ineffective";
+            detail = changePercent <= 0 ? `\u672A\u6539\u5584\uFF0C\u53CD\u964D ${Math.abs(changePercent)}% (${baseline} \u2192 ${currentValue})` : `\u4EC5\u4E0A\u5347 ${changePercent}% (${baseline} \u2192 ${currentValue})`;
+          }
+        }
+      }
+      item.metrics.afterValue = currentValue;
+      item.metrics.afterDate = (/* @__PURE__ */ new Date()).toISOString();
+      if (verdict === "effective" || verdict === "ineffective") {
+        item.metrics.verified = true;
+      }
+      await updateItemMetrics(item.id, item.metrics);
+    }
+    results.push({
+      itemId: item.id,
+      title: item.title,
+      baselineKey: item.metrics.baselineKey,
+      baselineValue: item.metrics.baselineValue,
+      afterValue: currentValue,
+      changePercent,
+      verdict,
+      detail
+    });
+  }
+  const summary = {
+    total: results.length,
+    effective: results.filter((r) => r.verdict === "effective").length,
+    ineffective: results.filter((r) => r.verdict === "ineffective").length,
+    pending: results.filter((r) => r.verdict === "pending").length,
+    noData: results.filter((r) => r.verdict === "no-data").length
+  };
+  return { timestamp: (/* @__PURE__ */ new Date()).toISOString(), results, summary };
+}
+function isLowerBetter(key) {
+  if (key.startsWith("cmd_fail_rate")) return true;
+  if (key === "error_count") return true;
+  if (key === "todo_count") return true;
+  if (key === "package_size") return true;
+  return false;
+}
+
+export {
+  inferBaselineKey,
+  getMetricValue,
+  recordBaseline,
+  verifyCompletedItems
+};