busy-cli 0.1.2

package/src/__tests__/fixtures/automated-workflow.busy.md

@@ -0,0 +1,84 @@
+---
+Name: AutomatedWorkflow
+Type: [Document]
+Description: A document with automated triggers for processing incoming data.
+---
+
+# [Imports]
+
+[Document]: ./document.busy.md
+[ValidateInput]: ./operations.busy.md#validateinput
+[ProcessData]: ./operations.busy.md#processdata
+
+# [Local Definitions]
+
+## InputSource
+External data sources that can trigger this workflow.
+
+## ProcessingRule
+Rules for how to handle incoming data.
+
+# [Setup]
+
+Before using this workflow:
+1. Configure API credentials
+2. Set up notification channels
+3. Verify processing rules
+
+# [Triggers]
+
+- Set alarm for 6am each morning to run DailyReport
+- When data.received from *@trusted.com, run ProcessIncoming
+- When webhook.triggered, run HandleWebhook
+
+# [Operations]
+
+## ProcessIncoming
+
+Process incoming data from external sources.
+
+### [Inputs]
+- source: The data source identifier
+- payload: The incoming data payload
+
+### [Outputs]
+- result: Processing result
+- log_id: Processing log identifier
+
+### [Steps]
+1. Run [ValidateInput] on the payload
+2. Apply processing rules from [ProcessingRule]
+3. Execute [ProcessData] with validated input
+4. Log results and notify stakeholders
+
+### [Checklist]
+- Input validated
+- Rules applied
+- Data processed
+- Stakeholders notified
+
+## DailyReport
+
+Generate and send daily activity report.
+
+### [Steps]
+1. Gather metrics from past 24 hours
+2. Generate summary report
+3. Send to configured recipients
+
+### [Checklist]
+- Metrics collected
+- Report generated
+- Report sent
+
+## HandleWebhook
+
+Handle incoming webhook requests.
+
+### [Inputs]
+- webhook_data: The webhook payload
+
+### [Steps]
+1. Parse webhook payload
+2. Determine action based on event type
+3. Execute appropriate handler

package/src/__tests__/fixtures/concept.busy.md

@@ -0,0 +1,30 @@
+---
+Name: Concept
+Type: [Concept]
+Description: Base concept type that all other types build upon.
+---
+# [Imports]
+
+# [Local Definitions]
+
+## Definition
+A named unit of meaning that can be referenced and composed.
+
+# [Setup]
+
+When evaluating a concept, resolve all imports first, then process definitions.
+
+# [Operations]
+
+## EvaluateConcept
+
+Evaluate a concept and return its resolved definition.
+
+### [Steps]
+1. Load the concept document
+2. Resolve any import references
+3. Return the concept definition
+
+### [Checklist]
+- Concept loaded successfully
+- All imports resolved

package/src/__tests__/fixtures/document.busy.md

@@ -0,0 +1,44 @@
+---
+Name: Document
+Type: [Document]
+Description: Base document type for all BUSY documents.
+---
+# [Imports]
+
+[Concept]: ./concept.busy.md
+
+# [Local Definitions]
+
+## Imports Section
+Section where external document references are declared.
+
+## Local Definitions Section
+Section where local concepts are defined.
+
+## Setup Section
+Section containing prerequisites and initialization.
+
+## Operations Section
+Section containing callable operations.
+
+# [Setup]
+
+A document must be evaluated before any operations can be executed.
+
+# [Operations]
+
+## EvaluateDocument
+
+Load and evaluate a BUSY document.
+
+### [Steps]
+1. Parse frontmatter for metadata
+2. Resolve all imports
+3. Load local definitions
+4. Execute setup section
+
+### [Checklist]
+- Frontmatter parsed
+- Imports resolved
+- Definitions loaded
+- Setup executed

package/src/__tests__/fixtures/simple-operation.busy.md

@@ -0,0 +1,45 @@
+---
+Name: SimpleOperation
+Type: [Operation]
+Description: A simple test operation for parsing validation.
+---
+# [Imports]
+
+[Concept]: ./concept.busy.md
+[Document]: ./document.busy.md
+
+# [Local Definitions]
+
+## InputParameter
+The input data required for this operation to execute.
+
+## OutputResult
+The result produced by executing this operation.
+
+# [Setup]
+
+Before executing this operation, ensure the context is properly initialized.
+
+# [Operations]
+
+## ExecuteTask
+
+Execute a simple task with inputs and outputs.
+
+### [Inputs]
+- task_name: Name of the task to execute
+- context: Execution context with required parameters
+
+### [Steps]
+1. Validate the input parameters are present
+2. Execute the main task logic referencing [Concept]
+3. Store the result in [OutputResult] format
+
+### [Outputs]
+- result: The computed result
+- status: Success or failure indicator
+
+### [Checklist]
+- Input parameters validated
+- Task executed successfully
+- Output stored correctly

package/src/__tests__/fixtures/tool-document.busy.md

@@ -0,0 +1,71 @@
+---
+Name: GmailTool
+Type: [Tool]
+Description: Tool for sending and receiving emails via Gmail API.
+Provider: composio
+---
+# [Imports]
+
+[Tool]: ./tool.busy.md
+[Operation]: ./operation.busy.md
+
+# [Local Definitions]
+
+## Capability
+Send and receive emails through the Gmail API with support for attachments and HTML content.
+
+## Invocation Contract
+Uses Composio's GMAIL integration with OAuth2 authentication.
+
+# [Setup]
+
+Ensure GMAIL_OAUTH_TOKEN environment variable is set.
+
+# [Tools]
+
+## send_email
+
+Send an email to one or more recipients.
+
+### [Inputs]
+- to: Recipient email address or comma-separated list
+- subject: Email subject line
+- body: Email body content (plain text or HTML)
+- attachments: Optional list of file paths to attach
+
+### [Outputs]
+- message_id: The ID of the sent message
+- thread_id: The thread ID for conversation tracking
+
+### [Examples]
+- send_email(to="user@example.com", subject="Hello", body="Test message")
+- send_email(to="a@x.com,b@x.com", subject="Team Update", body="<h1>News</h1>")
+
+#### composio
+Action: GMAIL_SEND_EMAIL
+Parameters:
+  to: to
+  subject: subject
+  body: body
+
+## read_inbox
+
+Read messages from the inbox.
+
+### [Inputs]
+- max_results: Maximum number of messages to return
+- query: Optional Gmail search query
+
+### [Outputs]
+- messages: List of message objects with id, subject, from, snippet
+
+#### composio
+Action: GMAIL_LIST_MESSAGES
+Parameters:
+  maxResults: max_results
+  q: query
+
+# [Triggers]
+
+- When gmail.message.received from *@important.com, run ProcessImportantEmail
+- Set alarm for 9am each morning to run InboxSummary

package/src/__tests__/fixtures/tool.busy.md

@@ -0,0 +1,54 @@
+---
+Name: GmailTools
+Type: [Tool]
+Description: Gmail integration tools for email management.
+Provider: composio
+---
+
+# [Imports]
+
+[Tool]: ../core/tool.busy.md
+
+# [Tools]
+
+## send_email
+
+Send an email to one or more recipients.
+
+### [Inputs]
+- to: Recipient email address
+- subject: Email subject line
+- body: Email body content
+
+### [Outputs]
+- message_id: The sent message ID
+- thread_id: The thread ID
+
+### [Providers]
+
+#### composio
+Action: GMAIL_SEND_EMAIL
+Parameters:
+  to: to
+  subject: subject
+  body: body
+
+## list_emails
+
+List emails from the inbox.
+
+### [Inputs]
+- limit: Maximum number of emails to return
+- query: Search query string
+
+### [Outputs]
+- emails: List of email objects
+- next_page_token: Token for pagination
+
+### [Providers]
+
+#### composio
+Action: GMAIL_LIST_EMAILS
+Parameters:
+  max_results: limit
+  q: query

package/src/__tests__/imports.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Import Parsing Tests - Match busy-python import format
+ *
+ * busy-python uses reference-style markdown links:
+ * [ConceptName]: path or [ConceptName]: path#anchor
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseImports, resolveImportTarget } from '../parsers/imports';
+import type { Import } from '../types/schema';
+
+describe('parseImports', () => {
+  it('should parse simple reference-style import', () => {
+    const content = `
+# [Imports]
+
+[Operation]: ./operation.busy.md
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(1);
+    expect(result.imports[0]).toEqual({
+      conceptName: 'Operation',
+      path: './operation.busy.md',
+      anchor: undefined,
+    });
+  });
+
+  it('should parse import with anchor', () => {
+    const content = `
+[RunChecklist]: ./checklist.busy.md#runchecklist
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(1);
+    expect(result.imports[0]).toEqual({
+      conceptName: 'RunChecklist',
+      path: './checklist.busy.md',
+      anchor: 'runchecklist',
+    });
+  });
+
+  it('should parse multiple imports', () => {
+    const content = `
+# [Imports]
+
+[Concept]: ./concept.busy.md
+[Document]: ./document.busy.md
+[Operation]: ./operation.busy.md
+[input]: ./operation.busy.md#input
+[output]: ./operation.busy.md#output
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(5);
+
+    // Check specific imports
+    const conceptImport = result.imports.find((i) => i.conceptName === 'Concept');
+    expect(conceptImport?.path).toBe('./concept.busy.md');
+    expect(conceptImport?.anchor).toBeUndefined();
+
+    const inputImport = result.imports.find((i) => i.conceptName === 'input');
+    expect(inputImport?.path).toBe('./operation.busy.md');
+    expect(inputImport?.anchor).toBe('input');
+  });
+
+  it('should handle imports with parent directory paths', () => {
+    const content = `
+[Tool]: ../toolbox/tool.busy.md
+[Utils]: ../../shared/utils.busy.md
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(2);
+    expect(result.imports[0].path).toBe('../toolbox/tool.busy.md');
+    expect(result.imports[1].path).toBe('../../shared/utils.busy.md');
+  });
+
+  it('should build symbol table from imports', () => {
+    const content = `
+[Operation]: ./operation.busy.md
+[RunChecklist]: ./checklist.busy.md#runchecklist
+`;
+
+    const result = parseImports(content);
+    expect(result.symbols).toHaveProperty('Operation');
+    expect(result.symbols).toHaveProperty('RunChecklist');
+  });
+
+  it('should handle imports anywhere in document (not just imports section)', () => {
+    const content = `
+---
+Name: Test
+Type: [Document]
+Description: Test
+---
+
+Some content here.
+
+[Concept]: ./concept.busy.md
+
+More content.
+
+[Other]: ./other.busy.md#anchor
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(2);
+  });
+
+  it('should not parse inline markdown links as imports', () => {
+    const content = `
+This is [not an import](./file.md) in inline format.
+
+[Actual Import]: ./import.busy.md
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(1);
+    expect(result.imports[0].conceptName).toBe('Actual Import');
+  });
+
+  it('should handle concept names with spaces', () => {
+    const content = `
+[Local Definitions]: ./document.busy.md#local-definitions
+[Imports Section]: ./document.busy.md#imports-section
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(2);
+    expect(result.imports[0].conceptName).toBe('Local Definitions');
+    expect(result.imports[1].conceptName).toBe('Imports Section');
+  });
+
+  it('should return empty array for document with no imports', () => {
+    const content = `
+---
+Name: NoImports
+Type: [Document]
+Description: Document with no imports
+---
+
+# [Setup]
+
+Just some setup content.
+`;
+
+    const result = parseImports(content);
+    expect(result.imports).toHaveLength(0);
+    expect(result.symbols).toEqual({});
+  });
+
+  it('should handle anchors with hyphens and numbers', () => {
+    const content = `
+[Step1]: ./steps.busy.md#step-1
+[RunStep2]: ./steps.busy.md#run-step-2-validation
+`;
+
+    const result = parseImports(content);
+    expect(result.imports[0].anchor).toBe('step-1');
+    expect(result.imports[1].anchor).toBe('run-step-2-validation');
+  });
+});
+
+describe('resolveImportTarget', () => {
+  const fileMap = new Map([
+    ['operation.busy.md', { docId: 'operation', path: './operation.busy.md' }],
+    ['concept.busy.md', { docId: 'concept', path: './concept.busy.md' }],
+    ['document.busy.md', { docId: 'document', path: './document.busy.md' }],
+    ['checklist.busy.md', { docId: 'checklist', path: './checklist.busy.md' }],
+    ['operation', { docId: 'operation', path: './operation.busy.md' }],
+  ]);
+
+  it('should resolve simple path to docId', () => {
+    const result = resolveImportTarget('./operation.busy.md', fileMap);
+    expect(result.docId).toBe('operation');
+    expect(result.slug).toBeUndefined();
+  });
+
+  it('should resolve path with anchor to docId and slug', () => {
+    const result = resolveImportTarget('./checklist.busy.md#runchecklist', fileMap);
+    expect(result.docId).toBe('checklist');
+    expect(result.slug).toBe('runchecklist');
+  });
+
+  it('should resolve relative parent paths', () => {
+    // The resolver should handle path normalization
+    const result = resolveImportTarget('../core/operation.busy.md', fileMap);
+    // This test may need adjustment based on actual implementation
+    // The key is that the basename should match
+  });
+
+  it('should return empty object for unresolved paths', () => {
+    const result = resolveImportTarget('./nonexistent.busy.md', fileMap);
+    expect(result).toEqual({});
+  });
+
+  it('should handle paths without ./ prefix', () => {
+    const result = resolveImportTarget('operation.busy.md', fileMap);
+    expect(result.docId).toBe('operation');
+  });
+});
+
+describe('Import Format Validation', () => {
+  it('should match busy-python regex pattern', () => {
+    // busy-python pattern: r"\[([^\]]+)\]:\s*([^\s#]+)(?:#([^\s]+))?"
+    const pattern = /\[([^\]]+)\]:\s*([^\s#]+)(?:#([^\s]+))?/g;
+
+    const testCases = [
+      { input: '[Concept]: ./concept.busy.md', expected: ['Concept', './concept.busy.md', undefined] },
+      { input: '[Run]: ./file.md#anchor', expected: ['Run', './file.md', 'anchor'] },
+      { input: '[Multi Word]: ../path/file.md', expected: ['Multi Word', '../path/file.md', undefined] },
+      { input: '[Test]:./no-space.md', expected: ['Test', './no-space.md', undefined] },
+      { input: '[Anchor]:./file.md#multi-word-anchor', expected: ['Anchor', './file.md', 'multi-word-anchor'] },
+    ];
+
+    for (const { input, expected } of testCases) {
+      const match = pattern.exec(input);
+      pattern.lastIndex = 0; // Reset for next iteration
+
+      expect(match).not.toBeNull();
+      if (match) {
+        expect(match[1]).toBe(expected[0]); // concept name
+        expect(match[2]).toBe(expected[1]); // path
+        expect(match[3]).toBe(expected[2]); // anchor (may be undefined)
+      }
+    }
+  });
+
+  it('should not match inline link format', () => {
+    const pattern = /^\[([^\]]+)\]:\s*([^\s#]+)(?:#([^\s]+))?$/m;
+
+    const inlineLinks = [
+      '[text](./file.md)',
+      '[text](./file.md#anchor)',
+      'Check [this](./link.md) out',
+    ];
+
+    for (const link of inlineLinks) {
+      const match = pattern.exec(link);
+      expect(match).toBeNull();
+    }
+  });
+});