openmemory-plus 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,630 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/install.ts
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/lib/detector.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import which from "which";
+var execAsync = promisify(exec);
+async function checkCommand(cmd) {
+  try {
+    return await which(cmd);
+  } catch {
+    return null;
+  }
+}
+async function getVersion(cmd, args = "--version") {
+  try {
+    const { stdout } = await execAsync(`${cmd} ${args}`);
+    return stdout.trim().split("\n")[0];
+  } catch {
+    return null;
+  }
+}
+async function checkDocker() {
+  const path = await checkCommand("docker");
+  if (!path) {
+    return { name: "Docker", installed: false, error: "\u672A\u5B89\u88C5" };
+  }
+  const version = await getVersion("docker", "--version");
+  try {
+    await execAsync("docker info");
+    return { name: "Docker", installed: true, version: version || void 0, running: true };
+  } catch {
+    return { name: "Docker", installed: true, version: version || void 0, running: false, error: "Docker \u5B88\u62A4\u8FDB\u7A0B\u672A\u8FD0\u884C" };
+  }
+}
+async function checkOllama() {
+  const path = await checkCommand("ollama");
+  if (!path) {
+    return { name: "Ollama", installed: false, error: "\u672A\u5B89\u88C5" };
+  }
+  const version = await getVersion("ollama", "--version");
+  try {
+    await execAsync("curl -s http://localhost:11434/api/tags");
+    return { name: "Ollama", installed: true, version: version || void 0, running: true };
+  } catch {
+    return { name: "Ollama", installed: true, version: version || void 0, running: false, error: "Ollama \u670D\u52A1\u672A\u8FD0\u884C" };
+  }
+}
+async function checkQdrant() {
+  try {
+    const { stdout } = await execAsync("curl -s http://localhost:6333/collections");
+    const data = JSON.parse(stdout);
+    return { name: "Qdrant", installed: true, running: true, version: "container" };
+  } catch {
+    try {
+      const { stdout } = await execAsync('docker ps -a --filter name=qdrant --format "{{.Status}}"');
+      if (stdout.trim()) {
+        return { name: "Qdrant", installed: true, running: false, error: "\u5BB9\u5668\u5B58\u5728\u4F46\u672A\u8FD0\u884C" };
+      }
+    } catch {
+    }
+    return { name: "Qdrant", installed: false, error: "\u5BB9\u5668\u672A\u521B\u5EFA" };
+  }
+}
+async function checkOpenMemory() {
+  try {
+    await execAsync("curl -s http://localhost:8765/health || curl -s http://localhost:8765");
+    return { name: "OpenMemory MCP", installed: true, running: true };
+  } catch {
+    return { name: "OpenMemory MCP", installed: false, running: false, error: "\u670D\u52A1\u672A\u8FD0\u884C" };
+  }
+}
+async function checkBgeM3() {
+  try {
+    const { stdout } = await execAsync("curl -s http://localhost:11434/api/tags");
+    const data = JSON.parse(stdout);
+    const hasModel = data.models?.some((m) => m.name.includes("bge-m3"));
+    if (hasModel) {
+      return { name: "BGE-M3", installed: true, running: true };
+    }
+    return { name: "BGE-M3", installed: false, error: "\u6A21\u578B\u672A\u4E0B\u8F7D" };
+  } catch {
+    return { name: "BGE-M3", installed: false, error: "Ollama \u672A\u8FD0\u884C\uFF0C\u65E0\u6CD5\u68C0\u6D4B" };
+  }
+}
+async function checkAllDependencies() {
+  const [docker, ollama, qdrant, openmemory, bgeM3] = await Promise.all([
+    checkDocker(),
+    checkOllama(),
+    checkQdrant(),
+    checkOpenMemory(),
+    checkBgeM3()
+  ]);
+  return { docker, ollama, qdrant, openmemory, bgeM3 };
+}
+function isSystemReady(status) {
+  return status.docker.installed && status.docker.running && status.ollama.installed && status.ollama.running && status.qdrant.running && status.bgeM3.installed;
+}
+
+// src/commands/install.ts
+var execAsync2 = promisify2(exec2);
+async function openUrl(url) {
+  const { platform } = process;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  await execAsync2(`${cmd} ${url}`);
+}
+async function installOllama() {
+  const spinner = ora("\u5B89\u88C5 Ollama...").start();
+  try {
+    await execAsync2("brew install ollama");
+    spinner.succeed("Ollama \u5B89\u88C5\u6210\u529F");
+    return true;
+  } catch {
+    spinner.fail("Ollama \u5B89\u88C5\u5931\u8D25");
+    console.log(chalk.yellow("\u8BF7\u624B\u52A8\u5B89\u88C5: https://ollama.com/download"));
+    return false;
+  }
+}
+async function startOllama() {
+  const spinner = ora("\u542F\u52A8 Ollama \u670D\u52A1...").start();
+  try {
+    exec2("ollama serve &");
+    await new Promise((r) => setTimeout(r, 2e3));
+    spinner.succeed("Ollama \u670D\u52A1\u5DF2\u542F\u52A8");
+    return true;
+  } catch {
+    spinner.fail("Ollama \u542F\u52A8\u5931\u8D25");
+    return false;
+  }
+}
+async function pullBgeM3() {
+  const spinner = ora("\u4E0B\u8F7D BGE-M3 \u6A21\u578B (\u53EF\u80FD\u9700\u8981\u51E0\u5206\u949F)...").start();
+  try {
+    await execAsync2("ollama pull bge-m3", { timeout: 6e5 });
+    spinner.succeed("BGE-M3 \u6A21\u578B\u5DF2\u4E0B\u8F7D");
+    return true;
+  } catch {
+    spinner.fail("BGE-M3 \u4E0B\u8F7D\u5931\u8D25");
+    return false;
+  }
+}
+async function startQdrant() {
+  const spinner = ora("\u542F\u52A8 Qdrant \u5BB9\u5668...").start();
+  try {
+    await execAsync2("docker run -d --name qdrant -p 6333:6333 -p 6334:6334 qdrant/qdrant");
+    spinner.succeed("Qdrant \u5BB9\u5668\u5DF2\u542F\u52A8");
+    return true;
+  } catch (e) {
+    if (e.message?.includes("already in use")) {
+      try {
+        await execAsync2("docker start qdrant");
+        spinner.succeed("Qdrant \u5BB9\u5668\u5DF2\u542F\u52A8");
+        return true;
+      } catch {
+      }
+    }
+    spinner.fail("Qdrant \u542F\u52A8\u5931\u8D25");
+    return false;
+  }
+}
+async function installCommand(options) {
+  console.log(chalk.cyan.bold("\n\u{1F9E0} OpenMemory Plus - \u5B89\u88C5\u5411\u5BFC\n"));
+  const spinner = ora("\u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...").start();
+  const status = await checkAllDependencies();
+  spinner.stop();
+  console.log(chalk.bold("\u5F53\u524D\u72B6\u6001:"));
+  console.log(`  \u{1F433} Docker:      ${status.docker.installed ? chalk.green("\u2713") : chalk.red("\u2717")}`);
+  console.log(`  \u{1F999} Ollama:      ${status.ollama.installed ? chalk.green("\u2713") : chalk.red("\u2717")}`);
+  console.log(`  \u{1F4E6} Qdrant:      ${status.qdrant.running ? chalk.green("\u2713") : chalk.red("\u2717")}`);
+  console.log(`  \u{1F524} BGE-M3:      ${status.bgeM3.installed ? chalk.green("\u2713") : chalk.red("\u2717")}`);
+  console.log("");
+  if (isSystemReady(status)) {
+    console.log(chalk.green.bold("\u2705 \u6240\u6709\u4F9D\u8D56\u5DF2\u5C31\u7EEA! \u65E0\u9700\u5B89\u88C5\u3002\n"));
+    console.log(chalk.gray("\u8FD0\u884C ") + chalk.cyan("openmemory-plus init") + chalk.gray(" \u521D\u59CB\u5316\u9879\u76EE"));
+    return;
+  }
+  if (!options.yes) {
+    const { confirm } = await inquirer.prompt([{
+      type: "confirm",
+      name: "confirm",
+      message: "\u9700\u8981\u5B89\u88C5\u7F3A\u5931\u7684\u4F9D\u8D56\uFF0C\u662F\u5426\u7EE7\u7EED?",
+      default: true
+    }]);
+    if (!confirm) {
+      console.log(chalk.yellow("\u5DF2\u53D6\u6D88\u5B89\u88C5"));
+      return;
+    }
+  }
+  if (!status.docker.installed && !options.skipDocker) {
+    console.log(chalk.yellow("\n\u{1F4E6} Docker \u9700\u8981\u624B\u52A8\u5B89\u88C5"));
+    console.log(chalk.gray("   \u8BF7\u8BBF\u95EE https://docker.com/download \u4E0B\u8F7D\u5B89\u88C5"));
+    const { openDocker } = await inquirer.prompt([{
+      type: "confirm",
+      name: "openDocker",
+      message: "\u662F\u5426\u6253\u5F00 Docker \u4E0B\u8F7D\u9875\u9762?",
+      default: true
+    }]);
+    if (openDocker) await openUrl("https://docker.com/download");
+    await inquirer.prompt([{ type: "input", name: "wait", message: "\u5B89\u88C5\u5B8C\u6210\u540E\u6309 Enter \u7EE7\u7EED..." }]);
+  }
+  if (!status.ollama.installed && !options.skipOllama) {
+    await installOllama();
+  }
+  if (status.ollama.installed && !status.ollama.running) {
+    await startOllama();
+  }
+  if (!status.bgeM3.installed) {
+    await pullBgeM3();
+  }
+  if (!status.qdrant.running && status.docker.running) {
+    await startQdrant();
+  }
+  console.log(chalk.green.bold("\n\u2705 \u5B89\u88C5\u5B8C\u6210!\n"));
+  console.log(chalk.gray("\u8FD0\u884C ") + chalk.cyan("openmemory-plus status") + chalk.gray(" \u9A8C\u8BC1\u72B6\u6001"));
+  console.log(chalk.gray("\u8FD0\u884C ") + chalk.cyan("openmemory-plus init") + chalk.gray(" \u521D\u59CB\u5316\u9879\u76EE\n"));
+}
+
+// src/commands/init.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import inquirer2 from "inquirer";
+import { existsSync, mkdirSync, copyFileSync, writeFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var IDE_CONFIGS = {
+  augment: { dir: ".augment", configFile: "AGENTS.md", commandsDir: "commands", skillsDir: "skills", rulesDir: ".rules/memory" },
+  claude: { dir: ".", configFile: "CLAUDE.md", commandsDir: ".claude/commands", skillsDir: ".claude/skills", rulesDir: ".rules/memory" },
+  cursor: { dir: ".cursor", configFile: ".cursorrules", commandsDir: "commands", skillsDir: "skills", rulesDir: ".rules/memory" },
+  gemini: { dir: ".", configFile: "gemini.md", commandsDir: ".gemini/commands", skillsDir: ".gemini/skills", rulesDir: ".rules/memory" },
+  common: { dir: ".", configFile: "AGENTS.md", commandsDir: ".agents/commands", skillsDir: ".agents/skills", rulesDir: ".rules/memory" }
+};
+function getTemplatesDir() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    join(__dirname, "..", "templates"),
+    // npm 包: dist/../templates
+    join(__dirname, "..", "..", "templates"),
+    // 开发时 (从 dist/)
+    join(__dirname, "..", "..", "..", "templates")
+    // 旧路径 (从 src/)
+  ];
+  for (const p of possiblePaths) {
+    if (existsSync(join(p, "shared"))) {
+      return p;
+    }
+  }
+  return possiblePaths[0];
+}
+function copyDir(src, dest) {
+  if (!existsSync(src)) return;
+  mkdirSync(dest, { recursive: true });
+  for (const file of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, file.name);
+    const destPath = join(dest, file.name);
+    if (file.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function generateProjectYaml(projectName) {
+  return `# OpenMemory Plus Project Configuration
+# Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+project:
+  name: "${projectName}"
+  version: "1.0.0"
+  description: ""
+
+memory:
+  # \u9879\u76EE\u7EA7\u8BB0\u5FC6\u5B58\u50A8\u4F4D\u7F6E
+  project_store: ".memory/"
+  # \u7528\u6237\u7EA7\u8BB0\u5FC6 (openmemory MCP)
+  user_store: "openmemory"
+
+classification:
+  # \u9879\u76EE\u7EA7\u4FE1\u606F\u5173\u952E\u8BCD (\u5B58\u5165 .memory/)
+  project_keywords:
+    - "\u9879\u76EE\u914D\u7F6E"
+    - "\u6280\u672F\u51B3\u7B56"
+    - "\u90E8\u7F72\u4FE1\u606F"
+    - "API \u5BC6\u94A5"
+    - "\u67B6\u6784\u8BBE\u8BA1"
+    - "\u6570\u636E\u5E93"
+  # \u7528\u6237\u7EA7\u4FE1\u606F\u5173\u952E\u8BCD (\u5B58\u5165 openmemory)
+  user_keywords:
+    - "\u7528\u6237\u504F\u597D"
+    - "\u7F16\u7801\u98CE\u683C"
+    - "\u6280\u80FD"
+    - "\u4E60\u60EF"
+    - "\u559C\u6B22"
+
+agent:
+  # \u5BF9\u8BDD\u7ED3\u675F\u65F6\u81EA\u52A8\u63D0\u53D6\u8BB0\u5FC6
+  auto_extract: true
+  # \u5BF9\u8BDD\u5F00\u59CB\u65F6\u81EA\u52A8\u641C\u7D22\u4E0A\u4E0B\u6587
+  auto_search: true
+  # MCP \u4E0D\u53EF\u7528\u65F6\u964D\u7EA7\u5230\u6587\u4EF6\u5B58\u50A8
+  fallback_to_file: true
+`;
+}
+async function initCommand(options) {
+  console.log(chalk2.cyan.bold("\n\u{1F9E0} OpenMemory Plus - \u9879\u76EE\u521D\u59CB\u5316\n"));
+  const spinner = ora2("\u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...").start();
+  const status = await checkAllDependencies();
+  spinner.stop();
+  if (!isSystemReady(status)) {
+    console.log(chalk2.yellow("\u26A0\uFE0F \u7CFB\u7EDF\u4F9D\u8D56\u672A\u5C31\u7EEA"));
+    console.log(chalk2.gray("\u5EFA\u8BAE\u5148\u8FD0\u884C ") + chalk2.cyan("openmemory-plus install"));
+    if (!options.yes) {
+      const { cont } = await inquirer2.prompt([{
+        type: "confirm",
+        name: "cont",
+        message: "\u662F\u5426\u7EE7\u7EED\u521D\u59CB\u5316?",
+        default: false
+      }]);
+      if (!cont) return;
+    }
+  }
+  let ide = options.ide?.toLowerCase();
+  if (!ide || !IDE_CONFIGS[ide]) {
+    const { selectedIde } = await inquirer2.prompt([{
+      type: "list",
+      name: "selectedIde",
+      message: "\u9009\u62E9 IDE \u7C7B\u578B:",
+      choices: [
+        { name: "Augment", value: "augment" },
+        { name: "Claude Code", value: "claude" },
+        { name: "Cursor", value: "cursor" },
+        { name: "Gemini", value: "gemini" },
+        { name: "\u901A\u7528 (AGENTS.md)", value: "common" }
+      ],
+      default: "augment"
+    }]);
+    ide = selectedIde;
+  }
+  let projectName = options.projectName;
+  if (!projectName) {
+    const cwd2 = process.cwd();
+    const defaultName = cwd2.split("/").pop() || "my-project";
+    const { name } = await inquirer2.prompt([{
+      type: "input",
+      name: "name",
+      message: "\u9879\u76EE\u540D\u79F0:",
+      default: defaultName
+    }]);
+    projectName = name;
+  }
+  const config = IDE_CONFIGS[ide];
+  const cwd = process.cwd();
+  console.log(chalk2.bold("\n\u{1F4C1} \u521B\u5EFA\u914D\u7F6E\u6587\u4EF6..."));
+  const memoryDir = join(cwd, ".memory");
+  if (!existsSync(memoryDir)) {
+    mkdirSync(memoryDir, { recursive: true });
+    console.log(chalk2.green("  \u2713 \u521B\u5EFA .memory/"));
+  }
+  const projectYaml = join(memoryDir, "project.yaml");
+  writeFileSync(projectYaml, generateProjectYaml(projectName));
+  console.log(chalk2.green("  \u2713 \u521B\u5EFA .memory/project.yaml"));
+  const templatesDir = getTemplatesDir();
+  const sharedTemplates = join(templatesDir, "shared");
+  const ideTemplates = join(templatesDir, ide === "common" ? "common" : ide);
+  const commandsDir = join(cwd, config.dir, config.commandsDir);
+  mkdirSync(commandsDir, { recursive: true });
+  copyDir(join(sharedTemplates, "commands"), commandsDir);
+  console.log(chalk2.green(`  \u2713 \u521B\u5EFA ${config.dir}/${config.commandsDir}/ (6 \u4E2A\u547D\u4EE4)`));
+  const skillsDir = join(cwd, config.dir, config.skillsDir);
+  mkdirSync(skillsDir, { recursive: true });
+  copyDir(join(sharedTemplates, "skills"), skillsDir);
+  console.log(chalk2.green(`  \u2713 \u521B\u5EFA ${config.dir}/${config.skillsDir}/ (memory-extraction)`));
+  const rulesDir = join(cwd, config.rulesDir);
+  mkdirSync(rulesDir, { recursive: true });
+  copyDir(join(sharedTemplates, "rules"), rulesDir);
+  console.log(chalk2.green(`  \u2713 \u521B\u5EFA ${config.rulesDir}/ (classification.md)`));
+  if (existsSync(ideTemplates)) {
+    copyDir(ideTemplates, join(cwd, config.dir));
+    console.log(chalk2.green(`  \u2713 \u590D\u5236 IDE \u914D\u7F6E\u6587\u4EF6`));
+  }
+  if (options.generateMcp) {
+    generateMcpConfig(ide);
+  }
+  console.log(chalk2.green.bold("\n\u{1F389} OpenMemory Plus \u521D\u59CB\u5316\u5B8C\u6210!\n"));
+  console.log(chalk2.gray("\u4F7F\u7528 ") + chalk2.cyan("/memory") + chalk2.gray(" \u67E5\u770B\u8BB0\u5FC6\u72B6\u6001"));
+  console.log(chalk2.gray("\u4F7F\u7528 ") + chalk2.cyan("/mem search <query>") + chalk2.gray(" \u641C\u7D22\u8BB0\u5FC6"));
+  if (!options.generateMcp) {
+    console.log(chalk2.gray("\n\u{1F4A1} \u63D0\u793A: \u8FD0\u884C ") + chalk2.cyan("openmemory-plus init --generate-mcp") + chalk2.gray(" \u751F\u6210 MCP \u914D\u7F6E\n"));
+  }
+}
+function generateMcpConfig(ide) {
+  console.log(chalk2.bold("\n\u{1F4CB} MCP \u914D\u7F6E (\u590D\u5236\u5230 IDE \u914D\u7F6E\u6587\u4EF6):"));
+  const mcpConfig = {
+    openmemory: {
+      command: "npx",
+      args: ["-y", "openmemory-mcp"],
+      env: {
+        OPENAI_API_KEY: "your-openai-key-or-use-ollama",
+        MEM0_EMBEDDING_MODEL: "bge-m3",
+        MEM0_EMBEDDING_PROVIDER: "ollama",
+        QDRANT_HOST: "localhost",
+        QDRANT_PORT: "6333"
+      }
+    }
+  };
+  console.log(chalk2.cyan("\n```json"));
+  console.log(JSON.stringify(mcpConfig, null, 2));
+  console.log(chalk2.cyan("```\n"));
+  const configPaths = {
+    augment: "~/.augment/settings.json (mcpServers \u5B57\u6BB5)",
+    claude: "~/.config/claude/mcp.json",
+    cursor: "~/.cursor/mcp.json",
+    gemini: "~/.config/gemini/mcp.json",
+    common: "\u53C2\u8003\u5404 IDE \u7684 MCP \u914D\u7F6E\u6587\u6863"
+  };
+  console.log(chalk2.gray(`\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E: ${configPaths[ide] || configPaths.common}`));
+}
+
+// src/commands/status.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+function formatStatus(dep) {
+  if (!dep.installed) {
+    return chalk3.red("\u2717 \u672A\u5B89\u88C5");
+  }
+  if (dep.running === false) {
+    return chalk3.yellow("\u26A0 \u5DF2\u5B89\u88C5\u4F46\u672A\u8FD0\u884C");
+  }
+  if (dep.running === true) {
+    const ver = dep.version ? chalk3.gray(` (${dep.version})`) : "";
+    return chalk3.green("\u2713 \u8FD0\u884C\u4E2D") + ver;
+  }
+  return chalk3.green("\u2713 \u5DF2\u5B89\u88C5");
+}
+function printStatusTable(status) {
+  console.log("\n" + chalk3.bold("\u4F9D\u8D56\u68C0\u6D4B\u7ED3\u679C:"));
+  console.log("");
+  const deps = [
+    { ...status.docker, icon: "\u{1F433}" },
+    { ...status.ollama, icon: "\u{1F999}" },
+    { ...status.qdrant, icon: "\u{1F4E6}" },
+    { ...status.openmemory, icon: "\u{1F9E0}" },
+    { ...status.bgeM3, icon: "\u{1F524}" }
+  ];
+  for (const dep of deps) {
+    const statusStr = formatStatus(dep);
+    const errorStr = dep.error && !dep.installed ? chalk3.gray(` - ${dep.error}`) : "";
+    console.log(`  ${dep.icon} ${dep.name.padEnd(16)} ${statusStr}${errorStr}`);
+  }
+  console.log("");
+}
+async function statusCommand() {
+  console.log(chalk3.cyan.bold("\n\u{1F9E0} OpenMemory Plus - \u7CFB\u7EDF\u72B6\u6001\n"));
+  const spinner = ora3("\u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...").start();
+  try {
+    const status = await checkAllDependencies();
+    spinner.stop();
+    printStatusTable(status);
+    if (isSystemReady(status)) {
+      console.log(chalk3.green.bold("\u2705 \u7CFB\u7EDF\u5C31\u7EEA! OpenMemory Plus \u53EF\u6B63\u5E38\u4F7F\u7528\u3002\n"));
+      console.log(chalk3.gray("\u63D0\u793A: \u4F7F\u7528 /memory \u547D\u4EE4\u67E5\u770B\u8BB0\u5FC6\u72B6\u6001"));
+    } else {
+      console.log(chalk3.yellow.bold("\u26A0\uFE0F \u7CFB\u7EDF\u672A\u5C31\u7EEA\uFF0C\u90E8\u5206\u4F9D\u8D56\u7F3A\u5931\u6216\u672A\u8FD0\u884C\u3002\n"));
+      console.log(chalk3.gray("\u8FD0\u884C ") + chalk3.cyan("openmemory-plus install") + chalk3.gray(" \u5B89\u88C5\u7F3A\u5931\u4F9D\u8D56"));
+      console.log(chalk3.gray("\u8FD0\u884C ") + chalk3.cyan("openmemory-plus doctor") + chalk3.gray(" \u8BCA\u65AD\u5E76\u4FEE\u590D\u95EE\u9898"));
+    }
+  } catch (error) {
+    spinner.fail("\u68C0\u6D4B\u5931\u8D25");
+    console.error(chalk3.red("\u9519\u8BEF:"), error);
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+function diagnoseIssues(status) {
+  const issues = [];
+  if (!status.docker.installed) {
+    issues.push({
+      name: "Docker \u672A\u5B89\u88C5",
+      description: "\u9700\u8981\u624B\u52A8\u5B89\u88C5 Docker Desktop",
+      severity: "error"
+    });
+  } else if (!status.docker.running) {
+    issues.push({
+      name: "Docker \u5B88\u62A4\u8FDB\u7A0B\u672A\u8FD0\u884C",
+      description: "\u8BF7\u542F\u52A8 Docker Desktop \u5E94\u7528",
+      severity: "error",
+      fix: async () => {
+        console.log(chalk4.yellow("  \u8BF7\u624B\u52A8\u542F\u52A8 Docker Desktop"));
+        return false;
+      }
+    });
+  }
+  if (!status.ollama.installed) {
+    issues.push({
+      name: "Ollama \u672A\u5B89\u88C5",
+      description: "\u4F7F\u7528 brew install ollama \u5B89\u88C5",
+      severity: "error",
+      fix: async () => {
+        try {
+          await execAsync3("brew install ollama");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+  } else if (!status.ollama.running) {
+    issues.push({
+      name: "Ollama \u670D\u52A1\u672A\u8FD0\u884C",
+      description: "\u4F7F\u7528 ollama serve \u542F\u52A8",
+      severity: "warning",
+      fix: async () => {
+        try {
+          exec3("ollama serve &");
+          await new Promise((r) => setTimeout(r, 2e3));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+  }
+  if (!status.qdrant.running) {
+    issues.push({
+      name: "Qdrant \u672A\u8FD0\u884C",
+      description: "\u9700\u8981\u542F\u52A8 Qdrant \u5BB9\u5668",
+      severity: "error",
+      fix: async () => {
+        try {
+          await execAsync3("docker start qdrant || docker run -d --name qdrant -p 6333:6333 -p 6334:6334 qdrant/qdrant");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+  }
+  if (!status.bgeM3.installed) {
+    issues.push({
+      name: "BGE-M3 \u6A21\u578B\u672A\u4E0B\u8F7D",
+      description: "\u4F7F\u7528 ollama pull bge-m3 \u4E0B\u8F7D",
+      severity: "warning",
+      fix: async () => {
+        try {
+          await execAsync3("ollama pull bge-m3", { timeout: 6e5 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+  }
+  return issues;
+}
+async function doctorCommand(options) {
+  console.log(chalk4.cyan.bold("\n\u{1FA7A} OpenMemory Plus - \u95EE\u9898\u8BCA\u65AD\n"));
+  const spinner = ora4("\u68C0\u6D4B\u7CFB\u7EDF\u72B6\u6001...").start();
+  const status = await checkAllDependencies();
+  spinner.stop();
+  const issues = diagnoseIssues(status);
+  if (issues.length === 0) {
+    console.log(chalk4.green.bold("\u2705 \u672A\u53D1\u73B0\u95EE\u9898\uFF0C\u7CFB\u7EDF\u8FD0\u884C\u6B63\u5E38!\n"));
+    return;
+  }
+  console.log(chalk4.yellow.bold(`\u53D1\u73B0 ${issues.length} \u4E2A\u95EE\u9898:
+`));
+  for (const issue of issues) {
+    const icon = issue.severity === "error" ? chalk4.red("\u2717") : chalk4.yellow("\u26A0");
+    console.log(`  ${icon} ${chalk4.bold(issue.name)}`);
+    console.log(`    ${chalk4.gray(issue.description)}`);
+  }
+  console.log("");
+  if (options.fix) {
+    console.log(chalk4.bold("\u5C1D\u8BD5\u81EA\u52A8\u4FEE\u590D...\n"));
+    for (const issue of issues) {
+      if (issue.fix) {
+        const fixSpinner = ora4(`\u4FEE\u590D: ${issue.name}`).start();
+        const success = await issue.fix();
+        if (success) {
+          fixSpinner.succeed(`\u5DF2\u4FEE\u590D: ${issue.name}`);
+        } else {
+          fixSpinner.fail(`\u65E0\u6CD5\u4FEE\u590D: ${issue.name}`);
+        }
+      }
+    }
+    console.log(chalk4.gray("\n\u8FD0\u884C ") + chalk4.cyan("openmemory-plus status") + chalk4.gray(" \u9A8C\u8BC1\u4FEE\u590D\u7ED3\u679C"));
+  } else {
+    const fixable = issues.filter((i) => i.fix).length;
+    if (fixable > 0) {
+      console.log(chalk4.gray(`${fixable} \u4E2A\u95EE\u9898\u53EF\u81EA\u52A8\u4FEE\u590D`));
+      console.log(chalk4.gray("\u8FD0\u884C ") + chalk4.cyan("openmemory-plus doctor --fix") + chalk4.gray(" \u5C1D\u8BD5\u4FEE\u590D"));
+    }
+  }
+  console.log("");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("openmemory-plus").description("\u{1F9E0} Agent Memory Management CLI - Install, configure, and manage OpenMemory Plus").version("1.0.0");
+program.command("install").description("Install and configure all dependencies (Docker, Ollama, Qdrant, OpenMemory)").option("-y, --yes", "Skip confirmation prompts").option("--skip-docker", "Skip Docker installation").option("--skip-ollama", "Skip Ollama installation").action(installCommand);
+program.command("init").description("Initialize OpenMemory Plus in current project").option("-i, --ide <type>", "IDE type: augment, claude, cursor, gemini, common", "augment").option("-y, --yes", "Skip confirmation prompts").option("--project-name <name>", "Project name for configuration").option("--generate-mcp", "Generate MCP configuration snippet").action(initCommand);
+program.command("status").description("Check OpenMemory Plus system status").action(statusCommand);
+program.command("doctor").description("Diagnose and fix common issues").option("--fix", "Attempt to fix issues automatically").action(doctorCommand);
+program.action(() => {
+  console.log(chalk5.cyan.bold("\n\u{1F9E0} OpenMemory Plus - Agent Memory Management\n"));
+  console.log("Usage: openmemory-plus <command> [options]\n");
+  console.log("Commands:");
+  console.log("  install   Install and configure dependencies");
+  console.log("  init      Initialize in current project");
+  console.log("  status    Check system status");
+  console.log("  doctor    Diagnose issues\n");
+  console.log('Run "openmemory-plus --help" for more information.');
+});
+program.parse();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "openmemory-plus",
+  "version": "1.0.0",
+  "description": "Agent Memory Management CLI - Install, configure, and manage OpenMemory Plus",
+  "type": "module",
+  "bin": {
+    "openmemory-plus": "./dist/index.js",
+    "omp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "memory",
+    "openmemory",
+    "cli",
+    "qdrant",
+    "ollama",
+    "mcp",
+    "llm",
+    "claude",
+    "cursor",
+    "augment"
+  ],
+  "author": "TreeRen Chou <miaojsi@outlook.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Alenryuichi/openmemory-plus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Alenryuichi/openmemory-plus/issues"
+  },
+  "homepage": "https://github.com/Alenryuichi/openmemory-plus#readme",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.0",
+    "ora": "^8.0.0",
+    "which": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.0.0",
+    "@types/which": "^3.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ]
+}
+