docshark 0.1.13 → 0.1.16

package/dist/cli.js

@@ -1,23 +1,30 @@
 #!/usr/bin/env bun
 // src/cli.ts — DocShark CLI entry point
-import { Command } from "commander";
+import { cac } from "cac";
 import { startHttpServer } from "./http.js";
 import { StdioTransport } from "@tmcp/transport-stdio";
 import { server, db, searchEngine, libraryService } from "./server.js";
 import { maybeNotifyAboutUpdate, runUpdateCommand } from "./cli-update.js";
 import { VERSION } from "./version.js";
-const program = new Command()
-    .name("docshark")
-    .description("🦈 Documentation MCP Server — scrape, index, and search any doc website")
-    .version(VERSION, "-v, --version", "output the current version");
-program
-    .command("start", { isDefault: true })
+const useColor = process.stdout.isTTY;
+const color = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m",
+    gray: "\x1b[90m",
+};
+const cli = cac("docshark");
+cli
+    .command("", "Start the MCP server")
+    .alias("start")
     .alias("s")
-    .description("Start the MCP server (aliases: s, -s)")
-    .option("-p, --port <port>", "HTTP server port", "6380")
+    .option("-p, --port <port>", "HTTP server port", { default: "6380" })
     .option("-S, --stdio", "Run in STDIO mode (for Claude Desktop, Cursor, etc.)")
-    .option("-D, --data-dir <path>", "Data directory", "")
+    .option("-D, --data-dir <path>", "Data directory")
     .action(async (opts) => {
+    await maybeNotifyForCommand("start", opts.stdio === true);
     if (opts.dataDir) {
         process.env.DOCSHARK_DATA_DIR = opts.dataDir;
     }
@@ -31,14 +38,70 @@ program
         await startHttpServer(parseInt(opts.port));
     }
 });
-program
-    .command("add <url>")
+const helpCommands = [
+    {
+        name: "start",
+        aliases: ["s", "-s"],
+        args: "",
+        description: "Start server",
+    },
+    {
+        name: "add",
+        aliases: ["a", "-a"],
+        args: "<url>",
+        description: "Add & crawl library",
+    },
+    {
+        name: "search",
+        aliases: ["f", "-f"],
+        args: "<query>",
+        description: "Search docs",
+    },
+    {
+        name: "list",
+        aliases: ["l", "-l"],
+        args: "",
+        description: "List libraries",
+    },
+    {
+        name: "refresh",
+        aliases: ["r", "-r"],
+        args: "<name>",
+        description: "Refresh library",
+    },
+    {
+        name: "remove",
+        aliases: ["rm", "-rm"],
+        args: "<name>",
+        description: "Remove library",
+    },
+    {
+        name: "get",
+        aliases: ["g", "-g"],
+        args: "[url]",
+        description: "Get page markdown",
+    },
+    {
+        name: "update",
+        aliases: ["u", "-u"],
+        args: "",
+        description: "Update DocShark",
+    },
+    {
+        name: "info",
+        aliases: ["i", "-i"],
+        args: "<name>",
+        description: "Library info + pages",
+    },
+];
+cli
+    .command("add <url>", "Add a documentation library and start crawling")
     .alias("a")
-    .description("Add a documentation library and start crawling (aliases: a, -a)")
     .option("-n, --name <name>", "Library name (auto-generated from URL if omitted)")
-    .option("-d, --depth <n>", "Max crawl depth", "3")
+    .option("-d, --depth <n>", "Max crawl depth", { default: "3" })
     .option("-V, --lib-version <version>", "Library version")
     .action(async (url, opts) => {
+    await maybeNotifyForCommand("add");
     db.init();
     try {
         const lib = await libraryService.add({
@@ -58,13 +121,36 @@ program
         process.exit(1);
     }
 });
-program
-    .command("search <query>")
+cli.command("help [command]", "Show help for a command").action((command) => {
+    if (command) {
+        printCommandHelp(command);
+        return;
+    }
+    printRootHelp();
+});
+cli
+    .command("rename <current-name> <new-name>", "Rename an existing documentation library")
+    .alias("mv")
+    .action(async (currentName, newName) => {
+    await maybeNotifyForCommand("rename");
+    db.init();
+    try {
+        const library = libraryService.rename({ currentName, newName });
+        console.log(`\n✅ Renamed library to "${library.display_name}" (${library.name}).\n`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        console.error(`\n❌ ${message}\n`);
+        process.exit(1);
+    }
+});
+cli
+    .command("search <query>", "Search indexed documentation")
     .alias("f")
-    .description("Search indexed documentation (aliases: f, -f)")
     .option("-l, --library <name>", "Filter by library")
-    .option("-m, --limit <n>", "Max results", "5")
+    .option("-m, --limit <n>", "Max results", { default: "5" })
     .action(async (query, opts) => {
+    await maybeNotifyForCommand("search");
     db.init();
     const results = searchEngine.search(query, {
         library: opts.library,
@@ -81,12 +167,12 @@ program
         console.log(`Source: ${r.page_url}\n`);
     }
 });
-program
-    .command("list")
+cli
+    .command("list", "List indexed libraries")
     .alias("l")
-    .description("List indexed libraries (aliases: l, -l)")
-    .option("-s, --status <status>", "Filter by status (indexed, crawling, error, all)", "all")
-    .action((opts) => {
+    .option("-s, --status <status>", "Filter by status (indexed, crawling, error, all)", { default: "all" })
+    .action(async (opts) => {
+    await maybeNotifyForCommand("list");
     db.init();
     const libs = db.listLibraries(opts.status);
     if (libs.length === 0) {
@@ -102,11 +188,11 @@ program
         "Last Crawled": l.last_crawled_at || "never",
     })));
 });
-program
-    .command("refresh <name>")
+cli
+    .command("refresh <name>", "Refresh an existing documentation library")
     .alias("r")
-    .description("Refresh an existing documentation library (aliases: r, -r)")
     .action(async (name) => {
+    await maybeNotifyForCommand("refresh");
     db.init();
     try {
         const lib = db.getLibraryByName(name);
@@ -123,11 +209,11 @@ program
         process.exit(1);
     }
 });
-program
-    .command("remove <name>")
+cli
+    .command("remove <name>", "Remove a documentation library and its index")
     .alias("rm")
-    .description("Remove a documentation library and its index (aliases: rm, -rm)")
-    .action((name) => {
+    .action(async (name) => {
+    await maybeNotifyForCommand("remove");
     db.init();
     try {
         const lib = db.getLibraryByName(name);
@@ -141,13 +227,13 @@ program
         process.exit(1);
     }
 });
-program
-    .command("get [url]")
+cli
+    .command("get [url]", "Get the full markdown content of a specific indexed page")
     .alias("g")
-    .description("Get the full markdown content of a specific indexed page (aliases: g, -g)")
     .option("-l, --library <name>", "Library name to search within")
     .option("-p, --path <path>", "Relative path within the library")
-    .action((url, opts) => {
+    .action(async (url, opts) => {
+    await maybeNotifyForCommand("get");
     if (!url && (!opts.library || !opts.path)) {
         console.error(`\n❌ Please provide either a URL, or both --library and --path\n`);
         process.exit(1);
@@ -163,20 +249,20 @@ program
     console.log(page.content_markdown);
     console.log("\n");
 });
-program
-    .command("update")
+cli
+    .command("update", "Update the global Bun installation of DocShark")
     .alias("u")
-    .description("Update the global Bun installation of DocShark (aliases: u, -u)")
     .option("-c, --check", "Only check whether a newer DocShark version is available")
     .option("-q, --quiet", "Suppress DocShark status output and rely on exit codes")
     .action(async (opts) => {
+    await maybeNotifyForCommand("update");
     await runUpdateCommand({
         checkOnly: opts.check,
         quiet: opts.quiet,
     });
 });
 // Intercept manual short flags (e.g., -l instead of l) so they act as command aliases
-const args = process.argv;
+const args = process.argv.slice(2);
 const cmdAliases = {
     "-s": "start",
     "-a": "add",
@@ -188,14 +274,29 @@ const cmdAliases = {
     "-i": "info",
     "-u": "update",
 };
-if (args[2] && cmdAliases[args[2]]) {
-    args[2] = cmdAliases[args[2]];
+const normalizedArgs = [...args];
+if (normalizedArgs[0] && cmdAliases[normalizedArgs[0]]) {
+    normalizedArgs[0] = cmdAliases[normalizedArgs[0]];
+}
+const helpRequest = getHelpRequest(normalizedArgs);
+if (helpRequest === "root") {
+    printRootHelp();
+    process.exit(0);
 }
-program
-    .command("info <name>")
+if (helpRequest && helpRequest !== "root") {
+    printCommandHelp(helpRequest);
+    process.exit(0);
+}
+if (normalizedArgs.includes("-v") || normalizedArgs.includes("--version")) {
+    printVersion();
+    process.exit(0);
+}
+const parseArgv = [process.argv[0], process.argv[1], ...normalizedArgs];
+cli
+    .command("info <name>", "Get information about a library and list its pages")
     .alias("i")
-    .description("Get information about a library and list its pages (aliases: i, -i)")
-    .action((name) => {
+    .action(async (name) => {
+    await maybeNotifyForCommand("info");
     db.init();
     const lib = db.getLibraryByName(name);
     if (!lib) {
@@ -221,17 +322,13 @@ program
         console.log(`\nNo pages found for this library.\n`);
     }
 });
-program.hook("preAction", async (_thisCommand, actionCommand) => {
-    const commandName = actionCommand.name();
-    const options = typeof actionCommand.opts === "function"
-        ? actionCommand.opts()
-        : {};
-    await maybeNotifyAboutUpdate({
-        commandName,
-        stdioMode: commandName === "start" && options.stdio === true,
-    });
-});
-await program.parseAsync(args);
+try {
+    cli.parse(parseArgv, { run: false });
+    await cli.runMatchedCommand();
+}
+catch (error) {
+    handleCliError(error);
+}
 /** Helper to wait for a crawl job to finish (CLI blocking mode) */
 async function waitForCrawl(jobId) {
     const { jobManager } = await import("./server.js");
@@ -256,3 +353,94 @@ async function waitForCrawl(jobId) {
         check();
     });
 }
+async function maybeNotifyForCommand(commandName, stdioMode = false) {
+    await maybeNotifyAboutUpdate({ commandName, stdioMode });
+}
+function getHelpRequest(args) {
+    if (args.length === 0) {
+        return null;
+    }
+    if (args[0] === "-h" || args[0] === "--help") {
+        return "root";
+    }
+    if (args[0] === "help") {
+        return args[1] ? normalizeCommandName(args[1]) : "root";
+    }
+    if (args[1] === "help") {
+        return normalizeCommandName(args[0]);
+    }
+    if (args.includes("-h") || args.includes("--help")) {
+        return normalizeCommandName(args[0]);
+    }
+    return null;
+}
+function normalizeCommandName(name) {
+    return cmdAliases[name] ?? name;
+}
+function printVersion() {
+    console.log(`${paint("DocShark", color.cyan)} ${VERSION}`);
+}
+function printRootHelp() {
+    printHeader();
+    console.log(`${paint("USAGE", color.gray)}`);
+    console.log(`  docshark [options] [command]\n`);
+    console.log(`${paint("OPTIONS", color.gray)}`);
+    console.log(`  ${paint("-v, --version", color.cyan).padEnd(18)} Show version`);
+    console.log(`  ${paint("-h, --help", color.cyan).padEnd(18)} Show this help\n`);
+    console.log(`${paint("COMMANDS", color.gray)}`);
+    const rows = helpCommands.map((command) => ({
+        primary: [
+            command.name,
+            ...command.aliases.filter((alias) => !alias.startsWith("-")),
+        ].join(", "),
+        shortAliases: command.aliases.filter((alias) => alias.startsWith("-")),
+        args: command.args,
+        description: command.description,
+    }));
+    const primaryWidth = Math.max(...rows.map((row) => row.primary.length));
+    const argsWidth = Math.max(...rows.map((row) => row.args.length));
+    for (const row of rows) {
+        const aliasSuffix = row.shortAliases.length > 0
+            ? `  [aliases: ${row.shortAliases.join(", ")}]`
+            : "";
+        const label = `${row.primary.padEnd(primaryWidth)}${row.args ? ` ${row.args.padEnd(argsWidth)}` : `${"".padEnd(argsWidth + 1)}`}${aliasSuffix}`.trimEnd();
+        console.log(`  ${paint(label.padEnd(36), color.cyan)} ${row.description}`);
+    }
+    console.log(`\n${paint("Run `docshark help <command>` for more information.", color.dim)}`);
+}
+function printCommandHelp(commandName) {
+    const command = helpCommands.find((item) => item.name === normalizeCommandName(commandName));
+    printHeader();
+    if (!command) {
+        console.log(`${paint(`Unknown command: ${commandName}`, color.cyan)}\n`);
+        printRootHelp();
+        return;
+    }
+    console.log(`${paint("USAGE", color.gray)}`);
+    console.log(`  docshark ${command.name} ${command.args ? paint(command.args, color.yellow) : ""}`.trimEnd());
+    console.log(``);
+    console.log(`${paint("ALIASES", color.gray)}`);
+    console.log(`  ${command.aliases.join(", ")}\n`);
+    console.log(`${paint("SUMMARY", color.gray)}`);
+    console.log(`  ${command.description}\n`);
+    console.log(`${paint("Run `docshark help` to see all commands.", color.dim)}`);
+}
+function printHeader() {
+    console.log();
+    console.log(`${paint("🦈 DocShark", color.cyan)}  ${paint("Documentation MCP Server", color.bold)}`);
+    console.log(`   ${paint("Scrape • Index • Search any docs site", color.dim)}\n`);
+}
+function paint(text, code) {
+    if (!useColor) {
+        return text;
+    }
+    return `${code}${text}${color.reset}`;
+}
+function handleCliError(error) {
+    const message = error instanceof Error ? error.message : "Unknown command error";
+    const prettyMessage = message.startsWith("Unused args:")
+        ? "Too many arguments passed. Run `docshark help <command>` for usage."
+        : message;
+    console.error(`\n❌ ${prettyMessage}\n`);
+    process.exit(1);
+}

package/dist/server.d.ts

@@ -1,10 +1,10 @@
-import { McpServer } from 'tmcp';
-import * as v from 'valibot';
-import { Database } from './storage/db.js';
-import { SearchEngine } from './storage/search.js';
-import { LibraryService } from './services/library.js';
-import { JobManager } from './jobs/manager.js';
-import { EventBus } from './jobs/events.js';
+import { McpServer } from "tmcp";
+import * as v from "valibot";
+import { Database } from "./storage/db.js";
+import { SearchEngine } from "./storage/search.js";
+import { LibraryService } from "./services/library.js";
+import { JobManager } from "./jobs/manager.js";
+import { EventBus } from "./jobs/events.js";
 export declare const db: Database;
 export declare const eventBus: EventBus;
 export declare const searchEngine: SearchEngine;

package/dist/server.js

@@ -1,14 +1,14 @@
 // src/server.ts — TMCP McpServer setup + tool registration
-import { McpServer } from 'tmcp';
-import { ValibotJsonSchemaAdapter } from '@tmcp/adapter-valibot';
-import * as v from 'valibot';
-import { tool } from 'tmcp/utils';
-import { Database } from './storage/db.js';
-import { SearchEngine } from './storage/search.js';
-import { LibraryService } from './services/library.js';
-import { JobManager } from './jobs/manager.js';
-import { VERSION } from './version.js';
-import { EventBus } from './jobs/events.js';
+import { McpServer } from "tmcp";
+import { ValibotJsonSchemaAdapter } from "@tmcp/adapter-valibot";
+import * as v from "valibot";
+import { tool } from "tmcp/utils";
+import { Database } from "./storage/db.js";
+import { SearchEngine } from "./storage/search.js";
+import { LibraryService } from "./services/library.js";
+import { JobManager } from "./jobs/manager.js";
+import { VERSION } from "./version.js";
+import { EventBus } from "./jobs/events.js";
 // Initialize core services
 export const db = new Database();
 export const eventBus = new EventBus();
@@ -17,9 +17,9 @@ export const jobManager = new JobManager(db, eventBus);
 export const libraryService = new LibraryService(db, jobManager);
 // Create TMCP server
 export const server = new McpServer({
-    name: 'docshark',
+    name: "docshark",
     version: VERSION,
-    description: '🦈 Documentation MCP Server — scrape, index, and search any doc website',
+    description: "🦈 Documentation MCP Server — scrape, index, and search any doc website",
 }, {
     adapter: new ValibotJsonSchemaAdapter(),
     capabilities: {
@@ -31,14 +31,14 @@ export const server = new McpServer({
 // Tool 1: search_docs — Primary search tool
 // ──────────────────────────────────────
 server.tool({
-    name: 'search_docs',
-    description: 'Search through indexed documentation libraries for relevant information. ' +
-        'Returns ranked documentation sections with code examples and source URLs. ' +
-        'Use this when you need to find information about a library, framework, API, ' +
-        'or any technical concept.',
+    name: "search_docs",
+    description: "Search through indexed documentation libraries for relevant information. " +
+        "Returns ranked documentation sections with code examples and source URLs. " +
+        "Use this when you need to find information about a library, framework, API, " +
+        "or any technical concept.",
     schema: v.object({
-        query: v.pipe(v.string(), v.description('Search query. Use natural language.')),
-        library: v.optional(v.pipe(v.string(), v.description('Filter to a specific library.'))),
+        query: v.pipe(v.string(), v.description("Search query. Use natural language.")),
+        library: v.optional(v.pipe(v.string(), v.description("Filter to a specific library."))),
         limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(20)), 5),
     }),
 }, async ({ query, library, limit }) => {
@@ -53,27 +53,59 @@ server.tool({
         block += r.content;
         return block;
     })
-        .join('\n\n---\n\n');
+        .join("\n\n---\n\n");
     return tool.text(`## Results for "${query}"\n\n${formatted}`);
 });
+function requireValue(value, message) {
+    if (value === undefined || value === null || value === "") {
+        throw new Error(message);
+    }
+    return value;
+}
+function formatLibraryInfo(libraryId) {
+    const lib = db.getLibraryById(libraryId);
+    if (!lib) {
+        return `Library not found.`;
+    }
+    const pages = db.getPagesByLibrary(lib.id);
+    let output = `## Library: ${lib.display_name} (${lib.name})\n`;
+    output += `- **URL:** ${lib.url}\n`;
+    output += `- **Status:** ${lib.status}\n`;
+    output += `- **Pages:** ${lib.page_count}\n`;
+    output += `- **Chunks:** ${lib.chunk_count}\n`;
+    output += `- **Last Crawled:** ${lib.last_crawled_at || "never"}\n\n`;
+    if (pages.length > 0) {
+        output += `### Pages (${pages.length})\n\n`;
+        output += "| Title | Path | URL |\n";
+        output += "| ----- | ---- | --- |\n";
+        for (const p of pages) {
+            const title = p.title?.replace(/\|/g, "-") || "Untitled";
+            output += `| ${title} | \`${p.path}\` | ${p.url} |\n`;
+        }
+    }
+    else {
+        output += `*No pages indexed yet for this library.*\n`;
+    }
+    return output;
+}
 // ──────────────────────────────────────
 // Tool 2: list_libraries — Discovery tool
 // ──────────────────────────────────────
 server.tool({
-    name: 'list_libraries',
-    description: 'List all documentation libraries currently indexed and available for searching. ' +
-        'Use this to discover what docs are available before running search_docs.',
+    name: "list_libraries",
+    description: "List all documentation libraries currently indexed and available for searching. " +
+        "Use this to discover what docs are available before running search_docs.",
     schema: v.object({
-        status: v.optional(v.pipe(v.picklist(['indexed', 'crawling', 'error', 'all']), v.description('Filter by status. Default: "all".')), 'all'),
+        status: v.optional(v.pipe(v.picklist(["indexed", "crawling", "error", "all"]), v.description('Filter by status. Default: "all".')), "all"),
     }),
 }, async ({ status }) => {
     const libraries = db.listLibraries(status);
     if (libraries.length === 0) {
-        return tool.text('No libraries indexed yet. Use add_library to add a documentation website.');
+        return tool.text("No libraries indexed yet. Use manage_library with action=add to add a documentation website.");
     }
     let output = `## Indexed Libraries (${libraries.length} total)\n\n`;
-    output += '| Library | URL | Pages | Chunks | Status |\n';
-    output += '| ------- | --- | ----- | ------ | ------ |\n';
+    output += "| Library | URL | Pages | Chunks | Status |\n";
+    output += "| ------- | --- | ----- | ------ | ------ |\n";
     for (const lib of libraries) {
         output += `| ${lib.name} | ${lib.url} | ${lib.page_count} | ${lib.chunk_count} | ${lib.status} |\n`;
     }
@@ -83,107 +115,85 @@ server.tool({
 // Tool 3: get_doc_page — Full page read
 // ──────────────────────────────────────
 server.tool({
-    name: 'get_doc_page',
-    description: 'Retrieve the complete content of a specific documentation page as markdown. ' +
-        'Use when search results reference a page and you need full context.',
+    name: "get_doc_page",
+    description: "Retrieve the complete content of a specific documentation page as markdown. " +
+        "Use when search results reference a page and you need full context.",
     schema: v.object({
-        url: v.optional(v.pipe(v.string(), v.description('The full URL of the documentation page.'))),
-        library: v.optional(v.pipe(v.string(), v.description('Library name to search within.'))),
-        path: v.optional(v.pipe(v.string(), v.description('Relative path within the library.'))),
+        url: v.optional(v.pipe(v.string(), v.description("The full URL of the documentation page."))),
+        library: v.optional(v.pipe(v.string(), v.description("Library name to search within."))),
+        path: v.optional(v.pipe(v.string(), v.description("Relative path within the library."))),
     }),
 }, async ({ url, library, path }) => {
     const page = db.getPage({ url, library, path });
     if (!page)
-        return tool.text('Page not found. Use search_docs to find the correct page.');
+        return tool.text("Page not found. Use search_docs to find the correct page.");
     return tool.text(`# ${page.title}\n**Source:** ${page.url}\n\n${page.content_markdown}`);
 });
 // ──────────────────────────────────────
-// Tool 4: add_library — Add new doc source
+// Tool 4: manage_library — Create, rename, refresh, remove, inspect
 // ──────────────────────────────────────
 server.tool({
-    name: 'add_library',
-    description: 'Add a new documentation library to be crawled and indexed. ' +
-        'Provide the URL and an optional name. Crawl runs in the background.',
+    name: "manage_library",
+    description: "Manage a documentation library lifecycle. Use action=add to crawl a new source, action=rename to change the library name, action=refresh to re-crawl, action=remove to delete it, or action=info to inspect its pages and stats.",
     schema: v.object({
-        url: v.pipe(v.string(), v.url(), v.description('Base URL of the documentation website.')),
-        name: v.optional(v.pipe(v.string(), v.description('Short identifier (auto-generated if omitted).'))),
-        version: v.optional(v.pipe(v.string(), v.description('Version string.'))),
+        action: v.pipe(v.picklist(["add", "rename", "refresh", "remove", "info"]), v.description("The management action to perform.")),
+        url: v.optional(v.pipe(v.string(), v.url(), v.description("Base URL of the documentation website."))),
+        name: v.optional(v.pipe(v.string(), v.description("Short identifier (auto-generated if omitted)."))),
+        version: v.optional(v.pipe(v.string(), v.description("Version string."))),
         max_depth: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(10)), 3),
+        current_name: v.optional(v.pipe(v.string(), v.description("The current library name (for rename)."))),
+        new_name: v.optional(v.pipe(v.string(), v.description("The new library name (for rename)."))),
+        library: v.optional(v.pipe(v.string(), v.description("The library name to manage."))),
     }),
-}, async ({ url, name, version, max_depth }) => {
+}, async (input) => {
     try {
-        const library = await libraryService.add({ url, name, version, maxDepth: max_depth });
-        return tool.text(`✅ Library "${library.display_name}" added.\n` +
-            `Crawl job ${library.jobId} started. Use list_libraries to check progress.`);
-    }
-    catch (err) {
-        return tool.text(`❌ Failed: ${err.message}`);
-    }
-});
-// ──────────────────────────────────────
-// Tool 5: refresh_library — Re-crawl
-// ──────────────────────────────────────
-server.tool({
-    name: 'refresh_library',
-    description: 'Re-crawl and re-index an existing documentation library to get the latest content.',
-    schema: v.object({
-        library: v.pipe(v.string(), v.description('The library name to refresh.')),
-    }),
-}, async ({ library }) => {
-    const lib = db.getLibraryByName(library);
-    if (!lib)
-        return tool.text(`Library "${library}" not found. Use list_libraries to see available.`);
-    const job = jobManager.startCrawl(lib.id, { incremental: true });
-    return tool.text(`🔄 Refresh started for "${lib.display_name}".\nJob ${job.id}: checking for updated pages...`);
-});
-// ──────────────────────────────────────
-// Tool 6: remove_library — Delete
-// ──────────────────────────────────────
-server.tool({
-    name: 'remove_library',
-    description: 'Remove a documentation library and all its indexed content permanently.',
-    schema: v.object({
-        library: v.pipe(v.string(), v.description('The library name to remove.')),
-    }),
-}, async ({ library }) => {
-    const lib = db.getLibraryByName(library);
-    if (!lib)
-        return tool.text(`Library "${library}" not found.`);
-    db.removeLibrary(lib.id);
-    return tool.text(`🗑️ Library "${lib.display_name}" removed.\nDeleted ${lib.page_count} pages and ${lib.chunk_count} chunks.`);
-});
-// ──────────────────────────────────────
-// Tool 7: library_info — detailed stats and pages
-// ──────────────────────────────────────
-server.tool({
-    name: 'library_info',
-    description: 'Get detailed information about a specific documentation library, including a list of all its indexed pages and their paths. ' +
-        'Use this to see what pages are available in a library before retrieving them.',
-    schema: v.object({
-        library: v.pipe(v.string(), v.description('The library name to get information for.')),
-    }),
-}, async ({ library }) => {
-    const lib = db.getLibraryByName(library);
-    if (!lib)
-        return tool.text(`Library "${library}" not found. Use list_libraries to see available libraries.`);
-    const pages = db.getPagesByLibrary(lib.id);
-    let output = `## Library: ${lib.display_name} (${lib.name})\n`;
-    output += `- **URL:** ${lib.url}\n`;
-    output += `- **Status:** ${lib.status}\n`;
-    output += `- **Pages:** ${lib.page_count}\n`;
-    output += `- **Chunks:** ${lib.chunk_count}\n`;
-    output += `- **Last Crawled:** ${lib.last_crawled_at || 'never'}\n\n`;
-    if (pages.length > 0) {
-        output += `### Pages (${pages.length})\n\n`;
-        output += '| Title | Path | URL |\n';
-        output += '| ----- | ---- | --- |\n';
-        for (const p of pages) {
-            const title = p.title?.replace(/\|/g, '-') || 'Untitled';
-            output += `| ${title} | \`${p.path}\` | ${p.url} |\n`;
+        switch (input.action) {
+            case "add": {
+                const url = requireValue(input.url, "The URL is required for action=add.");
+                const library = await libraryService.add({
+                    url,
+                    name: input.name,
+                    version: input.version,
+                    maxDepth: input.max_depth,
+                });
+                return tool.text(`✅ Library "${library.display_name}" added.\n` +
+                    `Crawl job ${library.jobId} started. Use list_libraries to check progress.`);
+            }
+            case "rename": {
+                const currentName = requireValue(input.current_name, "current_name is required for action=rename.");
+                const newName = requireValue(input.new_name, "new_name is required for action=rename.");
+                const library = libraryService.rename({ currentName, newName });
+                return tool.text(`✅ Library renamed to "${library.display_name}" (${library.name}).\n` +
+                    `Pages and crawl history remain attached to the same library.`);
+            }
+            case "refresh": {
+                const libraryName = requireValue(input.library, "library is required for action=refresh.");
+                const lib = db.getLibraryByName(libraryName);
+                if (!lib)
+                    return tool.text(`Library "${libraryName}" not found. Use list_libraries to see available.`);
+                const job = jobManager.startCrawl(lib.id, { incremental: true });
+                return tool.text(`🔄 Refresh started for "${lib.display_name}".\nJob ${job.id}: checking for updated pages...`);
+            }
+            case "remove": {
+                const libraryName = requireValue(input.library, "library is required for action=remove.");
+                const lib = db.getLibraryByName(libraryName);
+                if (!lib)
+                    return tool.text(`Library "${libraryName}" not found.`);
+                db.removeLibrary(lib.id);
+                return tool.text(`🗑️ Library "${lib.display_name}" removed.\nDeleted ${lib.page_count} pages and ${lib.chunk_count} chunks.`);
+            }
+            case "info": {
+                const libraryName = requireValue(input.library, "library is required for action=info.");
+                const lib = db.getLibraryByName(libraryName);
+                if (!lib)
+                    return tool.text(`Library "${libraryName}" not found. Use list_libraries to see available libraries.`);
+                return tool.text(formatLibraryInfo(lib.id));
+            }
         }
     }
-    else {
-        output += `*No pages indexed yet for this library.*\n`;
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return tool.text(`❌ Failed: ${message}`);
     }
-    return tool.text(output);
+    return tool.text(`❌ Failed: Unsupported action.`);
 });

package/dist/services/library.d.ts

@@ -1,6 +1,6 @@
-import type { Database } from '../storage/db.js';
-import type { JobManager } from '../jobs/manager.js';
-import type { Library } from '../types.js';
+import type { Database } from "../storage/db.js";
+import type { JobManager } from "../jobs/manager.js";
+import type { Library } from "../types.js";
 export declare class LibraryService {
     private db;
     private jobManager;
@@ -14,4 +14,9 @@ export declare class LibraryService {
     }): Promise<Library & {
         jobId: string;
     }>;
+    /** Rename an existing documentation library */
+    rename(opts: {
+        currentName: string;
+        newName: string;
+    }): Library;
 }

package/dist/services/library.js

@@ -1,5 +1,5 @@
 // src/services/library.ts — Library management service
-import { nanoid } from 'nanoid';
+import { nanoid } from "nanoid";
 export class LibraryService {
     db;
     jobManager;
@@ -15,12 +15,12 @@ export class LibraryService {
         // Check if already exists
         const existing = this.db.getLibraryByName(name);
         if (existing) {
-            throw new Error(`Library "${name}" already exists. Use refresh_library to re-crawl.`);
+            throw new Error(`Library "${name}" already exists. Use manage_library with action=refresh to re-crawl.`);
         }
         const id = nanoid();
         const crawlConfig = {
             maxDepth: opts.maxDepth ?? 3,
-            renderer: 'auto',
+            renderer: "auto",
         };
         this.db.addLibrary({
             id,
@@ -35,32 +35,62 @@ export class LibraryService {
         const library = this.db.getLibraryById(id);
         return { ...library, jobId: job.id };
     }
+    /** Rename an existing documentation library */
+    rename(opts) {
+        const currentName = opts.currentName.trim();
+        const newName = opts.newName.trim();
+        if (!currentName) {
+            throw new Error("Current library name is required.");
+        }
+        if (!newName) {
+            throw new Error("New library name is required.");
+        }
+        const library = this.db.getLibraryByName(currentName);
+        if (!library) {
+            throw new Error(`Library "${currentName}" not found.`);
+        }
+        if (library.name === newName) {
+            return library;
+        }
+        const existing = this.db.getLibraryByName(newName);
+        if (existing && existing.id !== library.id) {
+            throw new Error(`Library "${newName}" already exists.`);
+        }
+        const displayName = generateDisplayName(newName);
+        this.db.renameLibrary(library.id, newName, displayName);
+        const updated = this.db.getLibraryById(library.id);
+        if (!updated) {
+            throw new Error(`Failed to rename library "${currentName}".`);
+        }
+        return updated;
+    }
 }
 /** Normalize URL: ensure trailing slash for base docs */
 function normalizeUrl(url) {
     const parsed = new URL(url);
     // Remove trailing hash and query for base URL
-    parsed.hash = '';
+    parsed.hash = "";
     return parsed.href;
 }
 /** Generate a slug name from URL */
 function generateName(url) {
     const parsed = new URL(url);
-    const host = parsed.hostname.replace(/^www\./, '');
-    const path = parsed.pathname.replace(/\/$/, '').replace(/^\//, '');
+    const host = parsed.hostname.replace(/^www\./, "");
+    const path = parsed.pathname.replace(/\/$/, "").replace(/^\//, "");
     if (path) {
         // e.g. svelte.dev/docs → "svelte-docs"
-        const hostPart = host.split('.')[0];
-        const pathPart = path.split('/').slice(0, 2).join('-');
-        return `${hostPart}-${pathPart}`.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+        const hostPart = host.split(".")[0];
+        const pathPart = path.split("/").slice(0, 2).join("-");
+        return `${hostPart}-${pathPart}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     }
     // Just the hostname
-    return host.replace(/\./g, '-').toLowerCase();
+    return host.replace(/\./g, "-").toLowerCase();
 }
 /** Generate a display name from the slug */
 function generateDisplayName(name) {
     return name
-        .split('-')
+        .split(/[-_\s]+/)
+        .filter(Boolean)
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(' ');
+        .join(" ");
 }

package/dist/storage/db.d.ts

@@ -1,5 +1,5 @@
-import { Database as BunDatabase } from 'bun:sqlite';
-import type { Library, Page, CrawlJob } from '../types.js';
+import { Database as BunDatabase } from "bun:sqlite";
+import type { Library, Page, CrawlJob } from "../types.js";
 export declare class Database {
     private db;
     init(): void;
@@ -18,6 +18,7 @@ export declare class Database {
     getLibraryByName(name: string): Library | undefined;
     getLibraryById(id: string): Library | undefined;
     removeLibrary(id: string): import("bun:sqlite").Changes;
+    renameLibrary(id: string, name: string, displayName: string): import("bun:sqlite").Changes;
     updateLibraryStatus(id: string, status: string): import("bun:sqlite").Changes;
     updateLibraryStats(id: string, pageCount: number, chunkCount: number): import("bun:sqlite").Changes;
     upsertPage(page: {
@@ -52,6 +53,6 @@ export declare class Database {
         libraryId: string;
     }): CrawlJob;
     getJob(id: string): CrawlJob | undefined;
-    updateJob(id: string, updates: Partial<Pick<CrawlJob, 'status' | 'pages_discovered' | 'pages_crawled' | 'pages_failed' | 'chunks_created' | 'error_message' | 'started_at' | 'completed_at'>>): void;
+    updateJob(id: string, updates: Partial<Pick<CrawlJob, "status" | "pages_discovered" | "pages_crawled" | "pages_failed" | "chunks_created" | "error_message" | "started_at" | "completed_at">>): void;
     listJobs(libraryId?: string): CrawlJob[];
 }

package/dist/storage/db.js

@@ -1,16 +1,16 @@
 // src/storage/db.ts — SQLite + FTS5 storage layer (bun:sqlite)
-import { Database as BunDatabase } from 'bun:sqlite';
-import { resolve } from 'path';
-import { mkdirSync } from 'fs';
-import { homedir } from 'os';
+import { Database as BunDatabase } from "bun:sqlite";
+import { resolve } from "path";
+import { mkdirSync } from "fs";
+import { homedir } from "os";
 export class Database {
     db;
     init() {
-        const dir = process.env.DOCSHARK_DATA_DIR || resolve(homedir(), '.docshark');
+        const dir = process.env.DOCSHARK_DATA_DIR || resolve(homedir(), ".docshark");
         mkdirSync(dir, { recursive: true });
-        this.db = new BunDatabase(resolve(dir, 'docshark.db'));
-        this.db.run('PRAGMA journal_mode = WAL');
-        this.db.run('PRAGMA foreign_keys = ON');
+        this.db = new BunDatabase(resolve(dir, "docshark.db"));
+        this.db.run("PRAGMA journal_mode = WAL");
+        this.db.run("PRAGMA foreign_keys = ON");
         this.migrate();
     }
     /** Expose raw DB for search engine direct queries */
@@ -114,19 +114,32 @@ export class Database {
             .run(lib.id, lib.name, lib.displayName, lib.url, lib.version ?? null, lib.crawlConfig ? JSON.stringify(lib.crawlConfig) : null);
     }
     listLibraries(status) {
-        if (status && status !== 'all') {
-            return this.db.prepare('SELECT * FROM libraries WHERE status = ?').all(status);
+        if (status && status !== "all") {
+            return this.db
+                .prepare("SELECT * FROM libraries WHERE status = ?")
+                .all(status);
         }
-        return this.db.prepare('SELECT * FROM libraries ORDER BY name').all();
+        return this.db
+            .prepare("SELECT * FROM libraries ORDER BY name")
+            .all();
     }
     getLibraryByName(name) {
-        return this.db.prepare('SELECT * FROM libraries WHERE name = ?').get(name);
+        return this.db
+            .prepare("SELECT * FROM libraries WHERE name = ?")
+            .get(name);
     }
     getLibraryById(id) {
-        return this.db.prepare('SELECT * FROM libraries WHERE id = ?').get(id);
+        return this.db.prepare("SELECT * FROM libraries WHERE id = ?").get(id);
     }
     removeLibrary(id) {
-        return this.db.prepare('DELETE FROM libraries WHERE id = ?').run(id);
+        return this.db.prepare("DELETE FROM libraries WHERE id = ?").run(id);
+    }
+    renameLibrary(id, name, displayName) {
+        return this.db
+            .prepare(`UPDATE libraries
+         SET name = ?, display_name = ?, updated_at = datetime('now')
+         WHERE id = ?`)
+            .run(name, displayName, id);
     }
     updateLibraryStatus(id, status) {
         return this.db
@@ -154,12 +167,16 @@ export class Database {
            headings = excluded.headings,
            updated_at = datetime('now')`)
             .run(page.id, page.libraryId, page.url, page.path, page.title, page.contentMarkdown, page.contentHash, JSON.stringify(page.headings));
-        const row = this.db.prepare('SELECT id FROM pages WHERE library_id = ? AND url = ?').get(page.libraryId, page.url);
+        const row = this.db
+            .prepare("SELECT id FROM pages WHERE library_id = ? AND url = ?")
+            .get(page.libraryId, page.url);
         return row.id;
     }
     getPage(opts) {
         if (opts.url) {
-            return this.db.prepare('SELECT * FROM pages WHERE url = ?').get(opts.url);
+            return this.db
+                .prepare("SELECT * FROM pages WHERE url = ?")
+                .get(opts.url);
         }
         if (opts.library && opts.path) {
             return this.db
@@ -172,7 +189,7 @@ export class Database {
     }
     getPagesByLibrary(libraryId) {
         return this.db
-            .prepare('SELECT * FROM pages WHERE library_id = ? ORDER BY path')
+            .prepare("SELECT * FROM pages WHERE library_id = ? ORDER BY path")
             .all(libraryId);
     }
     // ──────────────────────────────────────
@@ -189,19 +206,21 @@ export class Database {
         tx();
     }
     deleteChunksByPage(pageId) {
-        this.db.prepare('DELETE FROM chunks WHERE page_id = ?').run(pageId);
+        this.db.prepare("DELETE FROM chunks WHERE page_id = ?").run(pageId);
     }
     // ──────────────────────────────────────
     // Crawl Jobs
     // ──────────────────────────────────────
     createJob(job) {
         this.db
-            .prepare('INSERT INTO crawl_jobs (id, library_id) VALUES (?, ?)')
+            .prepare("INSERT INTO crawl_jobs (id, library_id) VALUES (?, ?)")
             .run(job.id, job.libraryId);
-        return this.db.prepare('SELECT * FROM crawl_jobs WHERE id = ?').get(job.id);
+        return this.db
+            .prepare("SELECT * FROM crawl_jobs WHERE id = ?")
+            .get(job.id);
     }
     getJob(id) {
-        return this.db.prepare('SELECT * FROM crawl_jobs WHERE id = ?').get(id);
+        return this.db.prepare("SELECT * FROM crawl_jobs WHERE id = ?").get(id);
     }
     updateJob(id, updates) {
         const sets = [];
@@ -213,16 +232,18 @@ export class Database {
         if (sets.length === 0)
             return;
         values.push(id);
-        this.db.prepare(`UPDATE crawl_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+        this.db
+            .prepare(`UPDATE crawl_jobs SET ${sets.join(", ")} WHERE id = ?`)
+            .run(...values);
     }
     listJobs(libraryId) {
         if (libraryId) {
             return this.db
-                .prepare('SELECT * FROM crawl_jobs WHERE library_id = ? ORDER BY created_at DESC')
+                .prepare("SELECT * FROM crawl_jobs WHERE library_id = ? ORDER BY created_at DESC")
                 .all(libraryId);
         }
         return this.db
-            .prepare('SELECT * FROM crawl_jobs ORDER BY created_at DESC')
+            .prepare("SELECT * FROM crawl_jobs ORDER BY created_at DESC")
             .all();
     }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.13";
+export declare const VERSION: string;

package/dist/version.js

@@ -1,2 +1,6 @@
-// This file is automatically updated by release-please
-export const VERSION = '0.1.13'; // x-release-please-version
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), "../package.json");
+export const VERSION = JSON.parse(readFileSync(packageJsonPath, "utf8"))
+    .version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docshark",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "🦈 Documentation MCP Server — scrape, index, and search any doc website",
   "type": "module",
   "main": "./dist/index.js",
@@ -58,8 +58,8 @@
     "@tmcp/transport-http": "^0.8.4",
     "@tmcp/transport-sse": "^0.5.3",
     "@tmcp/transport-stdio": "^0.4.1",
+    "cac": "^7.0.0",
     "cheerio": "^1.2.0",
-    "commander": "^14.0.3",
     "linkedom": "^0.18.12",
     "nanoid": "^5.1.6",
     "puppeteer-core": "^24.37.5",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Michael-Obele
-
-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

@@ -1,176 +0,0 @@
-# 🦈 DocShark
-
-[![Built with Bun](https://img.shields.io/badge/Bun-%23000000.svg?style=flat&logo=bun&logoColor=white)](https://bun.sh/)
-[![NPM Version](https://img.shields.io/npm/v/docshark.svg?style=flat&color=blue)](https://www.npmjs.com/package/docshark)
-[![MCP Compatible](https://img.shields.io/badge/MCP-Ready-0D1117.svg?style=flat&logo=github&logoColor=white)](https://modelcontextprotocol.io/)
-[![GitHub Release](https://img.shields.io/github/v/release/Michael-Obele/docshark?color=success)](https://github.com/Michael-Obele/docshark/releases)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**DocShark** is a powerful MCP (Model Context Protocol) server designed to scrape, index, and search any documentation website. It creates a local, highly-searchable knowledge base from public documentation pages using FTS5 (Full-Text Search) and BM25 ranking, allowing AI assistants to query the latest docs effortlessly.
-
----
-
-## 🚀 Features
-
-- **Automated Crawling**: Discovers pages via `sitemap.xml` with fallback to BFS link crawling.
-- **Smart Extraction**: Uses Readability and Turndown to extract main content and convert it to clean Markdown, filtering out navbars and sidebars.
-- **Semantic Chunking**: Splits content based on headings, preserving contextual headers for better AI understanding.
-- **High-Performance Search**: Built-in SQLite + FTS5 indexing with BM25 ranking for accurate and lightning-fast search results.
-- **JS-Rendered Site Support**: Tiered fetching strategy automatically detects React/Vue SPAs (empty shells) and upgrades to `puppeteer-core` if you have it installed (zero-config, auto-fallback).
-- **Polite Crawling**: Respects `robots.txt` and implements rate limiting to prevent overloading documentation servers.
-- **Standard MCP Tooling**: Connect perfectly with Desktop Claude, VS Code, Cursor, and any other MCP-compatible clients via standard `stdio` or `http`/`sse` transports.
-
-## 📦 What We Have Done (Phase 1)
-
-**Phase 1: Core Engine** is fully implemented and tested.
-
-- ✅ Custom SQLite Database with FTS5 virtual tables and auto-sync triggers.
-- ✅ Web scraping engine supporting standard `fetch()` and `puppeteer-core`.
-- ✅ Markdown processor utilizing Readability + Turndown.
-- ✅ Heading-based semantic chunker (500-1200 tokens per chunk).
-- ✅ Asynchronous job manager and queue system.
-- ✅ Complete HTTP API (REST endpoints + SSE event streams).
-- ✅ Seamless integration of 6 MCP tools: `add_library`, `search_docs`, `list_libraries`, `get_doc_page`, `refresh_library`, and `remove_library`.
-- ✅ Robust CLI interface (`start`, `add`, `search`, `list`).
-
-## 🏗️ What We Are Doing
-
-We are actively polishing the integration between the core engine and external MCP clients (like VS Code Agents and Claude Desktop).
-
-## 🔮 What We Plan To Do (Phase 2 & Beyond)
-
-- **Web Dashboard**: An intuitive SvelteKit dashboard to manage your synced libraries, view crawl progress in real-time (via SSE), and test searches manually.
-- **Incremental Crawling**: Smarter `refresh` jobs that compare `ETag` and `Last-Modified` headers to only re-scrape updated pages.
-- **Vector Search (RAG)**: Integration of lightweight vector embeddings for semantic similarity search alongside the existing FTS5 keyword search.
-- **Advanced Scraping Setup**: Support for custom CSS selectors to define exactly where content lives in non-standard documentation websites.
-
----
-
-## 🛠️ Usage
-
-### Quick Start (from npm)
-
-You can run DocShark directly without installing it globally using `bunx`:
-
-```bash
-# Add a documentation library to the index
-bunx docshark add https://valibot.dev/guides/ --depth 2
-
-# Search your indexed docs
-bunx docshark search "schema validation"
-```
-
-### Installation
-
-To install DocShark globally as a CLI tool:
-
-DocShark is intended to be installed and run with Bun.
-
-```bash
-# Global Bun installation
-bun add -g docshark
-```
-
-After installation, you can use the `docshark` command:
-
-```bash
-docshark list
-
-# Update the global Bun installation when a new release is published
-docshark update
-
-# Script-friendly update check
-docshark update --check --quiet
-```
-
-Interactive CLI runs will also let you know when a newer version is available. Update notices are intentionally skipped for MCP `stdio` mode so they never interfere with protocol output.
-
-For scripts, `docshark update --check` exits `0` when current, `10` when a newer version is available, and `1` when the version check could not be completed.
-
-## 🔌 MCP Integration
-
-### VS Code (GitHub Copilot / MCP Extension)
-
-Add DocShark to your `.vscode/settings.json` or global MCP configuration:
-
-```json
-{
-  "mcpServers": {
-    "docshark": {
-      "command": "bunx",
-      "args": ["-y", "docshark", "start", "--stdio"]
-    }
-  }
-}
-```
-
-### Cursor
-
-1. Open **Cursor Settings** > **Models** > **MCP**.
-2. Click **+ Add New MCP Server**.
-3. Name: `docshark`
-4. Type: `command`
-5. Command: `bunx -y docshark start --stdio`
-
-### Claude Desktop
-
-Edit your Claude Desktop configuration file:
-
-- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "docshark": {
-      "command": "bunx",
-      "args": ["-y", "docshark", "start", "--stdio"]
-    }
-  }
-}
-```
-
----
-
-## 🛠️ Development
-
-### Local Setup
-
-Ensure you have [Bun](https://bun.sh/) installed.
-
-```bash
-# Clone the repository
-git clone https://github.com/Michael-Obele/docshark.git
-cd docshark
-
-# Install dependencies
-bun install
-
-# (Optional) Enable auto-detection & scraping of Javascript React/Vue single-page apps
-bun add puppeteer-core
-
-# Start the DocShark MCP server in HTTP mode for local testing
-bun run src/cli.ts start --port 6380
-```
-
-### Local CLI Debugging
-
-```bash
-# Run CLI directly while developing
-bun run src/cli.ts list
-```
-
-## 🔄 Versioning & Changelog
-
-This project uses [Google's Release Please](https://github.com/googleapis/release-please) to automate versioning and changelog generation.
-
-- **Semantic Versioning**: Our versions automatically bump (e.g. `0.0.1` -> `0.0.2` or `0.1.0`) based on standard Conventional Commits (`feat:`, `fix:`, `chore:`, etc.).
-- **Automated**: A PR is automatically created on `master` when standard commits are merged, generating a standard `CHANGELOG.md`.
-
-## 📜 License
-
-This project is open-source and available under the [MIT License](LICENSE).
-
----
-
-_Built to empower AI agents with the latest knowledge._