@gajae-code/coding-agent 0.17.2 → 0.17.5

package/vendor/markit-ai/dist/converters/yaml.js

@@ -0,0 +1,17 @@
+const EXTENSIONS = [".yaml", ".yml"];
+const MIMETYPES = ["text/yaml", "application/x-yaml"];
+export class YamlConverter {
+    name = "yaml";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const text = new TextDecoder(streamInfo.charset || "utf-8").decode(input);
+        return { markdown: `\`\`\`yaml\n${text}\n\`\`\`` };
+    }
+}

package/vendor/markit-ai/dist/converters/zip.d.ts

@@ -0,0 +1,8 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class ZipConverter implements Converter {
+    name: string;
+    private parentConverters;
+    constructor(parentConverters: Converter[]);
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/vendor/markit-ai/dist/converters/zip.js

@@ -0,0 +1,57 @@
+import { basename, extname } from "node:path";
+import JSZip from "jszip";
+const EXTENSIONS = [".zip"];
+const MIMETYPES = ["application/zip", "application/x-zip-compressed"];
+export class ZipConverter {
+    name = "zip";
+    parentConverters;
+    constructor(parentConverters) {
+        this.parentConverters = parentConverters;
+    }
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const zip = await JSZip.loadAsync(input);
+        const label = streamInfo.localPath || streamInfo.filename || "archive.zip";
+        const sections = [`Content from \`${basename(label)}\`:`];
+        for (const [path, file] of Object.entries(zip.files)) {
+            if (file.dir)
+                continue;
+            const ext = extname(path).toLowerCase();
+            const fileInfo = {
+                extension: ext,
+                filename: basename(path),
+            };
+            const buffer = Buffer.from(await file.async("arraybuffer"));
+            // Try each converter
+            let converted = false;
+            for (const converter of this.parentConverters) {
+                if (converter.name === "zip")
+                    continue; // avoid recursion loops
+                if (!converter.accepts(fileInfo))
+                    continue;
+                try {
+                    const result = await converter.convert(buffer, fileInfo);
+                    if (result.markdown.trim()) {
+                        sections.push(`## File: ${path}\n\n${result.markdown.trim()}`);
+                        converted = true;
+                        break;
+                    }
+                }
+                catch {
+                    // Try next converter
+                }
+            }
+            if (!converted) {
+                sections.push(`## File: ${path}\n\n*[binary file]*`);
+            }
+        }
+        return { markdown: sections.join("\n\n").trim() };
+    }
+}

package/vendor/markit-ai/dist/index.d.ts

@@ -0,0 +1,30 @@
+export type { MarkitConfig } from "./config.js";
+export { AudioConverter } from "./converters/audio.js";
+export { CsvConverter } from "./converters/csv.js";
+export { DocxConverter } from "./converters/docx.js";
+export { EpubConverter } from "./converters/epub.js";
+export { GitHubConverter } from "./converters/github.js";
+export { HtmlConverter } from "./converters/html.js";
+export { ImageConverter } from "./converters/image.js";
+export { IpynbConverter } from "./converters/ipynb.js";
+export { IWorkConverter } from "./converters/iwork.js";
+export { JsonConverter } from "./converters/json.js";
+export { PdfConverter } from "./converters/pdf/index.js";
+export { PlainTextConverter } from "./converters/plain-text.js";
+export { PptxConverter } from "./converters/pptx.js";
+export { RssConverter } from "./converters/rss.js";
+export { WikipediaConverter } from "./converters/wikipedia.js";
+export { XlsxConverter } from "./converters/xlsx.js";
+export { XmlConverter } from "./converters/xml.js";
+export { YamlConverter } from "./converters/yaml.js";
+export { ZipConverter } from "./converters/zip.js";
+export { Markit } from "./markit.js";
+export { createPluginAPI, resolvePluginExport } from "./plugins/api.js";
+export { installPlugin, listInstalled, removePlugin, } from "./plugins/installer.js";
+export { loadAllPlugins, loadPluginFromPath } from "./plugins/loader.js";
+export type { MarkitPluginAPI, PluginDef, PluginFunction, } from "./plugins/types.js";
+export { anthropic } from "./providers/anthropic.js";
+export { createLlmFunctions, getProvider, listProviders, registerProvider, } from "./providers/index.js";
+export { openai } from "./providers/openai.js";
+export type { Provider, ProviderConfig, ResolvedConfig, } from "./providers/types.js";
+export type { ConversionResult, Converter, MarkitOptions, StreamInfo, } from "./types.js";

package/vendor/markit-ai/dist/index.js

@@ -0,0 +1,26 @@
+export { AudioConverter } from "./converters/audio.js";
+export { CsvConverter } from "./converters/csv.js";
+export { DocxConverter } from "./converters/docx.js";
+export { EpubConverter } from "./converters/epub.js";
+export { GitHubConverter } from "./converters/github.js";
+export { HtmlConverter } from "./converters/html.js";
+export { ImageConverter } from "./converters/image.js";
+export { IpynbConverter } from "./converters/ipynb.js";
+export { IWorkConverter } from "./converters/iwork.js";
+export { JsonConverter } from "./converters/json.js";
+export { PdfConverter } from "./converters/pdf/index.js";
+export { PlainTextConverter } from "./converters/plain-text.js";
+export { PptxConverter } from "./converters/pptx.js";
+export { RssConverter } from "./converters/rss.js";
+export { WikipediaConverter } from "./converters/wikipedia.js";
+export { XlsxConverter } from "./converters/xlsx.js";
+export { XmlConverter } from "./converters/xml.js";
+export { YamlConverter } from "./converters/yaml.js";
+export { ZipConverter } from "./converters/zip.js";
+export { Markit } from "./markit.js";
+export { createPluginAPI, resolvePluginExport } from "./plugins/api.js";
+export { installPlugin, listInstalled, removePlugin, } from "./plugins/installer.js";
+export { loadAllPlugins, loadPluginFromPath } from "./plugins/loader.js";
+export { anthropic } from "./providers/anthropic.js";
+export { createLlmFunctions, getProvider, listProviders, registerProvider, } from "./providers/index.js";
+export { openai } from "./providers/openai.js";

package/vendor/markit-ai/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/vendor/markit-ai/dist/main.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { configGet, configSet, configShow } from "./commands/config.js";
+import { convert } from "./commands/convert.js";
+import { formats } from "./commands/formats.js";
+import { init } from "./commands/init.js";
+import { onboard } from "./commands/onboard.js";
+import { pluginInstall, pluginList, pluginRemove } from "./commands/plugin.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+const program = new Command();
+program
+    .name("markit")
+    .description("Convert anything to markdown.")
+    .version(`markit ${version}`, "-V, --version")
+    .option("--json", "Output as JSON")
+    .option("-q, --quiet", "Raw markdown only, no decoration")
+    .option("-p, --prompt <text>", "Extra instructions for image description")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .option("-i, --image-dir <dir>", "Extract images to this directory")
+    .addHelpText("after", `
+Examples:
+  $ markit report.pdf                  Convert a PDF to markdown
+  $ markit document.docx -o doc.md     Convert DOCX, write to file
+  $ markit https://example.com         Convert a web page
+  $ markit photo.jpg                    Extract EXIF + AI description
+  $ markit recording.mp3               Metadata + transcription
+  $ cat file.pdf | markit -            Read from stdin
+  $ markit init                        Create .markit/ config
+  $ markit config show                 Show LLM settings
+
+Docs: https://github.com/Michaelliv/markit`);
+program
+    .command("convert")
+    .alias("c")
+    .description("Convert a file or URL to markdown")
+    .argument("<source>", "File path, URL, or - for stdin")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(async (source, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await convert(source, {
+        json: globals.json,
+        quiet: globals.quiet,
+        output: opts.output,
+        prompt: globals.prompt,
+        imageDir: globals.imageDir,
+    });
+});
+program
+    .command("init")
+    .description("Create .markit/ config directory")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await init([], { json: globals.json, quiet: globals.quiet });
+});
+const configCmd = program
+    .command("config")
+    .description("Manage markit configuration");
+configCmd
+    .command("show")
+    .description("Show current configuration")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await configShow([], { json: globals.json, quiet: globals.quiet });
+});
+configCmd
+    .command("get <key>")
+    .description("Get a config value")
+    .action(async (key, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await configGet(key, { json: globals.json, quiet: globals.quiet });
+});
+configCmd
+    .command("set <key> [value]")
+    .description("Set a config value (secrets read from stdin if no value given)")
+    .action(async (key, value, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await configSet(key, value, { json: globals.json, quiet: globals.quiet });
+});
+const pluginCmd = program.command("plugin").description("Manage plugins");
+pluginCmd
+    .command("install <source>")
+    .description("Install a plugin (npm:pkg, git:url, or local path)")
+    .action(async (source, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginInstall(source, { json: globals.json, quiet: globals.quiet });
+});
+pluginCmd
+    .command("remove <name>")
+    .description("Remove an installed plugin")
+    .action(async (name, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginRemove(name, { json: globals.json, quiet: globals.quiet });
+});
+pluginCmd
+    .command("list")
+    .description("List installed plugins")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginList({ json: globals.json, quiet: globals.quiet });
+});
+program
+    .command("formats")
+    .description("List supported formats")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await formats([], { json: globals.json, quiet: globals.quiet });
+});
+program
+    .command("onboard")
+    .description("Add markit instructions to CLAUDE.md or AGENTS.md")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await onboard([], { json: globals.json, quiet: globals.quiet });
+});
+// Default behavior: if first arg isn't a known subcommand, treat it as a source to convert
+program.on("command:*", async (args) => {
+    const source = args[0];
+    if (!source) {
+        program.help();
+        return;
+    }
+    // Check for typos against known subcommands
+    const commands = [
+        "convert",
+        "formats",
+        "onboard",
+        "help",
+        "init",
+        "config",
+        "plugin",
+    ];
+    const close = commands.filter((c) => levenshtein(source, c) <= 2 && source !== c);
+    if (close.length > 0 &&
+        !source.includes("/") &&
+        !source.includes(".") &&
+        !source.startsWith("http")) {
+        const { error } = await import("./utils/output.js");
+        error(`Unknown command '${source}'. Did you mean '${close[0]}'?`);
+        process.exit(1);
+    }
+    const globals = program.opts();
+    await convert(source, {
+        json: globals.json,
+        quiet: globals.quiet,
+        output: globals.output,
+        prompt: globals.prompt,
+        imageDir: globals.imageDir,
+    });
+});
+// No args → show concise help
+if (process.argv.length <= 2) {
+    console.log(`markit — convert anything to markdown
+
+Usage:  markit <file-or-url> [options]
+
+Examples:
+  $ markit report.pdf
+  $ markit document.docx -o doc.md
+  $ markit https://example.com
+
+Commands:
+  markit init        Create .markit/ config directory
+  markit config      Manage settings (LLM, API keys)
+  markit formats     List supported formats
+  markit onboard     Add instructions to CLAUDE.md
+
+Run markit --help for all options.
+Docs: https://github.com/Michaelliv/markit`);
+    process.exit(0);
+}
+program.parseAsync(process.argv).catch((err) => {
+    console.error("Fatal error:", err.message);
+    process.exit(1);
+});
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] !== b[j - 1] ? 1 : 0));
+        }
+    }
+    return dp[m][n];
+}

package/vendor/markit-ai/dist/markit.d.ts

@@ -0,0 +1,45 @@
+import type { PluginDef } from "./plugins/types.js";
+import type { ConversionResult, MarkitOptions, StreamInfo } from "./types.js";
+export declare class Markit {
+    private converters;
+    private options;
+    constructor(options?: MarkitOptions, plugins?: PluginDef[]);
+    /**
+     * Convert a local file to markdown.
+     */
+    convertFile(path: string, extra?: Partial<StreamInfo>): Promise<ConversionResult>;
+    /**
+     * Convert a URL to markdown.
+     */
+    convertUrl(url: string): Promise<ConversionResult>;
+    /**
+     * For root URLs, check if the site publishes /llms.txt.
+     * If it exists, return it as markdown directly.
+     */
+    private tryLlmsTxt;
+    /**
+     * Inspect an HTML response for a discoverable markdown source URL.
+     * If found, fetch and convert the raw markdown instead.
+     */
+    private tryMarkdownSource;
+    /**
+     * Fetch a markdown source URL, validating the response is actually markdown.
+     */
+    private fetchMarkdownSource;
+    /**
+     * Convert a buffer with stream info to markdown.
+     */
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}
+/**
+ * Try to discover a raw markdown source URL from an HTML response.
+ * Checks for known markers in the HTML itself:
+ *   1. <link rel="alternate" type="text/markdown" href="..."> tag
+ *   2. VitePress markers → append .md to the URL
+ *
+ * The llms.txt .md probe is handled separately in tryMarkdownSource
+ * as a fallback when no markers are found.
+ *
+ * @internal Exported for testing.
+ */
+export declare function discoverMarkdownSource(html: string, url: string, ext: string): string | null;

package/vendor/markit-ai/dist/markit.js

@@ -0,0 +1,267 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { AudioConverter } from "./converters/audio.js";
+import { CsvConverter } from "./converters/csv.js";
+import { DocxConverter } from "./converters/docx.js";
+import { EpubConverter } from "./converters/epub.js";
+import { GitHubConverter } from "./converters/github.js";
+import { HtmlConverter } from "./converters/html.js";
+import { ImageConverter } from "./converters/image.js";
+import { IpynbConverter } from "./converters/ipynb.js";
+import { IWorkConverter } from "./converters/iwork.js";
+import { JsonConverter } from "./converters/json.js";
+import { PdfConverter } from "./converters/pdf/index.js";
+import { PlainTextConverter } from "./converters/plain-text.js";
+import { PptxConverter } from "./converters/pptx.js";
+import { RssConverter } from "./converters/rss.js";
+import { WikipediaConverter } from "./converters/wikipedia.js";
+import { XlsxConverter } from "./converters/xlsx.js";
+import { XmlConverter } from "./converters/xml.js";
+import { YamlConverter } from "./converters/yaml.js";
+import { ZipConverter } from "./converters/zip.js";
+const USER_AGENT = "markit/0.1.0";
+export class Markit {
+    converters = [];
+    options;
+    constructor(options = {}, plugins = []) {
+        this.options = options;
+        // Plugin converters go first — they override builtins for the same format
+        const pluginConverters = plugins.flatMap((p) => p.converters);
+        // Built-in converters: specific formats first, generic last.
+        const specific = [
+            new PdfConverter(),
+            new DocxConverter(),
+            new PptxConverter(),
+            new XlsxConverter(),
+            new EpubConverter(),
+            new IpynbConverter(),
+            new IWorkConverter(),
+            new GitHubConverter(),
+            new WikipediaConverter(),
+            new RssConverter(),
+            new CsvConverter(),
+            new JsonConverter(),
+            new YamlConverter(),
+            new ImageConverter(),
+            new AudioConverter(),
+        ];
+        const generic = [new XmlConverter(), new HtmlConverter()];
+        // ZIP gets all converters (plugin + builtin) for recursive extraction
+        const allNonZip = [...pluginConverters, ...specific, ...generic];
+        const zipConverter = new ZipConverter(allNonZip);
+        // Plugin converters first, then builtins, plain text last
+        this.converters = [
+            ...pluginConverters,
+            ...specific,
+            zipConverter,
+            ...generic,
+            new PlainTextConverter(),
+        ];
+    }
+    /**
+     * Convert a local file to markdown.
+     */
+    async convertFile(path, extra) {
+        const buffer = readFileSync(path);
+        const streamInfo = {
+            localPath: path,
+            extension: extname(path).toLowerCase(),
+            filename: basename(path),
+            ...extra,
+        };
+        return this.convert(buffer, streamInfo);
+    }
+    /**
+     * Convert a URL to markdown.
+     */
+    async convertUrl(url) {
+        // Let converters with a URL-specific hook handle it first
+        const streamInfo = { url };
+        for (const converter of this.converters) {
+            if (!converter.convertUrl || !converter.accepts(streamInfo))
+                continue;
+            try {
+                return await converter.convertUrl(url, this.options);
+            }
+            catch {
+                // Fall through to default fetch path
+            }
+        }
+        // For root URLs, check if the site has /llms.txt and return it if so
+        const parsedUrl = new URL(url);
+        if (parsedUrl.pathname === "/" || parsedUrl.pathname === "") {
+            const result = await this.tryLlmsTxt(parsedUrl.origin);
+            if (result)
+                return result;
+        }
+        const response = await fetch(url, {
+            headers: {
+                Accept: "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.1",
+                "User-Agent": USER_AGENT,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+        const contentType = response.headers.get("content-type") || "";
+        const mimetype = contentType.split(";")[0].trim();
+        const urlPath = new URL(url).pathname;
+        const ext = extname(urlPath).toLowerCase();
+        // Content negotiation worked — server returned markdown directly
+        if (mimetype === "text/markdown") {
+            const buffer = Buffer.from(await response.arrayBuffer());
+            return this.convert(buffer, {
+                url,
+                mimetype: "text/markdown",
+                extension: ".md",
+                filename: basename(urlPath) || undefined,
+            });
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        // For HTML responses, try to discover a raw markdown source.
+        // Patterns: <link rel="alternate">, VitePress .md files, llms.txt convention.
+        if (mimetype === "text/html") {
+            const result = await this.tryMarkdownSource(buffer, url, ext);
+            if (result)
+                return result;
+        }
+        return this.convert(buffer, {
+            url,
+            mimetype,
+            extension: ext || undefined,
+            filename: basename(urlPath) || undefined,
+        });
+    }
+    /**
+     * For root URLs, check if the site publishes /llms.txt.
+     * If it exists, return it as markdown directly.
+     */
+    async tryLlmsTxt(origin) {
+        const llmsTxtUrl = `${origin}/llms.txt`;
+        try {
+            const response = await fetch(llmsTxtUrl, {
+                method: "HEAD",
+                headers: { "User-Agent": USER_AGENT },
+            });
+            if (!response.ok)
+                return null;
+            const ct = (response.headers.get("content-type") || "")
+                .split(";")[0]
+                .trim();
+            if (!ct.includes("markdown") &&
+                !ct.includes("text/plain") &&
+                !ct.includes("text/html"))
+                return null;
+            // HEAD succeeded — now GET the content
+            const getResponse = await fetch(llmsTxtUrl, {
+                headers: { "User-Agent": USER_AGENT },
+            });
+            if (!getResponse.ok)
+                return null;
+            const buffer = Buffer.from(await getResponse.arrayBuffer());
+            return { markdown: buffer.toString("utf-8") };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Inspect an HTML response for a discoverable markdown source URL.
+     * If found, fetch and convert the raw markdown instead.
+     */
+    async tryMarkdownSource(htmlBuffer, url, ext) {
+        const html = htmlBuffer.toString("utf-8", 0, Math.min(htmlBuffer.length, 50_000));
+        const mdSourceUrl = discoverMarkdownSource(html, url, ext);
+        if (!mdSourceUrl)
+            return null;
+        return this.fetchMarkdownSource(mdSourceUrl);
+    }
+    /**
+     * Fetch a markdown source URL, validating the response is actually markdown.
+     */
+    async fetchMarkdownSource(mdUrl) {
+        try {
+            const response = await fetch(mdUrl, {
+                headers: { "User-Agent": USER_AGENT },
+            });
+            if (!response.ok)
+                return null;
+            const ct = (response.headers.get("content-type") || "")
+                .split(";")[0]
+                .trim();
+            if (!ct.includes("markdown") && !ct.includes("text/plain"))
+                return null;
+            const mdBuffer = Buffer.from(await response.arrayBuffer());
+            return this.convert(mdBuffer, {
+                url: mdUrl,
+                mimetype: "text/markdown",
+                extension: ".md",
+                filename: basename(new URL(mdUrl).pathname),
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Convert a buffer with stream info to markdown.
+     */
+    async convert(input, streamInfo) {
+        const errors = [];
+        for (const converter of this.converters) {
+            if (!converter.accepts(streamInfo))
+                continue;
+            try {
+                return await converter.convert(input, streamInfo, this.options);
+            }
+            catch (err) {
+                errors.push({
+                    converter: converter.name,
+                    error: err instanceof Error ? err : new Error(String(err)),
+                });
+            }
+        }
+        if (errors.length > 0) {
+            const details = errors
+                .map((e) => `  ${e.converter}: ${e.error.message}`)
+                .join("\n");
+            throw new AggregateError(errors.map((entry) => entry.error), `Conversion failed:\n${details}`, { cause: errors[0].error });
+        }
+        throw new Error(`Unsupported format: ${streamInfo.extension || streamInfo.mimetype || "unknown"}`);
+    }
+}
+/**
+ * Try to discover a raw markdown source URL from an HTML response.
+ * Checks for known markers in the HTML itself:
+ *   1. <link rel="alternate" type="text/markdown" href="..."> tag
+ *   2. VitePress markers → append .md to the URL
+ *
+ * The llms.txt .md probe is handled separately in tryMarkdownSource
+ * as a fallback when no markers are found.
+ *
+ * @internal Exported for testing.
+ */
+export function discoverMarkdownSource(html, url, ext) {
+    // 1. Look for <link rel="alternate" type="text/markdown" href="...">
+    const linkMatch = html.match(/<link[^>]+rel=["']alternate["'][^>]+type=["']text\/markdown["'][^>]+href=["']([^"']+)["']/i) ??
+        html.match(/<link[^>]+type=["']text\/markdown["'][^>]+rel=["']alternate["'][^>]+href=["']([^"']+)["']/i);
+    if (linkMatch?.[1]) {
+        try {
+            return new URL(linkMatch[1], url).href;
+        }
+        catch {
+            /* ignore malformed URLs */
+        }
+    }
+    // 2. VitePress detection — serves .md alongside HTML
+    if (!ext &&
+        (html.includes("__VP_HASH_MAP__") ||
+            html.includes("VPContent") ||
+            html.includes("vitepress"))) {
+        return appendMdExtension(url);
+    }
+    return null;
+}
+function appendMdExtension(url) {
+    return url.endsWith("/") ? `${url.slice(0, -1)}.md` : `${url}.md`;
+}

package/vendor/markit-ai/dist/plugins/api.d.ts

@@ -0,0 +1,7 @@
+import type { MarkitPluginAPI, PluginDef, PluginFunction } from "./types.js";
+export declare function createPluginAPI(pluginId: string): {
+    api: MarkitPluginAPI;
+    resolve: () => PluginDef;
+};
+export declare function isPluginFunction(val: any): val is PluginFunction;
+export declare function resolvePluginExport(exported: PluginFunction | PluginDef, pluginId: string): PluginDef;