hypercore-cli 1.1.2 → 1.4.0

package/dist/chunk-FCW3K6F2.js

@@ -1,263 +0,0 @@
-import {
-  hookManager
-} from "./chunk-CLKIMCXZ.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-GFORWAMW.js

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