hypercore-cli 1.1.0

package/dist/chunk-3RPFCQKJ.js

@@ -0,0 +1,288 @@
+import {
+  getEventsSummary,
+  readEvents
+} from "./chunk-2CMSCWQW.js";
+import {
+  addItem,
+  listItems
+} from "./chunk-MGLJ53QN.js";
+
+// src/admin/diagnose.ts
+async function runRuleDiagnosis(days = 7) {
+  const findings = [];
+  const events = await readEvents(days);
+  const summary = await getEventsSummary(days);
+  if (events.length === 0) {
+    return [{
+      severity: "warning",
+      title: "\u65E0\u4E8B\u4EF6\u6570\u636E",
+      detail: `\u8FD1 ${days} \u5929\u6CA1\u6709\u91C7\u96C6\u5230\u4EFB\u4F55\u4E8B\u4EF6`,
+      evidence: "\u4E8B\u4EF6\u6587\u4EF6\u4E3A\u7A7A\u6216\u4E0D\u5B58\u5728",
+      suggestion: "\u786E\u8BA4 telemetry \u5DF2\u542F\u7528\uFF0C\u6B63\u5E38\u4F7F\u7528 Hypercore \u540E\u4F1A\u81EA\u52A8\u91C7\u96C6",
+      suggestedType: "bugfix",
+      suggestedPriority: "A",
+      suggestedWuxing: "\u6728"
+    }];
+  }
+  for (const [cmd, stats] of Object.entries(summary.cmdCounts)) {
+    const failRate = stats.total >= 3 ? stats.fail / stats.total : 0;
+    if (failRate > 0.1) {
+      const failEvents = events.filter(
+        (e) => e.event === "cmd_exec" && e.cmd === cmd && !e.ok
+      );
+      const errorMessages = failEvents.map((e) => String(e.err || "")).filter(Boolean);
+      const topError = mostCommon(errorMessages) || "\u672A\u77E5";
+      findings.push({
+        severity: "high",
+        title: `${cmd} \u5931\u8D25\u7387 ${(failRate * 100).toFixed(0)}%`,
+        detail: `\u8FD1 ${days} \u5929\u5185 ${cmd} \u6267\u884C ${stats.total} \u6B21\uFF0C\u5931\u8D25 ${stats.fail} \u6B21`,
+        evidence: `\u5E38\u89C1\u9519\u8BEF: ${topError} (${stats.fail}/${stats.total})`,
+        suggestion: `\u6392\u67E5 ${cmd} \u547D\u4EE4\u7684\u9519\u8BEF\u5904\u7406\u903B\u8F91`,
+        suggestedType: "bugfix",
+        suggestedPriority: failRate > 0.2 ? "S" : "A",
+        suggestedWuxing: "\u6728"
+      });
+    }
+  }
+  for (const err of summary.errors) {
+    if (err.count >= 3) {
+      findings.push({
+        severity: "high",
+        title: `${err.type} \u9519\u8BEF\u9891\u53D1 (${err.count}\u6B21)`,
+        detail: `\u8FD1 ${days} \u5929\u5185 ${err.type} \u7C7B\u578B\u9519\u8BEF\u51FA\u73B0 ${err.count} \u6B21`,
+        evidence: `\u9519\u8BEF\u7C7B\u578B\u7EDF\u8BA1: ${err.type} = ${err.count}`,
+        suggestion: "\u68C0\u67E5\u9519\u8BEF\u6839\u56E0\u5E76\u4FEE\u590D",
+        suggestedType: "bugfix",
+        suggestedPriority: err.count >= 5 ? "S" : "A",
+        suggestedWuxing: "\u6728"
+      });
+    }
+  }
+  const lineEvents = events.filter((e) => e.event === "line_run");
+  const lineStats = {};
+  for (const e of lineEvents) {
+    const name = String(e.line || "unknown");
+    if (!lineStats[name]) lineStats[name] = { durations: [], fails: 0, total: 0 };
+    lineStats[name].total++;
+    if (e.duration_ms) lineStats[name].durations.push(e.duration_ms);
+    if (!e.ok) lineStats[name].fails++;
+  }
+  for (const [name, stats] of Object.entries(lineStats)) {
+    if (stats.durations.length >= 3) {
+      const avg = stats.durations.reduce((a, b) => a + b, 0) / stats.durations.length;
+      const p95 = stats.durations.sort((a, b) => a - b)[Math.floor(stats.durations.length * 0.95)];
+      if (p95 > 3e4) {
+        findings.push({
+          severity: "warning",
+          title: `\u751F\u4EA7\u7EBF "${name}" \u8017\u65F6\u504F\u9AD8`,
+          detail: `\u5E73\u5747 ${(avg / 1e3).toFixed(1)}s, p95 ${(p95 / 1e3).toFixed(1)}s (${stats.total}\u6B21\u8FD0\u884C)`,
+          evidence: `\u8017\u65F6\u6570\u636E: avg=${(avg / 1e3).toFixed(1)}s, p95=${(p95 / 1e3).toFixed(1)}s`,
+          suggestion: "\u68C0\u67E5 prompt \u957F\u5EA6\u6216\u8003\u8651\u5207\u6362\u66F4\u5FEB\u7684\u6A21\u578B",
+          suggestedType: "improvement",
+          suggestedPriority: "A",
+          suggestedWuxing: "\u6728"
+        });
+      }
+    }
+  }
+  const allCmds = events.filter((e) => e.event === "cmd_exec").map((e) => String(e.cmd));
+  const knownCmds = ["/model", "/team", "/memory", "/network", "/admin", "/run", "/git", "/session"];
+  for (const cmd of knownCmds) {
+    if (!allCmds.includes(cmd) && events.length > 20) {
+      findings.push({
+        severity: "opportunity",
+        title: `${cmd} \u8FD1 ${days} \u5929\u672A\u4F7F\u7528`,
+        detail: `\u5728 ${events.length} \u6761\u4E8B\u4EF6\u4E2D\u6CA1\u6709 ${cmd} \u7684\u4F7F\u7528\u8BB0\u5F55`,
+        evidence: `${cmd} \u8C03\u7528\u6B21\u6570: 0`,
+        suggestion: "\u8BC4\u4F30\u8BE5\u529F\u80FD\u662F\u5426\u9700\u8981\u6539\u8FDB\u5165\u53E3\u6216\u8003\u8651\u4E0B\u7EBF",
+        suggestedType: "idea",
+        suggestedPriority: "C",
+        suggestedWuxing: "\u91D1"
+      });
+    }
+  }
+  const sessionEnds = events.filter((e) => e.event === "session_end");
+  if (sessionEnds.length >= 4) {
+    const mid = Math.floor(sessionEnds.length / 2);
+    const firstHalf = sessionEnds.slice(0, mid);
+    const secondHalf = sessionEnds.slice(mid);
+    const avgFirst = firstHalf.reduce((s, e) => s + (e.rounds || 0), 0) / firstHalf.length;
+    const avgSecond = secondHalf.reduce((s, e) => s + (e.rounds || 0), 0) / secondHalf.length;
+    if (avgFirst > 0 && avgSecond / avgFirst < 0.6) {
+      findings.push({
+        severity: "warning",
+        title: `\u4F1A\u8BDD\u6DF1\u5EA6\u4E0B\u964D (${avgFirst.toFixed(1)} \u2192 ${avgSecond.toFixed(1)} \u8F6E)`,
+        detail: `\u524D\u534A\u671F\u5E73\u5747 ${avgFirst.toFixed(1)} \u8F6E\uFF0C\u540E\u534A\u671F ${avgSecond.toFixed(1)} \u8F6E`,
+        evidence: `\u4E0B\u964D\u5E45\u5EA6: ${((1 - avgSecond / avgFirst) * 100).toFixed(0)}%`,
+        suggestion: "\u5206\u6790\u7528\u6237\u662F\u5426\u63D0\u524D\u653E\u5F03\u8FD8\u662F\u9700\u6C42\u53D8\u7B80\u77ED",
+        suggestedType: "idea",
+        suggestedPriority: "B",
+        suggestedWuxing: "\u6C34"
+      });
+    }
+  }
+  return findings;
+}
+function buildDiagnosePrompt(summary, ruleFindings) {
+  const parts = [];
+  parts.push(`\u4F60\u662F\u8D85\u534F\u4F53 (Hypercore) \u9879\u76EE\u7684\u5185\u89C2\u8BCA\u65AD\u5F15\u64CE\u3002\u4EE5\u4E0B\u662F\u8FD1 ${summary.period.days} \u5929\u7684\u4F7F\u7528\u6570\u636E\u6458\u8981\u3002`);
+  parts.push(`\u8BF7\u5206\u6790\u5E76\u8865\u5145\u89C4\u5219\u5F15\u64CE\u53EF\u80FD\u9057\u6F0F\u7684\u6D1E\u5BDF\u3002
+`);
+  parts.push(`## \u57FA\u7840\u7EDF\u8BA1`);
+  parts.push(`- \u4E8B\u4EF6\u603B\u6570: ${summary.totalEvents}`);
+  parts.push(`- \u4F1A\u8BDD\u6570: ${summary.totalSessions}`);
+  parts.push(`- \u5E73\u5747\u4F1A\u8BDD\u8F6E\u6B21: ${summary.avgSessionRounds}`);
+  parts.push(`- \u7EDF\u8BA1\u5468\u671F: ${summary.period.from} \u2192 ${summary.period.to}
+`);
+  if (Object.keys(summary.cmdCounts).length > 0) {
+    parts.push(`## \u547D\u4EE4\u4F7F\u7528\u7EDF\u8BA1`);
+    for (const [cmd, stats] of Object.entries(summary.cmdCounts)) {
+      const failPart = stats.fail > 0 ? ` (\u5931\u8D25${stats.fail}\u6B21, \u7387${(stats.fail / stats.total * 100).toFixed(0)}%)` : "";
+      parts.push(`- ${cmd}: ${stats.total}\u6B21${failPart}`);
+    }
+    parts.push("");
+  }
+  if (summary.errors.length > 0) {
+    parts.push(`## \u9519\u8BEF\u7EDF\u8BA1`);
+    for (const e of summary.errors) {
+      parts.push(`- ${e.type}: ${e.count}\u6B21`);
+    }
+    parts.push("");
+  }
+  if (ruleFindings.length > 0) {
+    parts.push(`## \u89C4\u5219\u5F15\u64CE\u5DF2\u53D1\u73B0`);
+    for (const f of ruleFindings) {
+      parts.push(`- [${f.severity}] ${f.title}: ${f.detail}`);
+    }
+    parts.push("");
+  }
+  parts.push(`## \u4F60\u7684\u4EFB\u52A1`);
+  parts.push(`\u57FA\u4E8E\u4EE5\u4E0A\u6570\u636E\uFF0C\u8F93\u51FA\uFF1A`);
+  parts.push(`1. \u89C4\u5219\u5F15\u64CE\u53EF\u80FD\u9057\u6F0F\u7684\u95EE\u9898\u6216\u6A21\u5F0F`);
+  parts.push(`2. \u4F7F\u7528\u8D8B\u52BF\u7684\u6DF1\u5C42\u89E3\u8BFB`);
+  parts.push(`3. \u4EA7\u54C1\u6539\u8FDB\u673A\u4F1A`);
+  parts.push(`
+\u6BCF\u6761\u53D1\u73B0\u8BF7\u7528\u4EE5\u4E0B\u683C\u5F0F\uFF1A`);
+  parts.push(`### [severity: high/warning/opportunity] \u6807\u9898`);
+  parts.push(`- \u8BE6\u60C5: ...`);
+  parts.push(`- \u8BC1\u636E: ...`);
+  parts.push(`- \u5EFA\u8BAE: ...`);
+  parts.push(`- \u7C7B\u578B: bugfix/feature/improvement/idea`);
+  parts.push(`- \u4F18\u5148\u7EA7: S/A/B/C`);
+  parts.push(`- \u4E94\u884C: \u6728/\u706B/\u6C34/\u91D1/\u571F`);
+  parts.push(`
+\u5982\u679C\u6CA1\u6709\u989D\u5916\u53D1\u73B0\uFF0C\u76F4\u63A5\u8BF4"\u89C4\u5219\u5F15\u64CE\u5DF2\u8986\u76D6\u4E3B\u8981\u95EE\u9898"\u3002`);
+  return parts.join("\n");
+}
+function parseAIFindings(text) {
+  const findings = [];
+  const blocks = text.split(/###\s+\[/).filter(Boolean);
+  for (const block of blocks) {
+    const severityMatch = block.match(/^(high|warning|opportunity)\]\s*(.+)/);
+    if (!severityMatch) continue;
+    const severity = severityMatch[1];
+    const title = severityMatch[2].trim();
+    const detail = extractField(block, "\u8BE6\u60C5") || "";
+    const evidence = extractField(block, "\u8BC1\u636E") || "";
+    const suggestion = extractField(block, "\u5EFA\u8BAE") || "";
+    const typeStr = extractField(block, "\u7C7B\u578B") || "idea";
+    const priorityStr = extractField(block, "\u4F18\u5148\u7EA7") || "B";
+    const wuxingStr = extractField(block, "\u4E94\u884C") || "\u6728";
+    findings.push({
+      severity,
+      title,
+      detail,
+      evidence,
+      suggestion,
+      suggestedType: ["bugfix", "feature", "improvement", "idea"].includes(typeStr) ? typeStr : "idea",
+      suggestedPriority: ["S", "A", "B", "C"].includes(priorityStr) ? priorityStr : "B",
+      suggestedWuxing: ["\u6728", "\u706B", "\u6C34", "\u91D1", "\u571F"].includes(wuxingStr) ? wuxingStr : "\u6728"
+    });
+  }
+  return findings;
+}
+function extractField(block, fieldName) {
+  const regex = new RegExp(`-\\s*${fieldName}[\uFF1A:]\\s*(.+)`, "i");
+  const match = block.match(regex);
+  return match ? match[1].trim() : "";
+}
+async function runAIDiagnosis(ctx, days = 7) {
+  const summary = await getEventsSummary(days);
+  const ruleFindings = await runRuleDiagnosis(days);
+  const prompt = buildDiagnosePrompt(summary, ruleFindings);
+  let aiRawText = "";
+  const aiFindings = [];
+  try {
+    if (ctx.config.modelConfig.sdkType === "openai") {
+      const { streamOpenAIChat } = await import("./openai-compat-UQWJXBEK.js");
+      const OpenAI = (await import("openai")).default;
+      const client = ctx.getClient();
+      const result = await streamOpenAIChat(client, [
+        { role: "system", content: "\u4F60\u662F\u8D85\u534F\u4F53\u9879\u76EE\u7684\u5185\u89C2\u8BCA\u65AD\u5F15\u64CE\u3002\u5206\u6790\u6570\u636E\uFF0C\u8F93\u51FA\u7CBE\u51C6\u8BCA\u65AD\u3002\u7528\u4E2D\u6587\u56DE\u590D\u3002" },
+        { role: "user", content: prompt }
+      ], {
+        model: ctx.config.modelConfig.model,
+        tools: [],
+        onChunk: (text) => {
+          process.stdout.write(text);
+        },
+        onToolCall: () => {
+        }
+      });
+      aiRawText = result.content.trim();
+    } else {
+      const { streamCallLLM } = await import("./claude-NSQ442XD.js");
+      const Anthropic = (await import("@anthropic-ai/sdk")).default;
+      const client = ctx.getClient();
+      const result = await streamCallLLM(client, {
+        systemPrompt: "\u4F60\u662F\u8D85\u534F\u4F53\u9879\u76EE\u7684\u5185\u89C2\u8BCA\u65AD\u5F15\u64CE\u3002\u5206\u6790\u6570\u636E\uFF0C\u8F93\u51FA\u7CBE\u51C6\u8BCA\u65AD\u3002\u7528\u4E2D\u6587\u56DE\u590D\u3002",
+        userPrompt: prompt,
+        history: [],
+        tools: [],
+        model: ctx.config.modelConfig.model,
+        onText: (text) => {
+          process.stdout.write(text);
+        },
+        onToolCall: () => {
+        }
+      });
+      aiRawText = result.output.trim();
+    }
+    aiFindings.push(...parseAIFindings(aiRawText));
+  } catch (err) {
+    aiRawText = `AI \u8BCA\u65AD\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  return { ruleFindings, aiFindings, aiRawText };
+}
+async function findingsToBacklog(findings, targetVersion) {
+  const existing = await listItems();
+  const existingTitles = new Set(existing.map((i) => i.title.toLowerCase()));
+  const createdIds = [];
+  for (const f of findings) {
+    if (existingTitles.has(f.title.toLowerCase())) continue;
+    const item = await addItem({
+      title: f.title,
+      description: f.detail,
+      type: f.suggestedType,
+      wuxing: f.suggestedWuxing,
+      priority: f.suggestedPriority,
+      targetVersion,
+      source: "auto-diagnose",
+      evidence: f.evidence
+    });
+    createdIds.push(item.id);
+  }
+  return createdIds;
+}
+function mostCommon(arr) {
+  if (arr.length === 0) return void 0;
+  const counts = {};
+  for (const s of arr) counts[s] = (counts[s] || 0) + 1;
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+
+export {
+  runRuleDiagnosis,
+  runAIDiagnosis,
+  findingsToBacklog
+};

package/dist/chunk-43OLRXM5.js

@@ -0,0 +1,263 @@
+import {
+  hookManager
+} from "./chunk-B6A2AKLN.js";
+
+// src/llm/claude.ts
+import Anthropic from "@anthropic-ai/sdk";
+function createLLMClient(config) {
+  const options = {
+    apiKey: config.apiKey
+  };
+  if (config.baseURL) {
+    options.baseURL = config.baseURL;
+  }
+  return new Anthropic(options);
+}
+function buildMessages(history, userPrompt) {
+  const messages = [];
+  if (history && history.length > 0) {
+    for (const msg of history) {
+      messages.push({
+        role: msg.role,
+        content: msg.content
+      });
+    }
+  }
+  messages.push({ role: "user", content: userPrompt });
+  return messages;
+}
+async function triggerToolHook(event, context) {
+  try {
+    return await hookManager.trigger(event, context);
+  } catch {
+    return { intercepted: false };
+  }
+}
+async function callLLM(client, options) {
+  const {
+    systemPrompt,
+    userPrompt,
+    tools,
+    model = "claude-sonnet-4-20250514",
+    maxTokens = 8192,
+    history,
+    onText,
+    onToolCall,
+    onThinking,
+    onToolCallDone
+  } = options;
+  const toolDefinitions = tools.map((t) => ({
+    name: t.definition.name,
+    description: t.definition.description,
+    input_schema: t.definition.input_schema
+  }));
+  const messages = buildMessages(history, userPrompt);
+  let totalOutput = "";
+  let currentRoundText = "";
+  const allToolCalls = [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let maxIterations = 10;
+  while (maxIterations-- > 0) {
+    currentRoundText = "";
+    const response = await client.messages.create({
+      model,
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages,
+      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0
+    });
+    totalInputTokens += response.usage.input_tokens;
+    totalOutputTokens += response.usage.output_tokens;
+    let hasToolUse = false;
+    let thinkingEmitted = false;
+    const toolResults = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        totalOutput += block.text;
+        currentRoundText += block.text;
+        onText?.(block.text);
+      } else if (block.type === "tool_use") {
+        hasToolUse = true;
+        if (!thinkingEmitted && currentRoundText.trim()) {
+          onThinking?.(currentRoundText.trim());
+          thinkingEmitted = true;
+        }
+        const tool = tools.find((t) => t.definition.name === block.name);
+        const toolInput = block.input;
+        const toolInputText = JSON.stringify(toolInput);
+        onToolCall?.(block.name, toolInput);
+        let result;
+        const toolStart = Date.now();
+        const hookResult = await triggerToolHook("onToolCall", {
+          model,
+          toolName: block.name,
+          toolInput: toolInputText
+        });
+        if (hookResult.intercepted) {
+          result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
+        } else if (tool) {
+          try {
+            result = await tool.handler(toolInput);
+          } catch (err) {
+            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        } else {
+          result = `Error: Tool "${block.name}" not found`;
+        }
+        const toolDuration = Date.now() - toolStart;
+        onToolCallDone?.(block.name, toolDuration);
+        await triggerToolHook("onToolResult", {
+          model,
+          toolName: block.name,
+          toolInput: toolInputText,
+          toolResult: result
+        });
+        allToolCalls.push({
+          toolName: block.name,
+          input: toolInput,
+          output: result
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: result
+        });
+      }
+    }
+    if (hasToolUse) {
+      messages.push({ role: "assistant", content: response.content });
+      messages.push({ role: "user", content: toolResults });
+    } else {
+      break;
+    }
+    if (response.stop_reason === "end_turn") break;
+  }
+  return {
+    output: totalOutput,
+    responseText: allToolCalls.length > 0 ? currentRoundText : totalOutput,
+    toolCalls: allToolCalls,
+    tokenUsage: {
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    }
+  };
+}
+async function streamCallLLM(client, options) {
+  const {
+    systemPrompt,
+    userPrompt,
+    tools,
+    model = "claude-sonnet-4-20250514",
+    maxTokens = 8192,
+    history,
+    onText,
+    onToolCall,
+    onThinking,
+    onToolCallDone
+  } = options;
+  const toolDefinitions = tools.map((t) => ({
+    name: t.definition.name,
+    description: t.definition.description,
+    input_schema: t.definition.input_schema
+  }));
+  const messages = buildMessages(history, userPrompt);
+  let totalOutput = "";
+  let currentRoundText = "";
+  const allToolCalls = [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let maxIterations = 10;
+  while (maxIterations-- > 0) {
+    currentRoundText = "";
+    const stream = client.messages.stream({
+      model,
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages,
+      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0
+    });
+    stream.on("text", (text) => {
+      totalOutput += text;
+      currentRoundText += text;
+      onText?.(text);
+    });
+    const response = await stream.finalMessage();
+    totalInputTokens += response.usage.input_tokens;
+    totalOutputTokens += response.usage.output_tokens;
+    let hasToolUse = false;
+    let thinkingEmitted = false;
+    const toolResults = [];
+    for (const block of response.content) {
+      if (block.type === "tool_use") {
+        hasToolUse = true;
+        if (!thinkingEmitted && currentRoundText.trim()) {
+          onThinking?.(currentRoundText.trim());
+          thinkingEmitted = true;
+        }
+        const toolInput = block.input;
+        const toolInputText = JSON.stringify(toolInput);
+        onToolCall?.(block.name, toolInput);
+        const tool = tools.find((t) => t.definition.name === block.name);
+        let result;
+        const toolStart = Date.now();
+        const hookResult = await triggerToolHook("onToolCall", {
+          model,
+          toolName: block.name,
+          toolInput: toolInputText
+        });
+        if (hookResult.intercepted) {
+          result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
+        } else if (tool) {
+          try {
+            result = await tool.handler(toolInput);
+          } catch (err) {
+            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        } else {
+          result = `Error: Tool "${block.name}" not found`;
+        }
+        const toolDuration = Date.now() - toolStart;
+        onToolCallDone?.(block.name, toolDuration);
+        await triggerToolHook("onToolResult", {
+          model,
+          toolName: block.name,
+          toolInput: toolInputText,
+          toolResult: result
+        });
+        allToolCalls.push({
+          toolName: block.name,
+          input: toolInput,
+          output: result
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: result
+        });
+      }
+    }
+    if (hasToolUse) {
+      messages.push({ role: "assistant", content: response.content });
+      messages.push({ role: "user", content: toolResults });
+    } else {
+      break;
+    }
+    if (response.stop_reason === "end_turn") break;
+  }
+  return {
+    output: totalOutput,
+    responseText: allToolCalls.length > 0 ? currentRoundText : totalOutput,
+    toolCalls: allToolCalls,
+    tokenUsage: {
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    }
+  };
+}
+
+export {
+  createLLMClient,
+  callLLM,
+  streamCallLLM
+};

package/dist/chunk-4DVYJAJL.js

@@ -0,0 +1,57 @@
+// src/ui/notify.ts
+import { exec } from "child_process";
+import os from "os";
+var notificationsEnabled = true;
+function setNotificationsEnabled(enabled) {
+  notificationsEnabled = enabled;
+}
+function isNotificationsEnabled() {
+  return notificationsEnabled;
+}
+function sendNotification(title, body, subtitle) {
+  if (!notificationsEnabled) return;
+  const platform = os.platform();
+  try {
+    if (platform === "darwin") {
+      const subtitlePart = subtitle ? ` subtitle "${escapeOsascript(subtitle)}"` : "";
+      const script = `display notification "${escapeOsascript(body)}" with title "${escapeOsascript(title)}"${subtitlePart} sound name "default"`;
+      exec(`osascript -e '${script}'`, () => {
+      });
+    } else if (platform === "linux") {
+      const escapedTitle = escapeShell(title);
+      const escapedBody = escapeShell(body);
+      exec(`notify-send "${escapedTitle}" "${escapedBody}" --app-name=Hypercore`, () => {
+      });
+    } else if (platform === "win32") {
+      const escapedTitle = title.replace(/'/g, "''");
+      const escapedBody = body.replace(/'/g, "''");
+      const ps = `[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null; $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02); $textNodes = $template.GetElementsByTagName('text'); $textNodes.Item(0).AppendChild($template.CreateTextNode('${escapedTitle}')); $textNodes.Item(1).AppendChild($template.CreateTextNode('${escapedBody}')); $toast = [Windows.UI.Notifications.ToastNotification]::new($template); [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Hypercore').Show($toast)`;
+      exec(`powershell -Command "${ps}"`, () => {
+      });
+    }
+  } catch {
+  }
+}
+function bellNotify() {
+  process.stdout.write("\x07");
+}
+function notifyIfLong(title, body, durationMs, thresholdMs = 1e4) {
+  if (durationMs >= thresholdMs) {
+    sendNotification(title, body);
+    bellNotify();
+  }
+}
+function escapeOsascript(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function escapeShell(str) {
+  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+
+export {
+  setNotificationsEnabled,
+  isNotificationsEnabled,
+  sendNotification,
+  bellNotify,
+  notifyIfLong
+};