@polka-codes/cli-shared 0.10.22 → 0.10.24

package/dist/index.js

@@ -1,7 +1,1913 @@
-export * from './config.js';
-export * from './memory-manager.js';
-export * from './project-scope.js';
-export * from './provider.js';
-export * from './sqlite-memory-store.js';
-export * from './utils/index.js';
-//# sourceMappingURL=index.js.map
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { configSchema } from "@polka-codes/core";
+import { merge } from "lodash-es";
+import { parse } from "yaml";
+import { ZodError } from "zod";
+function getGlobalConfigPath(home = homedir()) {
+  return join(home, ".config", "polkacodes", "config.yml");
+}
+function loadConfigAtPath(path) {
+  try {
+    return readConfig(path);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.warn(`Config validation failed for ${path}: ${error.message}`);
+    }
+    return void 0;
+  }
+}
+var localConfigFileName = ".polkacodes.yml";
+var mergeArray = (a, b) => {
+  if (!a && !b) {
+    return void 0;
+  }
+  if (!a) {
+    return b;
+  }
+  if (!b) {
+    return a;
+  }
+  return [...a, ...b];
+};
+function mergeConfigs(configs) {
+  if (configs.length === 0) {
+    return {};
+  }
+  const mergedConfig = configs.reduce((acc, config) => {
+    const merged = merge({}, acc, config);
+    const accRules = acc.rules ? Array.isArray(acc.rules) ? acc.rules : [acc.rules] : void 0;
+    const configRules = config.rules ? Array.isArray(config.rules) ? config.rules : [config.rules] : void 0;
+    merged.rules = mergeArray(accRules, configRules);
+    merged.excludeFiles = mergeArray(acc.excludeFiles, config.excludeFiles);
+    return merged;
+  }, {});
+  return mergedConfig;
+}
+async function resolveRules(rules) {
+  if (!rules) {
+    return void 0;
+  }
+  if (typeof rules === "string") {
+    return rules;
+  }
+  const resolvedRules = await Promise.all(
+    rules.map(async (rule) => {
+      if (typeof rule === "string") {
+        return rule;
+      }
+      if ("url" in rule) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 3e4);
+          const response = await fetch(rule.url, { signal: controller.signal });
+          clearTimeout(timeoutId);
+          if (response.ok) {
+            return await response.text();
+          }
+          console.warn(`Failed to fetch rule from ${rule.url}: ${response.statusText}`);
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            console.warn(`Timeout fetching rule from ${rule.url} (30s)`);
+          } else {
+            console.warn(`Error fetching rule from ${rule.url}: ${error}`);
+          }
+        }
+      } else if ("repo" in rule) {
+        const ref = rule.commit ?? rule.tag ?? rule.branch ?? "main";
+        const url = `https://raw.githubusercontent.com/${rule.repo}/${ref}/${rule.path}`;
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 3e4);
+          const response = await fetch(url, { signal: controller.signal });
+          clearTimeout(timeoutId);
+          if (response.ok) {
+            return await response.text();
+          }
+          console.warn(`Failed to fetch rule from ${url}: ${response.statusText}`);
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            console.warn(`Timeout fetching rule from ${url} (30s)`);
+          } else {
+            console.warn(`Error fetching rule from ${url}: ${error}`);
+          }
+        }
+      } else if ("path" in rule) {
+        if (existsSync(rule.path)) {
+          return await readFile(rule.path, "utf-8");
+        }
+        console.warn(`Rule file not found: ${rule.path}`);
+      }
+      return void 0;
+    })
+  );
+  return resolvedRules.filter((rule) => rule !== void 0).join("\n\n");
+}
+async function loadConfig(paths, cwd = process.cwd(), home = homedir()) {
+  const configs = [];
+  const globalConfigPath = getGlobalConfigPath(home);
+  if (existsSync(globalConfigPath)) {
+    try {
+      const globalConfig = readConfig(globalConfigPath);
+      configs.push(globalConfig);
+    } catch (error) {
+      console.warn(`Error loading global config file: ${globalConfigPath}
+${error}`);
+    }
+  }
+  if (paths && paths.length > 0) {
+    const configPaths = Array.isArray(paths) ? paths : [paths];
+    for (const path of configPaths) {
+      try {
+        const config = readConfig(path);
+        configs.push(config);
+      } catch (error) {
+        const errorCode = error?.code;
+        if (errorCode === "ENOENT") {
+          continue;
+        }
+        console.error(`Error loading config file: ${path}
+${error}`);
+        throw error;
+      }
+    }
+  } else {
+    const configPath = join(cwd, localConfigFileName);
+    try {
+      const projectConfig = readConfig(configPath);
+      configs.push(projectConfig);
+    } catch (error) {
+      if (error instanceof ZodError) {
+        console.error(`Error in config file: ${configPath}
+${error}`);
+        throw error;
+      }
+    }
+  }
+  const mergedConfig = configs.length > 0 ? mergeConfigs(configs) : void 0;
+  if (!mergedConfig) {
+    return void 0;
+  }
+  const resolvedRules = await resolveRules(mergedConfig.rules);
+  return {
+    ...mergedConfig,
+    rules: resolvedRules
+  };
+}
+var readConfig = (path) => {
+  const file = readFileSync(path, "utf8");
+  const config = parse(file);
+  const result = configSchema.parse(config);
+  if (result == null) {
+    return {};
+  }
+  return result;
+};
+var readLocalConfig = (path) => {
+  try {
+    return readConfig(path ?? localConfigFileName);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.warn(`Local config validation failed for ${path ?? localConfigFileName}: ${error.message}`);
+    } else {
+      console.debug(
+        `Could not load local config from ${path ?? localConfigFileName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return void 0;
+  }
+};
+
+// src/memory-manager.ts
+var MemoryManager = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Read memory by topic name
+   */
+  async readMemory(topic) {
+    return this.store.readMemory(topic);
+  }
+  /**
+   * Update memory with operation
+   */
+  async updateMemory(operation, topic, content, metadata) {
+    return this.store.updateMemory(operation, topic, content, metadata);
+  }
+  /**
+   * Query memory with filters
+   */
+  async queryMemory(query = {}, options) {
+    const finalQuery = {
+      ...query
+    };
+    const operation = options?.operation;
+    if ((operation === "select" || !operation) && !finalQuery.limit) {
+      finalQuery.limit = 1e3;
+    }
+    return this.store.queryMemory(finalQuery, options);
+  }
+  /**
+   * Batch update memory
+   */
+  async batchUpdateMemory(operations) {
+    return this.store.batchUpdateMemory(operations);
+  }
+  /**
+   * Get database statistics
+   */
+  async getStats() {
+    return this.store.getStats();
+  }
+  /**
+   * Close the memory store
+   */
+  async close() {
+    await this.store.close();
+  }
+  /**
+   * Execute a transaction
+   * Exposes the underlying store's transaction method if available
+   */
+  async transaction(callback) {
+    const storeWithTransaction = this.store;
+    if (typeof storeWithTransaction.transaction === "function") {
+      return storeWithTransaction.transaction(callback);
+    }
+    return callback();
+  }
+};
+
+// src/project-scope.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname, normalize, resolve, sep } from "path";
+function detectProjectScope(cwd) {
+  const projectPath = findProjectRoot(cwd);
+  if (!projectPath) {
+    return "global";
+  }
+  const normalizedPath = normalizePath(projectPath);
+  return `project:${normalizedPath}`;
+}
+function findProjectRoot(dir) {
+  if (!existsSync2(dir)) {
+    return null;
+  }
+  const primaryMarkers = [".git", "package.json"];
+  const secondaryMarkers = [
+    "Cargo.toml",
+    // Rust
+    "go.mod",
+    // Go
+    "pyproject.toml",
+    // Python
+    "requirements.txt",
+    // Python
+    "setup.py",
+    // Python
+    "Gemfile",
+    // Ruby
+    "pom.xml",
+    // Java Maven
+    "build.gradle"
+    // Java Gradle
+  ];
+  for (const marker of primaryMarkers) {
+    if (existsSync2(resolve(dir, marker))) {
+      return dir;
+    }
+  }
+  for (const marker of secondaryMarkers) {
+    if (existsSync2(resolve(dir, marker))) {
+      return dir;
+    }
+  }
+  const parent = dirname(dir);
+  if (parent === dir) {
+    return null;
+  }
+  return findProjectRoot(parent);
+}
+function normalizePath(path) {
+  return normalize(path).split(sep).join("/");
+}
+
+// src/provider.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "fs/promises";
+import { dirname as dirname2, normalize as normalize2, resolve as resolve3 } from "path";
+import { vertex } from "@ai-sdk/google-vertex";
+import { input, select } from "@inquirer/prompts";
+import { generateText, stepCountIs } from "ai";
+import ignore2 from "ignore";
+import { lookup } from "mime-types";
+
+// src/utils/checkRipgrep.ts
+import { spawnSync } from "child_process";
+var rgAvailability = {
+  isAvailable: null
+};
+function checkRipgrep() {
+  if (rgAvailability.isAvailable !== null) {
+    return rgAvailability.isAvailable;
+  }
+  const rg = spawnSync("rg", ["--version"]);
+  if (rg.error || rg.status !== 0) {
+    rgAvailability.isAvailable = false;
+    return false;
+  }
+  rgAvailability.isAvailable = true;
+  return true;
+}
+
+// src/utils/listFiles.ts
+import { promises as fs } from "fs";
+import { join as join2, relative, resolve as resolve2 } from "path";
+import ignore from "ignore";
+var DEFAULT_IGNORES = [
+  "__pycache__",
+  ".DS_Store",
+  ".env",
+  ".git",
+  ".idea",
+  ".svn",
+  ".temp",
+  ".vscode",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "Thumbs.db"
+];
+async function extendPatterns(basePatterns, dirPath) {
+  try {
+    const gitignorePath = join2(dirPath, ".gitignore");
+    const content = await fs.readFile(gitignorePath, "utf8");
+    const lines = content.split(/\r?\n/).filter(Boolean);
+    return [...basePatterns, ...lines];
+  } catch {
+    return basePatterns;
+  }
+}
+function createIgnore(patterns) {
+  return ignore().add(patterns);
+}
+async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includeIgnored) {
+  let rootPatterns = [...excludeFiles || []];
+  if (!includeIgnored) {
+    rootPatterns.push(...DEFAULT_IGNORES);
+    try {
+      const rootGitignore = await fs.readFile(join2(cwd, ".gitignore"), "utf8");
+      const lines = rootGitignore.split(/\r?\n/).filter(Boolean);
+      rootPatterns = [...rootPatterns, ...lines];
+    } catch {
+    }
+  }
+  const results = [];
+  const processedDirs = /* @__PURE__ */ new Set();
+  const queue = [
+    {
+      path: resolve2(dirPath),
+      patterns: rootPatterns,
+      relPath: relative(cwd, resolve2(dirPath)).replace(/\\/g, "/") || "."
+    }
+  ];
+  while (queue.length > 0) {
+    const { path: currentPath, patterns: parentPatterns, relPath: currentRelPath } = queue.shift();
+    processedDirs.add(currentRelPath);
+    const mergedPatterns = includeIgnored ? parentPatterns : await extendPatterns(parentPatterns, currentPath);
+    const folderIg = createIgnore(mergedPatterns);
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const fullPath = join2(currentPath, entry.name);
+      const relPath = relative(cwd, fullPath).replace(/\\/g, "/");
+      if (folderIg.ignores(relPath)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (recursive) {
+          queue.push({
+            path: fullPath,
+            patterns: mergedPatterns,
+            relPath
+          });
+        }
+      } else {
+        results.push(relPath);
+        if (results.length >= maxCount) {
+          const remainingEntries = entries.slice(entries.indexOf(entry) + 1);
+          const hasRemainingFiles = remainingEntries.some(
+            (e) => !e.isDirectory() && !folderIg.ignores(relative(cwd, join2(currentPath, e.name)).replace(/\\/g, "/"))
+          );
+          if (hasRemainingFiles) {
+            const marker = `${currentRelPath}/(files omitted)`;
+            results.push(marker);
+          }
+          for (const queueItem of queue) {
+            if (!processedDirs.has(queueItem.relPath)) {
+              const marker = `${queueItem.relPath}/(files omitted)`;
+              results.push(marker);
+              processedDirs.add(queueItem.relPath);
+            }
+          }
+          results.sort();
+          return [results, true];
+        }
+      }
+    }
+  }
+  results.sort();
+  return [results, false];
+}
+
+// src/utils/searchFiles.ts
+import { spawn } from "child_process";
+
+// src/utils/search.constants.ts
+var SEARCH_CONSTANTS = {
+  /** Default number of context lines to show around search matches */
+  DEFAULT_CONTEXT_LINES: 5
+};
+
+// src/utils/searchFiles.ts
+async function searchFiles(path, regex, filePattern, cwd, excludeFiles) {
+  const args = [
+    "--line-number",
+    // Show line numbers
+    `--context=${SEARCH_CONSTANTS.DEFAULT_CONTEXT_LINES}`,
+    // Show lines before and after matches
+    "--color=never",
+    // No color codes in output
+    "--with-filename",
+    // Show filenames
+    "--smart-case"
+    // Smart case sensitivity
+  ];
+  if (filePattern && filePattern !== "*") {
+    const patterns = filePattern.split(",").map((p) => p.trim()).filter(Boolean);
+    for (const pattern of patterns) {
+      if (pattern) {
+        args.push("--glob", pattern);
+      }
+    }
+  }
+  if (excludeFiles) {
+    for (const pattern of excludeFiles) {
+      args.push("--glob", `!${pattern}`);
+    }
+  }
+  args.push(regex, path);
+  return new Promise((resolve5, reject) => {
+    const results = [];
+    const rg = spawn("rg", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    rg.stdout.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      results.push(...lines);
+    });
+    rg.on("error", (error) => {
+      reject(new Error(`Failed to execute ripgrep: ${error.message}`));
+    });
+    rg.on("close", (code) => {
+      if (code !== 0 && code !== 1) {
+        reject(new Error(`Ripgrep process exited with code ${code}`));
+        return;
+      }
+      resolve5(results);
+    });
+  });
+}
+
+// src/provider.ts
+var InMemoryStore = class {
+  #data;
+  async read() {
+    return this.#data;
+  }
+  async write(data) {
+    this.#data = data;
+  }
+};
+function isIMemoryStore(store) {
+  return "readMemory" in store && "updateMemory" in store;
+}
+var getProvider = (options = {}) => {
+  const ig = ignore2().add(options.excludeFiles ?? []);
+  const memoryStore = options.memoryStore ?? new InMemoryStore();
+  const todoItemStore = options.todoItemStore ?? new InMemoryStore();
+  const defaultMemoryTopic = ":default:";
+  const searchModel = options.getModel?.("search");
+  const readMemoryKV = async (topic) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return data[topic];
+    }
+    return memoryStore.readMemory(topic);
+  };
+  const updateMemoryKV = async (operation, topic, content) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      switch (operation) {
+        case "append":
+          if (content === void 0) {
+            throw new Error("Content is required for append operation.");
+          }
+          data[topic] = `${data[topic] || ""}
+${content}`;
+          break;
+        case "replace":
+          if (content === void 0) {
+            throw new Error("Content is required for replace operation.");
+          }
+          data[topic] = content;
+          break;
+        case "remove":
+          delete data[topic];
+          break;
+      }
+      await memoryStore.write(data);
+      return;
+    }
+    await memoryStore.updateMemory(operation, topic, content);
+  };
+  const listMemoryTopicsKV = async () => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return Object.keys(data);
+    }
+    const entries = await memoryStore.queryMemory({});
+    if (Array.isArray(entries)) {
+      return entries.map((e) => e.name);
+    }
+    return [];
+  };
+  const provider = {
+    listTodoItems: async (id, status) => {
+      const todoItems = await todoItemStore.read() ?? [];
+      let items;
+      if (!id) {
+        items = todoItems.filter((i) => !i.id.includes("."));
+      } else {
+        const parent = todoItems.find((i) => i.id === id);
+        if (!parent) {
+          throw new Error(`To-do item with id ${id} not found`);
+        }
+        items = todoItems.filter((i) => i.id.startsWith(`${id}.`) && i.id.split(".").length === id.split(".").length + 1);
+      }
+      if (status) {
+        items = items.filter((item) => item.status === status);
+      }
+      items.sort((a, b) => {
+        const aParts = a.id.split(".");
+        const bParts = b.id.split(".");
+        const len = Math.min(aParts.length, bParts.length);
+        for (let i = 0; i < len; i++) {
+          const comparison = aParts[i].localeCompare(bParts[i], void 0, { numeric: true });
+          if (comparison !== 0) {
+            return comparison;
+          }
+        }
+        return aParts.length - bParts.length;
+      });
+      return items;
+    },
+    getTodoItem: async (id) => {
+      const todoItems = await todoItemStore.read() ?? [];
+      const item = todoItems.find((i) => i.id === id);
+      if (!item) {
+        throw new Error(`To-do item with id ${id} not found`);
+      }
+      const subItems = todoItems.filter((i) => i.id.startsWith(`${id}.`) && i.id.split(".").length === id.split(".").length + 1).map(({ id: id2, title }) => ({ id: id2, title }));
+      return { ...item, subItems };
+    },
+    updateTodoItem: async (input2) => {
+      const todoItems = await todoItemStore.read() ?? [];
+      if (input2.operation === "add") {
+        const { parentId, title, description, status } = input2;
+        if (!title) {
+          throw new Error("Title is required for add operation");
+        }
+        let newId;
+        if (parentId) {
+          const parent = todoItems.find((i) => i.id === parentId);
+          if (!parent) {
+            throw new Error(`Parent to-do item with id ${parentId} not found`);
+          }
+          const childItems = todoItems.filter(
+            (i) => i.id.startsWith(`${parentId}.`) && i.id.split(".").length === parentId.split(".").length + 1
+          );
+          const maxId = childItems.reduce((max, item) => {
+            const parts = item.id.split(".");
+            const lastPart = parseInt(parts[parts.length - 1], 10);
+            return Math.max(max, lastPart);
+          }, 0);
+          newId = `${parentId}.${maxId + 1}`;
+        } else {
+          const rootItems = todoItems.filter((i) => !i.id.includes("."));
+          const maxId = rootItems.reduce((max, item) => {
+            const idNum = parseInt(item.id, 10);
+            return Math.max(max, idNum);
+          }, 0);
+          newId = `${maxId + 1}`;
+        }
+        const newItem = {
+          id: newId,
+          title,
+          description: description ?? "",
+          status: status ?? "open"
+        };
+        await todoItemStore.write([...todoItems, newItem]);
+        return { id: newId };
+      } else {
+        const { id } = input2;
+        if (!id) {
+          throw new Error("ID is required for update operation");
+        }
+        const item = todoItems.find((i) => i.id === id);
+        if (!item) {
+          throw new Error(`To-do item with id ${id} not found`);
+        }
+        if (input2.title != null) {
+          item.title = input2.title;
+        }
+        if (input2.description != null) {
+          item.description = input2.description ?? "";
+        }
+        if (input2.status != null) {
+          item.status = input2.status;
+        }
+        await todoItemStore.write(todoItems);
+        return { id };
+      }
+    },
+    listMemoryTopics: async () => {
+      return listMemoryTopicsKV();
+    },
+    readMemory: async (topic = defaultMemoryTopic) => {
+      return readMemoryKV(topic);
+    },
+    updateMemory: async (operation, topic, content) => {
+      const memoryTopic = topic ?? defaultMemoryTopic;
+      await updateMemoryKV(operation, memoryTopic, content);
+    },
+    readFile: async (path, includeIgnored) => {
+      if (!includeIgnored && ig.ignores(path)) {
+        throw new Error(`Not allow to access file ${path}`);
+      }
+      try {
+        return await readFile2(path, "utf8");
+      } catch (_e) {
+        return void 0;
+      }
+    },
+    writeFile: async (path, content) => {
+      if (ig.ignores(path)) {
+        throw new Error(`Not allow to access file ${path}`);
+      }
+      await mkdir(dirname2(path), { recursive: true });
+      return await writeFile(path, content, "utf8");
+    },
+    removeFile: async (path) => {
+      if (ig.ignores(path)) {
+        throw new Error(`Not allow to access file ${path}`);
+      }
+      return await unlink(path);
+    },
+    renameFile: async (sourcePath, targetPath) => {
+      if (ig.ignores(sourcePath) || ig.ignores(targetPath)) {
+        throw new Error(`Not allow to access file ${sourcePath} or ${targetPath}`);
+      }
+      return await rename(sourcePath, targetPath);
+    },
+    listFiles: async (path, recursive, maxCount, includeIgnored) => {
+      return await listFiles(path, recursive, maxCount, process.cwd(), options.excludeFiles, includeIgnored);
+    },
+    readBinaryFile: async (url) => {
+      if (url.startsWith("file://")) {
+        const filePath = decodeURIComponent(url.substring("file://".length));
+        const resolvedPath = normalize2(resolve3(process.cwd(), filePath));
+        if (!resolvedPath.startsWith(process.cwd())) {
+          throw new Error(`Access to file path "${filePath}" is restricted.`);
+        }
+        const data2 = await readFile2(resolvedPath);
+        const mediaType2 = lookup(resolvedPath) || "application/octet-stream";
+        return {
+          base64Data: data2.toString("base64"),
+          mediaType: mediaType2
+        };
+      }
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const data = await response.arrayBuffer();
+      const mediaType = lookup(url) || "application/octet-stream";
+      return {
+        base64Data: Buffer.from(data).toString("base64"),
+        mediaType
+      };
+    },
+    executeCommand: (command, _needApprove) => {
+      return new Promise((resolve5, reject) => {
+        options.command?.onStarted(command);
+        const child = spawn2(command, [], {
+          shell: true,
+          stdio: "pipe"
+        });
+        let stdoutText = "";
+        let stderrText = "";
+        child.stdout.on("data", (data) => {
+          const dataStr = data.toString();
+          options.command?.onStdout(dataStr);
+          stdoutText += dataStr;
+        });
+        child.stderr.on("data", (data) => {
+          const dataStr = data.toString();
+          options.command?.onStderr(dataStr);
+          stderrText += dataStr;
+        });
+        child.on("close", async (code) => {
+          options.command?.onExit(code ?? 0);
+          const totalLength = stdoutText.length + stderrText.length;
+          if (totalLength > (options.summaryThreshold ?? 5e3) && options.summarizeOutput) {
+            try {
+              const summary = await options.summarizeOutput(stdoutText, stderrText);
+              if (summary) {
+                resolve5({
+                  summary,
+                  stdout: stdoutText,
+                  stderr: stderrText,
+                  exitCode: code ?? 0
+                });
+                return;
+              }
+            } catch (_e) {
+              console.error("Summarization failed:", _e);
+            }
+          }
+          resolve5({
+            stdout: stdoutText,
+            stderr: stderrText,
+            exitCode: code ?? 0
+          });
+        });
+        child.on("error", (err) => {
+          options.command?.onError(err);
+          reject(err);
+        });
+      });
+    },
+    askFollowupQuestion: async (question, answerOptions) => {
+      if (options.yes) {
+        if (answerOptions.length > 0) {
+          return answerOptions[0];
+        }
+        return "";
+      }
+      if (answerOptions.length === 0) {
+        return await input({ message: question });
+      }
+      const otherMessage = "Other (enter text)";
+      answerOptions.push(otherMessage);
+      const answer = await select({
+        message: question,
+        choices: answerOptions.map((option) => ({ name: option, value: option }))
+      });
+      if (answer === otherMessage) {
+        return await input({ message: "Enter your answer:" });
+      }
+      return answer;
+    },
+    fetchUrl: async (url) => {
+      const isRaw = url.startsWith("https://raw.githubusercontent.com/");
+      const urlToFetch = isRaw ? url : `https://r.jina.ai/${url}`;
+      try {
+        const response = await fetch(urlToFetch);
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return await response.text();
+      } catch (error) {
+        console.error("Error fetching URL:", error);
+        throw error;
+      }
+    },
+    search: searchModel && (async (query) => {
+      const googleSearchTool = vertex.tools.googleSearch({});
+      const resp = await generateText({
+        model: searchModel,
+        system: "You are a web search assistant. When searching for information, provide comprehensive and detailed results. Include relevant facts, statistics, dates, and key details from the search results. Synthesize information from multiple sources when available. Structure your response clearly with the most relevant information first. Reference or cite sources when presenting specific claims or data.",
+        tools: {
+          google_search: googleSearchTool
+        },
+        prompt: query,
+        stopWhen: stepCountIs(5)
+      });
+      return resp.text;
+    })
+  };
+  if (checkRipgrep()) {
+    provider.searchFiles = async (path, regex, filePattern) => {
+      return await searchFiles(path, regex, filePattern, process.cwd(), options.excludeFiles);
+    };
+  } else {
+    console.error(
+      "Error: ripgrep (rg) is not installed. Search file tool is disabled. Please install it from https://github.com/BurntSushi/ripgrep#installation"
+    );
+  }
+  return provider;
+};
+
+// src/sqlite-memory-store.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, readdir, readFile as readFile3, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { basename, dirname as dirname3, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+import { DEFAULT_MEMORY_CONFIG, resolveHomePath } from "@polka-codes/core";
+import initSqlJs from "sql.js";
+var FileLock = class _FileLock {
+  lockfilePath;
+  static LOCK_TIMEOUT = 3e4;
+  // 30 seconds max lock time
+  static CLEANUP_AGE = 6e5;
+  // 10 minutes - cleanup old lock files
+  static lastCleanupTime = 0;
+  static CLEANUP_THROTTLE = 6e4;
+  // Throttle cleanup to once per minute
+  constructor(dbPath) {
+    this.lockfilePath = `${dbPath}.lock`;
+  }
+  /**
+   * Reset the cleanup throttle. For testing purposes only.
+   */
+  static resetCleanupThrottle() {
+    _FileLock.lastCleanupTime = 0;
+  }
+  /**
+   * Clean up old lock files (.released.*, .stale.*, .invalid.*, .corrupt.*)
+   * Only removes files older than CLEANUP_AGE (10 minutes by default)
+   * This method is safe to call multiple times concurrently
+   * Cleanup is throttled to run at most once per minute to avoid performance impact
+   * @param force - Skip throttling and force cleanup (for testing)
+   */
+  static async cleanupOldLockFiles(dbPath, maxAge = _FileLock.CLEANUP_AGE, force = false) {
+    const now = Date.now();
+    if (!force && now - _FileLock.lastCleanupTime < _FileLock.CLEANUP_THROTTLE) {
+      return;
+    }
+    _FileLock.lastCleanupTime = now;
+    try {
+      const lockDir = dirname3(dbPath);
+      const dbBaseName = basename(dbPath);
+      const files = await readdir(lockDir);
+      const now2 = Date.now();
+      for (const file of files) {
+        if (!file.startsWith(`${dbBaseName}.lock.`)) {
+          continue;
+        }
+        const match = file.match(/\.lock\.(released|stale|invalid|corrupt)\.(\d+)$/);
+        if (!match) {
+          continue;
+        }
+        const filePath = resolve4(lockDir, file);
+        const timestamp = Number.parseInt(match[2], 10);
+        const age = now2 - timestamp;
+        if (age > maxAge) {
+          try {
+            await unlink2(filePath);
+          } catch (error) {
+            const errorCode = error?.code;
+            if (errorCode !== "ENOENT") {
+              console.warn(`[FileLock] Failed to delete old lock file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.debug(`[FileLock] Cleanup encountered an error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Try to acquire lock with retries
+   * @throws Error if lock cannot be acquired after retries
+   */
+  async acquire(retries = 10, delay = 100) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        const lockData = JSON.stringify({
+          pid: process.pid,
+          acquiredAt: Date.now()
+        });
+        await writeFile2(this.lockfilePath, lockData, {
+          flag: "wx",
+          // Exclusive create - fails if file exists
+          mode: 384
+        });
+        return;
+      } catch (error) {
+        const errorCode = error?.code;
+        if (errorCode === "EEXIST") {
+          try {
+            const lockContent = await readFile3(this.lockfilePath, "utf-8");
+            const lockData = JSON.parse(lockContent);
+            if (!lockData || typeof lockData.acquiredAt !== "number" || lockData.acquiredAt <= 0) {
+              console.warn(`[FileLock] Lock file has invalid acquiredAt, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
+              continue;
+            }
+            const lockAge = Date.now() - lockData.acquiredAt;
+            if (lockAge > _FileLock.LOCK_TIMEOUT) {
+              console.warn(`[FileLock] Breaking stale lock (age: ${lockAge}ms)`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
+              continue;
+            }
+          } catch (readError) {
+            if (readError instanceof SyntaxError) {
+              console.warn(`[FileLock] Lock file contains invalid JSON, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
+              continue;
+            }
+          }
+          if (i < retries - 1) {
+            await new Promise((resolve5) => setTimeout(resolve5, delay));
+          } else {
+            throw new Error(`Cannot acquire lock after ${retries} retries (file: ${this.lockfilePath})`);
+          }
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+  /**
+   * Release the lock by removing the lockfile
+   */
+  async release() {
+    try {
+      await rename2(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
+      const dbPath = this.lockfilePath.slice(0, -5);
+      _FileLock.cleanupOldLockFiles(dbPath).catch(() => {
+      });
+    } catch (error) {
+      const errorCode = error.code;
+      if (errorCode !== "ENOENT") {
+        console.warn(`[FileLock] Error releasing lock: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+};
+var ReentrantMutex = class {
+  queue = [];
+  locked = false;
+  lockCount = 0;
+  owner = null;
+  async acquire(owner) {
+    if (this.locked && this.owner === owner) {
+      this.lockCount++;
+      return () => this.release(owner);
+    }
+    while (this.locked) {
+      await new Promise((resolve5) => this.queue.push(resolve5));
+    }
+    this.locked = true;
+    this.owner = owner;
+    this.lockCount = 1;
+    return () => this.release(owner);
+  }
+  release(owner) {
+    if (this.owner !== owner) {
+      return;
+    }
+    this.lockCount--;
+    if (this.lockCount === 0) {
+      this.locked = false;
+      this.owner = null;
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+};
+var SqlJs = null;
+var SqlJsInitPromise = null;
+var moduleDir = dirname3(fileURLToPath(import.meta.url));
+var bundledWasmPath = resolve4(moduleDir, "sql-wasm.wasm");
+var hasBundledWasm = existsSync3(bundledWasmPath);
+async function getSqlJs() {
+  if (SqlJs) {
+    return SqlJs;
+  }
+  if (SqlJsInitPromise) {
+    return SqlJsInitPromise;
+  }
+  try {
+    SqlJsInitPromise = initSqlJs({
+      locateFile: (filename, prefix) => {
+        if (hasBundledWasm) {
+          return bundledWasmPath;
+        }
+        return prefix + filename;
+      }
+    });
+    SqlJs = await SqlJsInitPromise;
+    return SqlJs;
+  } catch (error) {
+    throw new Error(
+      `Failed to initialize sql.js: ${error instanceof Error ? error.message : String(error)}
+
+Attempted to locate WASM at:
+  - ${bundledWasmPath}
+
+If you're developing, run: bun run build in packages/cli-shared`
+    );
+  }
+}
+var transactionOwnerStorage = new AsyncLocalStorage();
+var SQLiteMemoryStore = class _SQLiteMemoryStore {
+  db = null;
+  dbPromise = null;
+  config;
+  currentScope;
+  inTransaction = false;
+  // Track if we're in a transaction
+  transactionMutex = new ReentrantMutex();
+  // Serialize transactions
+  fileLock;
+  // Cross-process file lock (initialized in getFileLock())
+  /**
+   * Reset the lock file cleanup throttle. For testing purposes only.
+   */
+  static resetCleanupThrottle() {
+    FileLock.resetCleanupThrottle();
+  }
+  /**
+   * Get the configured database path, or default if not set
+   */
+  getDbPath() {
+    return this.config.path || DEFAULT_MEMORY_CONFIG.path;
+  }
+  /**
+   * Get lockfile instance for database path
+   */
+  getFileLock() {
+    if (!this.fileLock) {
+      const dbPath = this.resolvePath(this.getDbPath());
+      this.fileLock = new FileLock(dbPath);
+    }
+    return this.fileLock;
+  }
+  // Whitelists for validation
+  static SORT_COLUMNS = {
+    created: "created_at",
+    updated: "updated_at",
+    accessed: "last_accessed",
+    name: "name"
+  };
+  static ALLOWED_SORT_ORDERS = ["asc", "desc"];
+  static ALLOWED_PRIORITIES = ["low", "medium", "high", "critical"];
+  constructor(config, scope) {
+    this.config = config;
+    this.currentScope = scope;
+  }
+  /**
+   * Initialize database connection and schema
+   */
+  async initializeDatabase() {
+    if (this.dbPromise) {
+      return this.dbPromise;
+    }
+    this.dbPromise = (async () => {
+      if (this.db) {
+        return this.db;
+      }
+      const dbPath = this.resolvePath(this.getDbPath());
+      try {
+        const dir = dirname3(dbPath);
+        if (!existsSync3(dir)) {
+          await mkdir2(dir, { recursive: true, mode: 448 });
+        }
+        FileLock.cleanupOldLockFiles(dbPath).catch(() => {
+        });
+        let dbData;
+        if (existsSync3(dbPath)) {
+          const lock = this.getFileLock();
+          await lock.acquire();
+          try {
+            try {
+              dbData = await readFile3(dbPath);
+              if (dbData.length >= 16) {
+                const header = String.fromCharCode(...dbData.subarray(0, 15));
+                if (header !== "SQLite format 3") {
+                  console.warn("[SQLiteMemoryStore] Invalid SQLite database header, will recreate");
+                  dbData = void 0;
+                }
+              }
+            } catch (error) {
+              const errorCode = error?.code;
+              if (errorCode === "ENOENT") {
+                dbData = void 0;
+              } else {
+                throw new Error(`Failed to read database file at ${dbPath}: ${error instanceof Error ? error.message : String(error)}`);
+              }
+            }
+          } finally {
+            await lock.release();
+          }
+        }
+        const SqlJs2 = await getSqlJs();
+        const db = new SqlJs2.Database(dbData);
+        this.configurePragmas(db);
+        this.checkIntegrity(db);
+        this.initializeSchema(db);
+        this.db = db;
+        return db;
+      } catch (error) {
+        console.error("[SQLiteMemoryStore] Initialization failed:", error);
+        if (existsSync3(dbPath)) {
+          const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+          console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
+          try {
+            await rename2(dbPath, backupPath);
+          } catch (backupError) {
+            console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
+            this.dbPromise = null;
+            throw backupError;
+          }
+          this.dbPromise = null;
+          return this.initializeDatabase();
+        }
+        this.dbPromise = null;
+        throw error;
+      }
+    })();
+    return this.dbPromise;
+  }
+  /**
+   * Persist database to disk using atomic write with file locking
+   */
+  async saveDatabase() {
+    if (!this.db) {
+      return;
+    }
+    const lock = this.getFileLock();
+    await lock.acquire();
+    try {
+      const dbPath = this.resolvePath(this.getDbPath());
+      const tempPath = `${dbPath}.tmp`;
+      const data = this.db.export();
+      await writeFile2(tempPath, data, { mode: 384 });
+      await rename2(tempPath, dbPath);
+    } finally {
+      await lock.release();
+    }
+  }
+  /**
+   * Configure database pragmas
+   */
+  configurePragmas(db) {
+    db.run("PRAGMA synchronous = NORMAL");
+    db.run("PRAGMA busy_timeout = 5000");
+    db.run("PRAGMA foreign_keys = ON");
+    db.run("PRAGMA temp_store = MEMORY");
+  }
+  /**
+   * Check database integrity
+   */
+  checkIntegrity(db) {
+    try {
+      const results = db.exec("SELECT 1");
+      if (results.length === 0) {
+        throw new Error("Database query returned no results");
+      }
+    } catch (error) {
+      console.error("[SQLiteMemoryStore] Integrity check failed:", error);
+      throw new Error("Database is corrupted");
+    }
+  }
+  /**
+   * Initialize database schema
+   */
+  initializeSchema(db) {
+    db.run(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL CHECK(length(name) > 0),
+        scope TEXT NOT NULL CHECK(scope IN ('global') OR scope LIKE 'project:%'),
+        content TEXT NOT NULL CHECK(length(content) > 0),
+        entry_type TEXT NOT NULL CHECK(length(entry_type) > 0),
+        status TEXT CHECK(status IS NULL OR length(status) > 0),
+        priority TEXT CHECK(priority IS NULL OR priority IN ('low', 'medium', 'high', 'critical')),
+        tags TEXT CHECK(tags IS NULL OR length(tags) > 0),
+        metadata TEXT CHECK(metadata IS NULL OR json_valid(metadata)),
+        created_at INTEGER NOT NULL CHECK(created_at > 0),
+        updated_at INTEGER NOT NULL CHECK(updated_at > 0),
+        last_accessed INTEGER NOT NULL CHECK(last_accessed > 0),
+        UNIQUE(name, scope)
+      )
+    `);
+    db.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_scope_type ON memory_entries(scope, entry_type)");
+    db.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_updated ON memory_entries(updated_at)");
+  }
+  /**
+   * Get database instance
+   */
+  async getDatabase() {
+    if (!this.db) {
+      this.db = await this.initializeDatabase();
+    }
+    return this.db;
+  }
+  /**
+   * Resolve home directory in path using shared utility
+   */
+  resolvePath(path) {
+    const resolved = resolveHomePath(path);
+    return resolve4(resolved);
+  }
+  /**
+   * Generate UUID v4
+   */
+  generateUUID() {
+    return randomUUID();
+  }
+  /**
+   * Get current timestamp in milliseconds
+   */
+  now() {
+    return Date.now();
+  }
+  /**
+   * Execute transaction
+   * Uses Mutex to serialize concurrent transaction calls for safety
+   * Supports reentrancy (nested transactions from the same call chain)
+   */
+  async transaction(callback) {
+    let owner = transactionOwnerStorage.getStore();
+    if (!owner) {
+      owner = Symbol("transaction");
+    }
+    const release = await this.transactionMutex.acquire(owner);
+    return transactionOwnerStorage.run(owner, async () => {
+      try {
+        const db = await this.getDatabase();
+        const shouldBegin = !this.inTransaction;
+        try {
+          if (shouldBegin) {
+            db.run("BEGIN TRANSACTION");
+            this.inTransaction = true;
+          }
+          const result = await callback();
+          if (shouldBegin) {
+            db.run("COMMIT");
+            this.inTransaction = false;
+            try {
+              await this.saveDatabase();
+            } catch (saveError) {
+              console.error("[SQLiteMemoryStore] Failed to save database after commit, closing:", saveError);
+              await this.close(true);
+              throw saveError;
+            }
+          }
+          return result;
+        } catch (error) {
+          if (this.inTransaction) {
+            try {
+              db.run("ROLLBACK");
+            } catch (rollbackError) {
+              console.error("[SQLiteMemoryStore] ROLLBACK failed:", rollbackError);
+            }
+            this.inTransaction = false;
+          }
+          throw error;
+        }
+      } finally {
+        release();
+      }
+    });
+  }
+  /**
+   * Read memory by topic
+   * Note: Does NOT update last_accessed timestamp to avoid expensive disk writes on every read.
+   * The timestamp is updated when memory is modified through updateMemory operations.
+   */
+  async readMemory(topic) {
+    const db = await this.getDatabase();
+    const scope = this.currentScope;
+    const stmt = db.prepare("SELECT content FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      const content = row.content;
+      stmt.free();
+      return content;
+    }
+    stmt.free();
+    return void 0;
+  }
+  /**
+   * Internal update memory without transaction (used by batchUpdateMemory)
+   */
+  async updateMemoryInternal(db, operation, topic, content, metadata) {
+    const scope = this.currentScope;
+    const now = this.now();
+    const createdAt = metadata?.created_at ?? now;
+    const updatedAt = metadata?.updated_at ?? now;
+    const lastAccessed = metadata?.last_accessed ?? now;
+    if (operation === "remove") {
+      const stmt2 = db.prepare("DELETE FROM memory_entries WHERE name = ? AND scope = ?");
+      stmt2.run([topic, scope]);
+      stmt2.free();
+      return;
+    }
+    const stmt = db.prepare("SELECT content, entry_type, status, priority, tags FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    let existing;
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      existing = {
+        content: row.content,
+        entry_type: row.entry_type,
+        status: row.status,
+        priority: row.priority,
+        tags: row.tags
+      };
+      stmt.free();
+    } else {
+      existing = void 0;
+      stmt.free();
+    }
+    let finalContent;
+    let entry_type;
+    let status;
+    let priority;
+    let tags;
+    if (existing) {
+      if (operation === "append") {
+        if (!content) {
+          throw new Error("Content is required for append operation.");
+        }
+        finalContent = `${existing.content}
+${content}`;
+      } else {
+        if (!content) {
+          throw new Error("Content is required for replace operation.");
+        }
+        finalContent = content;
+      }
+      entry_type = metadata?.entry_type || existing.entry_type;
+      status = (metadata?.status || existing.status) ?? void 0;
+      priority = (metadata?.priority || existing.priority) ?? void 0;
+      tags = (metadata?.tags || existing.tags) ?? void 0;
+    } else {
+      if (!content) {
+        throw new Error("Content is required for new memory entries.");
+      }
+      finalContent = content;
+      entry_type = metadata?.entry_type || "note";
+      status = metadata?.status;
+      priority = metadata?.priority;
+      tags = metadata?.tags;
+    }
+    const upsertStmt = db.prepare(`
+      INSERT INTO memory_entries (id, name, scope, content, entry_type, status, priority, tags, created_at, updated_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, scope) DO UPDATE SET
+        content = excluded.content,
+        entry_type = excluded.entry_type,
+        status = excluded.status,
+        priority = excluded.priority,
+        tags = excluded.tags,
+        updated_at = excluded.updated_at,
+        last_accessed = excluded.last_accessed
+    `);
+    upsertStmt.run([
+      this.generateUUID(),
+      topic,
+      scope,
+      finalContent,
+      entry_type,
+      status ?? null,
+      priority ?? null,
+      tags ?? null,
+      createdAt,
+      updatedAt,
+      lastAccessed
+    ]);
+    upsertStmt.free();
+  }
+  /**
+   * Update memory
+   */
+  async updateMemory(operation, topic, content, metadata) {
+    return this.transaction(async () => {
+      const db = await this.getDatabase();
+      await this.updateMemoryInternal(db, operation, topic, content, metadata);
+    });
+  }
+  /**
+   * Query memory with filters
+   */
+  async queryMemory(query = {}, options = {}) {
+    if (options.operation === "delete") {
+      return this.transaction(async () => {
+        const db2 = await this.getDatabase();
+        const { sql: sql2, params: params2 } = this.buildQuery(query);
+        const deleteSql = `DELETE FROM memory_entries WHERE id IN (SELECT id FROM (${sql2}))`;
+        const stmt2 = db2.prepare(deleteSql);
+        stmt2.bind(params2);
+        stmt2.step();
+        stmt2.free();
+        return db2.getRowsModified();
+      });
+    }
+    const db = await this.getDatabase();
+    const { sql, params } = this.buildQuery(query);
+    if (options.operation === "count") {
+      const countSql = `SELECT COUNT(*) as count FROM (${sql})`;
+      const stmt2 = db.prepare(countSql);
+      stmt2.bind(params);
+      let count = 0;
+      if (stmt2.step()) {
+        const row = stmt2.getAsObject();
+        count = row.count;
+      }
+      stmt2.free();
+      return count;
+    }
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    const entries = [];
+    while (stmt.step()) {
+      entries.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return entries;
+  }
+  /**
+   * Build SQL query safely with parameterized statements
+   */
+  buildQuery(query) {
+    const conditions = [];
+    const params = [];
+    let sql = "SELECT * FROM memory_entries WHERE 1=1";
+    const scope = query.scope === "auto" ? this.currentScope : query.scope;
+    if (scope === "global") {
+      conditions.push(`scope = ?`);
+      params.push("global");
+    } else if (scope === "project" || !scope && this.currentScope !== "global") {
+      conditions.push(`scope = ?`);
+      params.push(this.currentScope);
+    }
+    if (query.name) {
+      if (!query.name.trim()) {
+        throw new Error("Name cannot be empty");
+      }
+      conditions.push(`name = ?`);
+      params.push(query.name.trim());
+    }
+    if (query.type) {
+      if (!query.type.trim()) {
+        throw new Error("Type cannot be empty");
+      }
+      conditions.push(`entry_type = ?`);
+      params.push(query.type.trim());
+    }
+    if (query.status) {
+      conditions.push(`status = ?`);
+      params.push(query.status);
+    }
+    if (query.priority) {
+      if (!_SQLiteMemoryStore.ALLOWED_PRIORITIES.includes(query.priority)) {
+        throw new Error(`Invalid priority: ${query.priority}`);
+      }
+      conditions.push(`priority = ?`);
+      params.push(query.priority);
+    }
+    if (query.tags) {
+      const tags = Array.isArray(query.tags) ? query.tags : [query.tags];
+      for (const tag of tags) {
+        const trimmed = tag.trim();
+        if (!trimmed) {
+          throw new Error("Tags cannot be empty");
+        }
+        const escaped = trimmed.replace(/[\\_%]/g, "\\$&");
+        conditions.push(`(tags = ? OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')`);
+        params.push(trimmed, `${escaped},%`, `%,${escaped}`, `%,${escaped},%`);
+      }
+    }
+    if (query.search) {
+      const searchTerm = query.search.trim();
+      conditions.push(`(content LIKE ? ESCAPE '\\' OR name LIKE ? ESCAPE '\\')`);
+      const searchPattern = `%${searchTerm.replace(/[\\_%]/g, "\\$&")}%`;
+      params.push(searchPattern, searchPattern);
+    }
+    if (query.createdAfter) {
+      conditions.push(`created_at >= ?`);
+      params.push(query.createdAfter);
+    }
+    if (query.createdBefore) {
+      conditions.push(`created_at <= ?`);
+      params.push(query.createdBefore);
+    }
+    if (query.updatedAfter) {
+      conditions.push(`updated_at >= ?`);
+      params.push(query.updatedAfter);
+    }
+    if (query.updatedBefore) {
+      conditions.push(`updated_at <= ?`);
+      params.push(query.updatedBefore);
+    }
+    if (conditions.length > 0) {
+      sql += ` AND ${conditions.join(" AND ")}`;
+    }
+    if (query.sortBy) {
+      const column = _SQLiteMemoryStore.SORT_COLUMNS[query.sortBy];
+      if (!column) {
+        throw new Error(`Invalid sortBy: ${query.sortBy}`);
+      }
+      const order = query.sortOrder || "desc";
+      if (!_SQLiteMemoryStore.ALLOWED_SORT_ORDERS.includes(order)) {
+        throw new Error(`Invalid sortOrder: ${order}`);
+      }
+      sql += ` ORDER BY ${column} ${order.toUpperCase()}`;
+    }
+    if (query.limit) {
+      const limit = Number(query.limit);
+      if (Number.isNaN(limit) || limit < 1 || limit > 1e4) {
+        throw new Error("Limit must be between 1 and 10000");
+      }
+      sql += ` LIMIT ?`;
+      params.push(limit);
+    }
+    if (query.offset) {
+      const offset = Number(query.offset);
+      if (Number.isNaN(offset) || offset < 0) {
+        throw new Error("Offset must be >= 0");
+      }
+      sql += ` OFFSET ?`;
+      params.push(offset);
+    }
+    return { sql, params };
+  }
+  /**
+   * Batch update memory
+   */
+  async batchUpdateMemory(operations) {
+    return this.transaction(async () => {
+      const db = await this.getDatabase();
+      for (const op of operations) {
+        await this.updateMemoryInternal(db, op.operation, op.name, op.content, op.metadata);
+      }
+    });
+  }
+  /**
+   * Close database connection
+   * @param skipSave - If true, skip saving before close (useful when save already failed)
+   */
+  async close(skipSave = false) {
+    const db = this.db;
+    if (db) {
+      try {
+        if (!skipSave) {
+          await this.saveDatabase();
+        }
+      } finally {
+        if (this.db === db) {
+          db.close();
+          this.db = null;
+        }
+      }
+    }
+    this.dbPromise = null;
+  }
+  /**
+   * Get database statistics
+   */
+  async getStats() {
+    const db = await this.getDatabase();
+    const results = db.exec("SELECT COUNT(*) as count FROM memory_entries");
+    const totalEntries = results[0]?.values[0]?.[0] || 0;
+    const typeResults = db.exec("SELECT entry_type, COUNT(*) as count FROM memory_entries GROUP BY entry_type");
+    const entriesByType = {};
+    if (typeResults.length > 0) {
+      for (const row of typeResults[0].values) {
+        entriesByType[row[0]] = row[1];
+      }
+    }
+    const dbPath = this.resolvePath(this.getDbPath());
+    let databaseSize = 0;
+    try {
+      const stats = await import("fs/promises").then((fs2) => fs2.stat(dbPath));
+      databaseSize = stats.size;
+    } catch {
+    }
+    return {
+      totalEntries,
+      entriesByType,
+      databaseSize
+    };
+  }
+};
+
+// src/utils/eventHandler.ts
+import { Console } from "console";
+import { TaskEventKind } from "@polka-codes/core";
+import chalk from "chalk";
+
+// src/utils/parameterSimplifier.ts
+function createSimplifier(keepFields) {
+  return (params) => {
+    const result = {};
+    for (const field of keepFields) {
+      if (params[field] !== void 0) {
+        result[field] = params[field];
+      }
+    }
+    return result;
+  };
+}
+function createCustomSimplifier(transform) {
+  return transform;
+}
+var SIMPLIFIERS = {
+  // Simple field-based simplifiers
+  replaceInFile: createSimplifier(["path"]),
+  writeToFile: createSimplifier(["path"]),
+  readFile: createSimplifier(["path", "includeIgnored"]),
+  executeCommand: createSimplifier(["command", "requiresApproval"]),
+  updateMemory: createSimplifier(["operation", "topic"]),
+  // searchFiles passes through all params
+  searchFiles: createCustomSimplifier((params) => ({ ...params })),
+  // listFiles has custom logic for maxCount default value
+  listFiles: createCustomSimplifier((params) => {
+    const DEFAULT_MAX_COUNT = 2e3;
+    const maxCount = params.maxCount;
+    return {
+      path: params.path,
+      recursive: params.recursive,
+      ...maxCount !== DEFAULT_MAX_COUNT && { maxCount }
+    };
+  })
+};
+function simplifyToolParameters(toolName, params) {
+  if (params === void 0 || params === null) {
+    return {};
+  }
+  const simplifier = SIMPLIFIERS[toolName];
+  if (simplifier) {
+    return simplifier(params);
+  }
+  return { ...params };
+}
+
+// src/utils/eventHandler.ts
+var taskToolCallStats = /* @__PURE__ */ new Map();
+var globalToolCallStats = /* @__PURE__ */ new Map();
+function logToolCallStats(stream, statsMap, title) {
+  const customConsole = new Console(stream, stream);
+  customConsole.log(`
+
+======== ${title} ========`);
+  if (statsMap.size > 0) {
+    const tableData = [...statsMap.entries()].map(([tool, stats]) => {
+      const successRate = stats.calls > 0 ? stats.success / stats.calls * 100 : 0;
+      return {
+        "Tool Name": tool,
+        Calls: stats.calls,
+        Success: stats.success,
+        Errors: stats.errors,
+        "Success Rate": `${successRate.toFixed(2)}%`
+      };
+    });
+    customConsole.table(tableData);
+  } else {
+    customConsole.log("No tools were called.");
+  }
+}
+var mergeToolCallStats = (a, b) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [tool, stat] of a) {
+    merged.set(tool, { ...stat });
+  }
+  for (const [tool, stat] of b) {
+    const existing = merged.get(tool);
+    if (existing) {
+      existing.calls += stat.calls;
+      existing.success += stat.success;
+      existing.errors += stat.errors;
+    } else {
+      merged.set(tool, { ...stat });
+    }
+  }
+  return merged;
+};
+function logGlobalToolCallStats(stream, verbose = 0) {
+  if (verbose < 0) {
+    return;
+  }
+  const merged = mergeToolCallStats(globalToolCallStats, taskToolCallStats);
+  logToolCallStats(stream, merged, "Global Tool Call Stats");
+}
+var printEvent = (verbose, usageMeter, stream = process.stdout) => {
+  if (verbose < 0) {
+    return (_event) => {
+    };
+  }
+  const customConsole = new Console(stream, stream);
+  let hadReasoning = false;
+  let hasText = false;
+  const write = stream.write.bind(stream);
+  return (event) => {
+    switch (event.kind) {
+      case TaskEventKind.StartTask:
+        taskToolCallStats.clear();
+        if (verbose > 2) {
+          customConsole.log(`
+====== System Prompt ======
+${event.systemPrompt}`);
+          customConsole.log("\n\n================\n");
+        }
+        break;
+      case TaskEventKind.StartRequest:
+        hasText = false;
+        if (verbose > 0) {
+          customConsole.log("\n\n======== New Request ========\n");
+        }
+        if (verbose > 1) {
+          for (const message of event.userMessage) {
+            const userMessage = message.content;
+            if (typeof userMessage === "string") {
+              customConsole.log(userMessage);
+            } else {
+              for (const content of userMessage) {
+                switch (content.type) {
+                  case "text":
+                    customConsole.log(content.text);
+                    break;
+                  case "image":
+                    if (content.image instanceof URL) {
+                      customConsole.log(chalk.yellow(`[Image content from URL: ${content.image}]`));
+                    } else {
+                      customConsole.log(chalk.yellow(`[Image content: ${content.mediaType}]`));
+                    }
+                    break;
+                  case "file":
+                    customConsole.log(chalk.yellow(`[File name: ${content.filename}, type: ${content.mediaType}]`));
+                    break;
+                  case "tool-call":
+                    customConsole.log(chalk.yellow(`[Tool call: ${content.toolName}]`));
+                    break;
+                  case "tool-result":
+                    customConsole.log(chalk.yellow(`[Tool result: ${content.toolName}]`));
+                    if (verbose > 1) {
+                      customConsole.log(content.output);
+                    }
+                    break;
+                  case "reasoning":
+                    break;
+                }
+              }
+            }
+          }
+          customConsole.log("\n\n======== Request Message Ended ========\n");
+        }
+        break;
+      case TaskEventKind.EndRequest:
+        if (verbose > 0) {
+          customConsole.log("\n\n======== Request Ended ========\n");
+        }
+        if (verbose === 0 && hasText) {
+          write("\n\n");
+        }
+        if (verbose > 1) {
+          customConsole.log(usageMeter.getUsageText());
+        }
+        break;
+      case TaskEventKind.Text: {
+        if (hadReasoning) {
+          write("\n\n");
+          hadReasoning = false;
+        }
+        if (event.newText.trim().length > 0) {
+          hasText = true;
+        }
+        write(event.newText);
+        break;
+      }
+      case TaskEventKind.Reasoning: {
+        if (verbose > 0) {
+          write(chalk.dim(event.newText));
+          hadReasoning = true;
+        }
+        break;
+      }
+      case TaskEventKind.ToolUse: {
+        if (verbose > 0) {
+          const params = verbose > 1 ? event.params : simplifyToolParameters(event.tool, event.params);
+          customConsole.log(chalk.yellow("\n\nTool use:", event.tool), params);
+        }
+        const stats = taskToolCallStats.get(event.tool) ?? { calls: 0, success: 0, errors: 0 };
+        stats.calls++;
+        taskToolCallStats.set(event.tool, stats);
+        break;
+      }
+      case TaskEventKind.ToolReply: {
+        const stats = taskToolCallStats.get(event.tool) ?? { calls: 0, success: 0, errors: 0 };
+        stats.success++;
+        taskToolCallStats.set(event.tool, stats);
+        break;
+      }
+      case TaskEventKind.ToolError: {
+        customConsole.error(chalk.red("\n\nTool error:", event.tool));
+        customConsole.error(event.error);
+        const stats = taskToolCallStats.get(event.tool) ?? { calls: 0, success: 0, errors: 0 };
+        stats.errors++;
+        taskToolCallStats.set(event.tool, stats);
+        break;
+      }
+      case TaskEventKind.UsageExceeded:
+        customConsole.log("\n\n======= Usage Exceeded ========\n");
+        break;
+      case TaskEventKind.EndTask:
+        customConsole.log("\n\n======== Task Ended ========\n");
+        customConsole.log("Reason:", event.exitReason.type);
+        switch (event.exitReason.type) {
+          case "Error": {
+            const { error } = event.exitReason;
+            customConsole.error(chalk.red(`Workflow failed: ${error.message}`));
+            if (verbose > 0 && error.stack) {
+              customConsole.error(chalk.red(error.stack));
+            }
+            break;
+          }
+        }
+        for (const [tool, taskStats] of taskToolCallStats.entries()) {
+          const globalStats = globalToolCallStats.get(tool) ?? { calls: 0, success: 0, errors: 0 };
+          globalStats.calls += taskStats.calls;
+          globalStats.success += taskStats.success;
+          globalStats.errors += taskStats.errors;
+          globalToolCallStats.set(tool, globalStats);
+        }
+        if (verbose > 0) {
+          logToolCallStats(stream, taskToolCallStats, "Task Tool Call Stats");
+        }
+        taskToolCallStats.clear();
+        break;
+    }
+  };
+};
+
+// src/utils/readMultiline.ts
+import readline from "readline";
+function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
+  return new Promise((resolve5) => {
+    console.log(prompt);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: ""
+    });
+    const lines = [];
+    rl.on("line", (line) => {
+      lines.push(line);
+    });
+    rl.on("close", () => {
+      resolve5(lines.join("\n"));
+    });
+  });
+}
+export {
+  InMemoryStore,
+  MemoryManager,
+  SQLiteMemoryStore,
+  checkRipgrep,
+  configSchema,
+  detectProjectScope,
+  getGlobalConfigPath,
+  getProvider,
+  listFiles,
+  loadConfig,
+  loadConfigAtPath,
+  localConfigFileName,
+  logGlobalToolCallStats,
+  logToolCallStats,
+  mergeConfigs,
+  printEvent,
+  readConfig,
+  readLocalConfig,
+  readMultiline,
+  resolveRules,
+  searchFiles,
+  simplifyToolParameters
+};