hypercore-cli 1.1.0

package/dist/chunk-V5UHPPSY.js

@@ -0,0 +1,140 @@
+// src/core/config.ts
+import { join } from "path";
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+
+// src/core/types.ts
+var MODEL_PROVIDERS = {
+  anthropic: {
+    defaultModel: "claude-sonnet-4-20250514",
+    name: "Anthropic (Claude)",
+    sdkType: "anthropic"
+  },
+  minimax: {
+    baseURL: "https://api.minimax.io/anthropic",
+    defaultModel: "MiniMax-M2.5",
+    name: "MiniMax (M2.5)",
+    sdkType: "anthropic"
+  },
+  gemini: {
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+    defaultModel: "gemini-2.5-flash",
+    name: "Google (Gemini)",
+    sdkType: "openai"
+  },
+  deepseek: {
+    baseURL: "https://api.deepseek.com/v1",
+    defaultModel: "deepseek-chat",
+    name: "DeepSeek",
+    sdkType: "openai"
+  },
+  "openai-compatible": {
+    defaultModel: "gpt-4o",
+    name: "OpenAI Compatible",
+    sdkType: "openai"
+  }
+};
+var MODEL_ALIASES = {
+  // Claude 系列
+  "sonnet": { provider: "anthropic", model: "claude-sonnet-4-20250514" },
+  "haiku": { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
+  "opus": { provider: "anthropic", model: "claude-opus-4-20250514" },
+  // Gemini 系列
+  "flash": { provider: "gemini", model: "gemini-2.5-flash" },
+  "gemini": { provider: "gemini", model: "gemini-2.5-flash" },
+  "gemini-pro": { provider: "gemini", model: "gemini-2.5-pro-preview-05-06" },
+  // DeepSeek
+  "deepseek": { provider: "deepseek", model: "deepseek-chat" },
+  "ds": { provider: "deepseek", model: "deepseek-chat" },
+  "deepseek-coder": { provider: "deepseek", model: "deepseek-coder" },
+  "deepseek-r1": { provider: "deepseek", model: "deepseek-reasoner" },
+  // MiniMax
+  "minimax": { provider: "minimax", model: "MiniMax-M2.5" },
+  "mm": { provider: "minimax", model: "MiniMax-M2.5" }
+};
+
+// src/core/config.ts
+var HYPERCORE_DIR = join(process.env.HOME || "~", ".hypercore");
+function parseSectionValues(content, sectionName) {
+  const sectionRegex = new RegExp(`\\[${sectionName}\\]([\\s\\S]*?)(?=\\[|$)`);
+  const match = content.match(sectionRegex);
+  if (!match) return {};
+  const result = {};
+  const lines = match[1].split("\n");
+  for (const line of lines) {
+    const kvMatch = line.match(/^\s*(\w+)\s*=\s*"([^"]*)"/);
+    if (kvMatch) {
+      result[kvMatch[1]] = kvMatch[2];
+    }
+  }
+  return result;
+}
+async function loadConfig() {
+  const configPath = join(HYPERCORE_DIR, "config.toml");
+  if (!existsSync(configPath)) {
+    throw new Error("\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\u3002\u8BF7\u5148\u8FD0\u884C hypercore init");
+  }
+  const content = await readFile(configPath, "utf-8");
+  const modelSection = parseSectionValues(content, "model");
+  const provider = modelSection["provider"] || "anthropic";
+  const apiKey = modelSection["api_key"];
+  if (!apiKey) {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6 [model] \u6BB5\u672A\u627E\u5230 api_key");
+  }
+  const providerConfig = MODEL_PROVIDERS[provider];
+  if (!providerConfig) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u6A21\u578B\u63D0\u4F9B\u5546: ${provider}\u3002\u652F\u6301: ${Object.keys(MODEL_PROVIDERS).join(", ")}`);
+  }
+  const searchSection = parseSectionValues(content, "search");
+  const outputSection = parseSectionValues(content, "output");
+  const keysSection = parseSectionValues(content, "keys");
+  const providerKeys = {};
+  providerKeys[provider] = apiKey;
+  const keyMapping = {
+    anthropic: "anthropic",
+    gemini: "gemini",
+    deepseek: "deepseek",
+    minimax: "minimax",
+    openai: "openai-compatible"
+  };
+  for (const [name, value] of Object.entries(keysSection)) {
+    const mappedProvider = keyMapping[name];
+    if (mappedProvider && value) {
+      providerKeys[mappedProvider] = value;
+    }
+  }
+  const uiSection = parseSectionValues(content, "ui");
+  const uiConfig = {};
+  if (uiSection["theme"]) {
+    const t = uiSection["theme"];
+    if (t === "dark" || t === "light" || t === "high-contrast") {
+      uiConfig.theme = t;
+    }
+  }
+  if (uiSection["vim_mode"] === "true") uiConfig.vimMode = true;
+  if (uiSection["notifications"] === "false") {
+    uiConfig.notifications = false;
+  } else {
+    uiConfig.notifications = true;
+  }
+  return {
+    modelConfig: {
+      provider,
+      model: modelSection["name"] || providerConfig.defaultModel,
+      apiKey,
+      baseURL: modelSection["base_url"] || providerConfig.baseURL,
+      sdkType: providerConfig.sdkType
+    },
+    tavilyApiKey: searchSection["api_key"] || void 0,
+    outputDir: outputSection["dir"] || join(HYPERCORE_DIR, "outputs"),
+    providerKeys,
+    uiConfig
+  };
+}
+
+export {
+  MODEL_PROVIDERS,
+  MODEL_ALIASES,
+  HYPERCORE_DIR,
+  loadConfig
+};

package/dist/chunk-WHLVZCQY.js

@@ -0,0 +1,245 @@
+// src/core/config-loader.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+function splitByHeadings(markdown, level) {
+  const regex = new RegExp(`^${"#".repeat(level)}\\s+(.+)$`, "gm");
+  const sections = [];
+  let lastIndex = 0;
+  let lastTitle = "";
+  let match;
+  while ((match = regex.exec(markdown)) !== null) {
+    if (lastTitle) {
+      sections.push({
+        title: lastTitle,
+        content: markdown.slice(lastIndex, match.index).trim(),
+        level
+      });
+    }
+    lastTitle = match[1].trim();
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastTitle) {
+    sections.push({
+      title: lastTitle,
+      content: markdown.slice(lastIndex).trim(),
+      level
+    });
+  }
+  return sections;
+}
+function parseKeyValue(text) {
+  const result = {};
+  const lines = text.split("\n");
+  let currentKey = "";
+  let currentValue = "";
+  let inMultiline = false;
+  for (const line of lines) {
+    if (inMultiline) {
+      if (/^\w+:/.test(line) && !line.startsWith(" ")) {
+        result[currentKey] = currentValue.trim();
+        inMultiline = false;
+      } else {
+        currentValue += "\n" + line;
+        continue;
+      }
+    }
+    const kvMatch = line.match(/^(\w[\w_]*)\s*:\s*(.*)$/);
+    if (kvMatch) {
+      const [, key, value] = kvMatch;
+      if (value === "|" || value === "") {
+        currentKey = key;
+        currentValue = "";
+        inMultiline = true;
+      } else {
+        result[key] = value.trim();
+      }
+    }
+  }
+  if (inMultiline && currentKey) {
+    result[currentKey] = currentValue.trim();
+  }
+  return result;
+}
+function parseList(text) {
+  return text.split("\n").filter((line) => line.trim().startsWith("-")).map((line) => line.replace(/^[\s]*-\s*/, "").trim());
+}
+function parsePWP(content) {
+  const sections = splitByHeadings(content, 2);
+  let identity = "";
+  let qualityStandards = [];
+  for (const section of sections) {
+    const titleLower = section.title.toLowerCase();
+    if (titleLower.includes("\u8EAB\u4EFD") || titleLower.includes("identity")) {
+      identity = section.content;
+    } else if (titleLower.includes("\u54C1\u8D28") || titleLower.includes("quality") || titleLower.includes("\u6807\u51C6")) {
+      qualityStandards = parseList(section.content);
+    }
+  }
+  return { identity, qualityStandards, rawContent: content };
+}
+function parseAgent(content) {
+  const sections = splitByHeadings(content, 2);
+  const firstLine = content.split("\n").find((l) => l.startsWith("# "));
+  const name = firstLine ? firstLine.replace(/^#\s+/, "").trim() : "unknown";
+  let role = "";
+  let skillIds = [];
+  let style = "";
+  for (const section of sections) {
+    const titleLower = section.title.toLowerCase();
+    if (titleLower.includes("\u89D2\u8272") || titleLower.includes("role")) {
+      role = section.content;
+    } else if (titleLower.includes("\u6280\u80FD") || titleLower.includes("skill")) {
+      skillIds = parseList(section.content);
+    } else if (titleLower.includes("\u98CE\u683C") || titleLower.includes("style") || titleLower.includes("\u6027\u683C")) {
+      style = section.content;
+    }
+  }
+  return { name, role, skillIds, style, rawContent: content };
+}
+function parseSkill(content) {
+  const sections = splitByHeadings(content, 2);
+  const firstLine = content.split("\n").find((l) => l.startsWith("# "));
+  const name = firstLine ? firstLine.replace(/^#\s+/, "").trim() : "unknown";
+  let domain = "";
+  let knowledge = "";
+  let toolStrategy = "";
+  let qualityStandards = [];
+  for (const section of sections) {
+    const titleLower = section.title.toLowerCase();
+    if (titleLower.includes("\u9886\u57DF") || titleLower.includes("domain")) {
+      domain = section.content;
+    } else if (titleLower.includes("\u77E5\u8BC6") || titleLower.includes("knowledge") || titleLower.includes("\u65B9\u6CD5")) {
+      knowledge = section.content;
+    } else if (titleLower.includes("\u5DE5\u5177") || titleLower.includes("tool")) {
+      toolStrategy = section.content;
+    } else if (titleLower.includes("\u8D28\u91CF") || titleLower.includes("quality") || titleLower.includes("\u6807\u51C6")) {
+      qualityStandards = parseList(section.content);
+    }
+  }
+  return { name, domain, knowledge, toolStrategy, qualityStandards, rawContent: content };
+}
+function parseProductionLine(content) {
+  const sections = splitByHeadings(content, 2);
+  const firstLine = content.split("\n").find((l) => l.startsWith("# "));
+  const name = firstLine ? firstLine.replace(/^#\s+/, "").trim() : "unknown";
+  let description = "";
+  let icon;
+  let inputs = [];
+  let stations = [];
+  let output = { format: "markdown", description: "" };
+  for (const section of sections) {
+    const titleLower = section.title.toLowerCase();
+    if (titleLower.includes("\u63CF\u8FF0") || titleLower.includes("description")) {
+      description = section.content;
+    } else if (titleLower.includes("\u56FE\u6807") || titleLower.includes("icon")) {
+      icon = section.content.trim();
+    } else if (titleLower.includes("\u8F93\u5165") || titleLower.includes("input")) {
+      inputs = parseInputs(section.content);
+    } else if (titleLower.includes("\u5DE5\u4F4D") || titleLower.includes("station")) {
+      stations = parseStations(section.content);
+    } else if (titleLower.includes("\u8F93\u51FA") || titleLower.includes("output")) {
+      const kv = parseKeyValue(section.content);
+      output = {
+        format: kv["format"] || "markdown",
+        description: kv["description"] || ""
+      };
+    }
+  }
+  return { name, description, icon, inputs, stations, output };
+}
+function parseInputs(content) {
+  return parseList(content).map((line) => {
+    const nameMatch = line.match(/^(\w+)\s*[:：]\s*(.+)/);
+    if (!nameMatch) return { name: line, type: "string", required: false, description: line };
+    const [, paramName, rest] = nameMatch;
+    const required = rest.includes("\u5FC5\u586B") || rest.includes("required");
+    const defaultMatch = rest.match(/默认值?\s*[:：]\s*(.+?)(?:[，,)）]|$)/);
+    return {
+      name: paramName,
+      type: "string",
+      required,
+      description: rest,
+      defaultValue: defaultMatch?.[1]?.trim()
+    };
+  });
+}
+function parseStations(content) {
+  const stationSections = splitByHeadings(content, 3);
+  return stationSections.map((section, i) => {
+    const nameMatch = section.title.match(/^\d+\.\s*(.+)/);
+    const stationName = nameMatch ? nameMatch[1].trim() : section.title;
+    const kv = parseKeyValue(section.content);
+    let checkpoint;
+    if (kv["checkpoint"]) {
+      const cp = kv["checkpoint"].toLowerCase();
+      if (cp === "decision" || cp === "approval") {
+        checkpoint = cp;
+      }
+    }
+    return {
+      index: i + 1,
+      name: stationName,
+      agentName: kv["agent"] || "default",
+      task: kv["task"] || section.content,
+      skillName: kv["skill"],
+      model: kv["model"],
+      retry: kv["retry"] ? parseInt(kv["retry"], 10) : void 0,
+      condition: kv["condition"],
+      checkpoint,
+      checkpointDescription: kv["checkpoint_description"]
+    };
+  });
+}
+async function loadFile(path) {
+  return readFile(path, "utf-8");
+}
+async function loadPWP(dir) {
+  const content = await loadFile(join(dir, "PWP.md"));
+  return parsePWP(content);
+}
+async function loadAgent(dir, name) {
+  const content = await loadFile(join(dir, "agents", `${name}.agent.md`));
+  return parseAgent(content);
+}
+async function loadSkill(dir, name) {
+  const content = await loadFile(join(dir, "skills", `${name}.skill.md`));
+  return parseSkill(content);
+}
+async function loadLine(dir, name) {
+  const content = await loadFile(join(dir, "lines", `${name}.line.md`));
+  return parseProductionLine(content);
+}
+async function listLines(dir) {
+  const linesDir = join(dir, "lines");
+  try {
+    const files = await readdir(linesDir);
+    const lines = [];
+    for (const file of files) {
+      if (file.endsWith(".line.md")) {
+        const content = await loadFile(join(linesDir, file));
+        const line = parseProductionLine(content);
+        lines.push({
+          name: line.name,
+          description: line.description,
+          icon: line.icon
+        });
+      }
+    }
+    return lines;
+  } catch {
+    return [];
+  }
+}
+
+export {
+  parsePWP,
+  parseAgent,
+  parseSkill,
+  parseProductionLine,
+  loadFile,
+  loadPWP,
+  loadAgent,
+  loadSkill,
+  loadLine,
+  listLines
+};

package/dist/chunk-XDRCBMZZ.js

@@ -0,0 +1,66 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/team/auth.ts
+import { randomBytes } from "crypto";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+function generateId() {
+  return randomBytes(4).toString("hex");
+}
+function generateToken() {
+  return randomBytes(8).toString("hex");
+}
+function generateJoinCode() {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  let code = "";
+  const bytes = randomBytes(6);
+  for (let i = 0; i < 6; i++) {
+    code += chars[bytes[i] % chars.length];
+  }
+  return code;
+}
+function validateToken(team, token) {
+  return team.members.find((m) => m.token === token) || null;
+}
+function isOwner(member) {
+  return member.role === "owner";
+}
+var TOKEN_FILE = "team-token.json";
+function getTokenPath() {
+  return join(HYPERCORE_DIR, TOKEN_FILE);
+}
+async function saveLocalToken(token) {
+  await mkdir(HYPERCORE_DIR, { recursive: true });
+  await writeFile(getTokenPath(), JSON.stringify(token, null, 2), "utf-8");
+}
+async function loadLocalToken() {
+  const p = getTokenPath();
+  if (!existsSync(p)) return null;
+  try {
+    const data = await readFile(p, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function clearLocalToken() {
+  const p = getTokenPath();
+  if (existsSync(p)) {
+    const { unlink } = await import("fs/promises");
+    await unlink(p);
+  }
+}
+
+export {
+  generateId,
+  generateToken,
+  generateJoinCode,
+  validateToken,
+  isOwner,
+  saveLocalToken,
+  loadLocalToken,
+  clearLocalToken
+};

package/dist/chunk-XOS6HPEF.js

@@ -0,0 +1,134 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/repl/session.ts
+import { mkdir, writeFile, readFile, readdir, rename } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+var SESSIONS_DIR = join(HYPERCORE_DIR, "sessions");
+function generateSessionId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0];
+  const time = now.toTimeString().split(" ")[0].replace(/:/g, "");
+  return `${date}-${time}`;
+}
+async function saveSession(sessionId, messages, name) {
+  await mkdir(SESSIONS_DIR, { recursive: true });
+  const data = {
+    id: sessionId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    messages
+  };
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (existsSync(filePath)) {
+    try {
+      const existing = JSON.parse(await readFile(filePath, "utf-8"));
+      data.createdAt = existing.createdAt;
+      if (!name && existing.name) data.name = existing.name;
+    } catch {
+    }
+  }
+  if (name) data.name = name;
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function loadSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(filePath)) {
+    throw new Error(`\u4F1A\u8BDD ${sessionId} \u4E0D\u5B58\u5728`);
+  }
+  const data = JSON.parse(await readFile(filePath, "utf-8"));
+  return data.messages;
+}
+async function listSessions(limit = 10) {
+  if (!existsSync(SESSIONS_DIR)) return [];
+  const files = await readdir(SESSIONS_DIR);
+  const sessions = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const data = JSON.parse(await readFile(join(SESSIONS_DIR, file), "utf-8"));
+      sessions.push({
+        id: data.id,
+        name: data.name,
+        updatedAt: data.updatedAt,
+        messageCount: data.messages.length
+      });
+    } catch {
+    }
+  }
+  sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return sessions.slice(0, limit);
+}
+async function renameSession(oldId, newId) {
+  const oldPath = join(SESSIONS_DIR, `${oldId}.json`);
+  const newPath = join(SESSIONS_DIR, `${newId}.json`);
+  if (!existsSync(oldPath)) throw new Error(`\u4F1A\u8BDD ${oldId} \u4E0D\u5B58\u5728`);
+  if (existsSync(newPath)) throw new Error(`\u4F1A\u8BDD ${newId} \u5DF2\u5B58\u5728`);
+  const data = JSON.parse(await readFile(oldPath, "utf-8"));
+  data.id = newId;
+  data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(newPath, JSON.stringify(data, null, 2), "utf-8");
+  await rename(oldPath, join(SESSIONS_DIR, `${oldId}.json.bak`)).catch(() => {
+  });
+  const { unlink } = await import("fs/promises");
+  await unlink(join(SESSIONS_DIR, `${oldId}.json.bak`)).catch(() => {
+  });
+}
+async function forkSession(sourceId) {
+  const sourcePath = join(SESSIONS_DIR, `${sourceId}.json`);
+  if (!existsSync(sourcePath)) throw new Error(`\u4F1A\u8BDD ${sourceId} \u4E0D\u5B58\u5728`);
+  const newId = generateSessionId() + "-fork";
+  const newPath = join(SESSIONS_DIR, `${newId}.json`);
+  const data = JSON.parse(await readFile(sourcePath, "utf-8"));
+  data.id = newId;
+  data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(newPath, JSON.stringify(data, null, 2), "utf-8");
+  return newId;
+}
+async function exportSession(sessionId, outputPath) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(filePath)) throw new Error(`\u4F1A\u8BDD ${sessionId} \u4E0D\u5B58\u5728`);
+  const data = JSON.parse(await readFile(filePath, "utf-8"));
+  const lines = [
+    `# \u4F1A\u8BDD: ${data.id}`,
+    ``,
+    `- \u521B\u5EFA: ${data.createdAt}`,
+    `- \u66F4\u65B0: ${data.updatedAt}`,
+    `- \u6D88\u606F\u6570: ${data.messages.length}`,
+    ``,
+    `---`,
+    ``
+  ];
+  for (const msg of data.messages) {
+    const role = msg.role === "user" ? "\u{1F464} \u7528\u6237" : "\u{1F916} AI";
+    lines.push(`## ${role}
+`);
+    lines.push(msg.content);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  const mdContent = lines.join("\n");
+  const dest = outputPath || join(process.cwd(), `session-${sessionId}.md`);
+  await writeFile(dest, mdContent, "utf-8");
+  return dest;
+}
+async function deleteSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(filePath)) throw new Error(`\u4F1A\u8BDD ${sessionId} \u4E0D\u5B58\u5728`);
+  const { unlink } = await import("fs/promises");
+  await unlink(filePath);
+}
+
+export {
+  generateSessionId,
+  saveSession,
+  loadSession,
+  listSessions,
+  renameSession,
+  forkSession,
+  exportSession,
+  deleteSession
+};