coding-friend-cli 1.16.0 → 1.17.1

package/lib/cf-memory/src/lib/daemon-client.ts

@@ -0,0 +1,163 @@
+import http from "node:http";
+import type { MemoryBackend } from "./backend.js";
+import type {
+  ListInput,
+  Memory,
+  MemoryMeta,
+  MemoryStats,
+  SearchInput,
+  SearchResult,
+  StoreInput,
+  UpdateInput,
+} from "./types.js";
+
+/**
+ * MemoryBackend implementation that talks to the daemon over UDS.
+ */
+export class DaemonClient implements MemoryBackend {
+  constructor(private socketPath: string) {}
+
+  private request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const options: http.RequestOptions = {
+        socketPath: this.socketPath,
+        path,
+        method,
+        headers: {
+          "Content-Type": "application/json",
+        },
+      };
+
+      const req = http.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk: Buffer) => {
+          data += chunk.toString();
+        });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data) as T;
+            if (res.statusCode && res.statusCode >= 400) {
+              reject(
+                new Error(
+                  (parsed as Record<string, string>).error ??
+                    `HTTP ${res.statusCode}`,
+                ),
+              );
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid JSON response: ${data}`));
+          }
+        });
+      });
+
+      req.on("error", (err) => {
+        reject(err);
+      });
+
+      req.setTimeout(10000, () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+
+  async store(input: StoreInput): Promise<Memory> {
+    const result = await this.request<{
+      id: string;
+      title: string;
+      stored: boolean;
+    }>("POST", "/memory", input);
+    // Retrieve full memory after store
+    const memory = await this.retrieve(result.id);
+    if (!memory) throw new Error("Store succeeded but retrieve failed");
+    return memory;
+  }
+
+  async search(input: SearchInput): Promise<SearchResult[]> {
+    const params = new URLSearchParams();
+    params.set("query", input.query);
+    if (input.type) params.set("type", input.type);
+    if (input.tags) params.set("tags", input.tags.join(","));
+    if (input.limit) params.set("limit", String(input.limit));
+
+    return this.request<SearchResult[]>(
+      "GET",
+      `/memory/search?${params.toString()}`,
+    );
+  }
+
+  async retrieve(id: string): Promise<Memory | null> {
+    try {
+      return await this.request<Memory>("GET", `/memory/${id}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async list(input: ListInput): Promise<MemoryMeta[]> {
+    const params = new URLSearchParams();
+    if (input.type) params.set("type", input.type);
+    if (input.category) params.set("category", input.category);
+    if (input.limit) params.set("limit", String(input.limit));
+
+    const qs = params.toString();
+    return this.request<MemoryMeta[]>("GET", qs ? `/memory?${qs}` : "/memory");
+  }
+
+  async update(input: UpdateInput): Promise<Memory | null> {
+    const { id, ...body } = input;
+    try {
+      await this.request("PATCH", `/memory/${id}`, body);
+      return this.retrieve(id);
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(id: string): Promise<boolean> {
+    try {
+      await this.request("DELETE", `/memory/${id}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async stats(): Promise<MemoryStats> {
+    return this.request<MemoryStats>("GET", "/stats");
+  }
+
+  async close(): Promise<void> {
+    // No-op — daemon keeps running
+  }
+
+  /**
+   * Check if the daemon is reachable.
+   */
+  async ping(): Promise<boolean> {
+    try {
+      const result = await this.request<{ status: string }>("GET", "/health");
+      return result.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Trigger index rebuild on the daemon.
+   */
+  async rebuild(): Promise<void> {
+    try {
+      await this.request<{ rebuilt: boolean }>("POST", "/rebuild");
+    } catch {
+      // Rebuild failed or not supported
+    }
+  }
+}

package/lib/cf-memory/src/lib/dedup.ts

@@ -0,0 +1,80 @@
+import type { MemoryBackend } from "./backend.js";
+import type { StoreInput } from "./types.js";
+
+export interface DedupResult {
+  isDuplicate: boolean;
+  similarId?: string;
+  similarity: number;
+}
+
+interface DedupOptions {
+  threshold?: number;
+}
+
+export function textSimilarity(a: string, b: string): number {
+  const tokenize = (s: string): Set<string> =>
+    new Set(
+      s
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((t) => t.length > 0),
+    );
+
+  const setA = tokenize(a);
+  const setB = tokenize(b);
+
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const token of setA) {
+    if (setB.has(token)) intersection++;
+  }
+
+  const union = new Set([...setA, ...setB]).size;
+  return intersection / union;
+}
+
+export async function checkDuplicate(
+  backend: MemoryBackend,
+  input: StoreInput,
+  options?: DedupOptions,
+): Promise<DedupResult> {
+  const searchScoreThreshold = options?.threshold ?? 0.8;
+  const titleThreshold = 0.85;
+
+  // Search by title only — more reliable across all backend tiers
+  // (MarkdownBackend uses substring matching, composite queries miss)
+  const results = await backend.search({ query: input.title, limit: 5 });
+
+  let maxSimilarity = 0;
+  const inputText = input.title + " " + input.description;
+
+  for (const result of results) {
+    const resultText =
+      result.memory.frontmatter.title +
+      " " +
+      result.memory.frontmatter.description;
+
+    const titleSim = textSimilarity(
+      input.title,
+      result.memory.frontmatter.title,
+    );
+    const overallSim = textSimilarity(inputText, resultText);
+
+    const combinedSim = Math.max(titleSim, overallSim);
+    if (combinedSim > maxSimilarity) {
+      maxSimilarity = combinedSim;
+    }
+
+    if (result.score > searchScoreThreshold && titleSim > titleThreshold) {
+      return {
+        isDuplicate: true,
+        similarId: result.memory.id,
+        similarity: combinedSim,
+      };
+    }
+  }
+
+  return { isDuplicate: false, similarity: maxSimilarity };
+}

package/lib/cf-memory/src/lib/lazy-install.ts

@@ -0,0 +1,274 @@
+/**
+ * Lazy dependency installer for Phase 3 (SQLite + Hybrid Search).
+ *
+ * Heavy deps (better-sqlite3, sqlite-vec, @huggingface/transformers) are installed
+ * into ~/.coding-friend/memory/node_modules/ — NOT bundled with the CLI package.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+
+/** Dependencies required for Tier 1 (SQLite + Hybrid Search) */
+export const SQLITE_DEPS: Record<string, string> = {
+  "better-sqlite3": "^11.0.0",
+  "sqlite-vec": "^0.1.6",
+};
+
+export const EMBEDDING_DEPS: Record<string, string> = {
+  "@huggingface/transformers": "^3.4.0",
+};
+
+export const ALL_DEPS = { ...SQLITE_DEPS, ...EMBEDDING_DEPS };
+
+export interface DepsManifest {
+  version: number;
+  installed: Record<string, string>;
+  installedAt: string;
+}
+
+const MANIFEST_VERSION = 1;
+
+/**
+ * Get the base directory for lazy-installed deps.
+ */
+export function getDepsDir(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return path.join(home, ".coding-friend", "memory");
+}
+
+/**
+ * Get the path to the deps manifest file.
+ */
+export function getManifestPath(depsDir?: string): string {
+  return path.join(depsDir ?? getDepsDir(), "deps.json");
+}
+
+/**
+ * Read the current deps manifest.
+ */
+export function readManifest(depsDir?: string): DepsManifest | null {
+  const manifestPath = getManifestPath(depsDir);
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the deps manifest.
+ */
+function writeManifest(manifest: DepsManifest, depsDir?: string): void {
+  const dir = depsDir ?? getDepsDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(getManifestPath(dir), JSON.stringify(manifest, null, 2));
+}
+
+/**
+ * Check if a specific set of deps are installed and up-to-date.
+ */
+export function areDepsInstalled(
+  deps: Record<string, string>,
+  depsDir?: string,
+): boolean {
+  const dir = depsDir ?? getDepsDir();
+  const manifest = readManifest(dir);
+  if (!manifest || manifest.version !== MANIFEST_VERSION) return false;
+
+  for (const [pkg, version] of Object.entries(deps)) {
+    const installedVersion = manifest.installed[pkg];
+    if (!installedVersion) return false;
+
+    // Semver caret range check:
+    // ^x.y.z (x>0): same major  →  ^11.0.0 accepts 11.x.x
+    // ^0.y.z (y>0): same major+minor  →  ^0.1.6 accepts 0.1.x
+    // ^0.0.z: exact  →  ^0.0.3 accepts only 0.0.3
+    const requiredParts = version.replace(/^\^/, "").split(".");
+    const installedParts = installedVersion.split(".");
+
+    if (requiredParts[0] !== "0") {
+      // Major > 0: check major version matches
+      if (requiredParts[0] !== installedParts[0]) return false;
+    } else if (requiredParts[1] !== "0") {
+      // ^0.y.z: check major + minor match
+      if (requiredParts[0] !== installedParts[0]) return false;
+      if (requiredParts[1] !== installedParts[1]) return false;
+    } else {
+      // ^0.0.z: exact match required
+      if (installedVersion !== version.replace(/^\^/, "")) return false;
+    }
+
+    // Also check that the module actually exists on disk
+    const modulePath = path.join(dir, "node_modules", pkg);
+    if (!fs.existsSync(modulePath)) return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check if SQLite deps are available (quick check for tier detection).
+ */
+export function areSqliteDepsAvailable(depsDir?: string): boolean {
+  return areDepsInstalled(SQLITE_DEPS, depsDir);
+}
+
+/**
+ * Check if embedding deps are available.
+ */
+export function areEmbeddingDepsAvailable(depsDir?: string): boolean {
+  return areDepsInstalled(EMBEDDING_DEPS, depsDir);
+}
+
+export interface InstallOptions {
+  onProgress?: (message: string) => void;
+  depsDir?: string;
+  sqliteOnly?: boolean;
+}
+
+/**
+ * Ensure all required deps are installed. Installs missing ones.
+ *
+ * Returns true if all deps are available after this call.
+ */
+export async function ensureDeps(opts?: InstallOptions): Promise<boolean> {
+  const dir = opts?.depsDir ?? getDepsDir();
+  const deps = opts?.sqliteOnly ? SQLITE_DEPS : ALL_DEPS;
+  const progress = opts?.onProgress ?? (() => {});
+
+  if (areDepsInstalled(deps, dir)) {
+    return true;
+  }
+
+  progress("Checking build tools...");
+
+  // Verify npm is available
+  try {
+    execFileSync("npm", ["--version"], { stdio: "ignore" });
+  } catch {
+    progress("Error: npm not found. Please install Node.js >= 18.");
+    return false;
+  }
+
+  // Create directory structure
+  fs.mkdirSync(dir, { recursive: true });
+
+  // Create a minimal package.json if it doesn't exist
+  const pkgPath = path.join(dir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    fs.writeFileSync(
+      pkgPath,
+      JSON.stringify(
+        {
+          name: "cf-memory-deps",
+          version: "1.0.0",
+          private: true,
+          description: "Lazy-installed dependencies for cf-memory Tier 1",
+        },
+        null,
+        2,
+      ),
+    );
+  }
+
+  // Build npm install args: ["install", "--save", "pkg1@ver1", "pkg2@ver2"]
+  const installArgs = ["install", "--save"];
+  for (const [name, version] of Object.entries(deps)) {
+    installArgs.push(`${name}@${version}`);
+  }
+
+  progress(`Installing dependencies: ${Object.keys(deps).join(", ")}...`);
+
+  try {
+    execFileSync("npm", installArgs, {
+      cwd: dir,
+      stdio: "pipe",
+      timeout: 300_000, // 5 minutes
+    });
+  } catch (err) {
+    const message =
+      err instanceof Error ? err.message : "Unknown installation error";
+    progress(`Installation failed: ${message}`);
+    return false;
+  }
+
+  // Read actual installed versions from node_modules
+  const installed: Record<string, string> = {};
+  for (const pkg of Object.keys(deps)) {
+    try {
+      const pkgJsonPath = path.join(dir, "node_modules", pkg, "package.json");
+      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      installed[pkg] = pkgJson.version;
+    } catch {
+      progress(`Warning: Could not read installed version for ${pkg}`);
+    }
+  }
+
+  // Write manifest
+  const manifest: DepsManifest = {
+    version: MANIFEST_VERSION,
+    installed,
+    installedAt: new Date().toISOString(),
+  };
+  writeManifest(manifest, dir);
+
+  progress("Dependencies installed successfully.");
+  return true;
+}
+
+/**
+ * Synchronously load a lazily-installed CJS module (e.g., better-sqlite3).
+ */
+export function loadDepSync<T = unknown>(
+  moduleName: string,
+  depsDir?: string,
+): T {
+  const dir = depsDir ?? getDepsDir();
+  const modulePath = path.join(dir, "node_modules", moduleName);
+
+  if (!fs.existsSync(modulePath)) {
+    throw new Error(
+      `Dependency "${moduleName}" not installed. Run "cf memory init" first.`,
+    );
+  }
+
+  const require = createRequire(path.join(dir, "package.json"));
+  return require(moduleName) as T;
+}
+
+/**
+ * Dynamically import a lazily-installed ESM module (e.g., @huggingface/transformers).
+ */
+export async function loadDepAsync<T = unknown>(
+  moduleName: string,
+  depsDir?: string,
+): Promise<T> {
+  const dir = depsDir ?? getDepsDir();
+  const modulePath = path.join(dir, "node_modules", moduleName);
+
+  if (!fs.existsSync(modulePath)) {
+    throw new Error(
+      `Dependency "${moduleName}" not installed. Run "cf memory init" first.`,
+    );
+  }
+
+  // Find the main entry point from package.json
+  const pkgJsonPath = path.join(modulePath, "package.json");
+  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+
+  // Try: exports → module → main
+  const entry =
+    typeof pkgJson.exports === "string"
+      ? pkgJson.exports
+      : (pkgJson.exports?.["."]?.import ??
+        pkgJson.exports?.["."]?.default ??
+        pkgJson.exports?.["."] ??
+        pkgJson.module ??
+        pkgJson.main ??
+        "index.js");
+
+  const entryPath = path.join(modulePath, entry);
+  return (await import(entryPath)) as T;
+}

package/lib/cf-memory/src/lib/ollama.ts

@@ -0,0 +1,76 @@
+/**
+ * Ollama integration for embedding generation.
+ *
+ * Provides auto-detection of Ollama availability and model listing.
+ */
+
+const DEFAULT_OLLAMA_URL = process.env.OLLAMA_HOST ?? "http://localhost:11434";
+
+/**
+ * Check if Ollama is running at the given URL.
+ */
+export async function isOllamaRunning(
+  url: string = DEFAULT_OLLAMA_URL,
+): Promise<boolean> {
+  try {
+    const response = await fetch(`${url}/api/tags`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List available Ollama models.
+ */
+export async function listOllamaModels(
+  url: string = DEFAULT_OLLAMA_URL,
+): Promise<string[]> {
+  try {
+    const response = await fetch(`${url}/api/tags`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) return [];
+
+    const data = (await response.json()) as {
+      models?: Array<{ name: string }>;
+    };
+    return data.models?.map((m) => m.name) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a specific embedding model is available in Ollama.
+ */
+export async function hasOllamaEmbeddingModel(
+  model: string = "all-minilm:l6-v2",
+  url: string = DEFAULT_OLLAMA_URL,
+): Promise<boolean> {
+  const models = await listOllamaModels(url);
+  return models.some((m) => m.startsWith(model));
+}
+
+/**
+ * Auto-detect the best embedding provider.
+ *
+ * Prefers Ollama if available and has an embedding model,
+ * otherwise falls back to Transformers.js.
+ */
+export async function detectEmbeddingProvider(
+  ollamaUrl?: string,
+): Promise<{ provider: "ollama" | "transformers"; model?: string }> {
+  const url = ollamaUrl ?? DEFAULT_OLLAMA_URL;
+
+  if (await isOllamaRunning(url)) {
+    if (await hasOllamaEmbeddingModel("all-minilm:l6-v2", url)) {
+      return { provider: "ollama", model: "all-minilm:l6-v2" };
+    }
+    // Ollama running but no embedding model — use transformers
+  }
+
+  return { provider: "transformers" };
+}

package/lib/cf-memory/src/lib/temporal-decay.ts

@@ -0,0 +1,19 @@
+export function applyTemporalDecay(
+  score: number,
+  updatedDate: string,
+  accessCount?: number,
+): number {
+  const updated = new Date(updatedDate);
+  if (isNaN(updated.getTime())) return score;
+
+  const now = new Date();
+  const ageDays = (now.getTime() - updated.getTime()) / (1000 * 60 * 60 * 24);
+
+  score *= 0.7 + 0.3 * Math.exp(-ageDays / 90);
+
+  if (accessCount !== undefined) {
+    score *= 1 + 0.05 * Math.min(accessCount, 10);
+  }
+
+  return score;
+}