@grumppie/ownsearch 0.1.3

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import {
+  OwnSearchError,
+  buildContextBundle,
+  createStore,
+  deleteRootDefinition,
+  embedQuery,
+  findRoot,
+  getConfigPath,
+  getEnvPath,
+  indexPath,
+  listRoots,
+  loadConfig,
+  loadOwnSearchEnv,
+  saveGeminiApiKey
+} from "./chunk-LGXCBOO4.js";
+
+// src/cli.ts
+import path from "path";
+import { spawn } from "child_process";
+import readline from "readline/promises";
+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
+loadOwnSearchEnv();
+var program = new Command();
+var PACKAGE_NAME = "@grumppie/ownsearch";
+function requireGeminiKey() {
+  if (!process.env.GEMINI_API_KEY) {
+    throw new OwnSearchError("Set GEMINI_API_KEY before running OwnSearch.");
+  }
+}
+async function promptForGeminiKey() {
+  if (process.env.GEMINI_API_KEY || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return Boolean(process.env.GEMINI_API_KEY);
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const apiKey = (await rl.question(
+      `Enter GEMINI_API_KEY to save in ${getEnvPath()} (leave blank to skip): `
+    )).trim();
+    if (!apiKey) {
+      return false;
+    }
+    await saveGeminiApiKey(apiKey);
+    process.env.GEMINI_API_KEY = apiKey;
+    return true;
+  } finally {
+    rl.close();
+  }
+}
+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();
+  const geminiApiKeyPresent = await promptForGeminiKey();
+  console.log(JSON.stringify({
+    configPath: getConfigPath(),
+    envPath: getEnvPath(),
+    qdrantUrl: config.qdrantUrl,
+    qdrantStarted: result.started,
+    geminiApiKeyPresent
+  }, null, 2));
+  if (!geminiApiKeyPresent) {
+    console.log(`GEMINI_API_KEY is not set. Re-run setup or add it to ${getEnvPath()} before indexing or search.`);
+  }
+});
+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(),
+    envPath: getEnvPath(),
+    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", PACKAGE_NAME, "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,243 @@
+#!/usr/bin/env node
+import {
+  OwnSearchError,
+  buildContextBundle,
+  createStore,
+  deleteRootDefinition,
+  embedQuery,
+  findRoot,
+  indexPath,
+  loadConfig,
+  loadOwnSearchEnv
+} from "../chunk-LGXCBOO4.js";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+loadOwnSearchEnv();
+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": "@grumppie/ownsearch",
+  "version": "0.1.3",
+  "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": "https://github.com/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"
+  }
+}