recallmem 0.1.0

package/bin/lib/detect.js

@@ -0,0 +1,215 @@
+/**
+ * Dependency detection utilities. Each function checks for a runtime dep
+ * and returns a result describing what's there or what's missing.
+ *
+ * Pure Node, no external deps. Uses child_process to shell out to system tools.
+ */
+
+const { execSync, spawnSync } = require("node:child_process");
+const os = require("node:os");
+
+function getOS() {
+  const p = os.platform();
+  if (p === "darwin") return "mac";
+  if (p === "linux") return "linux";
+  if (p === "win32") return "windows";
+  return p;
+}
+
+function commandExists(cmd) {
+  const which = spawnSync(getOS() === "windows" ? "where" : "which", [cmd], {
+    stdio: "pipe",
+  });
+  return which.status === 0;
+}
+
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Node.js version
+// ─────────────────────────────────────────────────────────────────────────────
+
+function detectNode() {
+  const version = process.version.replace(/^v/, "");
+  const major = parseInt(version.split(".")[0], 10);
+  return {
+    ok: major >= 20,
+    version,
+    major,
+    needed: 20,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Postgres
+// ─────────────────────────────────────────────────────────────────────────────
+
+function detectPostgres() {
+  // Try common locations for psql binary
+  const candidates = [
+    "/opt/homebrew/opt/postgresql@17/bin/psql",
+    "/opt/homebrew/opt/postgresql@18/bin/psql",
+    "/usr/local/opt/postgresql@17/bin/psql",
+    "/usr/lib/postgresql/17/bin/psql",
+    "/usr/bin/psql",
+    "psql",
+  ];
+
+  let psqlPath = null;
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate, ["--version"], { stdio: "pipe" });
+    if (result.status === 0) {
+      psqlPath = candidate;
+      break;
+    }
+  }
+
+  if (!psqlPath) {
+    return { ok: false, installed: false };
+  }
+
+  const versionStr = tryExec(`${psqlPath} --version`);
+  const versionMatch = versionStr?.match(/(\d+)\.(\d+)/);
+  const major = versionMatch ? parseInt(versionMatch[1], 10) : 0;
+
+  return {
+    ok: major >= 17,
+    installed: true,
+    psqlPath,
+    version: versionStr,
+    major,
+  };
+}
+
+function detectPostgresService() {
+  // Try connecting to the default port
+  const result = spawnSync(
+    "pg_isready",
+    ["-h", "localhost", "-p", "5432"],
+    { stdio: "pipe" }
+  );
+  return { running: result.status === 0 };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// pgvector extension (uses psql via shell to avoid pg dependency in the CLI)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function detectPgvector(connectionString) {
+  try {
+    const result = spawnSync(
+      "psql",
+      [
+        connectionString,
+        "-tAc",
+        "SELECT 1 FROM pg_available_extensions WHERE name = 'vector'",
+      ],
+      { stdio: "pipe", encoding: "utf-8" }
+    );
+    if (result.status !== 0) {
+      return { ok: false, available: false, error: result.stderr?.trim() };
+    }
+    const available = result.stdout.trim() === "1";
+    return { ok: available, available };
+  } catch (err) {
+    return { ok: false, available: false, error: err.message };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Ollama
+// ─────────────────────────────────────────────────────────────────────────────
+
+function detectOllama() {
+  const installed = commandExists("ollama");
+  if (!installed) return { ok: false, installed: false, running: false };
+
+  const version = tryExec("ollama --version");
+
+  // Check if the server is running
+  let running = false;
+  try {
+    execSync("curl -s -o /dev/null -w '%{http_code}' http://localhost:11434/api/version", {
+      stdio: "pipe",
+    });
+    running = true;
+  } catch {
+    running = false;
+  }
+
+  return { ok: running, installed, running, version };
+}
+
+async function detectOllamaModel(modelName) {
+  return new Promise((resolve) => {
+    const http = require("node:http");
+    const req = http.request(
+      {
+        host: "localhost",
+        port: 11434,
+        path: "/api/tags",
+        method: "GET",
+        timeout: 3000,
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            const models = data.models || [];
+            const found = models.some(
+              (m) => m.name === modelName || m.name === `${modelName}:latest`
+            );
+            resolve({ ok: found, installed: found });
+          } catch {
+            resolve({ ok: false, installed: false });
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve({ ok: false, installed: false }));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ ok: false, installed: false });
+    });
+    req.end();
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Database existence (uses psql via shell to avoid pg dependency in the CLI)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function detectDatabase(connectionString) {
+  try {
+    const result = spawnSync("psql", [connectionString, "-tAc", "SELECT 1"], {
+      stdio: "pipe",
+      encoding: "utf-8",
+    });
+    if (result.status !== 0) {
+      return { ok: false, exists: false, error: result.stderr?.trim() };
+    }
+    return { ok: true, exists: true };
+  } catch (err) {
+    return { ok: false, exists: false, error: err.message };
+  }
+}
+
+module.exports = {
+  getOS,
+  commandExists,
+  detectNode,
+  detectPostgres,
+  detectPostgresService,
+  detectPgvector,
+  detectOllama,
+  detectOllamaModel,
+  detectDatabase,
+};

package/bin/lib/install-hints.js

@@ -0,0 +1,94 @@
+/**
+ * OS-specific install hints. Printed when a dependency is missing.
+ * The user has to run these themselves -- we don't auto-install with sudo.
+ */
+
+const { color } = require("./output");
+const { getOS } = require("./detect");
+
+function postgresInstallHint() {
+  const os = getOS();
+  const lines = [
+    color.bold("Postgres is required (version 17+ with pgvector extension)."),
+    "",
+  ];
+  if (os === "mac") {
+    lines.push("Install via Homebrew:");
+    lines.push("  brew install postgresql@17 pgvector");
+    lines.push("  brew services start postgresql@17");
+  } else if (os === "linux") {
+    lines.push("Install via apt (Ubuntu/Debian):");
+    lines.push("  sudo apt update");
+    lines.push("  sudo apt install -y postgresql-17 postgresql-17-pgvector");
+    lines.push("  sudo systemctl start postgresql");
+    lines.push("");
+    lines.push("Or via dnf (Fedora):");
+    lines.push("  sudo dnf install postgresql17-server pgvector_17");
+  } else if (os === "windows") {
+    lines.push("Recommended: use WSL2 with Ubuntu and follow the Linux instructions.");
+    lines.push("Native Windows: download from https://www.postgresql.org/download/windows/");
+    lines.push("Then install pgvector separately.");
+  } else {
+    lines.push("See https://www.postgresql.org/download/ for your platform.");
+  }
+  return lines.join("\n");
+}
+
+function pgvectorInstallHint() {
+  const os = getOS();
+  const lines = [
+    color.bold("pgvector extension is required."),
+    "",
+  ];
+  if (os === "mac") {
+    lines.push("  brew install pgvector");
+  } else if (os === "linux") {
+    lines.push("  sudo apt install postgresql-17-pgvector");
+    lines.push("  # or: https://github.com/pgvector/pgvector#installation");
+  } else {
+    lines.push("See https://github.com/pgvector/pgvector#installation");
+  }
+  return lines.join("\n");
+}
+
+function ollamaInstallHint() {
+  const os = getOS();
+  const lines = [
+    color.bold("Ollama is required for local LLMs."),
+    color.dim("(Skip this if you only want to use cloud providers like Claude or GPT.)"),
+    "",
+  ];
+  if (os === "mac") {
+    lines.push("Install:");
+    lines.push("  brew install ollama");
+    lines.push("  brew services start ollama");
+  } else if (os === "linux") {
+    lines.push("Install:");
+    lines.push("  curl -fsSL https://ollama.com/install.sh | sh");
+  } else if (os === "windows") {
+    lines.push("Download from https://ollama.com/download/windows");
+  } else {
+    lines.push("See https://ollama.com/download");
+  }
+  return lines.join("\n");
+}
+
+function nodeInstallHint() {
+  return [
+    color.bold("Node.js 20 or newer is required."),
+    "",
+    "Install via nvm (recommended):",
+    "  curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash",
+    "  nvm install 20",
+    "",
+    "Or via Homebrew (Mac): brew install node",
+    "Or download from https://nodejs.org",
+  ].join("\n");
+}
+
+module.exports = {
+  postgresInstallHint,
+  pgvectorInstallHint,
+  ollamaInstallHint,
+  nodeInstallHint,
+};

package/bin/lib/install-mode.js

@@ -0,0 +1,141 @@
+/**
+ * Install mode detection.
+ *
+ * The CLI supports three workflows that all use the same `recallmem` command:
+ *
+ *   1. "dev" mode  - already inside a recallmem git checkout
+ *                    (cwd has package.json with name "recallmem", app/, lib/, migrations/)
+ *                    Use cwd. Don't clone anything. Hot reload works.
+ *
+ *   2. "user" mode - ~/.recallmem already exists from a previous run
+ *                    Use that. Skip the clone step.
+ *
+ *   3. "first-run" mode - neither of the above
+ *                         Clone the repo to ~/.recallmem, then proceed.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { execSync, spawnSync } = require("node:child_process");
+
+const RECALLMEM_HOME =
+  process.env.RECALLMEM_HOME || path.join(os.homedir(), ".recallmem");
+
+const REPO_URL =
+  process.env.RECALLMEM_REPO || "https://github.com/RealChrisSean/RecallMEM.git";
+
+function isRecallmemCheckout(dir) {
+  const pkgPath = path.join(dir, "package.json");
+  if (!fs.existsSync(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.name !== "recallmem") return false;
+    return (
+      fs.existsSync(path.join(dir, "app")) &&
+      fs.existsSync(path.join(dir, "lib")) &&
+      fs.existsSync(path.join(dir, "migrations"))
+    );
+  } catch {
+    return false;
+  }
+}
+
+function detectInstallMode() {
+  // 1. Are we already inside a recallmem checkout?
+  if (isRecallmemCheckout(process.cwd())) {
+    return { mode: "dev", path: process.cwd() };
+  }
+
+  // 2. Does ~/.recallmem already exist as a checkout?
+  if (isRecallmemCheckout(RECALLMEM_HOME)) {
+    return { mode: "user", path: RECALLMEM_HOME };
+  }
+
+  // 3. Need to clone
+  return { mode: "first-run", path: RECALLMEM_HOME };
+}
+
+function gitInstalled() {
+  try {
+    execSync("git --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clone the repo to ~/.recallmem and run npm install.
+ * Returns true on success, false on failure.
+ */
+function cloneAndInstall(targetPath) {
+  if (!gitInstalled()) {
+    return { ok: false, error: "git is not installed" };
+  }
+
+  // Make sure parent dir exists
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+
+  // Clone (shallow, single branch, fast)
+  const cloneResult = spawnSync(
+    "git",
+    ["clone", "--depth", "1", REPO_URL, targetPath],
+    { stdio: "inherit" }
+  );
+  if (cloneResult.status !== 0) {
+    return { ok: false, error: "git clone failed" };
+  }
+
+  // Install npm dependencies inside the clone
+  const installResult = spawnSync("npm", ["install"], {
+    cwd: targetPath,
+    stdio: "inherit",
+  });
+  if (installResult.status !== 0) {
+    return { ok: false, error: "npm install failed" };
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Pull latest changes inside an existing install. Used by `recallmem upgrade`.
+ */
+function gitPull(targetPath) {
+  if (!gitInstalled()) {
+    return { ok: false, error: "git is not installed" };
+  }
+  if (!fs.existsSync(path.join(targetPath, ".git"))) {
+    return {
+      ok: false,
+      error: `${targetPath} is not a git repository (was it cloned?)`,
+    };
+  }
+  const result = spawnSync("git", ["pull"], {
+    cwd: targetPath,
+    stdio: "inherit",
+  });
+  if (result.status !== 0) {
+    return { ok: false, error: "git pull failed" };
+  }
+  // Re-install in case dependencies changed
+  const installResult = spawnSync("npm", ["install"], {
+    cwd: targetPath,
+    stdio: "inherit",
+  });
+  if (installResult.status !== 0) {
+    return { ok: false, error: "npm install failed" };
+  }
+  return { ok: true };
+}
+
+module.exports = {
+  RECALLMEM_HOME,
+  REPO_URL,
+  isRecallmemCheckout,
+  detectInstallMode,
+  gitInstalled,
+  cloneAndInstall,
+  gitPull,
+};

package/bin/lib/output.js

@@ -0,0 +1,78 @@
+/**
+ * Tiny zero-dependency terminal output helpers.
+ * No external chalk/picocolors dependency to keep the npm package light.
+ */
+
+const isTTY = process.stdout.isTTY;
+const noColor = process.env.NO_COLOR || !isTTY;
+
+function wrap(start, end) {
+  return (s) => (noColor ? s : `\x1b[${start}m${s}\x1b[${end}m`);
+}
+
+const color = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39),
+};
+
+const symbols = {
+  check: color.green("✓"),
+  cross: color.red("✗"),
+  warn: color.yellow("⚠"),
+  arrow: color.cyan("→"),
+  bullet: color.dim("•"),
+};
+
+function printHeader() {
+  console.log("");
+  console.log(color.bold("RecallMEM") + color.dim(" - private local AI chatbot"));
+  console.log("");
+}
+
+function step(msg) {
+  console.log(`  ${symbols.arrow} ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${symbols.check} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${symbols.warn} ${color.yellow(msg)}`);
+}
+
+function fail(msg) {
+  console.log(`  ${symbols.cross} ${color.red(msg)}`);
+}
+
+function info(msg) {
+  console.log(`    ${color.dim(msg)}`);
+}
+
+function section(title) {
+  console.log("");
+  console.log(color.bold(title));
+}
+
+function blank() {
+  console.log("");
+}
+
+module.exports = {
+  color,
+  symbols,
+  printHeader,
+  step,
+  success,
+  warn,
+  fail,
+  info,
+  section,
+  blank,
+};

package/bin/lib/prompt.js

@@ -0,0 +1,43 @@
+/**
+ * Tiny zero-dependency CLI prompt helpers (yes/no, list picker).
+ * Uses node:readline so we don't pull in inquirer/prompts as a dep.
+ */
+
+const readline = require("node:readline");
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function confirm(question, defaultValue = true) {
+  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+  const answer = await ask(question + suffix);
+  if (!answer) return defaultValue;
+  return /^y/i.test(answer);
+}
+
+async function pick(question, choices) {
+  console.log(question);
+  choices.forEach((c, i) => {
+    console.log(`  ${i + 1}) ${c.label}${c.detail ? ` — ${c.detail}` : ""}`);
+  });
+  while (true) {
+    const answer = await ask("Pick a number: ");
+    const n = parseInt(answer, 10);
+    if (n >= 1 && n <= choices.length) {
+      return choices[n - 1];
+    }
+    console.log("  invalid choice, try again");
+  }
+}
+
+module.exports = { ask, confirm, pick };