@hippo-memo/cli 1.0.1 → 1.0.2

package/src/commands/memory/actions.ts

@@ -0,0 +1,268 @@
+import { existsSync } from "node:fs";
+import { createConfig, createStore } from "@hippo-memo/core";
+
+interface BaseOptions {
+  dir?: string;
+}
+
+interface CreateOptions extends BaseOptions {
+  priority?: string;
+  disclosure?: string;
+}
+
+interface SearchOptions extends BaseOptions {
+  domain?: string;
+  limit?: string;
+}
+
+interface DeleteOptions extends BaseOptions {
+  recursive?: boolean;
+}
+
+function normalizeNewlines(content: string): string {
+  return content.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n");
+}
+
+function getStore(directory: string | undefined) {
+  const rootPath = directory || process.cwd();
+  if (!existsSync(rootPath)) {
+    throw new Error(`目录不存在: ${rootPath}`);
+  }
+  return createStore({
+    type: "filesystem",
+    config: createConfig(rootPath)
+  });
+}
+
+export async function create(
+  uri: string,
+  content: string,
+  options: CreateOptions
+) {
+  try {
+    const store = getStore(options.dir);
+    const priority = options.priority
+      ? Number.parseInt(options.priority, 10)
+      : 5;
+    await store.createMemory({
+      uri,
+      content: normalizeNewlines(content),
+      priority,
+      disclosure: options.disclosure
+    });
+    console.log("OK");
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function read(uri: string, options: BaseOptions) {
+  try {
+    const store = getStore(options.dir);
+    const memory = await store.getMemory(uri);
+    if (!memory) {
+      console.error("Memory not found");
+      process.exit(1);
+    }
+    if (!memory.content || memory.content.trim() === "") {
+      console.log("No Content");
+      return;
+    }
+    console.log(memory.content);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function update(
+  uri: string,
+  content: string,
+  options: CreateOptions
+) {
+  try {
+    const store = getStore(options.dir);
+    const updateData: {
+      uri: string;
+      content: string;
+      priority?: number;
+      disclosure?: string;
+    } = {
+      uri,
+      content: normalizeNewlines(content)
+    };
+    if (options.priority) {
+      updateData.priority = Number.parseInt(options.priority, 10);
+    }
+    if (options.disclosure) {
+      updateData.disclosure = options.disclosure;
+    }
+    await store.updateMemory(updateData);
+    console.log("OK");
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function remove(uri: string, options: DeleteOptions) {
+  try {
+    const store = getStore(options.dir);
+    await store.deleteMemory(uri, {
+      recursive: options.recursive
+    });
+    console.log("OK");
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function search(query: string, options: SearchOptions) {
+  try {
+    const store = getStore(options.dir);
+    const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
+    const results = await store.searchMemory(query, {
+      domain: options.domain,
+      limit
+    });
+
+    if (results.length === 0) {
+      console.log(`No memories found matching "${query}"`);
+      return;
+    }
+
+    const truncateContent = (
+      content: string,
+      keyword: string,
+      maxLen = 50
+    ): string => {
+      if (content.length <= maxLen) return content;
+
+      const lowerContent = content.toLowerCase();
+      const lowerKeyword = keyword.toLowerCase();
+      const index = lowerContent.indexOf(lowerKeyword);
+      if (index === -1) {
+        return `${content.slice(0, maxLen - 3)}...`;
+      }
+
+      const keywordLen = keyword.length;
+      let start = index - Math.floor((maxLen - keywordLen) / 2);
+      let end = index + keywordLen + Math.ceil((maxLen - keywordLen) / 2);
+
+      if (start < 0) {
+        end += -start;
+        start = 0;
+      }
+      if (end > content.length) {
+        start -= end - content.length;
+        end = content.length;
+      }
+      start = Math.max(0, start);
+
+      let result = content.slice(start, end);
+      if (start > 0) result = `...${result}`;
+      if (end < content.length) result = `${result}...`;
+
+      return result;
+    };
+
+    const summary = results
+      .map((m) => {
+        const lines = [
+          `- ${m.uri} [★${m.priority}]`,
+          `  content: ${truncateContent(m.content, query)}`
+        ];
+        if (m.disclosure) {
+          lines.splice(1, 0, `  disclosure: ${m.disclosure}`);
+        }
+        return lines.join("\n");
+      })
+      .join("\n\n");
+
+    console.log(`Found ${results.length} memories:\n\n${summary}`);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function list(options: SearchOptions) {
+  try {
+    const store = getStore(options.dir);
+    const limit = options.limit
+      ? Number.parseInt(options.limit, 10)
+      : undefined;
+    const memories = await store.getAllMemories({
+      domain: options.domain
+    });
+
+    const limitedMemories = limit ? memories.slice(0, limit) : memories;
+
+    if (limitedMemories.length === 0) {
+      console.log("No memories found.");
+      return;
+    }
+
+    const truncateContent = (content: string, maxLen = 50): string => {
+      if (content.length <= maxLen) return content;
+      return `${content.slice(0, maxLen - 3)}...`;
+    };
+
+    const summary = limitedMemories
+      .map((m) => {
+        const lines = [
+          `- ${m.uri} [★${m.priority}]`,
+          `  content: ${truncateContent(m.content)}`
+        ];
+        if (m.disclosure) {
+          lines.splice(1, 0, `  disclosure: ${m.disclosure}`);
+        }
+        return lines.join("\n");
+      })
+      .join("\n\n");
+
+    const totalCount = memories.length;
+    const displayCount = limitedMemories.length;
+    const countText =
+      limit && totalCount > limit
+        ? `Showing ${displayCount} of ${totalCount} memories`
+        : `Total: ${totalCount} memories`;
+
+    console.log(`${countText}\n\n${summary}`);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function alias(
+  newUri: string,
+  targetUri: string,
+  options: CreateOptions
+) {
+  try {
+    const store = getStore(options.dir);
+    const aliasData: {
+      newUri: string;
+      targetUri: string;
+      priority?: number;
+      disclosure?: string;
+    } = {
+      newUri,
+      targetUri
+    };
+    if (options.priority) {
+      aliasData.priority = Number.parseInt(options.priority, 10);
+    }
+    if (options.disclosure) {
+      aliasData.disclosure = options.disclosure;
+    }
+    await store.addAlias(aliasData);
+    console.log("OK");
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/commands/memory/index.ts

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { alias, create, list, read, remove, search, update } from "./actions";
+
+export const memoryCmd = new Command("memory").description(
+  "Memory 管理操作 (无需 init，直接使用当前目录)"
+);
+
+memoryCmd
+  .command("create <uri> <content>")
+  .description("创建新记忆")
+  .option("-p, --priority <number>", "优先级 (1-10)", "5")
+  .option("-d, --disclosure <string>", "触发条件")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(create);
+
+memoryCmd
+  .command("read <uri>")
+  .description("读取指定记忆")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(read);
+
+memoryCmd
+  .command("update <uri> <content>")
+  .description("更新记忆内容")
+  .option("-p, --priority <number>", "优先级 (1-10)")
+  .option("-d, --disclosure <string>", "触发条件")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(update);
+
+memoryCmd
+  .command("delete <uri>")
+  .description("删除记忆")
+  .option("-r, --recursive", "递归删除子记忆")
+  .option("--permanent", "永久删除（不进入回收站）")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(remove);
+
+memoryCmd
+  .command("search <query>")
+  .description("搜索记忆")
+  .option("--domain <string>", "限定域名")
+  .option("-l, --limit <number>", "结果数量", "10")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(search);
+
+memoryCmd
+  .command("alias <newUri> <targetUri>")
+  .description("为已有记忆添加别名")
+  .option("-p, --priority <number>", "别名优先级 (继承目标默认)")
+  .option("-d, --disclosure <string>", "别名触发条件")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(alias);
+
+memoryCmd
+  .command("list")
+  .description("列出所有记忆")
+  .option("--domain <string>", "限定域名")
+  .option("-l, --limit <number>", "结果数量")
+  .option("--dir <directory>", "项目根目录 (默认: .)", ".")
+  .action(async (options) => {
+    await list(options);
+  });
+
+export default memoryCmd;

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { init, web } from "./commands";
+import memoryCmd from "./commands/memory";
 
 const program = new Command();
 
@@ -30,4 +31,6 @@ program
     await web(directory, port, storeType);
   });
 
+program.addCommand(memoryCmd);
+
 program.parse();