@gresmcp/mcp 1.0.0

package/dist/cli.js

@@ -0,0 +1,1103 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+function databaseUrl() {
+  return process.env.GRESMCP_DATABASE_URL || DEFAULT_DATABASE_URL;
+}
+function normalizeUrl(url) {
+  return url.replace(/\/+$/, "");
+}
+function ollamaUrl(override) {
+  const raw = override || process.env.GRESMCP_OLLAMA_URL || DEFAULT_OLLAMA_URL;
+  return normalizeUrl(raw);
+}
+var DEFAULT_DATABASE_URL, DEFAULT_OLLAMA_URL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    DEFAULT_DATABASE_URL = "postgresql://gres:gres@localhost/gres";
+    DEFAULT_OLLAMA_URL = "http://localhost:11434";
+  }
+});
+
+// src/db.ts
+var db_exports = {};
+__export(db_exports, {
+  assertTableName: () => assertTableName,
+  closePool: () => closePool,
+  contentHash: () => contentHash,
+  countEntries: () => countEntries,
+  createKs: () => createKs,
+  deleteBySource: () => deleteBySource,
+  deleteKs: () => deleteKs,
+  ensureEntryTable: () => ensureEntryTable,
+  entryTableName: () => entryTableName,
+  getKs: () => getKs,
+  getPool: () => getPool,
+  initDb: () => initDb,
+  insertChunks: () => insertChunks,
+  listKs: () => listKs,
+  sourceChunkHashes: () => sourceChunkHashes,
+  updateKs: () => updateKs
+});
+import { Pool } from "pg";
+import { toSql } from "pgvector";
+import { createHash } from "crypto";
+function getPool() {
+  if (!pool) {
+    pool = new Pool({ connectionString: databaseUrl(), max: 5 });
+  }
+  return pool;
+}
+async function closePool() {
+  if (pool) {
+    await pool.end();
+    pool = void 0;
+  }
+}
+function entryTableName(ks) {
+  const name = `entry_${ks.id.replace(/-/g, "")}`;
+  assertTableName(name);
+  return name;
+}
+function assertTableName(name) {
+  if (!/^entry_[0-9a-f]{32}$/.test(name)) {
+    throw new Error(`Refusing to use unsafe table name: ${name}`);
+  }
+}
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function initDb() {
+  const p = getPool();
+  await p.query(`CREATE EXTENSION IF NOT EXISTS vector`);
+  await p.query(`
+    CREATE TABLE IF NOT EXISTS ks (
+      id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+      name text NOT NULL UNIQUE,
+      description text NOT NULL DEFAULT '',
+      embedding_model text NOT NULL,
+      embedding_dim integer NOT NULL,
+      ollama_url text NOT NULL DEFAULT '${DEFAULT_OLLAMA_URL}',
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+}
+async function createKs(input) {
+  const res = await getPool().query(
+    `INSERT INTO ks (name, description, embedding_model, embedding_dim, ollama_url)
+     VALUES ($1, $2, $3, $4, $5)
+     RETURNING *`,
+    [input.name, input.description ?? "", input.model, input.dim, input.url]
+  );
+  const ks = res.rows[0];
+  await ensureEntryTable(ks);
+  return ks;
+}
+async function listKs() {
+  const res = await getPool().query(`SELECT * FROM ks ORDER BY name`);
+  return res.rows;
+}
+async function getKs(name) {
+  const res = await getPool().query(`SELECT * FROM ks WHERE name = $1`, [name]);
+  return res.rows[0];
+}
+async function updateKs(id, fields) {
+  const sets = [];
+  const params = [];
+  if (fields.name !== void 0) {
+    params.push(fields.name);
+    sets.push(`name = $${params.length}`);
+  }
+  if (fields.description !== void 0) {
+    params.push(fields.description);
+    sets.push(`description = $${params.length}`);
+  }
+  if (fields.ollama_url !== void 0) {
+    params.push(fields.ollama_url);
+    sets.push(`ollama_url = $${params.length}`);
+  }
+  if (sets.length === 0) {
+    const res2 = await getPool().query(`SELECT * FROM ks WHERE id = $1`, [id]);
+    return res2.rows[0];
+  }
+  sets.push(`updated_at = now()`);
+  params.push(id);
+  const res = await getPool().query(
+    `UPDATE ks SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`,
+    params
+  );
+  return res.rows[0];
+}
+async function deleteKs(ks) {
+  const tbl = entryTableName(ks);
+  await getPool().query(`DROP TABLE IF EXISTS ${tbl}`);
+  await getPool().query(`DELETE FROM ks WHERE id = $1`, [ks.id]);
+}
+async function ensureEntryTable(ks) {
+  const tbl = entryTableName(ks);
+  const p = getPool();
+  await p.query(`
+    CREATE TABLE IF NOT EXISTS ${tbl} (
+      id bigserial PRIMARY KEY,
+      source text NOT NULL,
+      title text NOT NULL DEFAULT '',
+      chunk_index integer NOT NULL DEFAULT 0,
+      content text NOT NULL,
+      content_hash text NOT NULL,
+      metadata jsonb NOT NULL DEFAULT '{}',
+      tsv tsvector GENERATED ALWAYS AS (to_tsvector('english', content)) STORED,
+      embedding vector(${ks.embedding_dim}) NOT NULL,
+      created_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  await p.query(`CREATE INDEX IF NOT EXISTS ${tbl}_tsv_idx ON ${tbl} USING gin (tsv)`);
+  await p.query(`CREATE INDEX IF NOT EXISTS ${tbl}_emb_idx ON ${tbl} USING hnsw (embedding vector_cosine_ops)`);
+  await p.query(`CREATE INDEX IF NOT EXISTS ${tbl}_source_idx ON ${tbl} (source)`);
+}
+async function insertChunks(ks, rows) {
+  if (rows.length === 0) return 0;
+  const tbl = entryTableName(ks);
+  const p = getPool();
+  const BATCH = 25;
+  let inserted = 0;
+  for (let i = 0; i < rows.length; i += BATCH) {
+    const batch = rows.slice(i, i + BATCH);
+    const values = [];
+    const params = [];
+    batch.forEach((r, j) => {
+      const b = j * 7;
+      values.push(`($${b + 1}, $${b + 2}, $${b + 3}, $${b + 4}, $${b + 5}, $${b + 6}, $${b + 7}::vector)`);
+      params.push(r.source, r.title, r.chunk_index, r.content, contentHash(r.content), JSON.stringify(r.metadata), toSql(r.embedding));
+    });
+    const res = await p.query(
+      `INSERT INTO ${tbl} (source, title, chunk_index, content, content_hash, metadata, embedding)
+       VALUES ${values.join(", ")}`,
+      params
+    );
+    inserted += res.rowCount ?? 0;
+  }
+  return inserted;
+}
+async function deleteBySource(ks, source) {
+  const tbl = entryTableName(ks);
+  const res = await getPool().query(`DELETE FROM ${tbl} WHERE source = $1`, [source]);
+  return res.rowCount ?? 0;
+}
+async function sourceChunkHashes(ks, source) {
+  const tbl = entryTableName(ks);
+  const res = await getPool().query(
+    `SELECT chunk_index, content_hash FROM ${tbl} WHERE source = $1`,
+    [source]
+  );
+  const map = /* @__PURE__ */ new Map();
+  for (const row of res.rows) {
+    map.set(Number(row.chunk_index), String(row.content_hash));
+  }
+  return map;
+}
+async function countEntries(ks) {
+  const tbl = entryTableName(ks);
+  const res = await getPool().query(`SELECT count(*)::int AS n FROM ${tbl}`);
+  return Number(res.rows[0]?.n ?? 0);
+}
+var pool;
+var init_db = __esm({
+  "src/db.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/cli.ts
+init_db();
+import { Command } from "commander";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/ollama.ts
+init_config();
+var OllamaError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "OllamaError";
+  }
+  status;
+};
+async function embed(baseUrl, model, inputs, timeoutMs = 12e4) {
+  const url = `${normalizeUrl(baseUrl)}/api/embed`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, input: inputs }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    throw new OllamaError(
+      `Cannot reach Ollama at ${normalizeUrl(baseUrl)} (${err instanceof Error ? err.message : err})`
+    );
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new OllamaError(`Ollama returned ${res.status} for ${url}: ${body.slice(0, 300)}`, res.status);
+  }
+  const data = await res.json();
+  if (data.error) {
+    throw new OllamaError(`Ollama error: ${data.error}`);
+  }
+  if (!Array.isArray(data.embeddings) || data.embeddings.length !== inputs.length) {
+    throw new OllamaError(`Unexpected response shape from ${url}`);
+  }
+  return data.embeddings;
+}
+async function embedBatch(baseUrl, model, inputs, batchSize = 32, onProgress) {
+  const out = [];
+  let done = 0;
+  for (let i = 0; i < inputs.length; i += batchSize) {
+    const batch = inputs.slice(i, i + batchSize);
+    const embs = await embed(baseUrl, model, batch);
+    out.push(...embs);
+    done += batch.length;
+    onProgress?.(done, inputs.length);
+  }
+  return out;
+}
+async function probeModel(baseUrl, model) {
+  const embs = await embed(baseUrl, model, ["gresmcp dimension probe"], 3e4);
+  const first = embs[0];
+  if (!first || first.length === 0) {
+    throw new OllamaError(`Ollama returned an empty embedding for model ${model}`);
+  }
+  return { dim: first.length };
+}
+
+// src/cli.ts
+init_config();
+
+// src/ingest.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/chunk.ts
+var HEADING_RE = /^(#{1,6})\s+(.+)$/;
+function splitBlocks(text) {
+  return text.split(/\n{2,}/).map((b) => b.trim()).filter((b) => b.length > 0);
+}
+function cutPoint(slice) {
+  const nl = slice.lastIndexOf("\n");
+  if (nl > slice.length * 0.5) return nl + 1;
+  const dot = slice.lastIndexOf(". ");
+  if (dot > slice.length * 0.5) return dot + 1;
+  const sp = slice.lastIndexOf(" ");
+  if (sp > slice.length * 0.5) return sp + 1;
+  return slice.length;
+}
+function hardSplit(block, maxLen, overlap) {
+  const parts = [];
+  let pos = 0;
+  while (pos < block.length) {
+    const end = Math.min(pos + maxLen, block.length);
+    let slice = block.slice(pos, end);
+    if (end < block.length) {
+      const cut = cutPoint(slice);
+      slice = slice.slice(0, cut);
+    }
+    parts.push(slice.trim());
+    if (end >= block.length) break;
+    const advanced = Math.max(slice.length - overlap, 1);
+    pos += advanced;
+  }
+  return parts.filter((p) => p.length > 0);
+}
+function packBlocks(blocks, maxLen, overlap) {
+  const pieces = [];
+  let current = "";
+  for (const block of blocks) {
+    const expanded = block.length > maxLen ? hardSplit(block, maxLen, overlap) : [block];
+    for (const part of expanded) {
+      if (!current) {
+        current = part;
+      } else if (current.length + 2 + part.length <= maxLen) {
+        current += "\n\n" + part;
+      } else {
+        pieces.push(current);
+        const tail = overlap > 0 && current.length > overlap ? current.slice(current.length - overlap).replace(/^\S+\s+/, "") : "";
+        current = tail ? tail + "\n\n" + part : part;
+      }
+    }
+  }
+  if (current) pieces.push(current);
+  return pieces;
+}
+function chunkMarkdown(text, opts = {}) {
+  const maxLen = opts.maxLen ?? 1200;
+  const overlap = Math.min(opts.overlap ?? 180, Math.floor(maxLen / 4));
+  const norm = text.replace(/\r\n?/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (!norm) return [];
+  const lines = norm.split("\n");
+  const sections = [{ path: [], body: [] }];
+  for (const line of lines) {
+    const m = HEADING_RE.exec(line);
+    if (m) {
+      const level = m[1].length;
+      const path2 = sections[sections.length - 1].path;
+      const parent = path2.slice(0, level - 1);
+      sections.push({ path: [...parent, m[2].trim()], body: [line] });
+    } else {
+      sections[sections.length - 1].body.push(line);
+    }
+  }
+  const pieces = [];
+  for (const s of sections) {
+    const body = s.body.join("\n").trim();
+    if (!body) continue;
+    const context = s.path.length > 0 ? s.path.join(" > ") + "\n" : "";
+    const packed = packBlocks(splitBlocks(body), maxLen, overlap);
+    packed.forEach((piece, i) => {
+      pieces.push(i === 0 || !context ? piece : context + piece);
+    });
+  }
+  return pieces.map((content, index) => ({ index, content }));
+}
+function chunkPlain(text, opts = {}) {
+  const maxLen = opts.maxLen ?? 1200;
+  const overlap = Math.min(opts.overlap ?? 180, Math.floor(maxLen / 4));
+  const norm = text.replace(/\r\n?/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (!norm) return [];
+  const pieces = packBlocks(splitBlocks(norm), maxLen, overlap);
+  return pieces.map((content, index) => ({ index, content }));
+}
+function mdTitle(text) {
+  const m = /^#\s+(.+)\s*$/m.exec(text);
+  return m ? m[1].trim() : void 0;
+}
+
+// src/html.ts
+import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
+import gfmModule from "turndown-plugin-gfm";
+var gfm = typeof gfmModule === "function" ? gfmModule : gfmModule.gfm;
+var REMOVE_SELECTORS = "script, style, noscript, template, iframe, svg, nav, footer, aside, form, button";
+var service;
+function turndown() {
+  if (!service) {
+    service = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    if (typeof gfm === "function") {
+      service.use(gfm);
+    }
+    service.remove(["button"]);
+  }
+  return service;
+}
+function htmlToMarkdown(html) {
+  const dom = new JSDOM(html);
+  const doc = dom.window.document;
+  doc.querySelectorAll(REMOVE_SELECTORS).forEach((el) => el.remove());
+  const title = doc.title?.trim() || doc.querySelector("h1")?.textContent?.trim() || void 0;
+  const root = doc.body ?? doc.documentElement;
+  let markdown = "";
+  try {
+    markdown = turndown().turndown(root.innerHTML);
+  } catch {
+    markdown = root.textContent ?? "";
+  }
+  markdown = markdown.replace(/\n{3,}/g, "\n\n").trim();
+  return { markdown, title: title || void 0 };
+}
+
+// src/ingest.ts
+init_db();
+init_config();
+var MD_EXT = /* @__PURE__ */ new Set([".md", ".markdown", ".mdx"]);
+var HTML_EXT = /* @__PURE__ */ new Set([".html", ".htm", ".xhtml"]);
+var TEXT_EXT = /* @__PURE__ */ new Set([
+  ".txt",
+  ".text",
+  ".log",
+  ".csv",
+  ".tsv",
+  ".json",
+  ".jsonl",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".xml",
+  ".rst",
+  ".adoc"
+]);
+var CODE_EXT = /* @__PURE__ */ new Set([
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".rb",
+  ".php",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cc",
+  ".cs",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".ps1",
+  ".psm1",
+  ".bat",
+  ".cmd",
+  ".sql",
+  ".css",
+  ".scss",
+  ".less",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".swift",
+  ".scala",
+  ".pl",
+  ".lua",
+  ".r",
+  ".dart",
+  ".gradle",
+  ".cmake",
+  ".dockerfile",
+  ".makefile",
+  ".proto",
+  ".graphql"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".idea",
+  ".vscode",
+  "target",
+  "coverage",
+  ".turbo",
+  ".cache"
+]);
+function isAllowed(ext) {
+  return MD_EXT.has(ext) || HTML_EXT.has(ext) || TEXT_EXT.has(ext) || CODE_EXT.has(ext);
+}
+async function walk(root) {
+  const out = [];
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      out.push(...await walk(full));
+    } else if (entry.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+async function loadTarget(target, opts) {
+  const stat = await fs.stat(target);
+  const files = stat.isDirectory() ? await walk(target) : [target];
+  const docs = [];
+  const skipped = [];
+  for (const file of files) {
+    const ext = path.extname(file).toLowerCase();
+    if (!isAllowed(ext)) {
+      skipped.push({ path: file, reason: `unsupported extension '${ext || "(none)"}'` });
+      continue;
+    }
+    let raw;
+    try {
+      raw = await fs.readFile(file, "utf8");
+    } catch {
+      skipped.push({ path: file, reason: "unreadable" });
+      continue;
+    }
+    if (raw.includes("\0")) {
+      skipped.push({ path: file, reason: "binary content" });
+      continue;
+    }
+    let text = raw;
+    let title = "";
+    if (HTML_EXT.has(ext)) {
+      const conv = htmlToMarkdown(raw);
+      text = conv.markdown;
+      title = conv.title ?? "";
+    } else if (MD_EXT.has(ext)) {
+      title = mdTitle(raw) ?? "";
+    }
+    if (!text.trim()) {
+      skipped.push({ path: file, reason: "empty" });
+      continue;
+    }
+    if (!title) title = path.basename(file);
+    const chunks = HTML_EXT.has(ext) || MD_EXT.has(ext) ? chunkMarkdown(text, opts) : chunkPlain(text, opts);
+    if (chunks.length === 0) {
+      skipped.push({ path: file, reason: "no chunks produced" });
+      continue;
+    }
+    docs.push({ source: path.resolve(file), title, chunks });
+  }
+  return { docs, fileCount: files.length, skipped };
+}
+async function embedAndInsert(ks, pending, opts) {
+  if (pending.length === 0 || opts.dryRun) return { inserted: 0 };
+  const contents = pending.map((p) => p.chunk.content);
+  opts.log?.(`Embedding ${contents.length} chunk(s) with ${ks.embedding_model} at ${opts.url} ...`);
+  const embeddings = await embedBatch(opts.url, ks.embedding_model, contents, opts.batchSize, (done, total) => {
+    opts.log?.(`  embedded ${done}/${total}`);
+  });
+  const byDoc = /* @__PURE__ */ new Map();
+  pending.forEach((p, i) => {
+    const list = byDoc.get(p.doc) ?? [];
+    list.push({
+      source: p.doc.source,
+      title: p.doc.title,
+      chunk_index: p.chunk.index,
+      content: p.chunk.content,
+      metadata: p.metadata,
+      embedding: embeddings[i]
+    });
+    byDoc.set(p.doc, list);
+  });
+  let inserted = 0;
+  for (const [, rows] of byDoc) {
+    inserted += await insertChunks(ks, rows);
+  }
+  return { inserted };
+}
+async function feedTarget(ks, target, opts = {}) {
+  const loadOpts = { maxLen: opts.maxLen ?? 1200, overlap: opts.overlap ?? 180 };
+  const { docs, fileCount, skipped } = await loadTarget(target, loadOpts);
+  const log = opts.log ?? ((m) => console.log(m));
+  for (const doc of docs) {
+    log(`${doc.source}: ${doc.chunks.length} chunk(s)`);
+  }
+  for (const s of skipped) {
+    log(`skipped ${s.path}: ${s.reason}`);
+  }
+  const meta = { ...opts.metadata };
+  if (opts.tags && opts.tags.length > 0) meta.tags = opts.tags;
+  let deletedForReplace = 0;
+  const pending = [];
+  let skippedExisting = 0;
+  for (const doc of docs) {
+    if (opts.replace) {
+      deletedForReplace += await deleteBySource(ks, doc.source);
+    }
+    const existing = await sourceChunkHashes(ks, doc.source);
+    for (const chunk of doc.chunks) {
+      if (!opts.replace && existing.get(chunk.index) === contentHash(chunk.content)) {
+        skippedExisting++;
+        continue;
+      }
+      pending.push({ doc, chunk, metadata: meta });
+    }
+  }
+  const { inserted } = await embedAndInsert(ks, pending, {
+    url: ollamaUrl(opts.url),
+    dryRun: opts.dryRun ?? false,
+    batchSize: opts.batchSize ?? 32,
+    log
+  });
+  return {
+    documents: docs.length,
+    chunks: docs.reduce((n, d) => n + d.chunks.length, 0),
+    inserted,
+    skippedExisting,
+    deletedForReplace,
+    skippedFiles: skipped,
+    dryRun: opts.dryRun ?? false
+  };
+}
+async function feedText(ks, text, opts = {}) {
+  const log = opts.log ?? ((m) => console.log(m));
+  const source = opts.sourceName?.trim() || "manual";
+  const title = opts.title?.trim() || source;
+  const chunks = chunkMarkdown(text, { maxLen: opts.maxLen ?? 1200, overlap: opts.overlap ?? 180 });
+  const doc = { source, title, chunks };
+  log(`${source}: ${chunks.length} chunk(s)`);
+  const meta = { ...opts.metadata };
+  if (opts.tags && opts.tags.length > 0) meta.tags = opts.tags;
+  let deletedForReplace = 0;
+  const pending = [];
+  let skippedExisting = 0;
+  if (opts.replace) {
+    deletedForReplace += await deleteBySource(ks, source);
+  }
+  const existing = await sourceChunkHashes(ks, source);
+  for (const chunk of chunks) {
+    if (!opts.replace && existing.get(chunk.index) === contentHash(chunk.content)) {
+      skippedExisting++;
+      continue;
+    }
+    pending.push({ doc, chunk, metadata: meta });
+  }
+  const { inserted } = await embedAndInsert(ks, pending, {
+    url: ollamaUrl(opts.url),
+    dryRun: opts.dryRun ?? false,
+    batchSize: opts.batchSize ?? 32,
+    log
+  });
+  return {
+    documents: 1,
+    chunks: chunks.length,
+    inserted,
+    skippedExisting,
+    deletedForReplace,
+    skippedFiles: [],
+    dryRun: opts.dryRun ?? false
+  };
+}
+
+// src/check.ts
+init_config();
+init_db();
+import pg from "pg";
+var MIN_NODE_MAJOR = 20;
+var MIN_PGVECTOR_VERSION = "0.5.0";
+var DB_CONNECT_TIMEOUT_MS = 5e3;
+var OLLAMA_TIMEOUT_MS = 1e4;
+function compareVersions(a, b) {
+  const pa = a.split(/[.-]/).map((s) => parseInt(s, 10) || 0);
+  const pb = b.split(/[.-]/).map((s) => parseInt(s, 10) || 0);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function modelMatches(tag, wanted) {
+  if (tag === wanted) return true;
+  if (wanted.includes(":")) return false;
+  return tag === `${wanted}:latest`;
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function shortVersion(v) {
+  return v.split(/\s+/).slice(0, 2).join(" ") || v;
+}
+async function fetchTags(baseUrl) {
+  try {
+    const res = await fetch(`${normalizeUrl(baseUrl)}/api/tags`, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(OLLAMA_TIMEOUT_MS)
+    });
+    if (!res.ok) return { error: `HTTP ${res.status}` };
+    const data = await res.json();
+    const names = (data.models ?? []).map((m) => m.name ?? m.model ?? "").filter(Boolean);
+    return { names };
+  } catch (err) {
+    return { error: errMsg(err) };
+  }
+}
+async function checkOneModel(id, model, baseUrl, names, ks, probe) {
+  const scope = ks ? ` (ks '${ks.name}')` : "";
+  if (!names.some((n) => modelMatches(n, model))) {
+    return {
+      id,
+      status: "fail",
+      detail: `model '${model}' not found at ${baseUrl}${scope} \u2014 run: ollama pull ${model}`
+    };
+  }
+  if (probe) {
+    try {
+      const { dim } = await probeModel(baseUrl, model);
+      if (ks && dim !== ks.embedding_dim) {
+        return {
+          id,
+          status: "fail",
+          detail: `model '${model}' serves dim=${dim} but ks '${ks.name}' expects dim=${ks.embedding_dim}`
+        };
+      }
+      return { id, status: "ok", detail: `model '${model}' available at ${baseUrl}${scope} (dim=${dim})` };
+    } catch (err) {
+      return { id, status: "fail", detail: `probe of model '${model}' failed \u2014 ${errMsg(err)}${scope}` };
+    }
+  }
+  return { id, status: "ok", detail: `model '${model}' available at ${baseUrl}${scope}` };
+}
+async function runChecks(opts = {}) {
+  const results = [];
+  const major = Number(process.versions.node.split(".")[0]);
+  results.push({
+    id: "node",
+    status: Number.isFinite(major) && major >= MIN_NODE_MAJOR ? "ok" : "fail",
+    detail: `Node ${process.versions.node} (>= ${MIN_NODE_MAJOR} required)`
+  });
+  let client;
+  let dbUp = false;
+  let kss = [];
+  try {
+    try {
+      client = new pg.Client({
+        connectionString: databaseUrl(),
+        connectionTimeoutMillis: DB_CONNECT_TIMEOUT_MS
+      });
+      client.on("error", () => {
+      });
+      await client.connect();
+      const v = await client.query("SELECT version() AS v");
+      dbUp = true;
+      results.push({
+        id: "postgres",
+        status: "ok",
+        detail: `PostgreSQL reachable at ${databaseUrl()} (${shortVersion(String(v.rows[0]?.v ?? ""))})`
+      });
+    } catch (err) {
+      results.push({
+        id: "postgres",
+        status: "fail",
+        detail: `PostgreSQL not reachable at ${databaseUrl()} \u2014 ${errMsg(err)}`
+      });
+    }
+    if (dbUp && client) {
+      try {
+        await client.query(`CREATE EXTENSION IF NOT EXISTS vector`);
+        const res = await client.query("SELECT extversion AS v FROM pg_extension WHERE extname = 'vector'");
+        const ver = res.rows[0]?.v;
+        if (!ver) {
+          results.push({
+            id: "pgvector",
+            status: "fail",
+            detail: "pgvector extension not installed \u2014 install it on the PostgreSQL server (https://github.com/pgvector/pgvector)"
+          });
+        } else if (compareVersions(ver, MIN_PGVECTOR_VERSION) < 0) {
+          results.push({
+            id: "pgvector",
+            status: "warn",
+            detail: `pgvector ${ver} installed (>= ${MIN_PGVECTOR_VERSION} required for HNSW indexes; older versions fall back to sequential scans)`
+          });
+        } else {
+          results.push({ id: "pgvector", status: "ok", detail: `pgvector ${ver} installed` });
+        }
+      } catch (err) {
+        results.push({
+          id: "pgvector",
+          status: "fail",
+          detail: `pgvector unavailable \u2014 ${errMsg(err)}`
+        });
+      }
+    } else {
+      results.push({ id: "pgvector", status: "skip", detail: "pgvector check skipped \u2014 PostgreSQL unreachable" });
+    }
+    if (dbUp && client) {
+      try {
+        const hasKs = await client.query("SELECT to_regclass('ks') IS NOT NULL AS present");
+        if (!hasKs.rows[0]?.present) {
+          results.push({ id: "schema", status: "fail", detail: "schema missing \u2014 run: gresmcp init" });
+        } else {
+          const ksRes = await client.query(
+            "SELECT id, name, embedding_model, embedding_dim, ollama_url FROM ks ORDER BY name"
+          );
+          kss = ksRes.rows;
+          const missing = [];
+          for (const ks of kss) {
+            const r = await client.query("SELECT to_regclass($1) IS NOT NULL AS present", [entryTableName(ks)]);
+            if (!r.rows[0]?.present) missing.push(ks.name);
+          }
+          if (missing.length > 0) {
+            results.push({
+              id: "schema",
+              status: "fail",
+              detail: `entry table missing for: ${missing.join(", ")} \u2014 run: gresmcp init`
+            });
+          } else {
+            results.push({
+              id: "schema",
+              status: "ok",
+              detail: `schema ready (${kss.length} knowledge source(s))`
+            });
+          }
+        }
+      } catch (err) {
+        results.push({ id: "schema", status: "fail", detail: `schema check failed \u2014 ${errMsg(err)}` });
+      }
+    } else {
+      results.push({ id: "schema", status: "skip", detail: "schema check skipped \u2014 PostgreSQL unreachable" });
+    }
+  } finally {
+    if (client) {
+      try {
+        await client.end();
+      } catch {
+      }
+    }
+  }
+  const defaultUrl = ollamaUrl(opts.url);
+  const tagCache = /* @__PURE__ */ new Map();
+  const getTags = (baseUrl) => {
+    const key = normalizeUrl(baseUrl);
+    let entry = tagCache.get(key);
+    if (!entry) {
+      entry = fetchTags(key);
+      tagCache.set(key, entry);
+    }
+    return entry;
+  };
+  const defaultTags = await getTags(defaultUrl);
+  results.push(
+    "error" in defaultTags ? { id: "ollama", status: "fail", detail: `Ollama not reachable at ${defaultUrl} \u2014 ${defaultTags.error}` } : { id: "ollama", status: "ok", detail: `Ollama reachable at ${defaultUrl} (${defaultTags.names.length} model(s))` }
+  );
+  if (opts.model) {
+    const tags = await getTags(defaultUrl);
+    if ("error" in tags) {
+      results.push({
+        id: "model",
+        status: "skip",
+        detail: `Ollama unreachable at ${defaultUrl} \u2014 cannot verify model '${opts.model}'`
+      });
+    } else {
+      results.push(await checkOneModel("model", opts.model, defaultUrl, tags.names, void 0, opts.probe ?? false));
+    }
+  }
+  for (const ks of kss) {
+    const tags = await getTags(ks.ollama_url);
+    if ("error" in tags) {
+      results.push({
+        id: `model:${ks.name}`,
+        status: "fail",
+        detail: `Ollama not reachable at ${ks.ollama_url} (required by ks '${ks.name}') \u2014 ${tags.error}`
+      });
+      continue;
+    }
+    results.push(
+      await checkOneModel(`model:${ks.name}`, ks.embedding_model, ks.ollama_url, tags.names, ks, opts.probe ?? false)
+    );
+  }
+  if (!opts.model && kss.length === 0) {
+    results.push({
+      id: "model",
+      status: "warn",
+      detail: "no embedding model to verify \u2014 pass --model <model> or create a knowledge source"
+    });
+  }
+  return results;
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/cli.ts
+async function run(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    console.error(`error: ${err instanceof Error ? err.message : err}`);
+    process.exitCode = 1;
+  } finally {
+    await closePool().catch(() => {
+    });
+  }
+}
+async function confirm(question) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function requireKs(ks, name) {
+  if (!ks) throw new Error(`knowledge source '${name}' not found`);
+  return ks;
+}
+function parseKeyValue(pairs) {
+  const out = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0) throw new Error(`invalid metadata entry '${pair}', expected key=value`);
+    out[pair.slice(0, idx)] = pair.slice(idx + 1);
+  }
+  return out;
+}
+function parseTags(tags) {
+  if (!tags) return void 0;
+  const list = tags.split(",").map((t) => t.trim()).filter(Boolean);
+  return list.length > 0 ? list : void 0;
+}
+var program = new Command();
+program.name("gresmcp").description("Manage Postgres-backed knowledge sources for the gresmcp MCP server").version(VERSION);
+program.command("init").description("Initialize the database schema (extension, ks table; repairs entry tables)").action(
+  () => run(async () => {
+    await initDb();
+    for (const ks of await listKs()) {
+      const { ensureEntryTable: ensureEntryTable2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+      await ensureEntryTable2(ks);
+    }
+    console.log("database ready");
+  })
+);
+program.command("check").description("Verify environment requirements (Node, Postgres, pgvector, schema, Ollama models)").option("--model <model>", "Verify this Ollama model is available (e.g. nomic-embed-text)").option("--url <url>", "Ollama base URL (default http://localhost:11434)").option("--probe", "Embed a test string with each model to verify dimensions (slower)").option("--json", "Output as JSON").action(
+  (opts) => run(async () => {
+    const results = await runChecks({ model: opts.model, url: opts.url, probe: opts.probe });
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      const symbols = { ok: "\u2714", warn: "\u26A0", fail: "\u2718", skip: "-" };
+      for (const r of results) console.log(`${symbols[r.status]} ${r.detail}`);
+      const failed = results.filter((r) => r.status === "fail").length;
+      const warned = results.filter((r) => r.status === "warn").length;
+      if (failed > 0) {
+        console.log(`${failed} check(s) failed${warned > 0 ? `, ${warned} warning(s)` : ""}`);
+      } else if (warned > 0) {
+        console.log(`all checks passed with ${warned} warning(s)`);
+      } else {
+        console.log("all checks passed");
+      }
+    }
+    if (results.some((r) => r.status === "fail")) process.exitCode = 1;
+  })
+);
+var ksCmd = program.command("ks").description("Manage knowledge sources");
+ksCmd.command("create <name>").description("Create a knowledge source (probes Ollama to validate the model and detect dimensions)").requiredOption("--model <model>", "Ollama embedding model, e.g. nomic-embed-text").option("--url <url>", "Ollama base URL (default http://localhost:11434)").option("--description <description>", "Human-readable description").option("--dim <n>", "Skip the Ollama probe and set the embedding dimension explicitly", parseInt).action(
+  (name, opts) => run(async () => {
+    await initDb();
+    if (await getKs(name)) throw new Error(`knowledge source '${name}' already exists`);
+    const url = ollamaUrl(opts.url);
+    let dim = opts.dim;
+    if (dim === void 0 || !Number.isFinite(dim) || dim <= 0) {
+      console.log(`Probing model ${opts.model} at ${url} ...`);
+      dim = (await probeModel(url, opts.model)).dim;
+      console.log(`Model OK, embedding dimension: ${dim}`);
+    }
+    const ks = await createKs({
+      name,
+      description: opts.description,
+      model: opts.model,
+      dim,
+      url
+    });
+    console.log(`Created knowledge source '${ks.name}' (dim=${ks.embedding_dim}, model=${ks.embedding_model}, url=${ks.ollama_url})`);
+  })
+);
+ksCmd.command("edit <name>").description("Edit a knowledge source (the embedding model is immutable)").option("--url <url>", "New Ollama base URL").option("--rename <new-name>", "Rename the knowledge source").option("--description <description>", "New description").action(
+  (name, opts) => run(async () => {
+    await initDb();
+    const ks = requireKs(await getKs(name), name);
+    if (opts.rename && opts.rename !== name && await getKs(opts.rename)) {
+      throw new Error(`knowledge source '${opts.rename}' already exists`);
+    }
+    const updated = await updateKs(ks.id, {
+      name: opts.rename,
+      description: opts.description,
+      ollama_url: opts.url ? ollamaUrl(opts.url) : void 0
+    });
+    console.log(`Updated '${updated.name}' (model=${updated.embedding_model}, url=${updated.ollama_url}, dim=${updated.embedding_dim})`);
+  })
+);
+ksCmd.command("list").description("List knowledge sources").option("--json", "Output as JSON").action(
+  (opts) => run(async () => {
+    await initDb();
+    const all = await listKs();
+    if (opts.json) {
+      console.log(JSON.stringify(all, null, 2));
+      return;
+    }
+    if (all.length === 0) {
+      console.log("no knowledge sources yet; create one with: gresmcp ks create <name> --model <model>");
+      return;
+    }
+    for (const ks of all) {
+      const n = await countEntries(ks);
+      console.log(
+        `${ks.name.padEnd(20)} ${`${ks.embedding_model}@${ks.ollama_url}`.padEnd(50)} dim=${String(ks.embedding_dim).padEnd(6)} entries=${String(n).padEnd(8)} ${ks.description}`
+      );
+    }
+  })
+);
+ksCmd.command("delete <name>").description("Delete a knowledge source and all of its entries").option("--yes", "Do not ask for confirmation").action(
+  (name, opts) => run(async () => {
+    await initDb();
+    const ks = requireKs(await getKs(name), name);
+    if (!opts.yes) {
+      const n = await countEntries(ks);
+      const ok = await confirm(`Delete knowledge source '${name}' and its ${n} entry chunk(s)?`);
+      if (!ok) {
+        console.log("aborted");
+        return;
+      }
+    }
+    await deleteKs(ks);
+    console.log(`Deleted knowledge source '${name}'`);
+  })
+);
+program.command("feed <ks>").description("Feed data into a knowledge source (from a file/folder via --path, or inline via --text/--stdin)").option("--path <path>", "File or folder to ingest (text, markdown, code, html)").option("--text <text>", "Inline text entry").option("--stdin", "Read entry text from stdin").option("--title <title>", "Title for manual entries").option("--source-name <name>", "Source name for manual entries (default 'manual')").option("--tags <tags>", "Comma-separated tags").option("--metadata <key=value...>", "Custom metadata entries", ((v, prev) => [...prev, v]), []).option("--url <url>", "Ollama base URL override for this run").option("--replace", "Replace existing chunks of the same source instead of deduplicating").option("--dry-run", "Parse and chunk only; do not embed or write").option("--chunk-size <n>", "Max chunk length in characters", parseInt).option("--overlap <n>", "Chunk overlap in characters", parseInt).action(
+  (name, opts) => run(async () => {
+    await initDb();
+    const ks = requireKs(await getKs(name), name);
+    const modes = [opts.path, opts.text, opts.stdin].filter(Boolean).length;
+    if (modes !== 1) throw new Error("provide exactly one of --path, --text or --stdin");
+    const common = {
+      title: opts.title,
+      url: opts.url,
+      replace: opts.replace,
+      dryRun: opts.dryRun,
+      batchSize: 32,
+      maxLen: opts.chunkSize && opts.chunkSize > 0 ? opts.chunkSize : void 0,
+      overlap: opts.overlap,
+      tags: parseTags(opts.tags),
+      metadata: parseKeyValue(opts.metadata ?? [])
+    };
+    let summary;
+    if (opts.path) {
+      summary = await feedTarget(ks, opts.path, common);
+    } else {
+      const text = opts.stdin ? await readStdin() : opts.text;
+      if (!text.trim()) throw new Error("empty input text");
+      summary = await feedText(ks, text, { ...common, sourceName: opts.sourceName });
+    }
+    if (summary.dryRun) {
+      console.log(`dry run: ${summary.documents} document(s), ${summary.chunks} chunk(s), ${summary.skippedFiles.length} file(s) skipped`);
+    } else {
+      console.log(
+        `fed '${ks.name}': ${summary.inserted} chunk(s) inserted` + (summary.skippedExisting ? `, ${summary.skippedExisting} unchanged chunk(s) skipped` : "") + (summary.deletedForReplace ? `, ${summary.deletedForReplace} old chunk(s) replaced` : "") + `, ${summary.skippedFiles.length} file(s) skipped`
+      );
+    }
+  })
+);
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+program.parseAsync(process.argv);
+//# sourceMappingURL=cli.js.map