markit-ai 0.1.0

package/dist/converters/wikipedia.js

@@ -0,0 +1,35 @@
+import TurndownService from "turndown";
+const WIKIPEDIA_RE = /^https?:\/\/[a-zA-Z]{2,3}\.wikipedia\.org\//;
+export class WikipediaConverter {
+    name = "wikipedia";
+    accepts(streamInfo) {
+        if (!streamInfo.url)
+            return false;
+        return WIKIPEDIA_RE.test(streamInfo.url);
+    }
+    async convert(input, streamInfo) {
+        const html = new TextDecoder(streamInfo.charset || "utf-8").decode(input);
+        // Extract the main content div
+        const contentMatch = html.match(/<div[^>]*id="mw-content-text"[^>]*>([\s\S]*?)<\/div>\s*(?:<\/div>|$)/i);
+        // Extract title
+        const titleMatch = html.match(/<span[^>]*class="mw-page-title-main"[^>]*>([\s\S]*?)<\/span>/i) ||
+            html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+        const title = titleMatch ? titleMatch[1].replace(/ - Wikipedia$/, "").trim() : undefined;
+        const turndown = new TurndownService({
+            headingStyle: "atx",
+            codeBlockStyle: "fenced",
+        });
+        // Clean up Wikipedia-specific elements
+        let content = contentMatch ? contentMatch[1] : html;
+        content = content
+            .replace(/<script[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[\s\S]*?<\/style>/gi, "")
+            .replace(/<div[^>]*class="[^"]*mw-editsection[^"]*"[\s\S]*?<\/div>/gi, "") // edit links
+            .replace(/<sup[^>]*class="[^"]*reference[^"]*"[\s\S]*?<\/sup>/gi, "") // reference numbers
+            .replace(/<div[^>]*class="[^"]*navbox[\s\S]*?<\/div>/gi, "") // navboxes
+            .replace(/<table[^>]*class="[^"]*sidebar[\s\S]*?<\/table>/gi, ""); // sidebars
+        const markdown = turndown.turndown(content).trim();
+        const result = title ? `# ${title}\n\n${markdown}` : markdown;
+        return { markdown: result, title };
+    }
+}

package/dist/converters/xlsx.d.ts

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

package/dist/converters/xlsx.js

@@ -0,0 +1,139 @@
+import JSZip from "jszip";
+import { XMLParser } from "fast-xml-parser";
+const EXTENSIONS = [".xlsx"];
+const MIMETYPES = [
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+];
+export class XlsxConverter {
+    name = "xlsx";
+    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 parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+        });
+        // Parse shared strings
+        const ssXml = await zip.file("xl/sharedStrings.xml")?.async("string");
+        const ss = ssXml ? parser.parse(ssXml) : null;
+        const siList = ss?.sst?.si;
+        const shared = toArray(siList);
+        // Parse workbook for sheet names
+        const wbXml = await zip.file("xl/workbook.xml")?.async("string");
+        if (!wbXml)
+            throw new Error("Invalid XLSX: missing workbook.xml");
+        const wb = parser.parse(wbXml);
+        const sheets = toArray(wb.workbook?.sheets?.sheet);
+        // Parse workbook rels to map rIds to sheet files
+        const relsXml = await zip.file("xl/_rels/workbook.xml.rels")?.async("string");
+        const rels = relsXml ? parser.parse(relsXml) : null;
+        const relList = toArray(rels?.Relationships?.Relationship);
+        const relMap = new Map();
+        for (const r of relList) {
+            relMap.set(r["@_Id"], r["@_Target"]);
+        }
+        const sections = [];
+        for (const sheet of sheets) {
+            const sheetName = sheet["@_name"];
+            const rId = sheet["@_r:id"];
+            const target = relMap.get(rId);
+            if (!target)
+                continue;
+            const sheetPath = target.startsWith("/") ? target.slice(1) : `xl/${target}`;
+            const sheetXml = await zip.file(sheetPath)?.async("string");
+            if (!sheetXml)
+                continue;
+            const parsed = parser.parse(sheetXml);
+            const rows = toArray(parsed.worksheet?.sheetData?.row);
+            if (rows.length === 0)
+                continue;
+            // Extract all rows as string arrays
+            const tableRows = [];
+            for (const row of rows) {
+                const cells = toArray(row.c);
+                const values = [];
+                for (const cell of cells) {
+                    values.push(this.getCellValue(cell, shared));
+                }
+                tableRows.push(values);
+            }
+            if (tableRows.length === 0)
+                continue;
+            // Normalize column count
+            const maxCols = Math.max(...tableRows.map((r) => r.length));
+            for (const row of tableRows) {
+                while (row.length < maxCols)
+                    row.push("");
+            }
+            sections.push(`## ${sheetName}`);
+            const [header, ...body] = tableRows;
+            const lines = [];
+            lines.push(`| ${header.join(" | ")} |`);
+            lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+            for (const row of body) {
+                lines.push(`| ${row.join(" | ")} |`);
+            }
+            sections.push(lines.join("\n"));
+        }
+        return { markdown: sections.join("\n\n") };
+    }
+    getCellValue(cell, shared) {
+        // Shared string
+        if (cell["@_t"] === "s") {
+            return this.getSharedString(shared, Number(cell.v));
+        }
+        // Inline string
+        if (cell["@_t"] === "inlineStr") {
+            const is = cell.is;
+            if (!is)
+                return "";
+            if (is.t != null)
+                return textValue(is.t);
+            if (is.r)
+                return toArray(is.r).map((r) => textValue(r.t)).join("");
+            return "";
+        }
+        // Boolean
+        if (cell["@_t"] === "b") {
+            return cell.v === 1 || cell.v === "1" ? "TRUE" : "FALSE";
+        }
+        // Number or formula result
+        if (cell.v != null)
+            return String(cell.v);
+        return "";
+    }
+    getSharedString(shared, idx) {
+        const si = shared[idx];
+        if (!si)
+            return "";
+        // Simple text
+        if (si.t != null)
+            return textValue(si.t);
+        // Rich text runs
+        if (si.r) {
+            return toArray(si.r)
+                .map((r) => textValue(r.t))
+                .join("");
+        }
+        return "";
+    }
+}
+function textValue(t) {
+    if (t == null)
+        return "";
+    if (typeof t === "object")
+        return t["#text"] || "";
+    return String(t);
+}
+function toArray(val) {
+    if (!val)
+        return [];
+    return Array.isArray(val) ? val : [val];
+}

package/dist/converters/xml.d.ts

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

package/dist/converters/xml.js

@@ -0,0 +1,17 @@
+const EXTENSIONS = [".xml", ".svg"];
+const MIMETYPES = ["text/xml", "application/xml"];
+export class XmlConverter {
+    name = "xml";
+    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);
+        const ext = streamInfo.extension?.slice(1) || "xml";
+        return { markdown: `\`\`\`${ext}\n${text}\n\`\`\`` };
+    }
+}

package/dist/converters/yaml.d.ts

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

package/dist/converters/yaml.js

@@ -0,0 +1,16 @@
+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/dist/converters/zip.d.ts

@@ -0,0 +1,8 @@
+import type { Converter, ConversionResult, 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/dist/converters/zip.js

@@ -0,0 +1,56 @@
+import JSZip from "jszip";
+import { extname, basename } from "node:path";
+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/dist/index.d.ts

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

package/dist/index.js

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

package/dist/llm.d.ts

@@ -0,0 +1,10 @@
+import type { MarkitOptions } from "./types.js";
+import type { MarkitConfig } from "./config.js";
+/**
+ * Build describe/transcribe functions from .markit/config.json + env vars.
+ * Uses the OpenAI-compatible provider by default.
+ */
+export declare function createLlmFunctions(config: MarkitConfig): MarkitOptions;
+export declare function createOpenAIDescribe(config: MarkitConfig): (image: Buffer, mimetype: string) => Promise<string>;
+export declare function createOpenAITranscribe(config: MarkitConfig): (audio: Buffer, mimetype: string) => Promise<string>;
+export declare function createAnthropicDescribe(config: MarkitConfig): (image: Buffer, mimetype: string) => Promise<string>;

package/dist/llm.js

@@ -0,0 +1,139 @@
+import { resolveApiKey, resolveApiBase, resolveModel, resolveTranscriptionModel, } from "./config.js";
+/**
+ * Build describe/transcribe functions from .markit/config.json + env vars.
+ * Uses the OpenAI-compatible provider by default.
+ */
+export function createLlmFunctions(config) {
+    const apiKey = resolveApiKey(config);
+    if (!apiKey)
+        return {};
+    const provider = config.llm?.provider || "openai";
+    if (provider === "anthropic") {
+        return {
+            describe: createAnthropicDescribe(config),
+            // Anthropic doesn't have a transcription API — leave undefined
+        };
+    }
+    return {
+        describe: createOpenAIDescribe(config),
+        transcribe: createOpenAITranscribe(config),
+    };
+}
+// ── OpenAI-compatible (also works with Groq, Together, Fireworks, Ollama) ──
+export function createOpenAIDescribe(config) {
+    const apiKey = resolveApiKey(config);
+    const baseUrl = resolveApiBase(config).replace(/\/+$/, "");
+    const model = resolveModel(config);
+    return async (image, mimetype) => {
+        const base64 = image.toString("base64");
+        const res = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            { type: "text", text: "Write a detailed description of this image." },
+                            { type: "image_url", image_url: { url: `data:${mimetype};base64,${base64}` } },
+                        ],
+                    },
+                ],
+                max_tokens: 1024,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`OpenAI API error ${res.status}: ${body}`);
+        }
+        const data = await res.json();
+        return data.choices?.[0]?.message?.content ?? "";
+    };
+}
+export function createOpenAITranscribe(config) {
+    const apiKey = resolveApiKey(config);
+    const baseUrl = resolveApiBase(config).replace(/\/+$/, "");
+    const transcriptionModel = resolveTranscriptionModel(config);
+    return async (audio, mimetype) => {
+        const ext = mimeToExt(mimetype);
+        const file = new File([audio], `audio${ext}`, { type: mimetype });
+        const formData = new FormData();
+        formData.append("model", transcriptionModel);
+        formData.append("file", file);
+        const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: formData,
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`Transcription API error ${res.status}: ${body}`);
+        }
+        const data = await res.json();
+        return data.text ?? "";
+    };
+}
+// ── Anthropic ───────────────────────────────────────────────────────────────
+export function createAnthropicDescribe(config) {
+    const apiKey = process.env.ANTHROPIC_API_KEY ||
+        config.llm?.apiKey ||
+        resolveApiKey(config);
+    const baseUrl = (process.env.ANTHROPIC_BASE_URL ||
+        config.llm?.apiBase ||
+        "https://api.anthropic.com").replace(/\/+$/, "");
+    const model = resolveModel(config, undefined) || "claude-sonnet-4-20250514";
+    return async (image, mimetype) => {
+        const base64 = image.toString("base64");
+        const res = await fetch(`${baseUrl}/v1/messages`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 1024,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "image",
+                                source: {
+                                    type: "base64",
+                                    media_type: mimetype,
+                                    data: base64,
+                                },
+                            },
+                            { type: "text", text: "Write a detailed description of this image." },
+                        ],
+                    },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`Anthropic API error ${res.status}: ${body}`);
+        }
+        const data = await res.json();
+        return data.content?.[0]?.text ?? "";
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function mimeToExt(mime) {
+    const map = {
+        "audio/mpeg": ".mp3",
+        "audio/wav": ".wav",
+        "audio/mp4": ".m4a",
+        "video/mp4": ".mp4",
+        "audio/ogg": ".ogg",
+        "audio/flac": ".flac",
+        "audio/aac": ".aac",
+    };
+    return map[mime] || ".mp3";
+}

package/dist/main.d.ts

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