coding-friend-cli 1.17.4 → 1.19.0

package/dist/chunk-WEMDLEK5.js

@@ -0,0 +1,331 @@
+import {
+  getLibPath
+} from "./chunk-RZRT7NGT.js";
+import {
+  BACK,
+  askScope,
+  formatScopeLabel,
+  injectBackChoice
+} from "./chunk-C5LYVVEI.js";
+import {
+  globalConfigPath,
+  localConfigPath,
+  mergeJson,
+  readJson
+} from "./chunk-RWUTFVRB.js";
+import {
+  log
+} from "./chunk-W5CD7WTX.js";
+
+// src/lib/memory-prompts.ts
+import { confirm, input, select } from "@inquirer/prompts";
+import { join } from "path";
+function getMemoryFieldScope(field, globalCfg, localCfg) {
+  const globalSection = globalCfg?.memory;
+  const localSection = localCfg?.memory;
+  const inGlobal = globalSection?.[field] !== void 0;
+  const inLocal = localSection?.[field] !== void 0;
+  if (inGlobal && inLocal) return "both";
+  if (inGlobal) return "global";
+  if (inLocal) return "local";
+  return "-";
+}
+function getMergedMemoryValue(field, globalCfg, localCfg) {
+  const localSection = localCfg?.memory;
+  if (localSection?.[field] !== void 0) return localSection[field];
+  const globalSection = globalCfg?.memory;
+  return globalSection?.[field];
+}
+function writeMemoryField(scope, field, value) {
+  const targetPath = scope === "global" ? globalConfigPath() : localConfigPath();
+  const existingConfig = readJson(targetPath);
+  const existingSection = existingConfig?.memory ?? {};
+  const updated = { ...existingSection, [field]: value };
+  mergeJson(targetPath, { memory: updated });
+  log.success(`Saved to ${targetPath}`);
+}
+async function editMemoryTier(globalCfg, localCfg) {
+  const currentValue = getMergedMemoryValue("tier", globalCfg, localCfg);
+  if (currentValue) {
+    log.dim(`Current: ${currentValue}`);
+  }
+  const choice = await select({
+    message: "Memory search tier:",
+    choices: injectBackChoice(
+      [
+        {
+          name: "auto \u2014 detect best available (recommended)",
+          value: "auto"
+        },
+        {
+          name: "full \u2014 SQLite + FTS5 + vector embeddings (Tier 1)",
+          value: "full"
+        },
+        {
+          name: "lite \u2014 MiniSearch daemon, in-memory BM25 + fuzzy (Tier 2)",
+          value: "lite"
+        },
+        {
+          name: "markdown \u2014 file-based substring search (Tier 3)",
+          value: "markdown"
+        }
+      ],
+      "Back"
+    )
+  });
+  if (choice === BACK) return;
+  const scope = await askScope();
+  if (scope === "back") return;
+  writeMemoryField(scope, "tier", choice);
+}
+async function editMemoryAutoCapture(globalCfg, localCfg) {
+  const currentValue = getMergedMemoryValue(
+    "autoCapture",
+    globalCfg,
+    localCfg
+  );
+  if (currentValue !== void 0) {
+    log.dim(`Current: ${currentValue}`);
+  }
+  const value = await confirm({
+    message: "Auto-capture session context to memory on PreCompact (context window compression)?",
+    default: currentValue ?? false
+  });
+  const scope = await askScope();
+  if (scope === "back") return;
+  writeMemoryField(scope, "autoCapture", value);
+}
+async function editMemoryAutoStart(globalCfg, localCfg) {
+  const currentValue = getMergedMemoryValue(
+    "autoStart",
+    globalCfg,
+    localCfg
+  );
+  if (currentValue !== void 0) {
+    log.dim(`Current: ${currentValue}`);
+  }
+  const value = await confirm({
+    message: "Auto-start memory daemon when MCP server connects?",
+    default: currentValue ?? false
+  });
+  const scope = await askScope();
+  if (scope === "back") return;
+  writeMemoryField(scope, "autoStart", value);
+}
+async function editMemoryEmbedding(globalCfg, localCfg) {
+  const currentEmbedding = getMergedMemoryValue(
+    "embedding",
+    globalCfg,
+    localCfg
+  );
+  if (currentEmbedding) {
+    const parts = [`provider: ${currentEmbedding.provider ?? "transformers"}`];
+    if (currentEmbedding.model) parts.push(`model: ${currentEmbedding.model}`);
+    if (currentEmbedding.ollamaUrl)
+      parts.push(`url: ${currentEmbedding.ollamaUrl}`);
+    log.dim(`Current: ${parts.join(", ")}`);
+  }
+  const provider = await select({
+    message: "Embedding provider:",
+    choices: injectBackChoice(
+      [
+        {
+          name: "transformers \u2014 Transformers.js, runs in-process (no external deps)",
+          value: "transformers"
+        },
+        {
+          name: "ollama \u2014 Local Ollama server (faster, GPU support, wider model selection)",
+          value: "ollama"
+        }
+      ],
+      "Back"
+    )
+  });
+  if (provider === BACK) return;
+  let model;
+  let ollamaUrl;
+  if (provider === "ollama") {
+    ollamaUrl = await input({
+      message: "Ollama server URL:",
+      default: currentEmbedding?.ollamaUrl ?? "http://localhost:11434"
+    });
+    if (ollamaUrl === "http://localhost:11434") ollamaUrl = void 0;
+    const mcpDir = getLibPath("cf-memory");
+    try {
+      const { isOllamaRunning, hasOllamaEmbeddingModel } = await import(join(mcpDir, "dist/lib/ollama.js"));
+      const url = ollamaUrl ?? "http://localhost:11434";
+      const running = await isOllamaRunning(url);
+      if (!running) {
+        console.log();
+        log.warn("Ollama is not running at " + url);
+        log.dim(
+          "Install Ollama: https://ollama.ai \xB7 Docs: https://cf.dinhanhthi.com/cli/cf-memory"
+        );
+        console.log();
+        const fallback = await confirm({
+          message: "Fall back to Transformers.js instead?",
+          default: true
+        });
+        if (fallback) {
+          const scope2 = await askScope();
+          if (scope2 === "back") return;
+          writeMemoryField(scope2, "embedding", { provider: "transformers" });
+          return;
+        }
+      } else {
+        model = await input({
+          message: "Ollama model name:",
+          default: currentEmbedding?.model ?? "all-minilm:l6-v2"
+        });
+        const hasModel = await hasOllamaEmbeddingModel(model, url);
+        if (!hasModel) {
+          console.log();
+          log.warn(`Model "${model}" not found in Ollama.`);
+          log.dim(`Pull it with: ollama pull ${model}`);
+          console.log();
+          const proceed = await confirm({
+            message: "Save this config anyway? (you can pull the model later)",
+            default: true
+          });
+          if (!proceed) return;
+        }
+      }
+    } catch {
+      model = await input({
+        message: "Ollama model name:",
+        default: currentEmbedding?.model ?? "all-minilm:l6-v2"
+      });
+    }
+  } else {
+    model = await input({
+      message: "Transformers.js model:",
+      default: currentEmbedding?.model ?? "Xenova/all-MiniLM-L6-v2"
+    });
+    if (model === "Xenova/all-MiniLM-L6-v2") model = void 0;
+  }
+  const scope = await askScope();
+  if (scope === "back") return;
+  const embedding = { provider };
+  if (model) embedding.model = model;
+  if (ollamaUrl) embedding.ollamaUrl = ollamaUrl;
+  writeMemoryField(scope, "embedding", embedding);
+}
+async function editMemoryDaemonTimeout(globalCfg, localCfg) {
+  const currentDaemon = getMergedMemoryValue("daemon", globalCfg, localCfg);
+  const currentMs = currentDaemon?.idleTimeout;
+  const currentMin = currentMs ? currentMs / 6e4 : void 0;
+  if (currentMin !== void 0) {
+    log.dim(`Current: ${currentMin} minutes`);
+  }
+  const value = await input({
+    message: "Daemon idle timeout (minutes):",
+    default: String(currentMin ?? 30),
+    validate: (val) => {
+      const n = Number(val);
+      if (isNaN(n) || n < 1) return "Must be a positive number";
+      return true;
+    }
+  });
+  const scope = await askScope();
+  if (scope === "back") return;
+  writeMemoryField(scope, "daemon", {
+    ...currentDaemon,
+    idleTimeout: Number(value) * 6e4
+  });
+}
+async function memoryConfigMenu(opts) {
+  while (true) {
+    const globalCfg = readJson(globalConfigPath());
+    const localCfg = readJson(localConfigPath());
+    const tierScope = getMemoryFieldScope("tier", globalCfg, localCfg);
+    const tierVal = getMergedMemoryValue("tier", globalCfg, localCfg);
+    const autoCaptureScope = getMemoryFieldScope(
+      "autoCapture",
+      globalCfg,
+      localCfg
+    );
+    const autoCaptureVal = getMergedMemoryValue(
+      "autoCapture",
+      globalCfg,
+      localCfg
+    );
+    const autoStartScope = getMemoryFieldScope(
+      "autoStart",
+      globalCfg,
+      localCfg
+    );
+    const autoStartVal = getMergedMemoryValue(
+      "autoStart",
+      globalCfg,
+      localCfg
+    );
+    const embeddingScope = getMemoryFieldScope(
+      "embedding",
+      globalCfg,
+      localCfg
+    );
+    const embeddingVal = getMergedMemoryValue(
+      "embedding",
+      globalCfg,
+      localCfg
+    );
+    const daemonScope = getMemoryFieldScope("daemon", globalCfg, localCfg);
+    const daemonVal = getMergedMemoryValue("daemon", globalCfg, localCfg);
+    const embeddingLabel = embeddingVal?.provider ? embeddingVal.model ? `${embeddingVal.model} (${embeddingVal.provider})` : embeddingVal.provider : "";
+    const choice = await select({
+      message: "Memory settings:",
+      choices: injectBackChoice(
+        [
+          {
+            name: `Tier ${formatScopeLabel(tierScope)}${tierVal ? ` (${tierVal})` : ""}`,
+            value: "tier"
+          },
+          {
+            name: `Auto-capture ${formatScopeLabel(autoCaptureScope)}${autoCaptureVal !== void 0 ? ` (${autoCaptureVal})` : ""}`,
+            value: "autoCapture"
+          },
+          {
+            name: `Auto-start daemon ${formatScopeLabel(autoStartScope)}${autoStartVal !== void 0 ? ` (${autoStartVal})` : ""}`,
+            value: "autoStart"
+          },
+          {
+            name: `Embedding ${formatScopeLabel(embeddingScope)}${embeddingLabel ? ` (${embeddingLabel})` : ""}`,
+            value: "embedding"
+          },
+          {
+            name: `Daemon timeout ${formatScopeLabel(daemonScope)}${daemonVal?.idleTimeout ? ` (${daemonVal.idleTimeout / 6e4}min)` : ""}`,
+            value: "daemon"
+          }
+        ],
+        opts?.exitLabel ?? "Back"
+      )
+    });
+    if (choice === BACK) return;
+    switch (choice) {
+      case "tier":
+        await editMemoryTier(globalCfg, localCfg);
+        break;
+      case "autoCapture":
+        await editMemoryAutoCapture(globalCfg, localCfg);
+        break;
+      case "autoStart":
+        await editMemoryAutoStart(globalCfg, localCfg);
+        break;
+      case "embedding":
+        await editMemoryEmbedding(globalCfg, localCfg);
+        break;
+      case "daemon":
+        await editMemoryDaemonTimeout(globalCfg, localCfg);
+        break;
+    }
+  }
+}
+
+export {
+  editMemoryTier,
+  editMemoryAutoCapture,
+  editMemoryAutoStart,
+  editMemoryEmbedding,
+  editMemoryDaemonTimeout,
+  memoryConfigMenu
+};