busy-cli 0.1.2

package/dist/parsers/tools.js

@@ -0,0 +1,178 @@
+/**
+ * Tool Parser - Matches busy-python Tool and ToolDocument models
+ *
+ * Tools have:
+ * - name: string
+ * - description: string
+ * - inputs: list[str]
+ * - outputs: list[str]
+ * - examples: Optional[list[str]]
+ * - providers: Optional[dict[str, dict[str, Any]]] (provider_name -> {action, parameters})
+ */
+/**
+ * Parse provider mappings from tool content
+ *
+ * @param content - Content of the tool section
+ * @returns Record of provider name to {action, parameters}
+ */
+export function parseToolProviders(content) {
+    const providers = {};
+    // Find Providers section - get everything after ### Providers or ### [Providers]
+    // Or if content starts with #### (direct provider definitions)
+    let providersContent;
+    const providersMatch = content.match(/###\s*\[?Providers\]?\s*\n([\s\S]*)$/i);
+    if (providersMatch) {
+        providersContent = providersMatch[1];
+    }
+    else if (content.match(/^####\s+/m)) {
+        // Content starts with provider definitions directly
+        providersContent = content;
+    }
+    else {
+        return providers;
+    }
+    // Trim at next ### that's not #### (to stop at next H3 section)
+    const nextSectionMatch = providersContent.match(/\n###\s+[^\#]/);
+    if (nextSectionMatch) {
+        providersContent = providersContent.slice(0, nextSectionMatch.index);
+    }
+    // Split by #### headings (provider names)
+    const parts = providersContent.split(/(?=####\s+)/);
+    for (const part of parts) {
+        if (!part.trim())
+            continue;
+        // Match provider heading: #### providerName
+        const providerMatch = part.match(/^####\s+(\w+)\s*\n?([\s\S]*)/);
+        if (providerMatch) {
+            const providerName = providerMatch[1];
+            const providerContent = providerMatch[2] || '';
+            // Extract Action
+            const actionMatch = providerContent.match(/Action:\s*(.+)/i);
+            const action = actionMatch ? actionMatch[1].trim() : '';
+            // Extract Parameters
+            const paramsMatch = providerContent.match(/Parameters:\s*\n([\s\S]*?)(?=####|Action:|$)/i);
+            let parameters;
+            if (paramsMatch) {
+                parameters = parseYamlLikeParams(paramsMatch[1]);
+            }
+            if (action) {
+                providers[providerName] = {
+                    action,
+                    parameters: parameters && Object.keys(parameters).length > 0 ? parameters : undefined,
+                };
+            }
+        }
+    }
+    return providers;
+}
+/**
+ * Parse YAML-like indented parameters
+ */
+function parseYamlLikeParams(content) {
+    const params = {};
+    const lines = content.split('\n');
+    let currentKey = '';
+    let currentNested = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Check indentation level
+        const leadingSpaces = line.match(/^(\s*)/)?.[1].length || 0;
+        // Match key: value pair
+        const kvMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+        if (kvMatch) {
+            const key = kvMatch[1];
+            const value = kvMatch[2].trim();
+            if (leadingSpaces <= 2) {
+                // Top-level key
+                if (value) {
+                    params[key] = value;
+                }
+                else {
+                    // Nested object
+                    currentKey = key;
+                    currentNested = {};
+                    params[key] = currentNested;
+                }
+            }
+            else if (currentNested && currentKey) {
+                // Nested key
+                currentNested[key] = value;
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Parse bullet list items from a section
+ */
+function parseBulletList(content, sectionName) {
+    const pattern = new RegExp(`###\\s*\\[?${sectionName}\\]?\\s*\\n([\\s\\S]*?)(?=\\n###|\\n##|$)`, 'i');
+    const match = content.match(pattern);
+    if (!match) {
+        return [];
+    }
+    const items = [];
+    const lines = match[1].split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+        if (bulletMatch) {
+            items.push(bulletMatch[1].trim());
+        }
+    }
+    return items;
+}
+/**
+ * Parse tools from markdown content
+ *
+ * @param content - Full markdown document content
+ * @returns Array of Tool objects
+ */
+export function parseTools(content) {
+    const tools = [];
+    // Find Tools section - handle both with and without brackets
+    const toolsMatch = content.match(/^#\s*\[?Tools\]?\s*$/im);
+    if (!toolsMatch) {
+        return [];
+    }
+    // Get content after Tools heading until next top-level section or end
+    const startIndex = toolsMatch.index + toolsMatch[0].length;
+    const restContent = content.slice(startIndex);
+    // Find next top-level heading (# not ##)
+    const nextH1Match = restContent.match(/\n#\s+[^\#]/);
+    const toolsContent = nextH1Match
+        ? restContent.slice(0, nextH1Match.index)
+        : restContent;
+    // Split by ## headings to find individual tools
+    const parts = toolsContent.split(/\n(?=##\s+)/);
+    for (const part of parts) {
+        if (!part.trim())
+            continue;
+        // Match tool heading: ## tool_name
+        const headingMatch = part.match(/^##\s+(\S+)\s*\n([\s\S]*)/);
+        if (headingMatch) {
+            const name = headingMatch[1].trim();
+            const toolContent = headingMatch[2] || '';
+            // Extract description (first paragraph before any ### section)
+            const descMatch = toolContent.match(/^([^#\n][\s\S]*?)(?=\n###|$)/);
+            const description = descMatch ? descMatch[1].trim() : '';
+            // Parse sections
+            const inputs = parseBulletList(toolContent, 'Inputs');
+            const outputs = parseBulletList(toolContent, 'Outputs');
+            const examples = parseBulletList(toolContent, 'Examples');
+            const providers = parseToolProviders(toolContent);
+            tools.push({
+                name,
+                description,
+                inputs,
+                outputs,
+                examples: examples.length > 0 ? examples : undefined,
+                providers: Object.keys(providers).length > 0 ? providers : undefined,
+            });
+        }
+    }
+    return tools;
+}
+//# sourceMappingURL=tools.js.map

package/dist/parsers/triggers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Trigger Parser - Matches busy-python trigger parsing
+ *
+ * Supports two trigger formats:
+ * 1. Time-based (alarm): "Set alarm for <time> to run <Operation>"
+ * 2. Event-based: "When <event> [from <filter>], run <Operation>"
+ *
+ * Triggers can appear in:
+ * - # [Triggers] section as bullet points
+ * - Frontmatter as a Triggers array
+ */
+import { Trigger } from '../types/schema.js';
+/**
+ * Parse a time specification into a cron expression
+ *
+ * @param timeSpec - Time string like "6am", "3pm each day", "9am on Monday"
+ * @returns Cron expression string
+ */
+export declare function parseTimeSpec(timeSpec: string): string;
+/**
+ * Parse a trigger declaration text into a Trigger object
+ *
+ * @param text - The trigger declaration text
+ * @returns Trigger object
+ */
+export declare function parseTriggerDeclaration(text: string): Trigger;
+/**
+ * Parse triggers from markdown content
+ * Combines triggers from both Triggers section and frontmatter
+ *
+ * @param content - Full markdown document content
+ * @returns Array of Trigger objects
+ */
+export declare function parseTriggers(content: string): Trigger[];
+//# sourceMappingURL=triggers.d.ts.map

package/dist/parsers/triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../src/parsers/triggers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAqB7C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuBtD;AAqCD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAmD7D;AAyCD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CA+CxD"}

package/dist/parsers/triggers.js

@@ -0,0 +1,219 @@
+/**
+ * Trigger Parser - Matches busy-python trigger parsing
+ *
+ * Supports two trigger formats:
+ * 1. Time-based (alarm): "Set alarm for <time> to run <Operation>"
+ * 2. Event-based: "When <event> [from <filter>], run <Operation>"
+ *
+ * Triggers can appear in:
+ * - # [Triggers] section as bullet points
+ * - Frontmatter as a Triggers array
+ */
+import matter from 'gray-matter';
+// Weekday mapping
+const WEEKDAYS = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6,
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6,
+};
+/**
+ * Parse a time specification into a cron expression
+ *
+ * @param timeSpec - Time string like "6am", "3pm each day", "9am on Monday"
+ * @returns Cron expression string
+ */
+export function parseTimeSpec(timeSpec) {
+    const spec = timeSpec.toLowerCase().trim();
+    // Extract hour and AM/PM
+    const timeMatch = spec.match(/(\d{1,2})\s*(am|pm)/i);
+    if (!timeMatch) {
+        return '* * * * *'; // Default: every minute (invalid spec)
+    }
+    let hour = parseInt(timeMatch[1], 10);
+    const isPM = timeMatch[2].toLowerCase() === 'pm';
+    // Convert to 24-hour format
+    if (isPM && hour !== 12) {
+        hour += 12;
+    }
+    else if (!isPM && hour === 12) {
+        hour = 0;
+    }
+    // Check for day specifications
+    const dayOfWeek = parseDayOfWeek(spec);
+    return `0 ${hour} * * ${dayOfWeek}`;
+}
+/**
+ * Parse day of week specification from time string
+ */
+function parseDayOfWeek(spec) {
+    // Check for "weekdays"
+    if (spec.includes('weekdays')) {
+        return '1-5';
+    }
+    // Check for "weekends"
+    if (spec.includes('weekends')) {
+        return '0,6';
+    }
+    // Check for specific days
+    const days = [];
+    for (const [dayName, dayNum] of Object.entries(WEEKDAYS)) {
+        // Match full day name or abbreviation
+        const pattern = new RegExp(`\\b${dayName}\\b`, 'i');
+        if (pattern.test(spec)) {
+            if (!days.includes(dayNum)) {
+                days.push(dayNum);
+            }
+        }
+    }
+    if (days.length > 0) {
+        return days.sort((a, b) => a - b).join(',');
+    }
+    // Default: every day
+    return '*';
+}
+/**
+ * Parse a trigger declaration text into a Trigger object
+ *
+ * @param text - The trigger declaration text
+ * @returns Trigger object
+ */
+export function parseTriggerDeclaration(text) {
+    const rawText = text.trim();
+    // Try to match alarm pattern: "Set alarm for <time> to run <Operation>"
+    const alarmMatch = rawText.match(/set\s+alarm\s+for\s+(.+?)\s+to\s+run\s+(\w+)/i);
+    if (alarmMatch) {
+        const timeSpec = alarmMatch[1];
+        const operation = alarmMatch[2];
+        const schedule = parseTimeSpec(timeSpec);
+        return {
+            rawText,
+            triggerType: 'alarm',
+            schedule,
+            operation,
+            queueWhenPaused: true,
+        };
+    }
+    // Try to match event pattern: "When <event> [from <filter>], run <Operation>"
+    const eventMatch = rawText.match(/when\s+([\w.]+)(?:\s+from\s+(.+?))?,\s*run\s+(\w+)/i);
+    if (eventMatch) {
+        const eventType = eventMatch[1];
+        const filterSpec = eventMatch[2];
+        const operation = eventMatch[3];
+        let filter;
+        if (filterSpec) {
+            // Treat filter as email pattern by default
+            filter = { from: filterSpec.trim() };
+        }
+        return {
+            rawText,
+            triggerType: 'event',
+            eventType,
+            filter,
+            operation,
+            queueWhenPaused: true,
+        };
+    }
+    // Fallback: couldn't parse, return minimal trigger
+    return {
+        rawText,
+        triggerType: 'event',
+        operation: 'Unknown',
+        queueWhenPaused: true,
+    };
+}
+/**
+ * Parse triggers from frontmatter data
+ */
+function parseFrontmatterTriggers(data) {
+    const triggers = [];
+    if (!data?.Triggers || !Array.isArray(data.Triggers)) {
+        return [];
+    }
+    for (const item of data.Triggers) {
+        if (typeof item === 'object' && item !== null) {
+            // Handle structured trigger from frontmatter
+            if (item.schedule) {
+                // Alarm trigger with explicit cron
+                triggers.push({
+                    rawText: JSON.stringify(item),
+                    triggerType: 'alarm',
+                    schedule: item.schedule,
+                    operation: item.operation || 'Unknown',
+                    queueWhenPaused: item.queue_when_paused ?? true,
+                });
+            }
+            else if (item.event_type) {
+                // Event trigger
+                triggers.push({
+                    rawText: JSON.stringify(item),
+                    triggerType: 'event',
+                    eventType: item.event_type,
+                    filter: item.filter,
+                    operation: item.operation || 'Unknown',
+                    queueWhenPaused: item.queue_when_paused ?? true,
+                });
+            }
+        }
+    }
+    return triggers;
+}
+/**
+ * Parse triggers from markdown content
+ * Combines triggers from both Triggers section and frontmatter
+ *
+ * @param content - Full markdown document content
+ * @returns Array of Trigger objects
+ */
+export function parseTriggers(content) {
+    const triggers = [];
+    // Extract only first frontmatter block to avoid "multiple documents" error
+    const trimmedContent = content.trimStart();
+    const frontmatterMatch = trimmedContent.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+        try {
+            const { data } = matter(frontmatterMatch[0]);
+            if (data && typeof data === 'object') {
+                const frontmatterTriggers = parseFrontmatterTriggers(data);
+                triggers.push(...frontmatterTriggers);
+            }
+        }
+        catch (e) {
+            // Frontmatter parsing error, continue without frontmatter triggers
+        }
+    }
+    // Find Triggers section
+    const triggersMatch = content.match(/^#\s*\[?Triggers\]?\s*$/im);
+    if (triggersMatch) {
+        // Get content after Triggers heading
+        const startIndex = triggersMatch.index + triggersMatch[0].length;
+        const restContent = content.slice(startIndex);
+        // Find next top-level heading
+        const nextH1Match = restContent.match(/\n#\s+[^\#]/);
+        const triggersContent = nextH1Match
+            ? restContent.slice(0, nextH1Match.index)
+            : restContent;
+        // Parse bullet items
+        const lines = triggersContent.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+            if (bulletMatch) {
+                const trigger = parseTriggerDeclaration(bulletMatch[1]);
+                triggers.push(trigger);
+            }
+        }
+    }
+    return triggers;
+}
+//# sourceMappingURL=triggers.js.map

package/dist/providers/base.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Provider system for URL handling
+ *
+ * Providers handle fetching content from different URL sources (GitHub, GitLab, generic URLs).
+ */
+export interface ParsedURL {
+    provider: string;
+    org?: string;
+    repo?: string;
+    ref?: string;
+    path: string;
+    anchor?: string;
+    rawUrl?: string;
+}
+export interface Provider {
+    name: string;
+    /**
+     * Check if this provider handles the given URL
+     */
+    matches(url: string): boolean;
+    /**
+     * Parse URL into components
+     */
+    parse(url: string): ParsedURL;
+    /**
+     * Convert parsed URL to raw content URL
+     */
+    getRawUrl(parsed: ParsedURL): string;
+    /**
+     * Fetch content from URL
+     */
+    fetch(url: string): Promise<string>;
+    /**
+     * Get the latest version/tag for a repo (optional)
+     */
+    getLatestVersion?(parsed: ParsedURL): Promise<string>;
+}
+/**
+ * Provider registry - manages all URL providers
+ */
+export declare class ProviderRegistry {
+    private providers;
+    /**
+     * Register a provider
+     */
+    register(provider: Provider): void;
+    /**
+     * Find provider that handles a URL
+     */
+    findProvider(url: string): Provider | undefined;
+    /**
+     * Get all registered providers
+     */
+    getProviders(): Provider[];
+}
+/**
+ * Global provider registry instance
+ */
+export declare const providerRegistry: ProviderRegistry;
+//# sourceMappingURL=base.d.ts.map

package/dist/providers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/providers/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAE9B;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC;IAErC;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEpC;;OAEG;IACH,gBAAgB,CAAC,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvD;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAkB;IAEnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIlC;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI/C;;OAEG;IACH,YAAY,IAAI,QAAQ,EAAE;CAG3B;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/providers/base.js

@@ -0,0 +1,34 @@
+/**
+ * Provider system for URL handling
+ *
+ * Providers handle fetching content from different URL sources (GitHub, GitLab, generic URLs).
+ */
+/**
+ * Provider registry - manages all URL providers
+ */
+export class ProviderRegistry {
+    providers = [];
+    /**
+     * Register a provider
+     */
+    register(provider) {
+        this.providers.push(provider);
+    }
+    /**
+     * Find provider that handles a URL
+     */
+    findProvider(url) {
+        return this.providers.find(p => p.matches(url));
+    }
+    /**
+     * Get all registered providers
+     */
+    getProviders() {
+        return [...this.providers];
+    }
+}
+/**
+ * Global provider registry instance
+ */
+export const providerRegistry = new ProviderRegistry();
+//# sourceMappingURL=base.js.map

package/dist/providers/github.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GitHub URL provider
+ *
+ * Handles URLs like:
+ * - https://github.com/org/repo/blob/ref/path/to/file.md
+ * - https://github.com/org/repo/tree/ref/path/to/dir
+ */
+import { Provider, ParsedURL } from './base.js';
+export declare class GitHubProvider implements Provider {
+    name: string;
+    matches(url: string): boolean;
+    parse(url: string): ParsedURL;
+    getRawUrl(parsed: ParsedURL): string;
+    fetch(url: string): Promise<string>;
+    getLatestVersion(parsed: ParsedURL): Promise<string>;
+}
+export declare const githubProvider: GitHubProvider;
+//# sourceMappingURL=github.d.ts.map

package/dist/providers/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../src/providers/github.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAoB,MAAM,WAAW,CAAC;AAWlE,qBAAa,cAAe,YAAW,QAAQ;IAC7C,IAAI,SAAY;IAEhB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAU7B,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IA+C7B,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM;IAO9B,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAYnC,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;CA0B3D;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/providers/github.js

@@ -0,0 +1,109 @@
+/**
+ * GitHub URL provider
+ *
+ * Handles URLs like:
+ * - https://github.com/org/repo/blob/ref/path/to/file.md
+ * - https://github.com/org/repo/tree/ref/path/to/dir
+ */
+import { providerRegistry } from './base.js';
+// Pattern for GitHub blob URLs (single file)
+const BLOB_PATTERN = /github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)/;
+// Pattern for GitHub tree URLs (directory)
+const TREE_PATTERN = /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/;
+// Pattern for raw GitHub URLs
+const RAW_PATTERN = /raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)/;
+export class GitHubProvider {
+    name = 'github';
+    matches(url) {
+        // Use proper URL parsing to check the hostname
+        try {
+            const parsed = new URL(url);
+            return parsed.hostname === 'github.com' || parsed.hostname === 'raw.githubusercontent.com';
+        }
+        catch {
+            return false;
+        }
+    }
+    parse(url) {
+        // Extract anchor if present
+        const [urlWithoutAnchor, anchor] = url.split('#');
+        // Try blob pattern first
+        let match = urlWithoutAnchor.match(BLOB_PATTERN);
+        if (match) {
+            return {
+                provider: 'github',
+                org: match[1],
+                repo: match[2],
+                ref: match[3],
+                path: match[4],
+                anchor,
+            };
+        }
+        // Try tree pattern (directory)
+        match = urlWithoutAnchor.match(TREE_PATTERN);
+        if (match) {
+            return {
+                provider: 'github',
+                org: match[1],
+                repo: match[2],
+                ref: match[3],
+                path: match[4],
+                anchor,
+            };
+        }
+        // Try raw URL pattern
+        match = urlWithoutAnchor.match(RAW_PATTERN);
+        if (match) {
+            return {
+                provider: 'github',
+                org: match[1],
+                repo: match[2],
+                ref: match[3],
+                path: match[4],
+                anchor,
+                rawUrl: urlWithoutAnchor,
+            };
+        }
+        throw new Error(`Cannot parse GitHub URL: ${url}`);
+    }
+    getRawUrl(parsed) {
+        if (parsed.rawUrl) {
+            return parsed.rawUrl;
+        }
+        return `https://raw.githubusercontent.com/${parsed.org}/${parsed.repo}/${parsed.ref}/${parsed.path}`;
+    }
+    async fetch(url) {
+        const parsed = this.parse(url);
+        const rawUrl = this.getRawUrl(parsed);
+        const response = await fetch(rawUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${rawUrl}: ${response.status} ${response.statusText}`);
+        }
+        return response.text();
+    }
+    async getLatestVersion(parsed) {
+        const apiUrl = `https://api.github.com/repos/${parsed.org}/${parsed.repo}/tags`;
+        const response = await fetch(apiUrl, {
+            headers: {
+                Accept: 'application/vnd.github.v3+json',
+                // Add User-Agent header as required by GitHub API
+                'User-Agent': 'busy-parser',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch tags from GitHub API: ${response.status}`);
+        }
+        const tags = await response.json();
+        if (tags.length === 0) {
+            throw new Error(`No tags found for ${parsed.org}/${parsed.repo}`);
+        }
+        // Return the first (latest) tag
+        // Note: GitHub API returns tags in reverse chronological order for most repos
+        // For proper semver sorting, we'd need to parse and sort the tags
+        return tags[0].name;
+    }
+}
+// Create and register the GitHub provider
+export const githubProvider = new GitHubProvider();
+providerRegistry.register(githubProvider);
+//# sourceMappingURL=github.js.map

package/dist/providers/gitlab.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GitLab URL provider
+ *
+ * Handles URLs like:
+ * - https://gitlab.com/org/repo/-/blob/ref/path/to/file.md
+ * - https://gitlab.com/org/repo/-/tree/ref/path/to/dir
+ */
+import { Provider, ParsedURL } from './base.js';
+export declare class GitLabProvider implements Provider {
+    name: string;
+    matches(url: string): boolean;
+    parse(url: string): ParsedURL;
+    getRawUrl(parsed: ParsedURL): string;
+    fetch(url: string): Promise<string>;
+    getLatestVersion(parsed: ParsedURL): Promise<string>;
+}
+export declare const gitlabProvider: GitLabProvider;
+//# sourceMappingURL=gitlab.d.ts.map

package/dist/providers/gitlab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitlab.d.ts","sourceRoot":"","sources":["../../src/providers/gitlab.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAoB,MAAM,WAAW,CAAC;AAWlE,qBAAa,cAAe,YAAW,QAAQ;IAC7C,IAAI,SAAY;IAEhB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAU7B,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IA+C7B,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM;IAO9B,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAYnC,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;CAkB3D;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}