@shahmilsaari/memory-core 0.2.8 → 0.2.11

package/README.md

@@ -8,7 +8,7 @@ You decide the architecture. memory-core remembers it. Every AI tool — Copilot
 npx @shahmilsaari/memory-core init
 ```
 
-No OpenAI key. No cloud. Fully local.
+Fully local or cloud — your choice. **v0.2.10**
 
 ---
 
@@ -18,10 +18,10 @@ Without memory-core, every AI agent starts fresh. It doesn't know you're using C
 
 With memory-core:
 
-1. You run `init` once — it verifies your PostgreSQL and Ollama connections, picks your model, and generates config files for every AI agent
+1. You run `init` once — it verifies your PostgreSQL and Ollama connections, picks your model, lets you choose which agents to generate files for, and installs a pre-commit hook
 2. Those agents read the files and follow your rules — automatically
 3. Watch mode catches violations as you type, not just at commit time
-4. When you commit, Claude Code automatically checks your code before the commit goes through
+4. When you commit, the hook checks your code before the commit goes through (advisory by default — logs violations but never blocks)
 
 ---
 
@@ -152,7 +152,7 @@ CREATE INDEX IF NOT EXISTS memories_scope_idx ON memories (scope);
 # 1. Go to your project
 cd my-api
 
-# 2. Initialize — verifies connections, picks your model, generates all config files
+# 2. Initialize — verifies connections, picks your model, generates config files
 npx @shahmilsaari/memory-core init
 
 # 3. Load 281 predefined best-practice rules
@@ -173,18 +173,36 @@ npx @shahmilsaari/memory-core init
 
 Walks you through:
 - PostgreSQL connection URL — **tested live, retries until connected**
-- Ollama URL — **tested live, retries until reachable**
-- Code-checking model — **verified to be installed in your Ollama**
+- Ollama URL — **tested live, retries until reachable** (used for embeddings)
+- Code-checking provider — **Ollama (local), OpenAI, Anthropic, or MiniMax**
+- Code-checking model — picked from a list, verified before continuing
 - Project name, type, architecture, language
-- Whether to enable the pre-commit hook (asked during setup — no separate step needed)
+- Which agents to generate files for — **multi-select, all pre-checked, Space to deselect** — saved to `.memory-core.json`
+- Hook mode — **advisory** (logs violations, never blocks) or **strict** (blocks commits)
 - Whether to enable caveman mode (optional token saver)
 
-Generates config files for every supported AI agent and saves your choices to `.memory-core.json`.
+Generates config files for every selected AI agent, saves your choices to `.memory-core.json`, and automatically adds all generated files to `.gitignore` under a `# memory-core generated files` block.
 
 At the end, the banner shows live ✓/✗ status for PostgreSQL and Ollama so you know everything is working.
 
 ---
 
+### `sync` — Refresh all agent files
+
+After saving new memories, regenerate every agent file to include them.
+
+```bash
+npx @shahmilsaari/memory-core sync
+```
+
+Multi-selects which agents to sync (pre-checked from your `.memory-core.json` config). Skips files that haven't changed and reports how many were updated vs already up to date:
+
+```
+  3 updated, 11 already up to date
+```
+
+---
+
 ### `remember` — Save a decision
 
 Made a decision your team should never forget? Save it.
@@ -213,16 +231,6 @@ npx @shahmilsaari/memory-core remember "Use DTOs for all API responses" \
 
 ---
 
-### `sync` — Refresh all agent files
-
-After saving new memories, regenerate every agent file to include them.
-
-```bash
-npx @shahmilsaari/memory-core sync
-```
-
----
-
 ### `search` — Find a rule or decision
 
 ```bash
@@ -246,17 +254,67 @@ npx @shahmilsaari/memory-core seed --force                     # re-seed existin
 
 ---
 
-### `hook install` — Block bad commits
+### `watch` — Catch violations as you type
 
 ```bash
-npx @shahmilsaari/memory-core hook install
+npx @shahmilsaari/memory-core watch
 ```
 
-Installs a git pre-commit hook in the current project. Every time you run `git commit`, your code is checked against your architecture rules before the commit goes through.
+Runs in the background and checks each file the moment you save it. You see violations immediately — before you even think about committing.
 
-> **Note:** If you use Claude Code, the hook is offered automatically during `init` — no separate step needed.
+```
+  archmind watch — real-time rule enforcement
 
-When a violation is found, the commit is blocked and you see exactly what's wrong and how to fix it:
+  watching: /your/project
+  model:    llama3.2
+  rules:    24
+  ctrl+c to stop
+
+  [10:42:11] saved: src/controllers/user.ts
+
+  ✗ 1 violation in src/controllers/user.ts
+
+  [1] src/controllers/user.ts:34
+      Rule:   Thin controllers — business logic belongs in services
+      Why:    Logic in controllers cannot be reused from other entry points
+      Issue:  Password hashing inside the route handler
+      Fix:    Move to UserService.hashPassword()
+```
+
+Options:
+```bash
+npx @shahmilsaari/memory-core watch --path src/   # watch a specific folder only
+npx @shahmilsaari/memory-core watch --verbose     # show extra details
+```
+
+Only checks source files — ignores `node_modules`, `dist`, config files, JSON, etc.
+
+---
+
+### `check` — Manual check (for CI)
+
+```bash
+npx @shahmilsaari/memory-core check --staged           # check staged files
+npx @shahmilsaari/memory-core check --staged --verbose # with extra detail
+```
+
+Same as the pre-commit hook. Use this in CI/CD pipelines.
+
+---
+
+### `hook install` — Install the pre-commit hook
+
+```bash
+npx @shahmilsaari/memory-core hook install             # advisory mode (default)
+npx @shahmilsaari/memory-core hook install --advisory  # logs violations, never blocks
+npx @shahmilsaari/memory-core hook install --strict    # blocks commits on violations
+```
+
+Installs a git pre-commit hook in the current project. Every time you run `git commit`, your code is checked against your architecture rules.
+
+**Advisory mode (default):** violations are logged so you can see them, but the commit always goes through. Useful for getting used to the rules without disrupting your flow.
+
+**Strict mode:** violations block the commit entirely. You see exactly what's wrong and how to fix it:
 
 ```
   ✗ 2 rule violations found — commit blocked
@@ -278,57 +336,130 @@ When a violation is found, the commit is blocked and you see exactly what's wron
   To save as memory: memory-core remember "<lesson>"
 ```
 
+The hook mode is chosen during `init` — no separate step needed unless you want to change it later.
+
 ```bash
 npx @shahmilsaari/memory-core hook uninstall   # remove the hook
 ```
 
 ---
 
-### `watch` — Catch violations as you type
+### `list` — List memories from the database
 
 ```bash
-npx @shahmilsaari/memory-core watch
+npx @shahmilsaari/memory-core list
 ```
 
-Runs in the background and checks each file the moment you save it. You see violations immediately — before you even think about committing.
+Shows all stored memories. Filter the results:
 
+```bash
+npx @shahmilsaari/memory-core list --type rule
+npx @shahmilsaari/memory-core list --scope global
+npx @shahmilsaari/memory-core list --arch clean-architecture
+npx @shahmilsaari/memory-core list --limit 50
 ```
-  archmind watch — real-time rule enforcement
 
-  watching: /your/project
-  model:    llama3.2
-  rules:    24
-  ctrl+c to stop
+| Flag | What it does |
+|---|---|
+| `--type <type>` | Filter by type: `decision` `rule` `pattern` `note` |
+| `--scope <scope>` | Filter by scope: `global` `project` |
+| `--arch <architecture>` | Filter by architecture profile |
+| `--limit <n>` | Max results (default 200) |
 
-  [10:42:11] saved: src/controllers/user.ts
+---
 
-  ✗ 1 violation in src/controllers/user.ts
+### `remove` — Delete a memory
 
-  [1] src/controllers/user.ts:34
-      Rule:   Thin controllers — business logic belongs in services
-      Why:    Logic in controllers cannot be reused from other entry points
-      Issue:  Password hashing inside the route handler
-      Fix:    Move to UserService.hashPassword()
+```bash
+npx @shahmilsaari/memory-core remove <id>
 ```
 
-Options:
+Deletes a memory by its ID. Get the ID from `list` or `search`.
+
+---
+
+### `edit` — Edit a memory
+
 ```bash
-npx @shahmilsaari/memory-core watch --path src/   # watch a specific folder only
-npx @shahmilsaari/memory-core watch --verbose     # show extra details
+npx @shahmilsaari/memory-core edit <id>
 ```
 
-Only checks source files — ignores `node_modules`, `dist`, config files, JSON, etc.
+Opens the memory interactively so you can update its content, reason, tags, type, or scope.
 
 ---
 
-### `check` — Manual check (for CI)
+### `export` — Export memories to a file
 
 ```bash
-npx @shahmilsaari/memory-core check --staged           # check staged files
-npx @shahmilsaari/memory-core check --staged --verbose # with extra detail
+npx @shahmilsaari/memory-core export
+npx @shahmilsaari/memory-core export --output path/to/my-rules.json
 ```
 
-Same as the pre-commit hook. Use this in CI/CD pipelines.
+Exports all memories from the database to `memories.json` in the project root (or the path you specify). Makes your rules portable and version-controllable — commit the file alongside your code.
+
+---
+
+### `import` — Import memories from a file
+
+```bash
+npx @shahmilsaari/memory-core import
+npx @shahmilsaari/memory-core import --file path/to/my-rules.json
+npx @shahmilsaari/memory-core import --url https://example.com/team-rules.json
+```
+
+Imports memories into the local database. Skips duplicates by content hash — safe to run more than once.
+
+| Flag | What it does |
+|---|---|
+| `--file <path>` | Import from a custom local file path |
+| `--url <url>` | Import from a remote URL |
+
+---
+
+### `ignore` — Mark false positives
+
+```bash
+npx @shahmilsaari/memory-core ignore "controllers may import prisma directly in migration scripts"
+```
+
+Saves a pattern so the hook and watcher never flag it again. Useful for intentional exceptions to a rule.
+
+```bash
+npx @shahmilsaari/memory-core ignore --list          # show all saved ignore patterns
+npx @shahmilsaari/memory-core ignore --remove <id>   # delete an ignore pattern
+```
+
+---
+
+### `ci-setup` — GitHub Actions integration
+
+```bash
+npx @shahmilsaari/memory-core ci-setup
+```
+
+Generates `.github/workflows/memory-core.yml`. Adds a PR check that runs your architecture rules on every pull request — same checks as the local hook, enforced in CI.
+
+---
+
+### `stats` — Violation counters
+
+```bash
+npx @shahmilsaari/memory-core stats
+```
+
+Shows which rules fire most often and which files have the most violations. Useful for spotting systemic issues in the codebase.
+
+---
+
+### `reset` — Remove all generated files
+
+```bash
+npx @shahmilsaari/memory-core reset              # remove all generated files + .memory-core.json
+npx @shahmilsaari/memory-core reset --soft       # keep config and DB, remove only generated files
+npx @shahmilsaari/memory-core reset --db         # also drop the memories table from the database
+```
+
+Cleans up everything memory-core created. Use `--soft` if you want to re-run `init` without losing your saved memories.
 
 ---
 
@@ -387,7 +518,7 @@ Pick the one that matches how your project is structured.
 | Modular Monolith | You're building feature modules that might become microservices later |
 | MVC | Standard web app with controllers and services |
 | Hexagonal | You want ports and adapters for maximum testability |
-| Next.js | Next.js 13+ with server components and server actions |
+| Go REST API | Go backend API with idiomatic error handling and clean package structure |
 | Laravel | Laravel with service-repository pattern |
 | NestJS | Modules, guards, pipes, DTOs, repository pattern |
 
@@ -422,7 +553,7 @@ Cuts AI response length by 65–75% by removing filler words. Opt in during `ini
 ```bash
 # Starting a new project
 cd my-api
-npx @shahmilsaari/memory-core init   # verifies connections, picks model, installs hook
+npx @shahmilsaari/memory-core init   # verifies connections, picks model, selects agents, installs hook
 npx @shahmilsaari/memory-core seed   # load 281 best-practice rules
 
 # Made an architectural decision? Save it.
@@ -435,7 +566,13 @@ npx @shahmilsaari/memory-core sync
 # Not sure how something was decided? Search.
 npx @shahmilsaari/memory-core search "caching strategy"
 
-# Commit code → Claude Code checks it automatically before committing
+# See what rules are saved
+npx @shahmilsaari/memory-core list --type rule
+
+# Export rules to version control
+npx @shahmilsaari/memory-core export
+
+# Commit code → hook checks it automatically before committing
 git commit -m "add user endpoint"
 ```
 
@@ -448,9 +585,12 @@ memory-core creates `.memory-core.env` automatically during `init`. You can also
 | Variable | Required | Default | What it does |
 |---|---|---|---|
 | `DATABASE_URL` | Yes | — | PostgreSQL connection string |
-| `OLLAMA_URL` | No | `http://localhost:11434` | Where Ollama is running |
-| `OLLAMA_MODEL` | No | `nomic-embed-text` | Model used for search (embeddings) |
-| `OLLAMA_CHAT_MODEL` | No | `llama3.2` | Model used for code checking — chosen during `init` |
+| `OLLAMA_URL` | No | `http://localhost:11434` | Where Ollama is running (used for embeddings) |
+| `OLLAMA_MODEL` | No | `nomic-embed-text` | Model used for search (embeddings) — always Ollama |
+| `CHAT_PROVIDER` | No | `ollama` | Provider for code checking: `ollama`, `openai`, `anthropic`, `minimax` |
+| `CHAT_MODEL` | No | `llama3.2` | Model used for code checking — chosen during `init` |
+| `CHAT_API_KEY` | No | — | API key for OpenAI / Anthropic / MiniMax (not needed for Ollama) |
+| `OLLAMA_CHAT_MODEL` | No | `llama3.2` | Legacy alias for `CHAT_MODEL` when provider is `ollama` |
 
 ---
 
@@ -463,7 +603,16 @@ 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 to another model: add `OLLAMA_CHAT_MODEL=mistral` to `.memory-core.env`.
+Run `ollama pull llama3.2`. Or switch provider/model by updating `CHAT_PROVIDER` and `CHAT_MODEL` in `.memory-core.env`.
+
+**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`:
+```
+CHAT_PROVIDER=openai
+CHAT_MODEL=gpt-4o
+CHAT_API_KEY=sk-...
+```
+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.
@@ -476,6 +625,9 @@ createuser -s $(whoami)
 **Hook is flagging JSON or config files**
 It won't — the hook only checks source code files: `.ts .tsx .js .jsx .py .php .rb .go .java .cs .swift .kt .rs .vue .svelte`. Everything else is skipped automatically.
 
+**Hook is flagging something that's intentional**
+Save an ignore pattern: `npx @shahmilsaari/memory-core ignore "your exception here"`. The hook and watcher will never flag it again.
+
 ---
 
 ## Roadmap
@@ -487,11 +639,22 @@ It won't — the hook only checks source code files: `.ts .tsx .js .jsx .py .php
 | ✓ | Connection validation — PostgreSQL and Ollama verified during setup |
 | ✓ | Svelte 5 / SvelteKit profile and 37 rules |
 | ✓ | NestJS profile and 39 rules |
-| | CI/CD — fail PRs that violate your rules |
-| | Violation memory — auto-save what went wrong as a new rule |
-| | Rule analytics — see which rules get broken most |
-| | Team sync — share memory across your whole team |
-| | Memory review — approve rules before they propagate |
+| ✓ | Hook auto-prompt — hook mode offered during init, no separate step needed |
+| ✓ | CI/CD — `ci-setup` generates GitHub Actions workflow for PR enforcement |
+| ✓ | Violation stats — see which rules fire most and which files break most |
+| ✓ | Agent selection — choose which agents to generate files for during init |
+| ✓ | Export / import — portable memories.json for version control and team sharing |
+| ✓ | 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 |
+| ✓ | Multi-provider code checking — Ollama, OpenAI, Anthropic, MiniMax |
+| | Context-aware retrieval — surface the most relevant rules for the file being edited |
+| | 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/chunk-73SRPNAL.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import {
+  Config
+} from "./chunk-KSLFLWB4.js";
+
+// src/db.ts
+import pg from "pg";
+import { createHash } from "crypto";
+var { Pool } = pg;
+var pool = null;
+var migrationsRun = false;
+function hashMemoryContent(content) {
+  return createHash("md5").update(content.trim()).digest("hex");
+}
+function getPool() {
+  if (!pool) {
+    if (!Config.databaseUrl) {
+      throw new Error("DATABASE_URL is not set. Add it to your .env or .memory-core.env file.");
+    }
+    pool = new Pool({ connectionString: Config.databaseUrl });
+  }
+  return pool;
+}
+async function runMigrations() {
+  if (migrationsRun) return;
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS reason TEXT`);
+    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS content_hash TEXT`);
+    await client.query(
+      `UPDATE memories
+       SET content_hash = md5(trim(content))
+       WHERE content_hash IS NULL`
+    );
+    await client.query(`CREATE INDEX IF NOT EXISTS memories_content_hash_idx ON memories (content_hash)`);
+    await client.query("COMMIT");
+    migrationsRun = true;
+  } catch (err) {
+    await client.query("ROLLBACK");
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+async function saveMemory(memory) {
+  await runMigrations();
+  const { type, scope, architecture, projectName, title, content, reason, tags, embedding } = memory;
+  const contentHash = hashMemoryContent(content);
+  await getPool().query(
+    `INSERT INTO memories (type, scope, architecture, project_name, title, content, reason, tags, embedding, content_hash)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+    [type, scope, architecture ?? null, projectName ?? null, title ?? null, content, reason ?? null, tags ?? [], `[${embedding.join(",")}]`, contentHash]
+  );
+}
+async function upsertMemory(memory) {
+  await runMigrations();
+  const contentHash = hashMemoryContent(memory.content);
+  const existing = await getPool().query(
+    `SELECT id FROM memories
+     WHERE content_hash = $1
+       AND COALESCE(architecture, '') = COALESCE($2, '')
+       AND scope = $3
+       AND type = $4
+     LIMIT 1`,
+    [contentHash, memory.architecture ?? null, memory.scope, memory.type]
+  );
+  if (existing.rowCount) return "skipped";
+  await saveMemory(memory);
+  return "inserted";
+}
+async function listMemories(filters = {}) {
+  await runMigrations();
+  const where = [];
+  const params = [];
+  if (filters.type) {
+    params.push(filters.type);
+    where.push(`type = $${params.length}`);
+  }
+  if (filters.scope) {
+    params.push(filters.scope);
+    where.push(`scope = $${params.length}`);
+  }
+  if (filters.architecture) {
+    params.push(filters.architecture);
+    where.push(`architecture = $${params.length}`);
+  }
+  const limit = filters.limit ?? 200;
+  params.push(limit);
+  const result = await getPool().query(
+    `SELECT id, type, scope, architecture, project_name, title, content, reason, tags, content_hash
+     FROM memories
+     ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+     ORDER BY id ASC
+     LIMIT $${params.length}`,
+    params
+  );
+  return result.rows;
+}
+async function getMemory(id) {
+  await runMigrations();
+  const result = await getPool().query(
+    `SELECT id, type, scope, architecture, project_name, title, content, reason, tags, content_hash
+     FROM memories
+     WHERE id = $1`,
+    [id]
+  );
+  return result.rows[0] ?? null;
+}
+async function deleteMemory(id) {
+  await runMigrations();
+  const result = await getPool().query(`DELETE FROM memories WHERE id = $1`, [id]);
+  return (result.rowCount ?? 0) > 0;
+}
+async function updateMemory(id, patch) {
+  await runMigrations();
+  const current = await getMemory(id);
+  if (!current) return null;
+  const content = patch.content ?? current.content;
+  const contentHash = hashMemoryContent(content);
+  const embedding = patch.embedding ? `[${patch.embedding.join(",")}]` : null;
+  const result = await getPool().query(
+    `UPDATE memories
+     SET type = $2,
+         scope = $3,
+         title = $4,
+         content = $5,
+         reason = $6,
+         tags = $7,
+         content_hash = $8,
+         embedding = COALESCE($9::vector, embedding)
+     WHERE id = $1
+     RETURNING id, type, scope, architecture, project_name, title, content, reason, tags, content_hash`,
+    [
+      id,
+      patch.type ?? current.type,
+      patch.scope ?? current.scope,
+      patch.title ?? current.title ?? null,
+      content,
+      patch.reason ?? current.reason ?? null,
+      patch.tags ?? current.tags ?? [],
+      contentHash,
+      embedding
+    ]
+  );
+  return result.rows[0] ?? null;
+}
+async function searchMemories(embedding, architecture, limit = 10) {
+  await runMigrations();
+  const vector = `[${embedding.join(",")}]`;
+  const params = [vector];
+  let whereClause = "";
+  if (architecture) {
+    whereClause = `WHERE (architecture = $2 OR scope = 'global')`;
+    params.push(architecture);
+  }
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    await client.query("SET LOCAL ivfflat.probes = 10");
+    const result = await client.query(
+      `SELECT id, type, scope, architecture, project_name, title, content, reason, tags,
+              1 - (embedding <=> $1) AS similarity
+       FROM memories
+       ${whereClause}
+       ORDER BY embedding <=> $1
+       LIMIT $${params.length + 1}`,
+      [...params, limit]
+    );
+    await client.query("COMMIT");
+    return result.rows;
+  } finally {
+    client.release();
+  }
+}
+async function closePool() {
+  if (pool) {
+    await pool.end();
+    pool = null;
+    migrationsRun = false;
+  }
+}
+
+export {
+  hashMemoryContent,
+  getPool,
+  runMigrations,
+  saveMemory,
+  upsertMemory,
+  listMemories,
+  getMemory,
+  deleteMemory,
+  updateMemory,
+  searchMemories,
+  closePool
+};

package/dist/chunk-HAGRPKR3.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  Config
+} from "./chunk-KSLFLWB4.js";
+
+// src/embedding.ts
+async function embed(text) {
+  let response;
+  try {
+    response = await fetch(`${Config.ollamaUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: Config.ollamaModel, prompt: text })
+    });
+  } catch {
+    throw new Error(
+      `Cannot reach Ollama at ${Config.ollamaUrl}. Run: ollama serve`
+    );
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Ollama embedding failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  return data.embedding;
+}
+
+export {
+  embed
+};

package/dist/chunk-KSLFLWB4.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { config } from "dotenv";
+import { existsSync } from "fs";
+import { join } from "path";
+var localEnv = join(process.cwd(), ".memory-core.env");
+config({ path: existsSync(localEnv) ? localEnv : join(process.cwd(), ".env") });
+var Config = {
+  get databaseUrl() {
+    return process.env.DATABASE_URL ?? "";
+  },
+  get ollamaUrl() {
+    return process.env.OLLAMA_URL ?? "http://localhost:11434";
+  },
+  get ollamaModel() {
+    return process.env.OLLAMA_MODEL ?? "nomic-embed-text";
+  },
+  get chatModel() {
+    return process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+  },
+  get chatProvider() {
+    return process.env.CHAT_PROVIDER ?? "ollama";
+  },
+  get chatApiKey() {
+    return process.env.CHAT_API_KEY ?? "";
+  }
+};
+
+export {
+  Config
+};