hypercore-cli 1.1.0

package/dist/chunk-B6A2AKLN.js

@@ -0,0 +1,139 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/core/hooks.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { spawn } from "child_process";
+var HookManager = class {
+  hooks = [];
+  loaded = false;
+  /** 从配置文件加载钩子 */
+  async load() {
+    this.hooks = [];
+    const systemPath = join(HYPERCORE_DIR, "hooks.json");
+    await this.loadFromFile(systemPath);
+    const projectPath = join(process.cwd(), ".hypercore", "hooks.json");
+    if (projectPath !== systemPath) {
+      await this.loadFromFile(projectPath);
+    }
+    this.loaded = true;
+  }
+  async loadFromFile(filePath) {
+    if (!existsSync(filePath)) return;
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const config = JSON.parse(content);
+      if (Array.isArray(config.hooks)) {
+        for (const hook of config.hooks) {
+          if (hook.event && hook.command) {
+            this.hooks.push(hook);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /** 触发钩子，返回拦截结果 */
+  async trigger(event, context = {}) {
+    if (!this.loaded) await this.load();
+    const matching = this.hooks.filter((h) => {
+      if (h.event !== event) return false;
+      if (h.match?.toolName && context.toolName !== h.match.toolName) return false;
+      if (h.match?.model && context.model !== h.match.model) return false;
+      return true;
+    });
+    if (matching.length === 0) return { intercepted: false };
+    const fullContext = {
+      event,
+      ...context
+    };
+    const blocking = matching.filter((h) => h.blocking);
+    const nonBlocking = matching.filter((h) => !h.blocking);
+    for (const hook of nonBlocking) {
+      this.executeHook(hook, fullContext).catch(() => {
+      });
+    }
+    for (const hook of blocking) {
+      const result = await this.executeHook(hook, fullContext);
+      if (hook.intercept && event === "onToolCall" && result.exitCode !== 0) {
+        return {
+          intercepted: true,
+          reason: result.stdout || `Hook "${hook.name || hook.command}" \u62E6\u622A\u4E86\u64CD\u4F5C (exit code: ${result.exitCode})`
+        };
+      }
+    }
+    return { intercepted: false };
+  }
+  async executeHook(hook, context) {
+    const timeout = hook.timeout || 1e4;
+    const env = {
+      ...process.env,
+      HYPERCORE_EVENT: context.event,
+      HYPERCORE_SESSION_ID: context.sessionId || "",
+      HYPERCORE_MODEL: context.model || "",
+      HYPERCORE_CWD: process.cwd()
+    };
+    if (context.toolName) env.HYPERCORE_TOOL_NAME = context.toolName;
+    if (context.toolInput) env.HYPERCORE_TOOL_INPUT = context.toolInput.slice(0, 1e3);
+    if (context.toolResult) env.HYPERCORE_TOOL_RESULT = context.toolResult.slice(0, 1e3);
+    if (context.userPrompt) env.HYPERCORE_USER_PROMPT = context.userPrompt.slice(0, 500);
+    if (context.error) env.HYPERCORE_ERROR = context.error.slice(0, 500);
+    return await new Promise((resolve) => {
+      const child = spawn("sh", ["-c", hook.command], {
+        cwd: process.cwd(),
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const finish = (exitCode, output) => {
+        if (settled) return;
+        settled = true;
+        resolve({ exitCode, stdout: output.trim() });
+      };
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        setTimeout(() => child.kill("SIGKILL"), 1e3);
+        const output = stdout || stderr || `Hook timeout after ${timeout}ms`;
+        finish(124, output);
+      }, timeout);
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        finish(1, stderr || stdout || err.message);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const output = stdout || stderr;
+        finish(code ?? 1, output);
+      });
+    });
+  }
+  /** 获取已加载的钩子数量 */
+  get count() {
+    return this.hooks.length;
+  }
+  /** 获取按事件分组的钩子列表 */
+  listByEvent() {
+    const grouped = {};
+    for (const hook of this.hooks) {
+      if (!grouped[hook.event]) grouped[hook.event] = [];
+      grouped[hook.event].push(hook);
+    }
+    return grouped;
+  }
+};
+var hookManager = new HookManager();
+
+export {
+  hookManager
+};

package/dist/chunk-BE46C7JW.js

@@ -0,0 +1,46 @@
+// 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-CUVAUOXL.js

@@ -0,0 +1,58 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/ui/keybindings.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var DEFAULT_BINDINGS = {
+  "ctrl+t": "todo",
+  "ctrl+n": "new",
+  "ctrl+k": "palette"
+};
+var loadedBindings = null;
+async function loadKeyBindings() {
+  const merged = { ...DEFAULT_BINDINGS };
+  const filePath = join(HYPERCORE_DIR, "keybindings.json");
+  if (existsSync(filePath)) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const userBindings = JSON.parse(content);
+      Object.assign(merged, userBindings);
+    } catch {
+    }
+  }
+  loadedBindings = merged;
+  return merged;
+}
+function getKeyBindings() {
+  return loadedBindings || DEFAULT_BINDINGS;
+}
+function keypressToCombo(key) {
+  if (!key.name) return null;
+  const parts = [];
+  if (key.ctrl) parts.push("ctrl");
+  if (key.meta) parts.push("alt");
+  if (key.shift) parts.push("shift");
+  parts.push(key.name);
+  return parts.join("+");
+}
+function matchKeyBinding(key) {
+  const combo = keypressToCombo(key);
+  if (!combo) return null;
+  const bindings = getKeyBindings();
+  return bindings[combo] || null;
+}
+function listKeyBindings() {
+  const bindings = getKeyBindings();
+  return Object.entries(bindings).map(([combo, command]) => ({ combo, command }));
+}
+
+export {
+  loadKeyBindings,
+  getKeyBindings,
+  keypressToCombo,
+  matchKeyBinding,
+  listKeyBindings
+};

package/dist/chunk-GH7E2OJE.js

@@ -0,0 +1,223 @@
+import {
+  displayWidth,
+  padToWidth,
+  truncateToWidth
+} from "./chunk-BE46C7JW.js";
+
+// src/ui/markdown.ts
+import chalk from "chalk";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+var INDENT = "  ";
+function renderTable(token) {
+  const termWidth = process.stdout.columns || 120;
+  const headers = token.header.map((h) => h.text.trim());
+  const rows = token.rows.map((r) => r.map((c) => c.text.trim()));
+  const colCount = headers.length;
+  const colWidths = headers.map((h) => displayWidth(h));
+  for (const row of rows) {
+    for (let i = 0; i < colCount; i++) {
+      const cellText = row[i] || "";
+      const w = displayWidth(cellText);
+      if (w > colWidths[i]) colWidths[i] = w;
+    }
+  }
+  const paddedWidths = colWidths.map((w) => w + 2);
+  const borderOverhead = colCount + 1;
+  const totalWidth = paddedWidths.reduce((a, b) => a + b, 0) + borderOverhead;
+  if (totalWidth > termWidth) {
+    const available = termWidth - borderOverhead - 4;
+    const ratio = available / paddedWidths.reduce((a, b) => a + b, 0);
+    for (let i = 0; i < colCount; i++) {
+      paddedWidths[i] = Math.max(4, Math.floor(paddedWidths[i] * ratio));
+    }
+  }
+  const contentWidths = paddedWidths.map((w) => w - 2);
+  const topLine = INDENT + "\u250C" + paddedWidths.map((w) => "\u2500".repeat(w)).join("\u252C") + "\u2510";
+  const midLine = INDENT + "\u251C" + paddedWidths.map((w) => "\u2500".repeat(w)).join("\u253C") + "\u2524";
+  const bottomLine = INDENT + "\u2514" + paddedWidths.map((w) => "\u2500".repeat(w)).join("\u2534") + "\u2518";
+  const headerCells = headers.map((h, i) => {
+    const text = displayWidth(h) > contentWidths[i] ? truncateToWidth(h, contentWidths[i]) : h;
+    return " " + padToWidth(text, contentWidths[i]) + " ";
+  });
+  const headerRow = INDENT + "\u2502" + headerCells.map((c) => chalk.bold(c)).join("\u2502") + "\u2502";
+  const dataRows = rows.map((row) => {
+    const cells = row.map((cell, i) => {
+      const cellText = cell || "";
+      const text = displayWidth(cellText) > contentWidths[i] ? truncateToWidth(cellText, contentWidths[i]) : cellText;
+      return " " + padToWidth(text, contentWidths[i]) + " ";
+    });
+    return INDENT + "\u2502" + cells.join("\u2502") + "\u2502";
+  });
+  return ["", topLine, headerRow, midLine, ...dataRows, bottomLine, ""].join("\n") + "\n";
+}
+function highlightCode(code, lang) {
+  const l = lang.toLowerCase();
+  if (l === "json" || l === "jsonc") {
+    return code.replace(/"([^"]*)"(?=\s*:)/g, chalk.cyan('"$1"')).replace(/:\s*"([^"]*)"/g, ": " + chalk.green('"$1"')).replace(/:\s*(\d+\.?\d*)/g, ": " + chalk.yellow("$1")).replace(/:\s*(true|false|null)/g, ": " + chalk.magenta("$1"));
+  }
+  if (l === "bash" || l === "sh" || l === "shell" || l === "zsh") {
+    return code.replace(/(#.*)$/gm, chalk.gray("$1")).replace(/\b(if|then|else|fi|for|do|done|while|case|esac|function|return|export|source|alias|echo|cd|ls|rm|cp|mv|mkdir|chmod|grep|sed|awk|cat|git|npm|node|docker)\b/g, chalk.blue("$1")).replace(/"([^"]*)"/g, chalk.green('"$1"')).replace(/'([^']*)'/g, chalk.green("'$1'")).replace(/\$\w+/g, chalk.cyan("$&"));
+  }
+  if (l === "css" || l === "scss" || l === "less") {
+    return code.replace(/(\/\*[\s\S]*?\*\/)/g, chalk.gray("$1")).replace(/(#[0-9a-fA-F]{3,8})\b/g, chalk.yellow("$1")).replace(/(\d+\.?\d*)(px|em|rem|%|vh|vw|s|ms)/g, chalk.yellow("$1$2")).replace(/\b(var|calc|rgba?|hsla?)\b/g, chalk.blue("$1"));
+  }
+  const isJSTS = ["js", "javascript", "ts", "typescript", "jsx", "tsx"].includes(l);
+  const isPython = ["python", "py"].includes(l);
+  const isGo = l === "go";
+  const isRust = l === "rust" || l === "rs";
+  if (isJSTS || isPython || isGo || isRust || !l) {
+    let result = code;
+    result = result.replace(/(\/\/.*)$/gm, chalk.gray("$1"));
+    result = result.replace(/(#.*)$/gm, chalk.gray("$1"));
+    result = result.replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, chalk.green('"$1"'));
+    result = result.replace(/'([^'\\]*(\\.[^'\\]*)*)'/g, chalk.green("'$1'"));
+    result = result.replace(/`([^`]*)`/g, chalk.green("`$1`"));
+    let keywords;
+    if (isJSTS) {
+      keywords = ["import", "export", "from", "const", "let", "var", "function", "class", "interface", "type", "enum", "return", "if", "else", "for", "while", "switch", "case", "break", "continue", "async", "await", "new", "this", "extends", "implements", "typeof", "instanceof", "default", "try", "catch", "finally", "throw"];
+    } else if (isPython) {
+      keywords = ["import", "from", "def", "class", "return", "if", "elif", "else", "for", "while", "try", "except", "finally", "with", "as", "in", "not", "and", "or", "is", "None", "True", "False", "lambda", "yield", "async", "await", "raise", "pass", "self"];
+    } else if (isGo) {
+      keywords = ["package", "import", "func", "return", "if", "else", "for", "range", "switch", "case", "default", "var", "const", "type", "struct", "interface", "map", "chan", "go", "defer", "select", "nil", "true", "false"];
+    } else if (isRust) {
+      keywords = ["use", "fn", "let", "mut", "const", "struct", "enum", "impl", "trait", "pub", "mod", "return", "if", "else", "for", "while", "loop", "match", "self", "Self", "true", "false", "None", "Some", "Ok", "Err", "async", "await", "move", "where"];
+    } else {
+      keywords = ["import", "export", "function", "class", "return", "if", "else", "for", "while", "const", "let", "var"];
+    }
+    const kwPattern = new RegExp(`\\b(${keywords.join("|")})\\b`, "g");
+    result = result.replace(kwPattern, chalk.blue("$1"));
+    result = result.replace(/\b(\d+\.?\d*)\b/g, chalk.yellow("$1"));
+    return result;
+  }
+  return code;
+}
+var cjkTableAndCodeExtension = {
+  renderer: {
+    // 标题渲染：去除 # 前缀，纯样式输出
+    heading(token) {
+      const text = token.text;
+      if (token.depth === 1) {
+        return "\n" + chalk.bold.underline(text) + "\n\n";
+      }
+      if (token.depth === 2) {
+        return "\n" + chalk.bold(text) + "\n\n";
+      }
+      return "\n" + chalk.bold(text) + "\n\n";
+    },
+    table(token) {
+      return renderTable(token);
+    },
+    code(token) {
+      const lang = token.lang || "";
+      const highlighted = highlightCode(token.text, lang);
+      const termW = process.stdout.columns || 80;
+      const codeW = Math.min(termW - 6, 76);
+      const langLabel = lang ? chalk.dim.italic(` ${lang}`) : "";
+      const topBorder = INDENT + chalk.dim("\u250C" + "\u2500".repeat(codeW) + "\u2510") + langLabel;
+      const botBorder = INDENT + chalk.dim("\u2514" + "\u2500".repeat(codeW) + "\u2518");
+      const codeLines = highlighted.split("\n").map((line) => {
+        return INDENT + chalk.dim("\u2502") + chalk.bgHex("#1a1a2e")(" " + line) + " ";
+      });
+      return "\n" + topBorder + "\n" + codeLines.join("\n") + "\n" + botBorder + "\n";
+    }
+  }
+};
+var marked = new Marked(
+  // 先注册 marked-terminal 基础渲染
+  markedTerminal({
+    code: chalk.yellow,
+    codespan: chalk.cyan,
+    strong: chalk.bold,
+    em: chalk.italic,
+    link: chalk.blue.underline,
+    // 标题：粗体 + 下划线（一级）/ 粗体（其他）
+    firstHeading: chalk.bold.underline,
+    heading: chalk.bold,
+    blockquote: chalk.gray.italic,
+    listitem: chalk.reset,
+    // 渲染宽度
+    width: (process.stdout.columns || 80) - 4
+  }),
+  // 后注册自定义扩展（优先级更高）
+  cjkTableAndCodeExtension
+);
+function preprocess(text) {
+  const normalized = normalizeSpacing(text);
+  return normalized.replace(/^(\s*)\* /gm, "$1- ");
+}
+function isListLine(line) {
+  const t = line.trim();
+  return /^[-+*]\s+/.test(t) || /^\d+\.\s+/.test(t);
+}
+function normalizeSpacing(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  let inCodeFence = false;
+  let blankCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const current = lines[i].replace(/\s+$/g, "");
+    const trimmed = current.trim();
+    if (/^```/.test(trimmed)) {
+      inCodeFence = !inCodeFence;
+      blankCount = 0;
+      out.push(current);
+      continue;
+    }
+    if (!inCodeFence && trimmed === "") {
+      const prev = out.length > 0 ? out[out.length - 1] : "";
+      const next = i + 1 < lines.length ? lines[i + 1].trim() : "";
+      if (isListLine(prev) && isListLine(next)) {
+        continue;
+      }
+      blankCount += 1;
+      if (blankCount > 1) continue;
+      out.push("");
+      continue;
+    }
+    blankCount = 0;
+    out.push(current);
+  }
+  return out.join("\n").trim();
+}
+function addIndent(rendered) {
+  const lines = rendered.split("\n");
+  const out = [];
+  let prevBlank = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isBlank = trimmed === "";
+    if (isBlank) {
+      if (!prevBlank) out.push("");
+      prevBlank = true;
+      continue;
+    }
+    prevBlank = false;
+    if (/^  /.test(line)) {
+      out.push(line);
+    } else {
+      out.push(INDENT + line);
+    }
+  }
+  return out.join("\n");
+}
+function renderMarkdown(text) {
+  try {
+    let rendered = marked.parse(preprocess(text));
+    rendered = rendered.replace(/^(\s*)(\*) /gm, "$1- ");
+    rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_m, content) => chalk.bold(content));
+    rendered = rendered.replace(/(?<!\*)\*([^*\s][^*]*?)\*(?!\*)/g, (_m, content) => chalk.italic(content));
+    rendered = rendered.replace(/^(\x1b\[0m)+/gm, "");
+    rendered = rendered.replace(/^\s*(\x1b\[[0-9;]*m\s*)+$/gm, "");
+    rendered = rendered.replace(/(\x1b\[0m){2,}/g, "\x1B[0m");
+    rendered = rendered.replace(/\n{3,}/g, "\n\n");
+    rendered = addIndent(rendered);
+    return rendered;
+  } catch {
+    return text;
+  }
+}
+
+export {
+  renderMarkdown
+};