ownsearch 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# ownsearch
+
+`ownsearch` is a text-first local semantic search package that indexes folders into Qdrant and exposes retrieval tools through an MCP server.
+
+V1 scope:
+
+- text and code files first
+- extracted text from PDFs
+- Gemini embeddings with `gemini-embedding-001`
+- Docker-backed Qdrant storage
+- stdio MCP server for agent attachment
+
+## Install
+
+For local development before publish:
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+After publish, the intended install is:
+
+```bash
+npm install -g ownsearch
+```
+
+## Quickstart
+
+```bash
+ownsearch setup
+ownsearch doctor
+ownsearch index ./docs --name docs
+ownsearch list-roots
+ownsearch search "what is this repo about?" --limit 5
+ownsearch search-context "what is this repo about?" --limit 8 --max-chars 12000
+ownsearch serve-mcp
+```
+
+## Agent Config
+
+Print a config snippet for your agent:
+
+```bash
+node dist/cli.js print-agent-config codex
+node dist/cli.js print-agent-config claude-desktop
+node dist/cli.js print-agent-config cursor
+```
+
+## MCP Tools
+
+- `index_path`
+- `search`
+- `search_context`
+- `get_chunks`
+- `list_roots`
+- `delete_root`
+- `store_status`
+
+`index_path` is incremental. Re-running it on the same folder only re-embeds changed files and removes stale chunks.
+
+## Notes
+
+- Roots are stored in `~/.ownsearch/config.json`.
+- Qdrant runs in Docker under the container name `ownsearch-qdrant`.
+- Each indexed folder is stored as payload-filtered chunks inside a single Qdrant collection.
+- Agents can call `search_context` for a ready-to-use context bundle, or call `search` first and then `get_chunks` for exact chunk retrieval.

package/dist/chunk-NLETDGQ5.js

@@ -0,0 +1,726 @@
+// src/context.ts
+function buildContextBundle(query, hits, maxChars = 12e3) {
+  const results = [];
+  let totalChars = 0;
+  for (const hit of hits) {
+    if (results.length > 0 && totalChars + hit.content.length > maxChars) {
+      break;
+    }
+    results.push({
+      id: hit.id,
+      score: hit.score,
+      rootId: hit.rootId,
+      rootName: hit.rootName,
+      relativePath: hit.relativePath,
+      chunkIndex: hit.chunkIndex,
+      content: hit.content
+    });
+    totalChars += hit.content.length;
+  }
+  return {
+    query,
+    totalChars,
+    results
+  };
+}
+
+// src/config.ts
+import fs from "fs/promises";
+import os from "os";
+import path2 from "path";
+
+// src/constants.ts
+var CONFIG_DIR_NAME = ".ownsearch";
+var CONFIG_FILE_NAME = "config.json";
+var DEFAULT_COLLECTION = "text_gemini_embedding_001_768";
+var DEFAULT_EMBEDDING_MODEL = "gemini-embedding-001";
+var DEFAULT_VECTOR_SIZE = 768;
+var DEFAULT_QDRANT_URL = "http://127.0.0.1:6333";
+var DEFAULT_QDRANT_CONTAINER = "ownsearch-qdrant";
+var DEFAULT_QDRANT_VOLUME = "ownsearch-qdrant-storage";
+var DEFAULT_CHUNK_SIZE = 1200;
+var DEFAULT_CHUNK_OVERLAP = 200;
+var DEFAULT_MAX_FILE_BYTES = 50 * 1024 * 1024;
+var SUPPORTED_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".c",
+  ".cpp",
+  ".cs",
+  ".css",
+  ".csv",
+  ".env",
+  ".go",
+  ".h",
+  ".hpp",
+  ".html",
+  ".java",
+  ".js",
+  ".json",
+  ".jsx",
+  ".md",
+  ".mdx",
+  ".mjs",
+  ".pdf",
+  ".ps1",
+  ".py",
+  ".rb",
+  ".rs",
+  ".sh",
+  ".sql",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".xml",
+  ".yaml",
+  ".yml"
+]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".idea",
+  ".next",
+  ".svn",
+  ".turbo",
+  ".venv",
+  ".vscode",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "venv"
+]);
+
+// src/utils.ts
+import crypto from "crypto";
+import path from "path";
+function toPosixPath(inputPath) {
+  return inputPath.split(path.sep).join("/");
+}
+function sha256(input) {
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+function hashToUuid(input) {
+  const hash = sha256(input);
+  const part1 = hash.slice(0, 8);
+  const part2 = hash.slice(8, 12);
+  const part3 = `5${hash.slice(13, 16)}`;
+  const variantNibble = parseInt(hash.slice(16, 17), 16) & 3 | 8;
+  const part4 = `${variantNibble.toString(16)}${hash.slice(17, 20)}`;
+  const part5 = hash.slice(20, 32);
+  return `${part1}-${part2}-${part3}-${part4}-${part5}`;
+}
+function normalizeVector(values) {
+  const magnitude = Math.sqrt(values.reduce((sum, value) => sum + value * value, 0));
+  if (magnitude === 0) {
+    return values;
+  }
+  return values.map((value) => value / magnitude);
+}
+function slugifyName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    qdrantUrl: DEFAULT_QDRANT_URL,
+    qdrantCollection: DEFAULT_COLLECTION,
+    qdrantContainerName: DEFAULT_QDRANT_CONTAINER,
+    qdrantVolumeName: DEFAULT_QDRANT_VOLUME,
+    embeddingModel: DEFAULT_EMBEDDING_MODEL,
+    vectorSize: DEFAULT_VECTOR_SIZE,
+    chunkSize: DEFAULT_CHUNK_SIZE,
+    chunkOverlap: DEFAULT_CHUNK_OVERLAP,
+    maxFileBytes: DEFAULT_MAX_FILE_BYTES,
+    roots: []
+  };
+}
+function getConfigDir() {
+  return path2.join(os.homedir(), CONFIG_DIR_NAME);
+}
+function getConfigPath() {
+  return path2.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+async function ensureConfigDir() {
+  await fs.mkdir(getConfigDir(), { recursive: true });
+}
+async function loadConfig() {
+  await ensureConfigDir();
+  const configPath = getConfigPath();
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const config = {
+      ...defaultConfig(),
+      ...parsed,
+      maxFileBytes: Math.max(parsed.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES, DEFAULT_MAX_FILE_BYTES),
+      roots: parsed.roots ?? []
+    };
+    if (config.maxFileBytes !== parsed.maxFileBytes) {
+      await saveConfig(config);
+    }
+    return config;
+  } catch (error) {
+    const config = defaultConfig();
+    await saveConfig(config);
+    return config;
+  }
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  await fs.writeFile(getConfigPath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function createRootDefinition(rootPath, name) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rootName = name?.trim() || path2.basename(rootPath);
+  return {
+    id: slugifyName(`${rootName}-${rootPath}`),
+    name: rootName,
+    path: path2.resolve(rootPath),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function upsertRoot(rootPath, name) {
+  const config = await loadConfig();
+  const absolutePath = path2.resolve(rootPath);
+  const existing = config.roots.find((root2) => root2.path === absolutePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) {
+    existing.name = name?.trim() || existing.name;
+    existing.updatedAt = now;
+    await saveConfig(config);
+    return existing;
+  }
+  const root = createRootDefinition(absolutePath, name);
+  config.roots.push(root);
+  await saveConfig(config);
+  return root;
+}
+async function deleteRootDefinition(rootId) {
+  const config = await loadConfig();
+  const initialLength = config.roots.length;
+  config.roots = config.roots.filter((root) => root.id !== rootId);
+  await saveConfig(config);
+  return config.roots.length !== initialLength;
+}
+async function findRoot(rootId) {
+  const config = await loadConfig();
+  return config.roots.find((root) => root.id === rootId);
+}
+async function listRoots() {
+  const config = await loadConfig();
+  return config.roots;
+}
+
+// src/errors.ts
+var OwnSearchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OwnSearchError";
+  }
+};
+
+// src/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var client;
+var MAX_EMBED_BATCH_SIZE = 20;
+function getClient() {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new OwnSearchError("GEMINI_API_KEY is required.");
+  }
+  if (!client) {
+    client = new GoogleGenAI({ apiKey });
+  }
+  return client;
+}
+async function embed(contents, taskType) {
+  const config = await loadConfig();
+  const vectors = [];
+  const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+  for (let index = 0; index < contents.length; index += MAX_EMBED_BATCH_SIZE) {
+    const batch = contents.slice(index, index + MAX_EMBED_BATCH_SIZE);
+    if (debug) {
+      console.log("[ownsearch:embed]", "batch", index / MAX_EMBED_BATCH_SIZE + 1, "size", batch.length, "chars", batch.reduce((sum, text) => sum + text.length, 0));
+    }
+    const response = await getClient().models.embedContent({
+      model: config.embeddingModel,
+      contents: batch,
+      config: {
+        taskType,
+        outputDimensionality: config.vectorSize
+      }
+    });
+    if (!response.embeddings?.length) {
+      throw new OwnSearchError("Gemini returned no embeddings.");
+    }
+    vectors.push(...response.embeddings.map((embedding) => normalizeVector(embedding.values ?? [])));
+  }
+  return vectors;
+}
+async function embedDocuments(contents) {
+  return embed(contents, "RETRIEVAL_DOCUMENT");
+}
+async function embedQuery(query) {
+  const [vector] = await embed([query], "RETRIEVAL_QUERY");
+  return vector;
+}
+
+// src/qdrant.ts
+import { QdrantClient } from "@qdrant/js-client-rest";
+var OwnSearchStore = class {
+  constructor(client2, collectionName, vectorSize) {
+    this.client = client2;
+    this.collectionName = collectionName;
+    this.vectorSize = vectorSize;
+  }
+  async ensureCollection() {
+    const collections = await this.client.getCollections();
+    const exists = collections.collections.some((collection) => collection.name === this.collectionName);
+    if (!exists) {
+      await this.client.createCollection(this.collectionName, {
+        vectors: {
+          size: this.vectorSize,
+          distance: "Cosine"
+        }
+      });
+    } else {
+      const info = await this.client.getCollection(this.collectionName);
+      const vectorConfig = info.config?.params?.vectors;
+      const actualSize = vectorConfig && !Array.isArray(vectorConfig) && "size" in vectorConfig ? Number(vectorConfig.size) : void 0;
+      if (actualSize && actualSize !== this.vectorSize) {
+        throw new Error(
+          `Qdrant collection ${this.collectionName} has vector size ${actualSize}, expected ${this.vectorSize}.`
+        );
+      }
+    }
+    await Promise.allSettled([
+      this.client.createPayloadIndex(this.collectionName, {
+        field_name: "root_id",
+        field_schema: "keyword"
+      }),
+      this.client.createPayloadIndex(this.collectionName, {
+        field_name: "relative_path",
+        field_schema: "keyword"
+      })
+    ]);
+  }
+  async upsertChunks(records, vectors) {
+    const batchSize = 50;
+    for (let index = 0; index < records.length; index += batchSize) {
+      const batchRecords = records.slice(index, index + batchSize);
+      const batchVectors = vectors.slice(index, index + batchSize);
+      const points = batchRecords.map((record, batchIndex) => ({
+        id: record.id,
+        vector: batchVectors[batchIndex],
+        payload: {
+          root_id: record.rootId,
+          root_name: record.rootName,
+          root_path: record.rootPath,
+          file_path: record.filePath,
+          relative_path: record.relativePath,
+          file_extension: record.fileExtension,
+          chunk_index: record.chunkIndex,
+          content: record.content,
+          content_hash: record.contentHash,
+          file_hash: record.fileHash,
+          mtime_ms: record.mtimeMs,
+          size_bytes: record.sizeBytes
+        }
+      }));
+      await this.client.upsert(this.collectionName, {
+        wait: true,
+        points
+      });
+    }
+  }
+  async scrollRootChunks(rootId) {
+    const chunks = [];
+    let offset;
+    do {
+      const result = await this.client.scroll(this.collectionName, {
+        limit: 1024,
+        offset,
+        with_payload: true,
+        with_vector: false,
+        filter: {
+          must: [
+            {
+              key: "root_id",
+              match: {
+                value: rootId
+              }
+            }
+          ]
+        }
+      });
+      chunks.push(
+        ...(result.points ?? []).map((point) => ({
+          id: String(point.id),
+          rootId: String(point.payload?.root_id ?? ""),
+          rootPath: String(point.payload?.root_path ?? ""),
+          rootName: String(point.payload?.root_name ?? ""),
+          filePath: String(point.payload?.file_path ?? ""),
+          relativePath: String(point.payload?.relative_path ?? ""),
+          fileExtension: String(point.payload?.file_extension ?? ""),
+          chunkIndex: Number(point.payload?.chunk_index ?? 0),
+          content: String(point.payload?.content ?? ""),
+          contentHash: String(point.payload?.content_hash ?? ""),
+          fileHash: String(point.payload?.file_hash ?? ""),
+          mtimeMs: Number(point.payload?.mtime_ms ?? 0),
+          sizeBytes: Number(point.payload?.size_bytes ?? 0)
+        }))
+      );
+      offset = result.next_page_offset;
+    } while (offset !== void 0 && offset !== null);
+    return chunks;
+  }
+  async deleteRoot(rootId) {
+    await this.client.delete(this.collectionName, {
+      wait: true,
+      filter: {
+        must: [
+          {
+            key: "root_id",
+            match: {
+              value: rootId
+            }
+          }
+        ]
+      }
+    });
+  }
+  async deleteFiles(rootId, filePaths) {
+    for (const filePath of filePaths) {
+      await this.client.delete(this.collectionName, {
+        wait: true,
+        filter: {
+          must: [
+            {
+              key: "root_id",
+              match: {
+                value: rootId
+              }
+            },
+            {
+              key: "file_path",
+              match: {
+                value: filePath
+              }
+            }
+          ]
+        }
+      });
+    }
+  }
+  async search(vector, filters, limit) {
+    const must = [];
+    if (filters.rootIds?.length) {
+      must.push({
+        key: "root_id",
+        match: {
+          any: filters.rootIds
+        }
+      });
+    }
+    const results = await this.client.search(this.collectionName, {
+      vector,
+      limit: filters.pathSubstring ? Math.max(limit * 3, limit) : limit,
+      with_payload: true,
+      filter: must.length ? { must } : void 0
+    });
+    const hits = results.map((result) => ({
+      id: String(result.id),
+      score: result.score,
+      rootId: String(result.payload?.root_id ?? ""),
+      rootName: String(result.payload?.root_name ?? ""),
+      filePath: String(result.payload?.file_path ?? ""),
+      relativePath: String(result.payload?.relative_path ?? ""),
+      chunkIndex: Number(result.payload?.chunk_index ?? 0),
+      content: String(result.payload?.content ?? "")
+    }));
+    if (!filters.pathSubstring) {
+      return hits.slice(0, limit);
+    }
+    const needle = filters.pathSubstring.toLowerCase();
+    return hits.filter((hit) => hit.relativePath.toLowerCase().includes(needle)).slice(0, limit);
+  }
+  async getChunks(ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+    const points = await this.client.retrieve(this.collectionName, {
+      ids,
+      with_payload: true,
+      with_vector: false
+    });
+    return (points ?? []).map((point) => ({
+      id: String(point.id),
+      rootId: String(point.payload?.root_id ?? ""),
+      rootName: String(point.payload?.root_name ?? ""),
+      filePath: String(point.payload?.file_path ?? ""),
+      relativePath: String(point.payload?.relative_path ?? ""),
+      chunkIndex: Number(point.payload?.chunk_index ?? 0),
+      content: String(point.payload?.content ?? "")
+    }));
+  }
+  async getStatus() {
+    const info = await this.client.getCollection(this.collectionName);
+    return {
+      collection: this.collectionName,
+      status: info.status,
+      pointsCount: info.points_count,
+      indexedVectorsCount: info.indexed_vectors_count,
+      vectorConfig: info.config?.params?.vectors ?? null
+    };
+  }
+};
+async function createStore() {
+  const config = await loadConfig();
+  const client2 = new QdrantClient({ url: config.qdrantUrl, checkCompatibility: false });
+  const store = new OwnSearchStore(client2, config.qdrantCollection, config.vectorSize);
+  await store.ensureCollection();
+  return store;
+}
+
+// src/indexer.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/chunking.ts
+function chunkText(content, chunkSize, chunkOverlap) {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < normalized.length) {
+    let end = Math.min(start + chunkSize, normalized.length);
+    if (end < normalized.length) {
+      const lastBoundary = normalized.lastIndexOf("\n", end);
+      if (lastBoundary > start + Math.floor(chunkSize * 0.5)) {
+        end = lastBoundary;
+      }
+    }
+    const chunk = normalized.slice(start, end).trim();
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    if (end >= normalized.length) {
+      break;
+    }
+    start = Math.max(end - chunkOverlap, start + 1);
+  }
+  return chunks;
+}
+
+// src/files.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import { PDFParse } from "pdf-parse";
+function sanitizeExtractedText(input) {
+  return input.replace(/\u0000/g, "").replace(/[\u0001-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\r\n/g, "\n");
+}
+async function collectTextFiles(rootPath, maxFileBytes) {
+  const files = [];
+  const absoluteRoot = path3.resolve(rootPath);
+  const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+  function debugLog(...parts) {
+    if (debug) {
+      console.log("[ownsearch:index]", ...parts);
+    }
+  }
+  async function parsePdf(filePath) {
+    const buffer = await fs2.readFile(filePath);
+    const parser = new PDFParse({ data: buffer });
+    try {
+      const pdfData = await parser.getText();
+      return pdfData.text ?? "";
+    } finally {
+      await parser.destroy();
+    }
+  }
+  async function walk(currentPath) {
+    const entries = await fs2.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".github") {
+        if (entry.isDirectory()) {
+          continue;
+        }
+      }
+      const nextPath = path3.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        await walk(nextPath);
+        continue;
+      }
+      const extension = path3.extname(entry.name).toLowerCase();
+      if (!SUPPORTED_TEXT_EXTENSIONS.has(extension)) {
+        debugLog("skip-extension", nextPath, extension);
+        continue;
+      }
+      const stats = await fs2.stat(nextPath);
+      if (stats.size > maxFileBytes) {
+        debugLog("skip-size", nextPath, stats.size);
+        continue;
+      }
+      let content = "";
+      try {
+        if (extension === ".pdf") {
+          content = await parsePdf(nextPath);
+        } else {
+          content = await fs2.readFile(nextPath, "utf8");
+        }
+        content = sanitizeExtractedText(content);
+      } catch (error) {
+        debugLog("skip-parse", nextPath, String(error));
+        continue;
+      }
+      if (!content || !content.trim()) {
+        debugLog("skip-empty", nextPath);
+        continue;
+      }
+      files.push({
+        path: nextPath,
+        relativePath: path3.relative(absoluteRoot, nextPath),
+        extension,
+        sizeBytes: stats.size,
+        mtimeMs: stats.mtimeMs,
+        content
+      });
+    }
+  }
+  await walk(absoluteRoot);
+  return files;
+}
+
+// src/indexer.ts
+function buildChunkId(rootId, relativePath, chunkIndex, fileHash) {
+  return hashToUuid(`${rootId}:${relativePath}:${chunkIndex}:${fileHash}`);
+}
+async function embedRecords(records) {
+  if (records.length === 0) {
+    return { records: [], vectors: [], skipped: 0 };
+  }
+  try {
+    const vectors = await embedDocuments(records.map((record) => record.content));
+    return { records, vectors, skipped: 0 };
+  } catch (error) {
+    if (records.length === 1) {
+      const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+      if (debug) {
+        console.log("[ownsearch:embed]", "skip-chunk", records[0].relativePath, String(error));
+      }
+      return { records: [], vectors: [], skipped: 1 };
+    }
+    const midpoint = Math.floor(records.length / 2);
+    const left = await embedRecords(records.slice(0, midpoint));
+    const right = await embedRecords(records.slice(midpoint));
+    return {
+      records: [...left.records, ...right.records],
+      vectors: [...left.vectors, ...right.vectors],
+      skipped: left.skipped + right.skipped
+    };
+  }
+}
+async function indexPath(rootPath, options = {}) {
+  const absolutePath = path4.resolve(rootPath);
+  const stats = await fs3.stat(absolutePath).catch(() => void 0);
+  if (!stats?.isDirectory()) {
+    throw new OwnSearchError(`Path is not a readable directory: ${absolutePath}`);
+  }
+  const config = await loadConfig();
+  const root = await upsertRoot(absolutePath, options.name);
+  const store = await createStore();
+  const files = await collectTextFiles(root.path, options.maxFileBytes ?? config.maxFileBytes);
+  const existingChunks = await store.scrollRootChunks(root.id);
+  const records = [];
+  const filesByPath = /* @__PURE__ */ new Map();
+  const existingByPath = /* @__PURE__ */ new Map();
+  const refreshAllMetadata = existingChunks.some(
+    (chunk) => chunk.rootName !== root.name || chunk.rootPath !== root.path
+  );
+  for (const file of files) {
+    filesByPath.set(file.path, file);
+  }
+  for (const chunk of existingChunks) {
+    const list = existingByPath.get(chunk.filePath) ?? [];
+    list.push(chunk);
+    existingByPath.set(chunk.filePath, list);
+  }
+  const staleFiles = [];
+  for (const file of files) {
+    const fileHash = sha256(file.content);
+    const chunks = chunkText(file.content, config.chunkSize, config.chunkOverlap);
+    const existing = existingByPath.get(file.path);
+    const existingFileHash = existing?.[0]?.fileHash;
+    const existingChunkCount = existing?.length ?? 0;
+    if (!refreshAllMetadata && existing && existingFileHash === fileHash && existingChunkCount === chunks.length) {
+      continue;
+    }
+    if (existing?.length) {
+      staleFiles.push(file.path);
+    }
+    chunks.forEach((content, chunkIndex) => {
+      records.push({
+        id: buildChunkId(root.id, toPosixPath(file.relativePath), chunkIndex, fileHash),
+        rootId: root.id,
+        rootPath: root.path,
+        rootName: root.name,
+        filePath: file.path,
+        relativePath: toPosixPath(file.relativePath),
+        fileExtension: file.extension,
+        chunkIndex,
+        content,
+        contentHash: sha256(content),
+        fileHash,
+        mtimeMs: file.mtimeMs,
+        sizeBytes: file.sizeBytes
+      });
+    });
+  }
+  for (const [existingFilePath] of existingByPath.entries()) {
+    if (!filesByPath.has(existingFilePath)) {
+      staleFiles.push(existingFilePath);
+    }
+  }
+  if (staleFiles.length > 0) {
+    await store.deleteFiles(root.id, Array.from(new Set(staleFiles)));
+  }
+  if (records.length === 0) {
+    return {
+      root,
+      indexedFiles: files.length,
+      indexedChunks: 0,
+      skippedFiles: 0
+    };
+  }
+  const embedded = await embedRecords(records);
+  if (embedded.records.length > 0) {
+    await store.upsertChunks(embedded.records, embedded.vectors);
+  }
+  return {
+    root,
+    indexedFiles: files.length,
+    indexedChunks: embedded.records.length,
+    skippedFiles: 0
+  };
+}
+
+export {
+  buildContextBundle,
+  getConfigPath,
+  loadConfig,
+  deleteRootDefinition,
+  findRoot,
+  listRoots,
+  OwnSearchError,
+  embedQuery,
+  createStore,
+  indexPath
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import {
+  OwnSearchError,
+  buildContextBundle,
+  createStore,
+  deleteRootDefinition,
+  embedQuery,
+  findRoot,
+  getConfigPath,
+  indexPath,
+  listRoots,
+  loadConfig
+} from "./chunk-NLETDGQ5.js";
+
+// src/cli.ts
+import "dotenv/config";
+import path from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/docker.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runDocker(args) {
+  try {
+    const { stdout } = await execFileAsync("docker", args, { windowsHide: true });
+    return stdout.trim();
+  } catch (error) {
+    throw new OwnSearchError("Docker is required for Qdrant setup. Install Docker and ensure `docker` is on PATH.");
+  }
+}
+async function ensureQdrantDocker() {
+  const config = await loadConfig();
+  const containerName = config.qdrantContainerName;
+  const volumeName = config.qdrantVolumeName;
+  const existing = await runDocker(["ps", "-a", "--filter", `name=^/${containerName}$`, "--format", "{{.Names}}"]);
+  if (existing === containerName) {
+    const running = await runDocker(["inspect", "-f", "{{.State.Running}}", containerName]);
+    if (running === "true") {
+      return { started: false, url: config.qdrantUrl };
+    }
+    await runDocker(["start", containerName]);
+    return { started: true, url: config.qdrantUrl };
+  }
+  await runDocker([
+    "run",
+    "-d",
+    "--name",
+    containerName,
+    "-p",
+    "6333:6333",
+    "-p",
+    "6334:6334",
+    "-v",
+    `${volumeName}:/qdrant/storage`,
+    "qdrant/qdrant:latest"
+  ]);
+  return { started: true, url: config.qdrantUrl };
+}
+
+// src/cli.ts
+var program = new Command();
+function requireGeminiKey() {
+  if (!process.env.GEMINI_API_KEY) {
+    throw new OwnSearchError("Set GEMINI_API_KEY before running OwnSearch.");
+  }
+}
+program.name("ownsearch").description("Gemini-powered local search MCP server backed by Qdrant.").version("0.1.0");
+program.command("setup").description("Create config and start a local Qdrant Docker container.").action(async () => {
+  const config = await loadConfig();
+  const result = await ensureQdrantDocker();
+  console.log(JSON.stringify({
+    configPath: getConfigPath(),
+    qdrantUrl: config.qdrantUrl,
+    qdrantStarted: result.started
+  }, null, 2));
+  if (!process.env.GEMINI_API_KEY) {
+    console.log("GEMINI_API_KEY is not set. Indexing and search will require it later.");
+  }
+});
+program.command("index").argument("<folder>", "Folder path to index").option("-n, --name <name>", "Display name for the indexed root").option("--max-file-bytes <n>", "Override the file size limit for this run", (value) => Number(value)).description("Index a local folder into Qdrant using Gemini embeddings.").action(async (folder, options) => {
+  requireGeminiKey();
+  const result = await indexPath(folder, {
+    name: options.name,
+    maxFileBytes: options.maxFileBytes
+  });
+  console.log(JSON.stringify(result, null, 2));
+});
+program.command("search").argument("<query>", "Natural language query").option("--root-id <rootId...>", "Restrict search to one or more root IDs (repeatable)").option("--limit <n>", "Max results (default 5)", (value) => Number(value), 5).option("--path <substr>", "Filter results to files whose relative path contains this substring").description("Embed a query with Gemini and search the local Qdrant store.").action(
+  async (query, options) => {
+    requireGeminiKey();
+    const store = await createStore();
+    const vector = await embedQuery(query);
+    const hits = await store.search(
+      vector,
+      {
+        rootIds: options.rootId,
+        pathSubstring: options.path
+      },
+      Math.max(1, Math.min(options.limit ?? 5, 50))
+    );
+    console.log(JSON.stringify({ query, hits }, null, 2));
+  }
+);
+program.command("search-context").argument("<query>", "Natural language query").option("--root-id <rootId...>", "Restrict search to one or more root IDs (repeatable)").option("--limit <n>", "Max search hits to consider (default 8)", (value) => Number(value), 8).option("--max-chars <n>", "Max context characters to return (default 12000)", (value) => Number(value), 12e3).option("--path <substr>", "Filter results to files whose relative path contains this substring").description("Search the local Qdrant store and return a bundled context payload for agent use.").action(
+  async (query, options) => {
+    requireGeminiKey();
+    const store = await createStore();
+    const vector = await embedQuery(query);
+    const hits = await store.search(
+      vector,
+      {
+        rootIds: options.rootId,
+        pathSubstring: options.path
+      },
+      Math.max(1, Math.min(options.limit ?? 8, 20))
+    );
+    console.log(JSON.stringify(buildContextBundle(query, hits, Math.max(500, options.maxChars ?? 12e3)), null, 2));
+  }
+);
+program.command("list-roots").description("List indexed roots registered in local config.").action(async () => {
+  console.log(JSON.stringify({ roots: await listRoots() }, null, 2));
+});
+program.command("delete-root").argument("<rootId>", "Root identifier to delete").description("Delete one indexed root from local config and Qdrant.").action(async (rootId) => {
+  const root = await findRoot(rootId);
+  if (!root) {
+    throw new OwnSearchError(`Unknown root: ${rootId}`);
+  }
+  const store = await createStore();
+  await store.deleteRoot(root.id);
+  await deleteRootDefinition(root.id);
+  console.log(JSON.stringify({ deleted: true, root }, null, 2));
+});
+program.command("store-status").description("Show Qdrant collection status for this package.").action(async () => {
+  const store = await createStore();
+  console.log(JSON.stringify(await store.getStatus(), null, 2));
+});
+program.command("doctor").description("Check local prerequisites and package configuration.").action(async () => {
+  const config = await loadConfig();
+  const roots = await listRoots();
+  let qdrantReachable = false;
+  try {
+    const store = await createStore();
+    await store.getStatus();
+    qdrantReachable = true;
+  } catch (error) {
+    qdrantReachable = false;
+  }
+  console.log(JSON.stringify({
+    configPath: getConfigPath(),
+    geminiApiKeyPresent: Boolean(process.env.GEMINI_API_KEY),
+    qdrantUrl: config.qdrantUrl,
+    qdrantReachable,
+    collection: config.qdrantCollection,
+    embeddingModel: config.embeddingModel,
+    vectorSize: config.vectorSize,
+    chunkSize: config.chunkSize,
+    chunkOverlap: config.chunkOverlap,
+    maxFileBytes: config.maxFileBytes,
+    rootCount: roots.length
+  }, null, 2));
+});
+program.command("serve-mcp").description("Start the stdio MCP server.").action(async () => {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const serverPath = path.join(path.dirname(currentFilePath), "mcp", "server.js");
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: "inherit",
+    env: process.env
+  });
+  child.on("exit", (code) => {
+    process.exitCode = code ?? 0;
+  });
+});
+program.command("print-agent-config").argument("<agent>", "codex | claude-desktop | cursor").description("Print an MCP config snippet for a supported agent.").action(async (agent) => {
+  const config = {
+    command: "npx",
+    args: ["-y", "ownsearch", "serve-mcp"],
+    env: {
+      GEMINI_API_KEY: "${GEMINI_API_KEY}"
+    }
+  };
+  switch (agent) {
+    case "codex":
+    case "claude-desktop":
+    case "cursor":
+      console.log(JSON.stringify({ ownsearch: config }, null, 2));
+      return;
+    default:
+      throw new OwnSearchError(`Unsupported agent: ${agent}`);
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/mcp/server.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+import {
+  OwnSearchError,
+  buildContextBundle,
+  createStore,
+  deleteRootDefinition,
+  embedQuery,
+  findRoot,
+  indexPath,
+  loadConfig
+} from "../chunk-NLETDGQ5.js";
+
+// src/mcp/server.ts
+import "dotenv/config";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+function asText(result) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+function asError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
+  };
+}
+var server = new Server(
+  {
+    name: "ownsearch",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "index_path",
+      description: "Register a local folder and sync its Gemini embedding index into Qdrant.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Absolute or relative folder path to index." },
+          name: { type: "string", description: "Optional display name for this indexed root." }
+        },
+        required: ["path"]
+      }
+    },
+    {
+      name: "search",
+      description: "Semantic search over one root or the full local Qdrant store.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Natural language search query." },
+          rootIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional list of root IDs to restrict search."
+          },
+          limit: { type: "number", description: "Maximum result count. Default 5." },
+          pathSubstring: { type: "string", description: "Optional file path substring filter." }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "search_context",
+      description: "Search and return a bundled context payload with top chunks for direct agent grounding.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Natural language search query." },
+          rootIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional list of root IDs to restrict search."
+          },
+          limit: { type: "number", description: "Maximum search hits to consider. Default 8." },
+          maxChars: { type: "number", description: "Maximum total characters of bundled context. Default 12000." },
+          pathSubstring: { type: "string", description: "Optional file path substring filter." }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "get_chunks",
+      description: "Fetch exact indexed chunks by id after a search step.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Chunk ids returned by search."
+          }
+        },
+        required: ["ids"]
+      }
+    },
+    {
+      name: "list_roots",
+      description: "List approved indexed roots.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "delete_root",
+      description: "Delete one indexed root from config and vector storage.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          rootId: { type: "string", description: "Root identifier returned by list_roots." }
+        },
+        required: ["rootId"]
+      }
+    },
+    {
+      name: "store_status",
+      description: "Inspect Qdrant collection status for the local index.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    switch (request.params.name) {
+      case "index_path": {
+        const args = request.params.arguments;
+        if (!args?.path) {
+          throw new OwnSearchError("`path` is required.");
+        }
+        const result = await indexPath(args.path, { name: args.name });
+        return asText(result);
+      }
+      case "search": {
+        const args = request.params.arguments;
+        if (!args?.query) {
+          throw new OwnSearchError("`query` is required.");
+        }
+        const vector = await embedQuery(args.query);
+        const store = await createStore();
+        const hits = await store.search(
+          vector,
+          {
+            rootIds: args.rootIds,
+            pathSubstring: args.pathSubstring
+          },
+          Math.max(1, Math.min(args.limit ?? 5, 20))
+        );
+        return asText({
+          query: args.query,
+          hits
+        });
+      }
+      case "search_context": {
+        const args = request.params.arguments;
+        if (!args?.query) {
+          throw new OwnSearchError("`query` is required.");
+        }
+        const vector = await embedQuery(args.query);
+        const store = await createStore();
+        const hits = await store.search(
+          vector,
+          {
+            rootIds: args.rootIds,
+            pathSubstring: args.pathSubstring
+          },
+          Math.max(1, Math.min(args.limit ?? 8, 20))
+        );
+        return asText(buildContextBundle(args.query, hits, Math.max(500, args.maxChars ?? 12e3)));
+      }
+      case "get_chunks": {
+        const args = request.params.arguments;
+        if (!args?.ids?.length) {
+          throw new OwnSearchError("`ids` is required.");
+        }
+        const store = await createStore();
+        const chunks = await store.getChunks(args.ids);
+        return asText({ chunks });
+      }
+      case "list_roots": {
+        const config = await loadConfig();
+        return asText({ roots: config.roots });
+      }
+      case "delete_root": {
+        const args = request.params.arguments;
+        if (!args?.rootId) {
+          throw new OwnSearchError("`rootId` is required.");
+        }
+        const root = await findRoot(args.rootId);
+        if (!root) {
+          throw new OwnSearchError(`Unknown root: ${args.rootId}`);
+        }
+        const store = await createStore();
+        await store.deleteRoot(root.id);
+        await deleteRootDefinition(root.id);
+        return asText({
+          deleted: true,
+          root
+        });
+      }
+      case "store_status": {
+        const store = await createStore();
+        return asText(await store.getStatus());
+      }
+      default:
+        throw new OwnSearchError(`Unknown tool: ${request.params.name}`);
+    }
+  } catch (error) {
+    return asError(error);
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "ownsearch",
+  "version": "0.1.0",
+  "description": "Text-first local document search MCP server backed by Gemini embeddings and Qdrant.",
+  "type": "module",
+  "bin": {
+    "ownsearch": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts src/mcp/server.ts --format esm --dts --clean --external pdf-parse",
+    "dev": "tsx src/cli.ts",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "serve-mcp": "tsx src/mcp/server.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "mcp",
+    "search",
+    "embeddings",
+    "gemini",
+    "qdrant",
+    "rag"
+  ],
+  "author": "OwnSearch contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@personal/Grumppie/OwnSearch.git"
+  },
+  "homepage": "https://github.com/Grumppie/OwnSearch#readme",
+  "bugs": {
+    "url": "https://github.com/Grumppie/OwnSearch/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@google/genai": "^1.46.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@qdrant/js-client-rest": "^1.17.0",
+    "commander": "^14.0.1",
+    "dotenv": "^17.3.1",
+    "pdf-parse": "^2.4.5",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@types/pdf-parse": "^1.1.5",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}