@gajae-code/coding-agent 0.17.1 → 0.17.4

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

@@ -0,0 +1,92 @@
+import { loadAllPlugins } from "../plugins/loader.js";
+import { bold, dim, output } from "../utils/output.js";
+const BUILTIN_FORMATS = [
+    { name: "PDF", extensions: [".pdf"], builtin: true },
+    { name: "Word", extensions: [".docx"], builtin: true },
+    { name: "PowerPoint", extensions: [".pptx"], builtin: true },
+    { name: "Excel", extensions: [".xlsx"], builtin: true },
+    { name: "HTML", extensions: [".html", ".htm"], builtin: true },
+    { name: "EPUB", extensions: [".epub"], builtin: true },
+    { name: "Jupyter", extensions: [".ipynb"], builtin: true },
+    { name: "RSS/Atom", extensions: [".rss", ".atom", ".xml"], builtin: true },
+    { name: "CSV", extensions: [".csv", ".tsv"], builtin: true },
+    { name: "JSON", extensions: [".json"], builtin: true },
+    { name: "YAML", extensions: [".yaml", ".yml"], builtin: true },
+    { name: "XML", extensions: [".xml", ".svg"], builtin: true },
+    {
+        name: "Images",
+        extensions: [".jpg", ".png", ".gif", ".webp"],
+        builtin: true,
+    },
+    {
+        name: "Audio",
+        extensions: [".mp3", ".wav", ".m4a", ".flac"],
+        builtin: true,
+    },
+    {
+        name: "Pages",
+        extensions: [".pages"],
+        builtin: true,
+    },
+    {
+        name: "Keynote",
+        extensions: [".key"],
+        builtin: true,
+    },
+    {
+        name: "Numbers",
+        extensions: [".numbers"],
+        builtin: true,
+    },
+    {
+        name: "GitHub",
+        extensions: ["github.com/*", "gist.github.com/*"],
+        builtin: true,
+    },
+    { name: "ZIP", extensions: [".zip"], builtin: true },
+    {
+        name: "Plain text",
+        extensions: [".txt", ".md", ".rst", ".log"],
+        builtin: true,
+    },
+    {
+        name: "Code",
+        extensions: [".py", ".js", ".ts", ".go", ".rs", "..."],
+        builtin: true,
+    },
+    { name: "URLs", extensions: ["http://", "https://"], builtin: true },
+    { name: "Wikipedia", extensions: ["*.wikipedia.org"], builtin: true },
+];
+export async function formats(_args, options) {
+    const plugins = await loadAllPlugins();
+    const pluginFormats = plugins.flatMap((p) => p.formats.map((f) => ({
+        name: f.name,
+        extensions: f.extensions,
+        builtin: false,
+        plugin: p.name,
+    })));
+    const allFormats = [...BUILTIN_FORMATS, ...pluginFormats];
+    output(options, {
+        json: () => ({ formats: allFormats }),
+        human: () => {
+            console.log();
+            console.log(bold("Supported formats"));
+            console.log();
+            for (const fmt of BUILTIN_FORMATS) {
+                const exts = fmt.extensions.join(", ");
+                const note = fmt.dep ? dim(` (requires: npm i ${fmt.dep})`) : "";
+                console.log(`  ${fmt.name.padEnd(14)} ${dim(exts)}${note}`);
+            }
+            if (pluginFormats.length > 0) {
+                console.log();
+                console.log(bold("Plugin formats"));
+                console.log();
+                for (const fmt of pluginFormats) {
+                    const exts = fmt.extensions.join(", ");
+                    console.log(`  ${fmt.name.padEnd(14)} ${dim(exts)} ${dim(`(${fmt.plugin})`)}`);
+                }
+            }
+            console.log();
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { OutputOptions } from "../utils/output.js";
+export declare function init(_args: string[], options: OutputOptions): Promise<void>;

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

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { cmd, hint, output, success } from "../utils/output.js";
+const DATA_DIR = ".markit";
+export async function init(_args, options) {
+    const root = join(process.cwd(), DATA_DIR);
+    if (existsSync(root)) {
+        output(options, {
+            json: () => ({ success: true, path: root, message: "already_exists" }),
+            human: () => success(`.markit/ already exists`),
+        });
+        return;
+    }
+    mkdirSync(root, { recursive: true });
+    const config = {
+        llm: {},
+    };
+    writeFileSync(join(root, "config.json"), `${JSON.stringify(config, null, 2)}\n`);
+    output(options, {
+        json: () => ({ success: true, path: root }),
+        human: () => {
+            success(`Created .markit/ in ${process.cwd()}`);
+            hint("Set your API key for image/audio AI features:");
+            console.log(`  ${cmd("export OPENAI_API_KEY=sk-...")}`);
+            hint("Or configure directly:");
+            console.log(`  ${cmd("markit config set llm.apiKey sk-...")}`);
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { OutputOptions } from "../utils/output.js";
+export declare function onboard(_args: string[], options: OutputOptions): Promise<void>;

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

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { output, success } from "../utils/output.js";
+const INSTRUCTIONS = `
+<mill>
+Use \`markit\` to convert files and URLs to markdown. Supports PDF, DOCX, HTML, XLSX, CSV, JSON, and plain text.
+
+<commands>
+- \`markit <file-or-url>\` - convert to markdown (stdout)
+- \`markit <file-or-url> -o output.md\` - convert to file
+- \`markit formats\` - list supported formats
+</commands>
+
+<rules>
+- Use \`--json\` flag to get structured output for parsing
+- Use \`-q\` to get raw markdown without formatting
+- Pipe output directly: \`markit report.pdf | other-tool\`
+</rules>
+</markit>
+`.trim();
+const MARKER = "<mill>";
+export async function onboard(_args, options) {
+    const cwd = process.cwd();
+    const claudeMd = join(cwd, "CLAUDE.md");
+    const agentsMd = join(cwd, "AGENTS.md");
+    let targetFile;
+    if (existsSync(claudeMd)) {
+        targetFile = claudeMd;
+    }
+    else if (existsSync(agentsMd)) {
+        targetFile = agentsMd;
+    }
+    else {
+        targetFile = claudeMd;
+    }
+    let existingContent = "";
+    if (existsSync(targetFile)) {
+        existingContent = readFileSync(targetFile, "utf-8");
+    }
+    if (existingContent.includes(MARKER)) {
+        output(options, {
+            json: () => ({
+                success: true,
+                file: targetFile,
+                message: "already_onboarded",
+            }),
+            human: () => success(`Already onboarded (${targetFile})`),
+        });
+        return;
+    }
+    if (existingContent) {
+        writeFileSync(targetFile, `${existingContent.trimEnd()}\n\n${INSTRUCTIONS}\n`);
+    }
+    else {
+        writeFileSync(targetFile, `${INSTRUCTIONS}\n`);
+    }
+    output(options, {
+        json: () => ({ success: true, file: targetFile }),
+        human: () => success(`Added markit instructions to ${targetFile}`),
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { OutputOptions } from "../utils/output.js";
+export declare function pluginInstall(source: string, options: OutputOptions): Promise<void>;
+export declare function pluginRemove(name: string, options: OutputOptions): Promise<void>;
+export declare function pluginList(options: OutputOptions): Promise<void>;

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

@@ -0,0 +1,58 @@
+import { installPlugin, listInstalled, removePlugin, } from "../plugins/installer.js";
+import { EXIT_ERROR } from "../utils/exit-codes.js";
+import { bold, dim, error, output, success } from "../utils/output.js";
+export async function pluginInstall(source, options) {
+    try {
+        const result = await installPlugin(source);
+        output(options, {
+            json: () => ({ success: true, ...result }),
+            human: () => {
+                success(`Installed ${result.name}`);
+                console.log(dim(`  ${result.path}`));
+            },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        output(options, {
+            json: () => ({ success: false, error: msg }),
+            human: () => error(msg),
+        });
+        process.exit(EXIT_ERROR);
+    }
+}
+export async function pluginRemove(name, options) {
+    const removed = removePlugin(name);
+    output(options, {
+        json: () => ({ success: removed, name }),
+        human: () => {
+            if (removed) {
+                success(`Removed ${name}`);
+            }
+            else {
+                error(`Plugin '${name}' not found`);
+            }
+        },
+    });
+    if (!removed)
+        process.exit(EXIT_ERROR);
+}
+export async function pluginList(options) {
+    const plugins = listInstalled();
+    output(options, {
+        json: () => ({ plugins }),
+        human: () => {
+            if (plugins.length === 0) {
+                console.log(dim("  No plugins installed"));
+                return;
+            }
+            console.log();
+            console.log(bold("Installed plugins"));
+            console.log();
+            for (const p of plugins) {
+                console.log(`  ${p.name.padEnd(20)} ${dim(p.type)} ${dim(p.source)}`);
+            }
+            console.log();
+        },
+    });
+}

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

@@ -0,0 +1,26 @@
+export interface MarkitConfig {
+    llm?: {
+        /** Provider name: "openai" (default), "anthropic", or any registered provider */
+        provider?: string;
+        /** API base URL (overrides provider default) */
+        apiBase?: string;
+        /** API key — prefer env vars over storing here */
+        apiKey?: string;
+        /** Model override (overrides provider default) */
+        model?: string;
+        /** Transcription model override */
+        transcriptionModel?: string;
+    };
+}
+/**
+ * Walk up from cwd to find .markit/ directory.
+ */
+export declare function findConfigDir(): string | null;
+/**
+ * Load config from .markit/config.json.
+ */
+export declare function loadConfig(): MarkitConfig;
+/**
+ * Save config to .markit/config.json. Creates .markit/ if needed.
+ */
+export declare function saveConfig(config: MarkitConfig): void;

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

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const DATA_DIR = ".markit";
+const CONFIG_FILE = "config.json";
+/**
+ * Walk up from cwd to find .markit/ directory.
+ */
+export function findConfigDir() {
+    let dir = process.cwd();
+    while (true) {
+        if (existsSync(join(dir, DATA_DIR))) {
+            return join(dir, DATA_DIR);
+        }
+        const parent = join(dir, "..");
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Load config from .markit/config.json.
+ */
+export function loadConfig() {
+    const configDir = findConfigDir();
+    if (!configDir)
+        return {};
+    const configFile = join(configDir, CONFIG_FILE);
+    if (!existsSync(configFile))
+        return {};
+    const raw = JSON.parse(readFileSync(configFile, "utf-8"));
+    return { ...raw, llm: { ...raw.llm } };
+}
+/**
+ * Save config to .markit/config.json. Creates .markit/ if needed.
+ */
+export function saveConfig(config) {
+    const configDir = findConfigDir();
+    const dir = configDir || join(process.cwd(), DATA_DIR);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`);
+}

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

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

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

@@ -0,0 +1,104 @@
+const EXTENSIONS = [
+    ".mp3",
+    ".wav",
+    ".m4a",
+    ".mp4",
+    ".ogg",
+    ".flac",
+    ".aac",
+    ".wma",
+];
+const MIMETYPES = ["audio/", "video/mp4"];
+export class AudioConverter {
+    name = "audio";
+    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 audio metadata
+        try {
+            const mm = await import("music-metadata");
+            const metadata = await mm.parseBuffer(new Uint8Array(input), {
+                mimeType: streamInfo.mimetype,
+                size: input.length,
+            });
+            const { common, format } = metadata;
+            sections.push("## Metadata\n");
+            const fields = {
+                Title: common.title,
+                Artist: common.artist,
+                Album: common.album,
+                Genre: common.genre?.join(", "),
+                Track: common.track?.no
+                    ? `${common.track.no}${common.track.of ? ` of ${common.track.of}` : ""}`
+                    : undefined,
+                Year: common.year ? String(common.year) : undefined,
+                Duration: format.duration
+                    ? this.formatDuration(format.duration)
+                    : undefined,
+                Format: format.codec || format.container,
+                SampleRate: format.sampleRate ? `${format.sampleRate} Hz` : undefined,
+                Channels: format.numberOfChannels
+                    ? String(format.numberOfChannels)
+                    : undefined,
+                Bitrate: format.bitrate
+                    ? `${Math.round(format.bitrate / 1000)} kbps`
+                    : undefined,
+            };
+            for (const [key, value] of Object.entries(fields)) {
+                if (value)
+                    sections.push(`${key}: ${value}`);
+            }
+            if (common.lyrics?.length) {
+                sections.push(`\n## Lyrics\n\n${common.lyrics.join("\n")}`);
+            }
+        }
+        catch {
+            // Metadata parsing failed
+        }
+        // AI transcription
+        if (options?.transcribe) {
+            try {
+                const mimetype = streamInfo.mimetype || guessMimetype(streamInfo.extension);
+                const transcript = await options.transcribe(input, mimetype);
+                if (transcript) {
+                    sections.push(`\n## Transcript\n\n${transcript}`);
+                }
+            }
+            catch {
+                // Transcription failed
+            }
+        }
+        if (sections.length === 0) {
+            return { markdown: `*[audio: ${streamInfo.filename || "unknown"}]*` };
+        }
+        return { markdown: sections.join("\n").trim() };
+    }
+    formatDuration(seconds) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        const s = Math.round(seconds % 60);
+        if (h > 0)
+            return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+        return `${m}:${String(s).padStart(2, "0")}`;
+    }
+}
+function guessMimetype(ext) {
+    const map = {
+        ".mp3": "audio/mpeg",
+        ".wav": "audio/wav",
+        ".m4a": "audio/mp4",
+        ".mp4": "video/mp4",
+        ".ogg": "audio/ogg",
+        ".flac": "audio/flac",
+        ".aac": "audio/aac",
+        ".wma": "audio/x-ms-wma",
+    };
+    return map[ext || ""] || "audio/mpeg";
+}

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

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

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

@@ -0,0 +1,83 @@
+const EXTENSIONS = [".csv", ".tsv"];
+const MIMETYPES = ["text/csv", "text/tab-separated-values"];
+export class CsvConverter {
+    name = "csv";
+    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 delimiter = streamInfo.extension === ".tsv" ? "\t" : ",";
+        const rows = this.parseRows(text, delimiter);
+        if (rows.length === 0) {
+            return { markdown: "" };
+        }
+        const [header, ...body] = rows;
+        const lines = [];
+        // Header
+        lines.push(`| ${header.join(" | ")} |`);
+        lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+        // Body
+        for (const row of body) {
+            // Pad row to match header length
+            while (row.length < header.length)
+                row.push("");
+            lines.push(`| ${row.join(" | ")} |`);
+        }
+        return { markdown: lines.join("\n") };
+    }
+    parseRows(text, delimiter) {
+        const rows = [];
+        let current = [];
+        let cell = "";
+        let inQuotes = false;
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            if (inQuotes) {
+                if (ch === '"' && text[i + 1] === '"') {
+                    cell += '"';
+                    i++;
+                }
+                else if (ch === '"') {
+                    inQuotes = false;
+                }
+                else {
+                    cell += ch;
+                }
+            }
+            else if (ch === '"') {
+                inQuotes = true;
+            }
+            else if (ch === delimiter) {
+                current.push(cell.trim());
+                cell = "";
+            }
+            else if (ch === "\n" || (ch === "\r" && text[i + 1] === "\n")) {
+                current.push(cell.trim());
+                if (current.some((c) => c.length > 0))
+                    rows.push(current);
+                current = [];
+                cell = "";
+                if (ch === "\r")
+                    i++;
+            }
+            else {
+                cell += ch;
+            }
+        }
+        // Last row
+        if (cell || current.length > 0) {
+            current.push(cell.trim());
+            if (current.some((c) => c.length > 0))
+                rows.push(current);
+        }
+        return rows;
+    }
+}

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

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

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

@@ -0,0 +1,57 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import mammoth from "mammoth";
+import { createTurndown, normalizeTablesHtml } from "../utils/turndown.js";
+const EXTENSIONS = [".docx"];
+const MIMETYPES = [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+];
+export class DocxConverter {
+    name = "docx";
+    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 imageDir = streamInfo.imageDir;
+        if (imageDir) {
+            mkdirSync(imageDir, { recursive: true });
+        }
+        let imageCount = 0;
+        const convertImage = imageDir
+            ? mammoth.images.imgElement((image) => {
+                imageCount++;
+                const ext = (image.contentType?.split("/")[1] || "png").replace("jpeg", "jpg");
+                const filename = `image_${imageCount}.${ext}`;
+                const filepath = join(imageDir, filename);
+                return image.read("base64").then((base64) => {
+                    writeFileSync(filepath, Buffer.from(base64, "base64"));
+                    return { src: filepath, alt: `image_${imageCount}` };
+                });
+            })
+            : mammoth.images.imgElement((image) => {
+                imageCount++;
+                const contentType = image.contentType || "image/png";
+                return image.read("base64").then((base64) => {
+                    return {
+                        src: `data:${contentType};base64,${base64.slice(0, 0)}`,
+                        alt: `image_${imageCount}`,
+                    };
+                });
+            });
+        const { value: html } = await mammoth.convertToHtml({ buffer: input }, { convertImage });
+        const turndown = createTurndown();
+        let markdown = turndown.turndown(normalizeTablesHtml(html));
+        // Replace data URI images with comment placeholders when no imageDir
+        if (!imageDir) {
+            markdown = markdown.replace(/!\[([^\]]*)\]\(data:[^)]*\)/g, "<!-- image: $1 -->");
+        }
+        return { markdown: markdown.trim() };
+    }
+}

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

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