@shahmilsaari/memory-core 0.2.13 → 0.2.14

package/README.md

@@ -8,7 +8,7 @@ You decide the architecture. memory-core remembers it. Every AI tool — Copilot
 npx @shahmilsaari/memory-core init
 ```
 
-Fully local or cloud — your choice. **v0.2.10**
+Fully local or cloud — your choice. **v0.2.13**
 
 ---
 
@@ -165,6 +165,14 @@ That's it. Every AI agent in your project now has your rules.
 
 ## Commands
 
+For the full CLI reference, examples, and command behavior notes, see [COMMANDS.md](./COMMANDS.md).
+
+New setup-management commands:
+- `memory-core status` — show project name, provider/model, agents, hook state, generated files, and health checks
+- `memory-core provider set <provider>` — switch code-checking provider without rerunning `init`
+- `memory-core model set <model>` — update chat or embedding model from the CLI
+- `memory-core model doctor` — verify database, Ollama, model installation, and cloud API key presence
+
 ### `init` — Set up a project
 
 ```bash
@@ -566,6 +574,13 @@ npx @shahmilsaari/memory-core sync
 # Not sure how something was decided? Search.
 npx @shahmilsaari/memory-core search "caching strategy"
 
+# Inspect current setup, provider, model, and health checks
+npx @shahmilsaari/memory-core status
+
+# Switch code-checking provider or model without rerunning init
+npx @shahmilsaari/memory-core provider set openai --model gpt-4o-mini --api-key $OPENAI_API_KEY
+npx @shahmilsaari/memory-core model set qwen2.5-coder --provider ollama
+
 # See what rules are saved
 npx @shahmilsaari/memory-core list --type rule
 
@@ -603,10 +618,15 @@ pgvector isn't installed for your PostgreSQL version. Follow the [pgvector insta
 Start Ollama: `brew services start ollama` (macOS) or `ollama serve` (Linux).
 
 **`Chat model "llama3.2" not found`**
-Run `ollama pull llama3.2`. Or switch provider/model by updating `CHAT_PROVIDER` and `CHAT_MODEL` in `.memory-core.env`.
+Run `ollama pull llama3.2`. Or switch provider/model with `npx @shahmilsaari/memory-core provider set ...` or `npx @shahmilsaari/memory-core model set ...`.
 
 **Using an API key instead of Ollama for code checking**
-During `init` choose OpenAI, Anthropic, or MiniMax when prompted for the check provider. Or set manually in `.memory-core.env`:
+During `init` choose OpenAI, Anthropic, or MiniMax when prompted for the check provider. Or switch later:
+```bash
+npx @shahmilsaari/memory-core provider set openai --model gpt-4o --api-key sk-...
+```
+
+Equivalent manual `.memory-core.env` settings:
 ```
 CHAT_PROVIDER=openai
 CHAT_MODEL=gpt-4o
@@ -617,6 +637,12 @@ Embeddings always use Ollama (`nomic-embed-text`) regardless of provider.
 **`DATABASE_URL is not set`**
 Run `npx @shahmilsaari/memory-core init` — it will create the `.memory-core.env` file for you.
 
+**Not sure what memory-core is configured to use**
+Run `npx @shahmilsaari/memory-core status`.
+
+**Need to verify the model/database setup**
+Run `npx @shahmilsaari/memory-core model doctor`.
+
 **`createdb: role does not exist`**
 ```bash
 createuser -s $(whoami)
@@ -647,11 +673,12 @@ Save an ignore pattern: `npx @shahmilsaari/memory-core ignore "your exception he
 | ✓ | List / remove / edit — full CRUD for stored memories |
 | ✓ | False positive tagging — `ignore` command saves exceptions for hook and watcher |
 | ✓ | Reset command — clean up generated files and optionally drop the DB table |
-| ✓ | Test suite — Vitest smoke tests for all core commands and providers |
+| ✓ | Test suite — smoke tests for all core commands and providers |
 | ✓ | Multi-provider code checking — Ollama, OpenAI, Anthropic, MiniMax |
-| | Context-aware retrieval — surface the most relevant rules for the file being edited |
+| ✓ | Context-aware retrieval — surface the most relevant rules for the file being edited |
+| ✓ | Setup management — `status`, `provider set`, `model set`, `model doctor` |
+| ✓ | `--debug` flag — verbose output for diagnosing hook and watcher issues |
 | | Model guidance during init — recommend a model based on machine specs |
-| | `--debug` flag — verbose output for diagnosing hook and watcher issues |
 | | Violation → rule pipeline — auto-suggest a new rule when the same violation repeats |
 | | Rule analytics dashboard — visual breakdown of rule coverage and violations |
 | | Team sync — shared database so the whole team works from the same rule set |

package/dist/cli.js

@@ -711,11 +711,11 @@ import chalk from "chalk";
 
 // src/chat.ts
 function getChatConfig() {
-  const provider = process.env.CHAT_PROVIDER ?? "ollama";
-  const model = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+  const provider2 = process.env.CHAT_PROVIDER ?? "ollama";
+  const model2 = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
   return {
-    provider,
-    model,
+    provider: provider2,
+    model: model2,
     ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
     apiKey: process.env.CHAT_API_KEY ?? ""
   };
@@ -1301,10 +1301,10 @@ async function checkCi(options = {}) {
   recordViolations(violations);
   process.exit(1);
 }
-function printModelMissing(model) {
+function printModelMissing(model2) {
   console.log(chalk.yellow(`
-  \u26A0  Chat model "${model}" not found in Ollama.`));
-  console.log(chalk.gray(`     Pull a model: ollama pull ${model}`));
+  \u26A0  Chat model "${model2}" not found in Ollama.`));
+  console.log(chalk.gray(`     Pull a model: ollama pull ${model2}`));
   console.log(chalk.gray("     Or set OLLAMA_CHAT_MODEL=<model> in .env"));
   console.log(chalk.gray("     Recommended: llama3.2  |  qwen2.5-coder:3b  |  mistral\n"));
 }
@@ -1697,6 +1697,139 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
 }
 var { version } = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+var DEFAULT_CHAT_MODEL = "llama3.2";
+function getEnvPath() {
+  const memoryEnv = join6(process.cwd(), ".memory-core.env");
+  if (existsSync6(memoryEnv)) return memoryEnv;
+  const dotEnv = join6(process.cwd(), ".env");
+  return existsSync6(dotEnv) ? dotEnv : memoryEnv;
+}
+function parseEnvFile(raw) {
+  const lines = raw.split(/\r?\n/);
+  const values = {};
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex === -1) continue;
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    if (key) values[key] = value;
+  }
+  return values;
+}
+function readRuntimeEnv() {
+  const envPath = getEnvPath();
+  const fileValues = existsSync6(envPath) ? parseEnvFile(readFileSync6(envPath, "utf-8")) : {};
+  const values = {
+    ...fileValues
+  };
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string" && value !== "") values[key] = value;
+  }
+  return { envPath, values };
+}
+function writeRuntimeEnv(values, envPath = getEnvPath()) {
+  const orderedKeys = [
+    "DATABASE_URL",
+    "OLLAMA_URL",
+    "OLLAMA_MODEL",
+    "CHAT_PROVIDER",
+    "CHAT_MODEL",
+    "OLLAMA_CHAT_MODEL",
+    "CHAT_API_KEY"
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const key of orderedKeys) {
+    const value = values[key];
+    if (value) {
+      lines.push(`${key}=${value}`);
+      seen.add(key);
+    }
+  }
+  for (const key of Object.keys(values).sort()) {
+    if (seen.has(key)) continue;
+    const value = values[key];
+    if (value) lines.push(`${key}=${value}`);
+  }
+  writeFileSync5(envPath, `${lines.join("\n")}
+`, "utf-8");
+}
+function applyRuntimeEnv(values) {
+  for (const [key, value] of Object.entries(values)) {
+    process.env[key] = value;
+  }
+}
+function ensureEnvFileIgnored(envPath = getEnvPath()) {
+  const envFileName = envPath.split("/").pop() ?? ".memory-core.env";
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  if (!existing.includes(envFileName)) {
+    appendFileSync(gitignorePath, `${existing ? "\n" : ""}${envFileName}
+`);
+  }
+}
+function normalizeProvider(value) {
+  const provider2 = value.trim().toLowerCase();
+  if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax") {
+    return provider2;
+  }
+  throw new Error(`Unsupported provider "${value}". Use: ollama, openai, anthropic, minimax`);
+}
+function providerLabel(provider2) {
+  switch (provider2) {
+    case "openai":
+      return "OpenAI";
+    case "anthropic":
+      return "Anthropic";
+    case "minimax":
+      return "MiniMax";
+    default:
+      return "Ollama";
+  }
+}
+function redactDatabaseUrl(url) {
+  if (!url) return "(not set)";
+  return url.replace(/:\/\/([^:@/]+)(?::[^@/]+)?@/, "://$1:***@");
+}
+function getConfiguredProvider(values) {
+  return normalizeProvider(values.CHAT_PROVIDER ?? "ollama");
+}
+function getConfiguredChatModel(values) {
+  return values.CHAT_MODEL ?? values.OLLAMA_CHAT_MODEL ?? DEFAULT_CHAT_MODEL;
+}
+async function resolveOllamaInstalledModel(ollamaUrl, model2) {
+  const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const data = await res.json();
+  const models = data.models ?? [];
+  const exact = models.find((entry) => entry.name === model2);
+  const prefixed = models.find((entry) => entry.name.startsWith(`${model2}:`));
+  return (exact ?? prefixed)?.name ?? null;
+}
+async function verifyDatabaseConnection(dbUrl) {
+  if (!dbUrl) return "DATABASE_URL is not set";
+  try {
+    const { Pool } = (await import("pg")).default;
+    const testPool = new Pool({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
+    await testPool.query("SELECT 1");
+    await testPool.end();
+    return null;
+  } catch (err) {
+    return err.message;
+  }
+}
+async function verifyOllamaConnection(ollamaUrl) {
+  try {
+    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+    return res.ok ? null : `HTTP ${res.status}`;
+  } catch (err) {
+    return err.message;
+  }
+}
 function readProjectConfig() {
   const path = join6(process.cwd(), CONFIG_FILE);
   if (!existsSync6(path)) return null;
@@ -1744,6 +1877,130 @@ function printMemoryTable(memories, title = "Rules in memory") {
   });
   console.log(chalk3.gray("\n  Use: memory-core remove <id>  |  memory-core edit <id>\n"));
 }
+function printStatusLine(label, value) {
+  console.log(`  ${chalk3.dim(label.padEnd(18))} ${value}`);
+}
+async function runModelDoctor() {
+  const { envPath, values } = readRuntimeEnv();
+  const provider2 = getConfiguredProvider(values);
+  const model2 = getConfiguredChatModel(values);
+  const ollamaUrl = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+  const embeddingModel = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+  const dbUrl = values.DATABASE_URL ?? "";
+  console.log(chalk3.bold("\n  memory-core model doctor\n"));
+  printStatusLine("Env file", existsSync6(envPath) ? envPath : `${envPath} ${chalk3.yellow("(will be created on first write)")}`);
+  printStatusLine("Provider", provider2);
+  printStatusLine("Chat model", model2);
+  printStatusLine("Embedding model", embeddingModel);
+  printStatusLine("Ollama URL", ollamaUrl);
+  console.log();
+  let ok = true;
+  const dbError = await verifyDatabaseConnection(dbUrl);
+  if (dbError) {
+    ok = false;
+    console.log(chalk3.red("  \u2717 PostgreSQL ") + chalk3.dim(dbError));
+  } else {
+    console.log(chalk3.green("  \u2713 PostgreSQL ") + chalk3.dim("connected"));
+  }
+  const ollamaError = await verifyOllamaConnection(ollamaUrl);
+  if (ollamaError) {
+    ok = false;
+    console.log(chalk3.red("  \u2717 Ollama     ") + chalk3.dim(ollamaError));
+  } else {
+    console.log(chalk3.green("  \u2713 Ollama     ") + chalk3.dim("reachable"));
+  }
+  if (!ollamaError) {
+    try {
+      const installedEmbeddingModel = await resolveOllamaInstalledModel(ollamaUrl, embeddingModel);
+      if (installedEmbeddingModel) {
+        console.log(chalk3.green("  \u2713 Embedding  ") + chalk3.dim(`${installedEmbeddingModel} installed`));
+      } else {
+        ok = false;
+        console.log(chalk3.red("  \u2717 Embedding  ") + chalk3.dim(`${embeddingModel} not installed in Ollama`));
+      }
+    } catch (err) {
+      ok = false;
+      console.log(chalk3.red("  \u2717 Embedding  ") + chalk3.dim(err.message));
+    }
+  }
+  if (provider2 === "ollama") {
+    if (ollamaError) {
+      ok = false;
+      console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim("cannot verify while Ollama is unreachable"));
+    } else {
+      try {
+        const installedChatModel = await resolveOllamaInstalledModel(ollamaUrl, model2);
+        if (installedChatModel) {
+          console.log(chalk3.green("  \u2713 Chat model ") + chalk3.dim(`${installedChatModel} installed`));
+        } else {
+          ok = false;
+          console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim(`${model2} not installed in Ollama`));
+        }
+      } catch (err) {
+        ok = false;
+        console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim(err.message));
+      }
+    }
+  } else {
+    if (!values.CHAT_API_KEY) {
+      ok = false;
+      console.log(chalk3.red(`  \u2717 ${providerLabel(provider2)} API`) + chalk3.dim(" CHAT_API_KEY is missing"));
+    } else {
+      console.log(chalk3.green(`  \u2713 ${providerLabel(provider2)} API`) + chalk3.dim(" key configured"));
+      console.log(chalk3.gray("    Remote provider connectivity is not verified live by doctor."));
+    }
+  }
+  console.log();
+  return { ok, provider: provider2, model: model2 };
+}
+async function printProjectStatus() {
+  const config = readProjectConfig();
+  const { envPath, values } = readRuntimeEnv();
+  const provider2 = getConfiguredProvider(values);
+  const model2 = getConfiguredChatModel(values);
+  const architectures = inferProjectArchitectures(process.cwd(), config);
+  const generatedFiles = OUTPUT_FILES.map((entry) => entry.path).filter((relativePath) => existsSync6(join6(process.cwd(), relativePath)));
+  const hookPath = join6(process.cwd(), ".git", "hooks", "pre-commit");
+  const memoryFilePath = join6(process.cwd(), MEMORY_FILE);
+  const statsPath = join6(process.cwd(), ".memory-core-stats.json");
+  const dbError = await verifyDatabaseConnection(values.DATABASE_URL ?? "");
+  const ollamaError = await verifyOllamaConnection(values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL);
+  console.log(chalk3.bold("\n  memory-core status\n"));
+  printStatusLine("Project", config?.projectName ?? process.cwd().split("/").pop() ?? "unknown");
+  printStatusLine("Project type", config?.projectType ?? chalk3.yellow("not initialized"));
+  printStatusLine("Language", config?.language ?? detectProject().language);
+  printStatusLine("Backend arch", config?.backendArchitecture ?? chalk3.gray("\u2014"));
+  printStatusLine("Frontend fw", config?.frontendFramework ?? chalk3.gray("\u2014"));
+  printStatusLine("Architectures", architectures.length ? architectures.join(", ") : chalk3.gray("none detected"));
+  printStatusLine("Agents", config?.agents?.length ? `${config.agents.length} selected` : chalk3.gray("none saved"));
+  printStatusLine("Caveman", config?.caveman?.enabled ? `enabled (${config.caveman.intensity})` : "disabled");
+  printStatusLine("Allow patterns", String(getAllowPatterns(config).length));
+  printStatusLine("Env file", `${existsSync6(envPath) ? "present" : "missing"} (${envPath.split("/").pop()})`);
+  printStatusLine("Memory file", existsSync6(memoryFilePath) ? MEMORY_FILE : chalk3.gray("not exported"));
+  printStatusLine("Project config", existsSync6(join6(process.cwd(), CONFIG_FILE)) ? CONFIG_FILE : chalk3.gray("missing"));
+  printStatusLine("Generated files", String(generatedFiles.length));
+  printStatusLine("Hook", existsSync6(hookPath) ? "installed" : "not installed");
+  printStatusLine("Stats file", existsSync6(statsPath) ? ".memory-core-stats.json" : chalk3.gray("none"));
+  console.log();
+  printStatusLine("Database URL", redactDatabaseUrl(values.DATABASE_URL ?? ""));
+  printStatusLine("Ollama URL", values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL);
+  printStatusLine("Embedding model", values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL);
+  printStatusLine("Chat provider", provider2);
+  printStatusLine("Chat model", model2);
+  console.log();
+  console.log(
+    dbError ? chalk3.red("  \u2717 PostgreSQL ") + chalk3.dim(dbError) : chalk3.green("  \u2713 PostgreSQL ") + chalk3.dim("connected")
+  );
+  console.log(
+    ollamaError ? chalk3.red("  \u2717 Ollama     ") + chalk3.dim(ollamaError) : chalk3.green("  \u2713 Ollama     ") + chalk3.dim("reachable")
+  );
+  if (provider2 !== "ollama") {
+    console.log(
+      values.CHAT_API_KEY ? chalk3.green(`  \u2713 ${providerLabel(provider2)} API`) + chalk3.dim(" key configured") : chalk3.red(`  \u2717 ${providerLabel(provider2)} API`) + chalk3.dim(" CHAT_API_KEY is missing")
+    );
+  }
+  console.log();
+}
 var program = new Command();
 program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
 program.command("init").description("Initialize memory-core in the current project").option("--quick", "Use smart defaults and skip optional prompts").action(async (opts) => {
@@ -1755,25 +2012,19 @@ program.command("init").description("Initialize memory-core in the current proje
   if (!hasEnv && quick) {
     const dbUser = process.env.USER ?? process.env.USERNAME ?? "postgres";
     const dbUrl = `postgresql://${dbUser}@localhost:5432/memory_core`;
-    const ollamaUrl = "http://localhost:11434";
-    const chatModel = "llama3.2";
-    const envContent = [
-      `DATABASE_URL=${dbUrl}`,
-      `OLLAMA_URL=${ollamaUrl}`,
-      `OLLAMA_MODEL=nomic-embed-text`,
-      `OLLAMA_CHAT_MODEL=${chatModel}`
-    ].join("\n") + "\n";
-    writeFileSync5(envPath, envContent);
-    process.env.DATABASE_URL = dbUrl;
-    process.env.OLLAMA_URL = ollamaUrl;
-    process.env.OLLAMA_MODEL = "nomic-embed-text";
-    process.env.OLLAMA_CHAT_MODEL = chatModel;
-    const gitignorePath2 = join6(process.cwd(), ".gitignore");
-    const gitignore = existsSync6(gitignorePath2) ? readFileSync6(gitignorePath2, "utf-8") : "";
-    if (!gitignore.includes(".memory-core.env")) {
-      appendFileSync(gitignorePath2, `${gitignore ? "\n" : ""}.memory-core.env
-`);
-    }
+    const ollamaUrl = DEFAULT_OLLAMA_URL;
+    const chatModel = DEFAULT_CHAT_MODEL;
+    const envValues = {
+      DATABASE_URL: dbUrl,
+      OLLAMA_URL: ollamaUrl,
+      OLLAMA_MODEL: DEFAULT_EMBEDDING_MODEL,
+      CHAT_PROVIDER: "ollama",
+      CHAT_MODEL: chatModel,
+      OLLAMA_CHAT_MODEL: chatModel
+    };
+    writeRuntimeEnv(envValues, envPath);
+    applyRuntimeEnv(envValues);
+    ensureEnvFileIgnored(envPath);
     console.log(chalk3.green("  \u2713 .memory-core.env created with local defaults"));
   } else if (!hasEnv) {
     console.log(chalk3.dim("  No .memory-core.env found \u2014 let's set up your connection.\n"));
@@ -1889,33 +2140,18 @@ program.command("init").description("Initialize memory-core in the current proje
       });
       console.log(chalk3.green(`  \u2713 ${chatProvider} / ${chatModel} configured`));
     }
-    const envLines = [
-      `DATABASE_URL=${dbUrl}`,
-      `OLLAMA_URL=${ollamaUrl}`,
-      `OLLAMA_MODEL=nomic-embed-text`,
-      `CHAT_PROVIDER=${chatProvider}`,
-      `CHAT_MODEL=${chatModel}`
-    ];
-    if (chatProvider === "ollama") envLines.push(`OLLAMA_CHAT_MODEL=${chatModel}`);
-    if (chatApiKey) envLines.push(`CHAT_API_KEY=${chatApiKey}`);
-    const envContent = envLines.join("\n") + "\n";
-    writeFileSync5(envPath, envContent);
-    process.env.DATABASE_URL = dbUrl;
-    process.env.OLLAMA_URL = ollamaUrl;
-    process.env.OLLAMA_MODEL = "nomic-embed-text";
-    process.env.CHAT_PROVIDER = chatProvider;
-    process.env.CHAT_MODEL = chatModel;
-    if (chatProvider === "ollama") process.env.OLLAMA_CHAT_MODEL = chatModel;
-    if (chatApiKey) process.env.CHAT_API_KEY = chatApiKey;
-    const gitignorePath2 = join6(process.cwd(), ".gitignore");
-    if (existsSync6(gitignorePath2)) {
-      const gi = readFileSync6(gitignorePath2, "utf-8");
-      if (!gi.includes(".memory-core.env")) {
-        appendFileSync(gitignorePath2, "\n.memory-core.env\n");
-      }
-    } else {
-      writeFileSync5(gitignorePath2, ".memory-core.env\n");
-    }
+    const envValues = {
+      DATABASE_URL: dbUrl,
+      OLLAMA_URL: ollamaUrl,
+      OLLAMA_MODEL: DEFAULT_EMBEDDING_MODEL,
+      CHAT_PROVIDER: chatProvider,
+      CHAT_MODEL: chatModel
+    };
+    if (chatProvider === "ollama") envValues.OLLAMA_CHAT_MODEL = chatModel;
+    if (chatApiKey) envValues.CHAT_API_KEY = chatApiKey;
+    writeRuntimeEnv(envValues, envPath);
+    applyRuntimeEnv(envValues);
+    ensureEnvFileIgnored(envPath);
     console.log(chalk3.green("\n  \u2713 .memory-core.env created"));
     console.log(chalk3.gray("    Added to .gitignore \u2014 your DB credentials stay local.\n"));
   }
@@ -2617,6 +2853,82 @@ read:
   console.log(chalk3.bold("\n  Every AI agent now follows your memory globally.\n"));
   await closePool();
 });
+var provider = program.command("provider").description("Manage the code-checking provider configuration");
+provider.command("set <name>").description("Set the code-checking provider (ollama, openai, anthropic, minimax)").option("--model <model>", "Chat model to set alongside the provider").option("--api-key <key>", "API key for cloud providers").action(async (name, opts) => {
+  try {
+    const providerName = normalizeProvider(name);
+    const runtimeEnv = readRuntimeEnv();
+    const values = { ...runtimeEnv.values };
+    values.CHAT_PROVIDER = providerName;
+    values.OLLAMA_URL = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+    values.OLLAMA_MODEL = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+    if (opts.model) {
+      values.CHAT_MODEL = opts.model;
+    } else if (!values.CHAT_MODEL && !values.OLLAMA_CHAT_MODEL) {
+      values.CHAT_MODEL = DEFAULT_CHAT_MODEL;
+    }
+    if (providerName === "ollama") {
+      const model2 = values.CHAT_MODEL ?? values.OLLAMA_CHAT_MODEL ?? DEFAULT_CHAT_MODEL;
+      values.CHAT_MODEL = model2;
+      values.OLLAMA_CHAT_MODEL = model2;
+      delete values.CHAT_API_KEY;
+    } else {
+      delete values.OLLAMA_CHAT_MODEL;
+      if (opts.apiKey) {
+        values.CHAT_API_KEY = opts.apiKey;
+      } else if (!values.CHAT_API_KEY) {
+        values.CHAT_API_KEY = await input({
+          message: `${providerLabel(providerName)} API key?`
+        });
+      }
+    }
+    writeRuntimeEnv(values, runtimeEnv.envPath);
+    applyRuntimeEnv(values);
+    ensureEnvFileIgnored(runtimeEnv.envPath);
+    console.log(chalk3.green(`Updated provider: ${providerName}`));
+    console.log(chalk3.gray(`  Chat model: ${getConfiguredChatModel(values)}`));
+  } catch (err) {
+    console.error(chalk3.red(`Provider update failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+var model = program.command("model").description("Manage code-checking and embedding models");
+model.command("set <name>").description("Set the chat model used for code checking").option("--provider <provider>", "Override provider while setting the model").option("--embedding", "Set the embedding model instead of the chat model").action(async (name, opts) => {
+  try {
+    const runtimeEnv = readRuntimeEnv();
+    const values = { ...runtimeEnv.values };
+    if (opts.provider) values.CHAT_PROVIDER = normalizeProvider(opts.provider);
+    const providerName = getConfiguredProvider(values);
+    if (opts.embedding) {
+      values.OLLAMA_MODEL = name;
+    } else {
+      values.CHAT_MODEL = name;
+      if (providerName === "ollama") values.OLLAMA_CHAT_MODEL = name;
+    }
+    values.OLLAMA_URL = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+    values.OLLAMA_MODEL = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+    writeRuntimeEnv(values, runtimeEnv.envPath);
+    applyRuntimeEnv(values);
+    ensureEnvFileIgnored(runtimeEnv.envPath);
+    console.log(chalk3.green(`Updated ${opts.embedding ? "embedding" : "chat"} model: ${name}`));
+    console.log(chalk3.gray(`  Provider: ${providerName}`));
+  } catch (err) {
+    console.error(chalk3.red(`Model update failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+model.command("doctor").description("Verify provider, model, database, and Ollama setup").action(async () => {
+  const result = await runModelDoctor();
+  if (!result.ok) process.exit(1);
+});
+program.command("status").description("Show the current memory-core project and runtime setup").action(async () => {
+  try {
+    await printProjectStatus();
+  } catch (err) {
+    console.error(chalk3.red(`Status failed: ${err.message}`));
+    process.exit(1);
+  }
+});
 var hook = program.command("hook").description("Manage the pre-commit rule enforcement hook");
 hook.command("install").description("Install pre-commit hook (advisory mode by default \u2014 logs violations, never blocks)").option("--advisory", "Log violations but never block commits (default)").option("--strict", "Block commits that violate your rules").action((opts) => {
   const advisory = opts.strict ? false : true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
   "type": "module",
   "bin": {