hypercore-cli 1.1.1 → 1.3.0

package/dist/chunk-77FRUHTU.js

@@ -1,271 +0,0 @@
-import {
-  hookManager
-} from "./chunk-NHPDLYEW.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-7ZYMJFCA.js

@@ -1,251 +0,0 @@
-import {
-  HYPERCORE_DIR
-} from "./chunk-SVF2VWOZ.js";
-
-// src/memory/store.ts
-import { randomBytes } from "crypto";
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-
-// src/memory/types.ts
-var DEFAULT_EXTRACTION_CONFIG = {
-  extractEveryNRounds: 3,
-  maxMemoriesPerExtraction: 5,
-  minConfidence: 0.6,
-  maxPersonalMemories: 100,
-  maxProjectMemories: 150,
-  maxSystemPromptChars: 3e3
-};
-function createEmptyStore(layer) {
-  return {
-    version: "1",
-    layer,
-    records: [],
-    totalExtractions: 0,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-var CATEGORY_LABELS = {
-  preference: "\u504F\u597D",
-  decision: "\u51B3\u7B56",
-  entity: "\u5B9E\u4F53",
-  pattern: "\u6A21\u5F0F",
-  fact: "\u4E8B\u5B9E",
-  convention: "\u7EA6\u5B9A",
-  insight: "\u6D1E\u5BDF",
-  manual: "\u624B\u52A8"
-};
-var CATEGORY_MD_HEADERS = {
-  preference: "User Preferences",
-  decision: "Key Decisions",
-  entity: "Named Entities",
-  pattern: "Patterns & Solutions",
-  fact: "Known Facts",
-  convention: "Conventions",
-  insight: "Team Insights",
-  manual: "User Notes"
-};
-
-// src/memory/store.ts
-function memoryDir(layer, opts) {
-  switch (layer) {
-    case "personal":
-      return join(HYPERCORE_DIR, "memory");
-    case "project":
-      return join(opts?.projectPath || process.cwd(), ".hypercore", "memory");
-    case "team":
-      if (!opts?.teamId) throw new Error("team layer requires teamId");
-      return join(HYPERCORE_DIR, "teams", opts.teamId, "memory");
-  }
-}
-function jsonPath(layer, opts) {
-  return join(memoryDir(layer, opts), `${layer}.json`);
-}
-function mdPath(layer, opts) {
-  return join(memoryDir(layer, opts), `${layer}.md`);
-}
-function generateMemoryId() {
-  const ts = Date.now();
-  const rand = randomBytes(2).toString("hex");
-  return `mem_${ts}_${rand}`;
-}
-async function loadStore(layer, opts) {
-  const fp = jsonPath(layer, opts);
-  if (!existsSync(fp)) return createEmptyStore(layer);
-  try {
-    const raw = await readFile(fp, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return createEmptyStore(layer);
-  }
-}
-async function saveStore(store, opts) {
-  const dir = memoryDir(store.layer, opts);
-  await mkdir(dir, { recursive: true });
-  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile(jsonPath(store.layer, opts), JSON.stringify(store, null, 2), "utf-8");
-  await rebuildMarkdown(store, opts);
-}
-async function addMemory(layer, record, opts) {
-  const store = await loadStore(layer, opts);
-  const config = DEFAULT_EXTRACTION_CONFIG;
-  const maxRecords = layer === "personal" ? config.maxPersonalMemories : config.maxProjectMemories;
-  const existingIdx = findDuplicate(store.records, record.content);
-  if (existingIdx >= 0) {
-    const existing = store.records[existingIdx];
-    existing.content = record.content;
-    existing.tags = record.tags;
-    existing.confidence = Math.max(existing.confidence, record.confidence);
-    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.accessCount++;
-    await saveStore(store, opts);
-    return existing;
-  }
-  if (store.records.length >= maxRecords) {
-    store.records.sort((a, b) => a.confidence - b.confidence || a.updatedAt.localeCompare(b.updatedAt));
-    store.records.shift();
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const newRecord = {
-    ...record,
-    id: generateMemoryId(),
-    layer,
-    createdAt: now,
-    updatedAt: now,
-    accessCount: 0
-  };
-  store.records.push(newRecord);
-  await saveStore(store, opts);
-  return newRecord;
-}
-async function removeMemory(layer, memoryId, opts) {
-  const store = await loadStore(layer, opts);
-  const idx = store.records.findIndex((r) => r.id === memoryId);
-  if (idx < 0) return false;
-  store.records.splice(idx, 1);
-  await saveStore(store, opts);
-  return true;
-}
-async function searchMemories(layer, query, opts) {
-  const store = await loadStore(layer, opts);
-  let records = store.records;
-  if (opts?.category) {
-    records = records.filter((r) => r.category === opts.category);
-  }
-  const queryLower = query.toLowerCase();
-  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-  const scored = records.map((record) => {
-    const contentLower = record.content.toLowerCase();
-    const tagsLower = record.tags.join(" ").toLowerCase();
-    const combined = contentLower + " " + tagsLower;
-    let matchedTerms = 0;
-    for (const term of queryTerms) {
-      if (combined.includes(term)) matchedTerms++;
-    }
-    const score = queryTerms.length > 0 ? matchedTerms / queryTerms.length : 0;
-    return { record, score };
-  });
-  const results = scored.filter((r) => r.score > 0).sort((a, b) => b.score - a.score || b.record.confidence - a.record.confidence);
-  for (const r of results) {
-    r.record.accessCount++;
-    r.record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  if (results.length > 0) {
-    await saveStore(store, opts);
-  }
-  return results.slice(0, opts?.limit || 20);
-}
-async function listMemories(layer, opts) {
-  const store = await loadStore(layer, opts);
-  return [...store.records].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-async function getMemoryStats(layer, opts) {
-  const store = await loadStore(layer, opts);
-  const byCategory = {};
-  for (const r of store.records) {
-    byCategory[r.category] = (byCategory[r.category] || 0) + 1;
-  }
-  return {
-    total: store.records.length,
-    byCategory,
-    lastExtractionAt: store.lastExtractionAt,
-    totalExtractions: store.totalExtractions
-  };
-}
-async function markExtraction(layer, opts) {
-  const store = await loadStore(layer, opts);
-  store.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-  store.totalExtractions++;
-  await saveStore(store, opts);
-}
-function findDuplicate(records, content) {
-  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim();
-  for (let i = 0; i < records.length; i++) {
-    const existing = records[i].content.toLowerCase().replace(/\s+/g, " ").trim();
-    if (similarityRatio(existing, normalized) > 0.8) return i;
-  }
-  return -1;
-}
-function similarityRatio(a, b) {
-  if (a === b) return 1;
-  if (!a || !b) return 0;
-  const bigramsA = /* @__PURE__ */ new Set();
-  for (let i = 0; i < a.length - 1; i++) bigramsA.add(a.slice(i, i + 2));
-  const bigramsB = /* @__PURE__ */ new Set();
-  for (let i = 0; i < b.length - 1; i++) bigramsB.add(b.slice(i, i + 2));
-  let intersection = 0;
-  for (const bg of bigramsA) {
-    if (bigramsB.has(bg)) intersection++;
-  }
-  const union = bigramsA.size + bigramsB.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-async function rebuildMarkdown(store, opts) {
-  const lines = [
-    `--- Memory Context (${store.layer}) ---`,
-    ""
-  ];
-  const grouped = {};
-  for (const r of store.records) {
-    if (!grouped[r.category]) grouped[r.category] = [];
-    grouped[r.category].push(r);
-  }
-  for (const [category, records] of Object.entries(grouped)) {
-    const header = CATEGORY_MD_HEADERS[category] || category;
-    lines.push(`[${header}]`);
-    const sorted = records.sort((a, b) => b.confidence - a.confidence);
-    for (const r of sorted) {
-      const tags = r.tags.map((t) => `#${t}`).join(" ");
-      lines.push(`- ${r.content} ${tags}`);
-    }
-    lines.push("");
-  }
-  lines.push(`--- End Memory Context ---`);
-  const fp = mdPath(store.layer, opts);
-  await writeFile(fp, lines.join("\n"), "utf-8");
-}
-async function readMemoryMarkdown(layer, opts) {
-  const fp = mdPath(layer, opts);
-  if (!existsSync(fp)) return "";
-  try {
-    return await readFile(fp, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-export {
-  DEFAULT_EXTRACTION_CONFIG,
-  CATEGORY_LABELS,
-  generateMemoryId,
-  loadStore,
-  saveStore,
-  addMemory,
-  removeMemory,
-  searchMemories,
-  listMemories,
-  getMemoryStats,
-  markExtraction,
-  readMemoryMarkdown
-};

package/dist/chunk-BE46C7JW.js

@@ -1,46 +0,0 @@
-// src/ui/text-utils.ts
-function isCJK(char) {
-  const code = char.codePointAt(0);
-  if (!code) return false;
-  return code >= 11904 && code <= 40959 || // CJK 部首/汉字
-  code >= 44032 && code <= 55215 || // 韩文音节
-  code >= 63744 && code <= 64255 || // CJK 兼容汉字
-  code >= 65072 && code <= 65103 || // CJK 兼容形式
-  code >= 65280 && code <= 65376 || // 全角 ASCII
-  code >= 65504 && code <= 65510 || // 全角符号
-  code >= 126976 && code <= 130047 || // 表情/符号
-  code >= 131072 && code <= 195103;
-}
-function displayWidth(str) {
-  const clean = str.replace(/\x1b\[[0-9;]*m/g, "");
-  let width = 0;
-  for (const char of clean) {
-    width += isCJK(char) ? 2 : 1;
-  }
-  return width;
-}
-function padToWidth(str, targetWidth) {
-  const currentWidth = displayWidth(str);
-  const padding = targetWidth - currentWidth;
-  return padding > 0 ? str + " ".repeat(padding) : str;
-}
-function truncateToWidth(str, maxWidth) {
-  let width = 0;
-  let result = "";
-  for (const char of str) {
-    const charWidth = isCJK(char) ? 2 : 1;
-    if (width + charWidth > maxWidth - 1) {
-      result += "\u2026";
-      break;
-    }
-    result += char;
-    width += charWidth;
-  }
-  return result;
-}
-
-export {
-  displayWidth,
-  padToWidth,
-  truncateToWidth
-};

package/dist/chunk-CM423E2U.js

@@ -1,133 +0,0 @@
-import {
-  HYPERCORE_DIR
-} from "./chunk-SVF2VWOZ.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
-};