busy-cli 0.1.2

package/src/parsers/tools.ts

@@ -0,0 +1,215 @@
+/**
+ * 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})
+ */
+
+import { Tool } from '../types/schema.js';
+
+/**
+ * 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: string): Record<string, { action: string; parameters?: Record<string, any> }> {
+  const providers: Record<string, { action: string; parameters?: Record<string, any> }> = {};
+
+  // Find Providers section - get everything after ### Providers or ### [Providers]
+  // Or if content starts with #### (direct provider definitions)
+  let providersContent: string;
+
+  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: Record<string, any> | undefined;
+
+      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: string): Record<string, any> {
+  const params: Record<string, any> = {};
+  const lines = content.split('\n');
+
+  let currentKey = '';
+  let currentNested: Record<string, any> | null = 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: string, sectionName: string): string[] {
+  const pattern = new RegExp(
+    `###\\s*\\[?${sectionName}\\]?\\s*\\n([\\s\\S]*?)(?=\\n###|\\n##|$)`,
+    'i'
+  );
+  const match = content.match(pattern);
+
+  if (!match) {
+    return [];
+  }
+
+  const items: string[] = [];
+  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: string): Tool[] {
+  const tools: Tool[] = [];
+
+  // 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;
+}

package/src/parsers/triggers.ts

@@ -0,0 +1,252 @@
+/**
+ * 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';
+import matter from 'gray-matter';
+
+// Weekday mapping
+const WEEKDAYS: Record<string, number> = {
+  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: string): string {
+  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: string): string {
+  // 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: number[] = [];
+
+  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: string): Trigger {
+  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: Record<string, string> | undefined;
+    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: Record<string, any>): Trigger[] {
+  const triggers: Trigger[] = [];
+
+  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: string): Trigger[] {
+  const triggers: Trigger[] = [];
+
+  // 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;
+}

package/src/providers/base.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 class ProviderRegistry {
+  private providers: Provider[] = [];
+
+  /**
+   * Register a provider
+   */
+  register(provider: Provider): void {
+    this.providers.push(provider);
+  }
+
+  /**
+   * Find provider that handles a URL
+   */
+  findProvider(url: string): Provider | undefined {
+    return this.providers.find(p => p.matches(url));
+  }
+
+  /**
+   * Get all registered providers
+   */
+  getProviders(): Provider[] {
+    return [...this.providers];
+  }
+}
+
+/**
+ * Global provider registry instance
+ */
+export const providerRegistry = new ProviderRegistry();

package/src/providers/github.ts

@@ -0,0 +1,129 @@
+/**
+ * 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, 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 implements Provider {
+  name = 'github';
+
+  matches(url: string): boolean {
+    // 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: string): ParsedURL {
+    // 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: ParsedURL): string {
+    if (parsed.rawUrl) {
+      return parsed.rawUrl;
+    }
+    return `https://raw.githubusercontent.com/${parsed.org}/${parsed.repo}/${parsed.ref}/${parsed.path}`;
+  }
+
+  async fetch(url: string): Promise<string> {
+    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: ParsedURL): Promise<string> {
+    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() as Array<{ name: string }>;
+
+    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);