@gajae-code/coding-agent 0.17.2 → 0.17.4

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

@@ -0,0 +1,128 @@
+import { XMLParser } from "fast-xml-parser";
+import JSZip from "jszip";
+import { createTurndown, normalizeTablesHtml } from "../utils/turndown.js";
+const EXTENSIONS = [".epub"];
+const MIMETYPES = [
+    "application/epub",
+    "application/epub+zip",
+    "application/x-epub+zip",
+];
+export class EpubConverter {
+    name = "epub";
+    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",
+            processEntities: { maxTotalExpansions: 1_000_000 },
+        });
+        // Find content.opf path from container.xml
+        const containerXml = await zip
+            .file("META-INF/container.xml")
+            ?.async("string");
+        if (!containerXml)
+            throw new Error("Invalid EPUB: missing container.xml");
+        const container = parser.parse(containerXml);
+        const rootfile = container.container?.rootfiles?.rootfile;
+        const opfPath = Array.isArray(rootfile)
+            ? rootfile[0]["@_full-path"]
+            : rootfile?.["@_full-path"];
+        if (!opfPath)
+            throw new Error("Invalid EPUB: missing rootfile path");
+        // Parse content.opf
+        const opfXml = await zip.file(opfPath)?.async("string");
+        if (!opfXml)
+            throw new Error("Invalid EPUB: missing content.opf");
+        const opf = parser.parse(opfXml);
+        // Extract metadata
+        const meta = opf.package?.metadata ?? {};
+        const metadata = {
+            title: this.getText(meta["dc:title"]),
+            authors: this.getTextArray(meta["dc:creator"]).join(", ") || undefined,
+            language: this.getText(meta["dc:language"]),
+            publisher: this.getText(meta["dc:publisher"]),
+            date: this.getText(meta["dc:date"]),
+            description: this.getText(meta["dc:description"]),
+        };
+        // Build manifest map (id → href)
+        const manifestItems = opf.package?.manifest?.item;
+        const itemList = Array.isArray(manifestItems)
+            ? manifestItems
+            : manifestItems
+                ? [manifestItems]
+                : [];
+        const manifest = new Map();
+        for (const item of itemList) {
+            manifest.set(item["@_id"], item["@_href"]);
+        }
+        // Get spine order
+        const spineItems = opf.package?.spine?.itemref;
+        const spineList = Array.isArray(spineItems)
+            ? spineItems
+            : spineItems
+                ? [spineItems]
+                : [];
+        const spineOrder = spineList.map((s) => s["@_idref"]);
+        // Resolve file paths
+        const basePath = opfPath.includes("/")
+            ? opfPath.substring(0, opfPath.lastIndexOf("/"))
+            : "";
+        const turndown = createTurndown();
+        const sections = [];
+        // Add metadata header
+        const metaLines = [];
+        for (const [key, value] of Object.entries(metadata)) {
+            if (value)
+                metaLines.push(`**${key.charAt(0).toUpperCase() + key.slice(1)}:** ${value}`);
+        }
+        if (metaLines.length > 0)
+            sections.push(metaLines.join("\n"));
+        // Convert spine files
+        for (const idref of spineOrder) {
+            const href = manifest.get(idref);
+            if (!href)
+                continue;
+            const filePath = basePath ? `${basePath}/${href}` : href;
+            const html = await zip.file(filePath)?.async("string");
+            if (!html)
+                continue;
+            // Strip script/style, convert to markdown
+            const cleaned = html
+                .replace(/<script[\s\S]*?<\/script>/gi, "")
+                .replace(/<style[\s\S]*?<\/style>/gi, "");
+            const md = turndown.turndown(normalizeTablesHtml(cleaned)).trim();
+            if (md)
+                sections.push(md);
+        }
+        return {
+            markdown: sections.join("\n\n").trim(),
+            title: metadata.title,
+        };
+    }
+    getText(node) {
+        if (!node)
+            return undefined;
+        if (typeof node === "string")
+            return node;
+        if (node["#text"])
+            return String(node["#text"]);
+        if (Array.isArray(node))
+            return this.getText(node[0]);
+        return undefined;
+    }
+    getTextArray(node) {
+        if (!node)
+            return [];
+        const list = Array.isArray(node) ? node : [node];
+        return list.map((n) => this.getText(n)).filter(Boolean);
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { ConversionResult, Converter, MarkitOptions, StreamInfo } from "../types.js";
+/**
+ * Matches GitHub URLs and fetches clean markdown content directly
+ * from raw endpoints or the GitHub API — no HTML scraping needed.
+ *
+ * Supported patterns:
+ *   - Repos:   github.com/owner/repo          → raw README.md
+ *   - Files:   github.com/owner/repo/blob/…   → raw file content
+ *   - Gists:   gist.github.com/owner/id       → raw gist content
+ *   - Issues:  github.com/owner/repo/issues/N  → API (title + body)
+ *   - PRs:     github.com/owner/repo/pull/N    → API (title + body)
+ */
+export declare class GitHubConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convertUrl(url: string, _options?: MarkitOptions): Promise<ConversionResult>;
+    convert(_input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

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

@@ -0,0 +1,148 @@
+const GITHUB_HOSTS = new Set([
+    "github.com",
+    "www.github.com",
+    "gist.github.com",
+]);
+/**
+ * Matches GitHub URLs and fetches clean markdown content directly
+ * from raw endpoints or the GitHub API — no HTML scraping needed.
+ *
+ * Supported patterns:
+ *   - Repos:   github.com/owner/repo          → raw README.md
+ *   - Files:   github.com/owner/repo/blob/…   → raw file content
+ *   - Gists:   gist.github.com/owner/id       → raw gist content
+ *   - Issues:  github.com/owner/repo/issues/N  → API (title + body)
+ *   - PRs:     github.com/owner/repo/pull/N    → API (title + body)
+ */
+export class GitHubConverter {
+    name = "github";
+    accepts(streamInfo) {
+        if (!streamInfo.url)
+            return false;
+        try {
+            const { hostname } = new URL(streamInfo.url);
+            return GITHUB_HOSTS.has(hostname);
+        }
+        catch {
+            return false;
+        }
+    }
+    async convertUrl(url, _options) {
+        const parsed = new URL(url);
+        if (parsed.hostname === "gist.github.com") {
+            return fetchGist(parsed);
+        }
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        // Need at least owner/repo
+        if (segments.length < 2) {
+            throw new Error(`Unsupported GitHub URL: ${url}`);
+        }
+        const [owner, repo, type, ...rest] = segments;
+        // github.com/owner/repo/blob/ref/path → raw file
+        if (type === "blob" && rest.length >= 2) {
+            const ref = rest[0];
+            const filePath = rest.slice(1).join("/");
+            return fetchRawFile(owner, repo, ref, filePath);
+        }
+        // github.com/owner/repo/issues/N or /pull/N
+        if ((type === "issues" || type === "pull") && rest[0]) {
+            const number = Number.parseInt(rest[0], 10);
+            if (!Number.isNaN(number)) {
+                return fetchIssueOrPr(owner, repo, number);
+            }
+        }
+        // github.com/owner/repo (no subpath or tree/wiki/etc) → README
+        if (!type) {
+            return fetchReadme(owner, repo);
+        }
+        throw new Error(`Unsupported GitHub URL pattern: ${url}`);
+    }
+    async convert(_input, streamInfo) {
+        // GitHub URLs are handled entirely via convertUrl.
+        // If we end up here, the URL was already fetched by the default path —
+        // just delegate to convertUrl.
+        if (streamInfo.url) {
+            return this.convertUrl(streamInfo.url);
+        }
+        throw new Error("GitHub converter requires a URL");
+    }
+}
+// ---------------------------------------------------------------------------
+// Fetchers
+// ---------------------------------------------------------------------------
+async function fetchReadme(owner, repo) {
+    const url = `https://raw.githubusercontent.com/${owner}/${repo}/HEAD/README.md`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch README: ${res.status} ${res.statusText}`);
+    }
+    const markdown = (await res.text()).trim();
+    const title = extractFirstHeading(markdown) ?? `${owner}/${repo}`;
+    return { markdown, title };
+}
+async function fetchRawFile(owner, repo, ref, filePath) {
+    const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch file: ${res.status} ${res.statusText}`);
+    }
+    const content = (await res.text()).trim();
+    const filename = filePath.split("/").pop() ?? filePath;
+    // If it's markdown, return as-is. Otherwise wrap in a code block.
+    if (filePath.endsWith(".md") || filePath.endsWith(".mdx")) {
+        const title = extractFirstHeading(content) ?? filename;
+        return { markdown: content, title };
+    }
+    const ext = filename.includes(".") ? filename.split(".").pop() : "";
+    const markdown = `# ${filename}\n\n\`\`\`${ext}\n${content}\n\`\`\``;
+    return { markdown, title: filename };
+}
+async function fetchGist(parsed) {
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    // gist.github.com/owner/id
+    const [owner, id] = segments;
+    if (!owner || !id) {
+        throw new Error(`Unsupported gist URL: ${parsed.href}`);
+    }
+    const url = `https://gist.githubusercontent.com/${owner}/${id}/raw`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch gist: ${res.status} ${res.statusText}`);
+    }
+    const content = (await res.text()).trim();
+    const title = `gist:${id}`;
+    return { markdown: content, title };
+}
+async function fetchIssueOrPr(owner, repo, number) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/issues/${number}`;
+    const res = await fetch(url, {
+        headers: { Accept: "application/vnd.github.v3+json" },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch issue/PR: ${res.status} ${res.statusText}`);
+    }
+    const data = (await res.json());
+    const title = data.title ?? `#${number}`;
+    const parts = [`# ${title}`];
+    // Metadata line
+    const meta = [];
+    if (data.user?.login)
+        meta.push(`@${data.user.login}`);
+    if (data.state)
+        meta.push(data.state);
+    if (data.labels?.length) {
+        meta.push(data.labels.map((l) => l.name).join(", "));
+    }
+    if (meta.length > 0)
+        parts.push(meta.join(" · "));
+    if (data.body?.trim())
+        parts.push(data.body.trim());
+    return { markdown: parts.join("\n\n"), title };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extractFirstHeading(markdown) {
+    const match = markdown.match(/^#\s+(.+)$/m);
+    return match?.[1]?.trim();
+}

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

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

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

@@ -0,0 +1,30 @@
+import { createTurndown, normalizeTablesHtml } from "../utils/turndown.js";
+const EXTENSIONS = [".html", ".htm"];
+const MIMETYPES = ["text/html", "application/xhtml"];
+export class HtmlConverter {
+    name = "html";
+    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 charset = streamInfo.charset || "utf-8";
+        const html = new TextDecoder(charset).decode(input);
+        const turndown = createTurndown();
+        // Remove script and style tags before converting
+        const cleaned = html
+            .replace(/<script[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[\s\S]*?<\/style>/gi, "");
+        const markdown = turndown.turndown(normalizeTablesHtml(cleaned));
+        // Try to extract title
+        const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+        const title = titleMatch ? titleMatch[1].trim() : undefined;
+        return { markdown: markdown.trim(), title };
+    }
+}

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

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

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

@@ -0,0 +1,124 @@
+const EXTENSIONS = [
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".gif",
+    ".webp",
+    ".tiff",
+    ".tif",
+    ".bmp",
+    ".svg",
+];
+const MIMETYPES = ["image/"];
+export class ImageConverter {
+    name = "image";
+    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, options) {
+        const sections = [];
+        // Extract EXIF metadata
+        try {
+            const exifr = await import("exifr");
+            const metadata = await exifr.parse(input, {
+                pick: [
+                    "ImageWidth",
+                    "ImageHeight",
+                    "Make",
+                    "Model",
+                    "DateTimeOriginal",
+                    "CreateDate",
+                    "GPSLatitude",
+                    "GPSLongitude",
+                    "Artist",
+                    "Copyright",
+                    "Description",
+                    "Title",
+                    "Keywords",
+                    "Software",
+                    "ExposureTime",
+                    "FNumber",
+                    "ISO",
+                    "FocalLength",
+                ],
+            });
+            if (metadata && Object.keys(metadata).length > 0) {
+                sections.push("## Metadata\n");
+                if (metadata.ImageWidth && metadata.ImageHeight) {
+                    sections.push(`ImageSize: ${metadata.ImageWidth}x${metadata.ImageHeight}`);
+                }
+                const fields = {
+                    Title: metadata.Title,
+                    Description: metadata.Description || metadata.ImageDescription,
+                    Keywords: Array.isArray(metadata.Keywords)
+                        ? metadata.Keywords.join(", ")
+                        : metadata.Keywords,
+                    Artist: metadata.Artist,
+                    Copyright: metadata.Copyright,
+                    Camera: [metadata.Make, metadata.Model].filter(Boolean).join(" "),
+                    DateTimeOriginal: metadata.DateTimeOriginal
+                        ? String(metadata.DateTimeOriginal)
+                        : undefined,
+                    CreateDate: metadata.CreateDate
+                        ? String(metadata.CreateDate)
+                        : undefined,
+                    GPS: metadata.GPSLatitude && metadata.GPSLongitude
+                        ? `${metadata.GPSLatitude}, ${metadata.GPSLongitude}`
+                        : undefined,
+                    ExposureTime: metadata.ExposureTime
+                        ? `1/${Math.round(1 / metadata.ExposureTime)}s`
+                        : undefined,
+                    FNumber: metadata.FNumber ? `f/${metadata.FNumber}` : undefined,
+                    ISO: metadata.ISO ? String(metadata.ISO) : undefined,
+                    FocalLength: metadata.FocalLength
+                        ? `${metadata.FocalLength}mm`
+                        : undefined,
+                    Software: metadata.Software,
+                };
+                for (const [key, value] of Object.entries(fields)) {
+                    if (value)
+                        sections.push(`${key}: ${value}`);
+                }
+            }
+        }
+        catch {
+            // EXIF parsing failed — not all images have EXIF
+        }
+        // AI description
+        if (options?.describe) {
+            try {
+                const mimetype = streamInfo.mimetype || guessMimetype(streamInfo.extension);
+                const description = await options.describe(input, mimetype);
+                if (description) {
+                    sections.push(`\n## Description\n\n${description}`);
+                }
+            }
+            catch {
+                // Description failed — continue without it
+            }
+        }
+        if (sections.length === 0) {
+            return { markdown: `*[image: ${streamInfo.filename || "unknown"}]*` };
+        }
+        return { markdown: sections.join("\n").trim() };
+    }
+}
+function guessMimetype(ext) {
+    const map = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".tiff": "image/tiff",
+        ".tif": "image/tiff",
+        ".bmp": "image/bmp",
+        ".svg": "image/svg+xml",
+    };
+    return map[ext || ""] || "image/png";
+}

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

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

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

@@ -0,0 +1,75 @@
+const EXTENSIONS = [".ipynb"];
+export class IpynbConverter {
+    name = "ipynb";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        return false;
+    }
+    async convert(input, _streamInfo) {
+        const text = new TextDecoder("utf-8").decode(input);
+        const notebook = JSON.parse(text);
+        const sections = [];
+        let title;
+        for (const cell of notebook.cells ?? []) {
+            const source = Array.isArray(cell.source)
+                ? cell.source.join("")
+                : (cell.source ?? "");
+            if (cell.cell_type === "markdown") {
+                sections.push(source);
+                // Extract first heading as title
+                if (!title) {
+                    const match = source.match(/^# (.+)$/m);
+                    if (match)
+                        title = match[1].trim();
+                }
+            }
+            else if (cell.cell_type === "code") {
+                // Detect language from kernel
+                const lang = notebook.metadata?.kernelspec?.language ||
+                    notebook.metadata?.language_info?.name ||
+                    "python";
+                sections.push(`\`\`\`${lang}\n${source}\n\`\`\``);
+                // Include text outputs
+                const outputs = [];
+                for (const out of cell.outputs ?? []) {
+                    if (out.output_type === "stream") {
+                        const text = Array.isArray(out.text)
+                            ? out.text.join("")
+                            : (out.text ?? "");
+                        if (text.trim())
+                            outputs.push(text.trim());
+                    }
+                    else if (out.output_type === "execute_result" ||
+                        out.output_type === "display_data") {
+                        const data = out.data;
+                        if (data?.["text/plain"]) {
+                            const plain = Array.isArray(data["text/plain"])
+                                ? data["text/plain"].join("")
+                                : data["text/plain"];
+                            if (plain.trim())
+                                outputs.push(plain.trim());
+                        }
+                    }
+                    else if (out.output_type === "error") {
+                        const tb = (out.traceback ?? []).join("\n");
+                        if (tb.trim())
+                            outputs.push(`Error: ${out.ename}: ${out.evalue}`);
+                    }
+                }
+                if (outputs.length > 0) {
+                    sections.push(`\`\`\`\n${outputs.join("\n")}\n\`\`\``);
+                }
+            }
+            else if (cell.cell_type === "raw") {
+                sections.push(`\`\`\`\n${source}\n\`\`\``);
+            }
+        }
+        // Check metadata for title
+        title = notebook.metadata?.title ?? title;
+        return {
+            markdown: sections.join("\n\n").trim(),
+            title,
+        };
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+/**
+ * Converts Apple iWork files (Pages, Keynote, Numbers) to markdown.
+ *
+ * All three formats are ZIP archives containing an XML file:
+ *   - Pages:   index.xml   (sf:p paragraphs with named styles)
+ *   - Keynote: index.apxl  (key:slide elements with sf:p text)
+ *   - Numbers: index.xml   (sf:t text cells + sf:n number cells)
+ */
+export declare class IWorkConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    private convertPages;
+    private convertKeynote;
+    private convertNumbers;
+    private extractGrid;
+    private convertNumbersFallback;
+    private readIndex;
+}