geomind 0.1.0

package/.geomind/extensions/memory.ts

@@ -0,0 +1,330 @@
+import type { AgentEndEvent, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const MEMORY_CATEGORIES = ["database", "user"] as const;
+type MemoryCategory = (typeof MEMORY_CATEGORIES)[number];
+
+const REFLECTION_INTERVAL = 5;
+
+const MEMORY_FILES = {
+  database: [
+    {
+      key: "schema-overview",
+      title: "Database schema overview",
+      description: "数据库整体概览（有哪些表、各表用途一句话总结）",
+    },
+    {
+      key: "table-details",
+      title: "Database table details",
+      description: "各表详细结构（列名、类型、SRID、数据量、重要字段含义）",
+    },
+    {
+      key: "query-patterns",
+      title: "Database query patterns",
+      description: "有用的 SQL 模式、踩过的坑",
+    },
+  ],
+  user: [
+    {
+      key: "profile",
+      title: "User profile",
+      description: "用户身份（姓名、职业、研究背景）",
+    },
+    {
+      key: "preferences",
+      title: "User preferences",
+      description: "用户偏好（常用区域、分析习惯、展示偏好）",
+    },
+    {
+      key: "corrections",
+      title: "User corrections",
+      description: "用户纠错记录",
+    },
+  ],
+} as const;
+
+type DatabaseMemoryKey = (typeof MEMORY_FILES.database)[number]["key"];
+type UserMemoryKey = (typeof MEMORY_FILES.user)[number]["key"];
+type MemoryKey = DatabaseMemoryKey | UserMemoryKey;
+
+const CATEGORY_TITLES: Record<MemoryCategory, string> = {
+  database: "Database Knowledge",
+  user: "User Preferences",
+};
+
+function getGlobalMemoryDir(): string {
+  return path.join(os.homedir(), ".geomind", "memory");
+}
+
+function getProjectMemoryDir(cwd: string): string {
+  return path.join(cwd, ".geomind", "memory");
+}
+
+function getCategoryMemoryDir(cwd: string, category: MemoryCategory): string {
+  const memoryDir = category === "user" ? getGlobalMemoryDir() : getProjectMemoryDir(cwd);
+  return path.join(memoryDir, category);
+}
+
+function ensureDir(dir: string) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function stripFrontmatter(content: string): string {
+  return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
+}
+
+function getMemoryFiles(category: MemoryCategory) {
+  return MEMORY_FILES[category];
+}
+
+function isMemoryKeyForCategory(category: MemoryCategory, key: MemoryKey): boolean {
+  return getMemoryFiles(category).some((file) => file.key === key);
+}
+
+function getMemoryFilePath(cwd: string, category: MemoryCategory, key: MemoryKey): string {
+  return path.join(getCategoryMemoryDir(cwd, category), `${key}.md`);
+}
+
+function readUpdatedFromFrontmatter(content: string): string | undefined {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return undefined;
+
+  const updatedLine = match[1].split(/\r?\n/).find((line) => line.startsWith("updated:"));
+  return updatedLine?.replace(/^updated:\s*/, "").trim();
+}
+
+function readMemoryEntries(cwd: string, category: MemoryCategory) {
+  const categoryDir = getCategoryMemoryDir(cwd, category);
+  if (!fs.existsSync(categoryDir)) return [];
+
+  return getMemoryFiles(category)
+    .map(({ key }) => {
+      const filePath = getMemoryFilePath(cwd, category, key);
+      if (!fs.existsSync(filePath)) return undefined;
+
+      const content = fs.readFileSync(filePath, "utf-8");
+      return { key, content: stripFrontmatter(content) };
+    })
+    .filter((entry): entry is { key: MemoryKey; content: string } => Boolean(entry?.content));
+}
+
+function buildMemoryContext(cwd: string): string {
+  const sections: string[] = [];
+
+  for (const category of MEMORY_CATEGORIES) {
+    const entries = readMemoryEntries(cwd, category);
+    if (entries.length === 0) continue;
+
+    const body = entries.map((entry) => `[${entry.key}]\n${entry.content}`).join("\n\n");
+    sections.push(`### ${CATEGORY_TITLES[category]}\n${body}`);
+  }
+
+  if (sections.length === 0) return "";
+  return `## Your Current Memory\n\n${sections.join("\n\n")}`;
+}
+
+function hasMemoryReflection(messages: AgentEndEvent["messages"]): boolean {
+  return messages.some(
+    (message) => message.role === "custom" && message.customType === "memory-reflection"
+  );
+}
+
+const memoryCategorySchema = Type.Union([Type.Literal("database"), Type.Literal("user")]);
+const memoryKeySchema = Type.Union([
+  Type.Literal("schema-overview"),
+  Type.Literal("table-details"),
+  Type.Literal("query-patterns"),
+  Type.Literal("profile"),
+  Type.Literal("preferences"),
+  Type.Literal("corrections"),
+]);
+
+export default function (pi: ExtensionAPI) {
+  let turnsSinceLastReflection = 0;
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    const memoryContext = buildMemoryContext(ctx.cwd);
+    if (!memoryContext) return;
+
+    return {
+      systemPrompt: `${event.systemPrompt.trimEnd()}\n\n${memoryContext}`,
+    };
+  });
+
+  pi.on("agent_end", async (event) => {
+    if (hasMemoryReflection(event.messages)) {
+      turnsSinceLastReflection = 0;
+      return;
+    }
+
+    turnsSinceLastReflection += 1;
+    if (turnsSinceLastReflection < REFLECTION_INTERVAL) return;
+    turnsSinceLastReflection = 0;
+
+    pi.sendMessage(
+      {
+        customType: "memory-reflection",
+        content: `请回顾本轮对话（最近5轮），提炼值得长期记忆的信息。
+
+步骤：
+1. 先用 memory_list 查看当前有哪些记忆
+2. 对于需要更新的记忆，先 memory_read 读取已有内容
+3. 将新知识合并到已有内容中，用 memory_write 写回
+
+可用的记忆 key：
+- database/schema-overview：数据库整体概览（有哪些表、各表用途一句话总结）
+- database/table-details：各表详细结构（列名、类型、SRID、数据量、重要字段含义）
+- database/query-patterns：有用的 SQL 模式、踩过的坑
+- user/profile：用户身份（姓名、职业、研究背景）
+- user/preferences：用户偏好（常用区域、分析习惯、展示偏好）
+- user/corrections：用户纠错记录
+
+规则：
+- 不要创建新的 key，只能用上面列出的 6 个
+- 如果某个 key 已有内容，读取后合并新信息，不要覆盖丢失旧信息
+- 如果没有值得记忆的新信息，直接说"无需更新记忆"
+- 记忆内容要简洁结构化，用 markdown 列表或表格组织`,
+        display: false,
+      },
+      {
+        triggerTurn: true,
+        deliverAs: "followUp",
+      }
+    );
+  });
+
+  pi.registerTool({
+    name: "memory_write",
+    label: "Memory Write",
+    description:
+      "Save knowledge to one of GeoMind's fixed persistent memory files. Existing content is overwritten; read and merge first when preserving old information.",
+    parameters: Type.Object({
+      category: memoryCategorySchema,
+      key: memoryKeySchema,
+      content: Type.String({
+        description:
+          "要写入的完整内容。会覆盖该 key 的已有内容。如果要追加信息，请先用 memory_read 读取已有内容，合并后再写入。",
+      }),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const { category, key, content } = params;
+      if (!isMemoryKeyForCategory(category, key)) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Invalid memory key [${category}/${key}]. Use memory_list to see the fixed keys for each category.`,
+            },
+          ],
+          details: {},
+        };
+      }
+
+      const categoryDir = getCategoryMemoryDir(ctx.cwd, category);
+      ensureDir(categoryDir);
+
+      const filePath = getMemoryFilePath(ctx.cwd, category, key);
+      const timestamp = new Date().toISOString();
+
+      const fileContent = `---
+key: ${key}
+category: ${category}
+updated: ${timestamp}
+---
+
+${content}
+`;
+
+      fs.writeFileSync(filePath, fileContent, "utf-8");
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Memory saved: [${category}/${key}] at ${timestamp}`,
+          },
+        ],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_read",
+    label: "Memory Read",
+    description: "Read a specific memory entry by category and key.",
+    parameters: Type.Object({
+      category: memoryCategorySchema,
+      key: memoryKeySchema,
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const { category, key } = params;
+      if (!isMemoryKeyForCategory(category, key)) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Invalid memory key [${category}/${key}]. Use memory_list to see the fixed keys for each category.`,
+            },
+          ],
+          details: {},
+        };
+      }
+
+      const filePath = getMemoryFilePath(ctx.cwd, category, key);
+
+      if (!fs.existsSync(filePath)) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `No memory found for [${category}/${key}]`,
+            },
+          ],
+          details: {},
+        };
+      }
+
+      const content = fs.readFileSync(filePath, "utf-8");
+      return {
+        content: [{ type: "text" as const, text: content }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_list",
+    label: "Memory List",
+    description: "List GeoMind's fixed memory files and show whether each one exists.",
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      const results: string[] = [];
+
+      for (const category of MEMORY_CATEGORIES) {
+        results.push(`\n[${category}] ${getCategoryMemoryDir(ctx.cwd, category)}`);
+        for (const file of getMemoryFiles(category)) {
+          const filePath = getMemoryFilePath(ctx.cwd, category, file.key);
+          if (!fs.existsSync(filePath)) {
+            results.push(`  - ${file.key}: missing (${file.description})`);
+            continue;
+          }
+
+          const content = fs.readFileSync(filePath, "utf-8");
+          const updated = readUpdatedFromFrontmatter(content) ?? fs.statSync(filePath).mtime.toISOString();
+          results.push(`  - ${file.key}: exists, updated ${updated} (${file.description})`);
+        }
+      }
+
+      return {
+        content: [{ type: "text" as const, text: results.join("\n").trim() }],
+        details: {},
+      };
+    },
+  });
+}

package/.geomind/extensions/setup.ts

@@ -0,0 +1,247 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+interface GeoMindConfig {
+  psql?: {
+    command: string;
+    database: string;
+    user?: string;
+    host?: string;
+    port?: number;
+  };
+  qgis_process?: {
+    path: string;
+    available: boolean;
+  };
+}
+
+interface CommandResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+}
+
+const LOCAL_HOSTS = new Set(["", "localhost", "127.0.0.1", "::1"]);
+
+function getGlobalDir(): string {
+  return path.join(os.homedir(), ".geomind");
+}
+
+function getConfigPath(cwd: string, scope: "global" | "project"): string {
+  return scope === "global"
+    ? path.join(getGlobalDir(), "config.json")
+    : path.join(cwd, ".geomind", "config.json");
+}
+
+function runCommand(command: string, args: string[], timeout = 5_000): CommandResult {
+  const result = spawnSync(command, args, {
+    encoding: "utf-8",
+    timeout,
+    shell: false,
+  });
+
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout?.toString() ?? "",
+    stderr: result.stderr?.toString() ?? "",
+  };
+}
+
+function findExecutable(command: string): string | undefined {
+  const lookupCommand = process.platform === "win32" ? "where" : "which";
+  const result = runCommand(lookupCommand, [command]);
+  if (!result.ok) return undefined;
+  return result.stdout.trim().split(/\r?\n/)[0] || undefined;
+}
+
+function parsePort(value: string | undefined): number | undefined {
+  if (!value?.trim()) return undefined;
+  const port = Number(value.trim());
+  return Number.isInteger(port) && port > 0 ? port : undefined;
+}
+
+function parseDatabaseList(outputText: string): string[] {
+  const names = outputText
+    .split(/\r?\n/)
+    .map((line) => line.split("|")[0]?.trim())
+    .filter((name): name is string => Boolean(name));
+
+  return [...new Set(names)].sort((a, b) => a.localeCompare(b));
+}
+
+function chooseDefaultDatabase(databases: string[]): string {
+  if (databases.includes("ggai")) return "ggai";
+  if (databases.includes("postgres")) return "postgres";
+  return databases.find((name) => !name.startsWith("template")) ?? "ggai";
+}
+
+function isLocalHost(host: string | undefined): boolean {
+  return LOCAL_HOSTS.has(host?.trim().toLowerCase() ?? "");
+}
+
+function getPsqlListArgs(config: NonNullable<GeoMindConfig["psql"]>): string[] {
+  const args = ["-lqt"];
+
+  if (config.host) {
+    args.push("-h", config.host);
+  }
+  if (config.port) {
+    args.push("-p", String(config.port));
+  }
+  if (config.user) {
+    args.push("-U", config.user);
+  }
+
+  return args;
+}
+
+function getQgisSearchPaths(): string[] {
+  if (process.platform === "win32") {
+    return [
+      "C:\\Program Files\\QGIS 3.40\\bin\\qgis_process.exe",
+      "C:\\Program Files\\QGIS 3.38\\bin\\qgis_process.exe",
+      "C:\\Program Files\\QGIS 3.34\\bin\\qgis_process.exe",
+      "C:\\OSGeo4W\\bin\\qgis_process.exe",
+    ];
+  }
+
+  if (process.platform === "darwin") {
+    return [
+      "/Applications/QGIS-LTR.app/Contents/MacOS/bin/qgis_process",
+      "/Applications/QGIS.app/Contents/MacOS/bin/qgis_process",
+    ];
+  }
+
+  return ["/usr/bin/qgis_process", "/usr/local/bin/qgis_process"];
+}
+
+function verifyQgisProcess(candidate: string): boolean {
+  if (!fs.existsSync(candidate)) return false;
+  return runCommand(candidate, ["--version"], 5_000).ok;
+}
+
+function detectQgisProcess(): NonNullable<GeoMindConfig["qgis_process"]> {
+  const candidates = [
+    findExecutable(process.platform === "win32" ? "qgis_process.exe" : "qgis_process"),
+    ...getQgisSearchPaths(),
+  ].filter((candidate): candidate is string => Boolean(candidate));
+
+  for (const candidate of [...new Set(candidates)]) {
+    if (verifyQgisProcess(candidate)) {
+      return {
+        path: candidate,
+        available: true,
+      };
+    }
+  }
+
+  return {
+    path: "",
+    available: false,
+  };
+}
+
+async function askInput(
+  ctx: ExtensionCommandContext,
+  prompt: string,
+  placeholder?: string
+): Promise<string | undefined> {
+  return ctx.ui.input(prompt, placeholder);
+}
+
+async function selectDatabase(
+  ctx: ExtensionCommandContext,
+  psqlCommand: string,
+  partialConfig: NonNullable<GeoMindConfig["psql"]>
+): Promise<string> {
+  if (!isLocalHost(partialConfig.host)) {
+    const database = await askInput(ctx, "请输入数据库名", "ggai");
+    return database?.trim() || "ggai";
+  }
+
+  const listResult = runCommand(psqlCommand, getPsqlListArgs(partialConfig), 8_000);
+  const databases = listResult.ok ? parseDatabaseList(listResult.stdout) : [];
+  const defaultDatabase = chooseDefaultDatabase(databases);
+
+  if (!listResult.ok && listResult.stderr.trim()) {
+    ctx.ui.notify(`数据库列表读取失败：${listResult.stderr.trim()}`, "warning");
+  }
+
+  if (databases.length > 0) {
+    const choice = await ctx.ui.select("请选择数据库", databases);
+    return choice ?? defaultDatabase;
+  }
+
+  const database = await askInput(ctx, "请输入数据库名", defaultDatabase);
+  return database?.trim() || defaultDatabase;
+}
+
+async function collectPsqlConfig(ctx: ExtensionCommandContext): Promise<GeoMindConfig["psql"]> {
+  const detectedPsql = findExecutable("psql");
+  const commandAnswer = await askInput(ctx, "请输入 psql 命令或完整路径", detectedPsql ?? "psql");
+  const command = commandAnswer?.trim() || detectedPsql || "psql";
+
+  const hostAnswer = await askInput(ctx, "请输入数据库 host，留空表示本机", "localhost");
+  const host = hostAnswer?.trim();
+
+  const portAnswer = await askInput(ctx, "请输入数据库端口，留空使用默认端口", "5432");
+  const port = parsePort(portAnswer);
+
+  const userAnswer = await askInput(ctx, "请输入数据库用户名，留空使用当前系统用户");
+  const user = userAnswer?.trim();
+
+  const partialConfig: NonNullable<GeoMindConfig["psql"]> = {
+    command,
+    database: "ggai",
+    host: host && host !== "localhost" ? host : undefined,
+    port,
+    user: user || undefined,
+  };
+
+  return {
+    ...partialConfig,
+    database: await selectDatabase(ctx, command, partialConfig),
+  };
+}
+
+function writeConfig(cwd: string, scope: "global" | "project", config: GeoMindConfig): string {
+  const configPath = getConfigPath(cwd, scope);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+  return configPath;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("setup", {
+    description: "Configure GeoMind database connection and QGIS path",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("当前模式不支持交互式 setup。请在 TUI 中运行 /setup。", "error");
+        return;
+      }
+
+      const saveGlobal = await ctx.ui.confirm(
+        "配置保存位置",
+        "是否将配置保存为全局？全局配置会在所有目录下生效"
+      );
+      const scope = saveGlobal ? "global" : "project";
+
+      const psql = await collectPsqlConfig(ctx);
+      const qgisProcess = detectQgisProcess();
+      if (!qgisProcess.available) {
+        ctx.ui.notify("未检测到 qgis_process。GeoMind 仍可正常启动。", "warning");
+      }
+
+      const configPath = writeConfig(ctx.cwd, scope, {
+        psql,
+        qgis_process: qgisProcess,
+      });
+
+      ctx.ui.notify(`GeoMind 配置已保存：${configPath}`, "info");
+      ctx.ui.notify("配置将在新会话或重启后完整生效。", "info");
+    },
+  });
+}