@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/ai-service/skills/system/migration-api-verification/skill.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.generated.js","sourceRoot":"","sources":["../../../../../src/ai-service/skills/system/migration-api-verification/skill.generated.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,mDAAmD;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHtB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/code-blocks.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const content = "# JavaScript and Python Code Blocks\n\nReference documentation for working with JavaScript and Python code blocks in Superblocks APIs.\n\n## JavaScript Block\n\n```typescript\nimport { JavaScript } from \"@superblocksteam/library\";\n\nnew JavaScript(\"process_data\", {\n  fn: ({ input }: { input: any }) => {\n    // Your JavaScript code here\n    return processedResult;\n  },\n});\n```\n\n### Key Features\n\n- Full ES2020+ syntax support\n- Access to previous block outputs\n- Can return any JSON-serializable value\n- Runs in Node.js environment\n\n### Common Patterns\n\n```typescript\n// Data transformation\nnew JavaScript(\"transform\", {\n  fn: ({ users }) =>\n    users.output.map((user: any) => ({\n      id: user.id,\n      displayName: `${user.firstName} ${user.lastName}`,\n      email: user.email.toLowerCase(),\n    })),\n});\n\n// Conditional logic\nnew JavaScript(\"validate\", {\n  fn: ({ data }: { data: any }) => {\n    if (!data.email || !data.email.includes(\"@\")) {\n      throw new Error(\"Invalid email address\");\n    }\n    return { valid: true, data };\n  },\n});\n\n// Aggregation\nnew JavaScript(\"aggregate\", {\n  fn: ({ orders }) => {\n    const output = orders.output;\n    return {\n      totalOrders: output.length,\n      totalRevenue: output.reduce((sum: number, o: any) => sum + o.amount, 0),\n      averageOrder:\n        output.reduce((sum: number, o: any) => sum + o.amount, 0) /\n        output.length,\n    };\n  },\n});\n\n// Working with Variables block\nnew JavaScript(\"update_state\", {\n  fn: ({ counter, items, newItem }) => {\n    // Variables use .value for reading and .set() for writing\n    const currentCount = counter.value;\n    const currentItems = items.value;\n\n    items.set([...currentItems, newItem]);\n    counter.set(currentCount + 1);\n\n    return { added: newItem, newCount: currentCount + 1 };\n  },\n});\n```\n\n### Available Globals\n\n```typescript\nnew JavaScript(\"with_globals\", {\n  fn: ({ Global }) => {\n    // Global object contains user/org context\n    const userId = Global.user.id;\n    const userEmail = Global.user.email;\n    const userGroups = Global.groups;\n\n    return {\n      userId,\n      userEmail,\n      isAdmin: userGroups.some((g) => g.name === \"Admin\"),\n    };\n  },\n});\n```\n\n## Python Block\n\n```typescript\nimport { Python } from \"@superblocksteam/library\";\n\nnew Python(\"python_transform\", {\n  code: `\nimport json\n\n# Access inputs directly\nresult = {\n    \"processed\": True,\n    \"count\": len(data)\n}\n\n# Return must be JSON serializable\nreturn result\n  `,\n});\n```\n\n### Key Features\n\n- Python 3.x runtime\n- Common libraries available (pandas, numpy, etc.)\n- Access inputs as Python variables\n- Return value must be JSON serializable\n\n### Common Patterns\n\n```python\n# Data processing with pandas\nimport pandas as pd\n\ndf = pd.DataFrame(users_data)\nfiltered = df[df['status'] == 'active']\nresult = filtered.to_dict(orient='records')\nreturn result\n```\n\n```python\n# Statistical analysis\nimport numpy as np\n\nvalues = [item['amount'] for item in orders_data]\nreturn {\n    'mean': float(np.mean(values)),\n    'median': float(np.median(values)),\n    'std': float(np.std(values))\n}\n```\n\n### Python Variable Access\n\n```python\n# Inputs are available as Python variables\n# Previous block outputs are also available\n\n# Access input parameter\nemail = input_email  # Direct variable access\n\n# Access previous block output\nusers = fetch_users  # Output from previous block named 'fetch_users'\n```\n\n## Choosing JavaScript vs Python\n\n**Use JavaScript when:**\n\n- Simple data transformations\n- JSON manipulation\n- Working with Superblocks Variables\n- Need to use `.set()` for state updates\n\n**Use Python when:**\n\n- Complex data analysis (pandas)\n- Statistical computations (numpy/scipy)\n- Machine learning operations\n- Heavy numerical processing\n\n## Error Handling\n\nBoth languages throw errors that can be caught with TryCatch:\n\n```typescript\nnew TryCatch(\"safe_process\", {\n  try: [\n    new JavaScript(\"risky_operation\", {\n      fn: ({ data }) => {\n        if (!data) throw new Error(\"Data is required\");\n        return processData(data);\n      },\n    }),\n  ],\n  catch: [\n    new JavaScript(\"handle_error\", {\n      fn: ({ processError }) => ({\n        success: false,\n        error: processError.value.message,\n      }),\n    }),\n  ],\n  variables: { error: \"processError\" },\n});\n```\n\n## Processing File Content\n\nWhen you need to read and process file content (parse CSV, extract text, validate, etc.):\n\nFilePicker files are stored on the orchestrator's file server.\n\n### Methods\n\n- `readContents(mode?)` - Synchronous\n- `readContentsAsync(mode?)` - Asynchronous\n\n### Mode Parameter\n\n- (none) - auto-detects: returns base64 string for binary files, UTF-8 string for text\n- `'raw'` - returns Buffer in JavaScript, bytes in Python (for direct byte access)\n- `'text'` - returns UTF-8 string\n- `'binary'` - returns base64 string\n\n### JavaScript - use await directly\n\n```typescript\nnew JavaScript(\"parse_csv\", {\n  fn: async ({ csvFile }) => {\n    const file = csvFile.files[0];\n    const content = await file.readContentsAsync();\n    const headers = content\n      .split(\"\\n\")[0]\n      .split(\",\")\n      .map((h) => h.trim());\n    return { fileName: file.name, headers };\n  },\n});\n\n// Binary file - use 'raw' mode for byte access\nnew JavaScript(\"check_jpeg\", {\n  fn: async ({ imageFile }) => {\n    const buf = await imageFile.files[0].readContentsAsync(\"raw\"); // Buffer\n    const isJPEG = buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff;\n    return { isJPEG };\n  },\n});\n```\n\n### Python - use sync for single file, async for parallel\n\n```python\n# Single file - use sync (simpler)\ncontent = file.readContents()\nrows = content.split('\\n')\n\n# Check file type by magic bytes\nraw = file.readContents('raw')\nis_pdf = raw[:4] == b'%PDF'\n\n# Multiple files in parallel - use async\nimport asyncio\nasync def fetch_all(files):\n    return await asyncio.gather(*[f.readContentsAsync() for f in files])\ncontents = asyncio.run(fetch_all(files))\n```\n\n## Best Practices\n\n1. **Keep blocks focused** - One logical operation per block\n2. **Use descriptive names** - `calculate_shipping_cost` not `calc`\n3. **Type your inputs** - `({ userId }: { userId: string })` not `({ userId })`\n4. **Handle edge cases** - Check for null/undefined/empty arrays\n5. **Return clean data** - Only return what's needed downstream\n";
+//# sourceMappingURL=code-blocks.generated.d.ts.map

package/dist/ai-service/skills/system/superblocks-api/references/code-blocks.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-blocks.generated.d.ts","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/code-blocks.generated.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,i8MA8QnB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/code-blocks.generated.js

@@ -0,0 +1,274 @@
+// Auto-generated from src/ai-service/skills/system/superblocks-api/references/code-blocks.md
+// Do not edit directly - edit the .md file instead
+export const content = `# JavaScript and Python Code Blocks
+
+Reference documentation for working with JavaScript and Python code blocks in Superblocks APIs.
+
+## JavaScript Block
+
+\`\`\`typescript
+import { JavaScript } from "@superblocksteam/library";
+
+new JavaScript("process_data", {
+  fn: ({ input }: { input: any }) => {
+    // Your JavaScript code here
+    return processedResult;
+  },
+});
+\`\`\`
+
+### Key Features
+
+- Full ES2020+ syntax support
+- Access to previous block outputs
+- Can return any JSON-serializable value
+- Runs in Node.js environment
+
+### Common Patterns
+
+\`\`\`typescript
+// Data transformation
+new JavaScript("transform", {
+  fn: ({ users }) =>
+    users.output.map((user: any) => ({
+      id: user.id,
+      displayName: \`\${user.firstName} \${user.lastName}\`,
+      email: user.email.toLowerCase(),
+    })),
+});
+
+// Conditional logic
+new JavaScript("validate", {
+  fn: ({ data }: { data: any }) => {
+    if (!data.email || !data.email.includes("@")) {
+      throw new Error("Invalid email address");
+    }
+    return { valid: true, data };
+  },
+});
+
+// Aggregation
+new JavaScript("aggregate", {
+  fn: ({ orders }) => {
+    const output = orders.output;
+    return {
+      totalOrders: output.length,
+      totalRevenue: output.reduce((sum: number, o: any) => sum + o.amount, 0),
+      averageOrder:
+        output.reduce((sum: number, o: any) => sum + o.amount, 0) /
+        output.length,
+    };
+  },
+});
+
+// Working with Variables block
+new JavaScript("update_state", {
+  fn: ({ counter, items, newItem }) => {
+    // Variables use .value for reading and .set() for writing
+    const currentCount = counter.value;
+    const currentItems = items.value;
+
+    items.set([...currentItems, newItem]);
+    counter.set(currentCount + 1);
+
+    return { added: newItem, newCount: currentCount + 1 };
+  },
+});
+\`\`\`
+
+### Available Globals
+
+\`\`\`typescript
+new JavaScript("with_globals", {
+  fn: ({ Global }) => {
+    // Global object contains user/org context
+    const userId = Global.user.id;
+    const userEmail = Global.user.email;
+    const userGroups = Global.groups;
+
+    return {
+      userId,
+      userEmail,
+      isAdmin: userGroups.some((g) => g.name === "Admin"),
+    };
+  },
+});
+\`\`\`
+
+## Python Block
+
+\`\`\`typescript
+import { Python } from "@superblocksteam/library";
+
+new Python("python_transform", {
+  code: \`
+import json
+
+# Access inputs directly
+result = {
+    "processed": True,
+    "count": len(data)
+}
+
+# Return must be JSON serializable
+return result
+  \`,
+});
+\`\`\`
+
+### Key Features
+
+- Python 3.x runtime
+- Common libraries available (pandas, numpy, etc.)
+- Access inputs as Python variables
+- Return value must be JSON serializable
+
+### Common Patterns
+
+\`\`\`python
+# Data processing with pandas
+import pandas as pd
+
+df = pd.DataFrame(users_data)
+filtered = df[df['status'] == 'active']
+result = filtered.to_dict(orient='records')
+return result
+\`\`\`
+
+\`\`\`python
+# Statistical analysis
+import numpy as np
+
+values = [item['amount'] for item in orders_data]
+return {
+    'mean': float(np.mean(values)),
+    'median': float(np.median(values)),
+    'std': float(np.std(values))
+}
+\`\`\`
+
+### Python Variable Access
+
+\`\`\`python
+# Inputs are available as Python variables
+# Previous block outputs are also available
+
+# Access input parameter
+email = input_email  # Direct variable access
+
+# Access previous block output
+users = fetch_users  # Output from previous block named 'fetch_users'
+\`\`\`
+
+## Choosing JavaScript vs Python
+
+**Use JavaScript when:**
+
+- Simple data transformations
+- JSON manipulation
+- Working with Superblocks Variables
+- Need to use \`.set()\` for state updates
+
+**Use Python when:**
+
+- Complex data analysis (pandas)
+- Statistical computations (numpy/scipy)
+- Machine learning operations
+- Heavy numerical processing
+
+## Error Handling
+
+Both languages throw errors that can be caught with TryCatch:
+
+\`\`\`typescript
+new TryCatch("safe_process", {
+  try: [
+    new JavaScript("risky_operation", {
+      fn: ({ data }) => {
+        if (!data) throw new Error("Data is required");
+        return processData(data);
+      },
+    }),
+  ],
+  catch: [
+    new JavaScript("handle_error", {
+      fn: ({ processError }) => ({
+        success: false,
+        error: processError.value.message,
+      }),
+    }),
+  ],
+  variables: { error: "processError" },
+});
+\`\`\`
+
+## Processing File Content
+
+When you need to read and process file content (parse CSV, extract text, validate, etc.):
+
+FilePicker files are stored on the orchestrator's file server.
+
+### Methods
+
+- \`readContents(mode?)\` - Synchronous
+- \`readContentsAsync(mode?)\` - Asynchronous
+
+### Mode Parameter
+
+- (none) - auto-detects: returns base64 string for binary files, UTF-8 string for text
+- \`'raw'\` - returns Buffer in JavaScript, bytes in Python (for direct byte access)
+- \`'text'\` - returns UTF-8 string
+- \`'binary'\` - returns base64 string
+
+### JavaScript - use await directly
+
+\`\`\`typescript
+new JavaScript("parse_csv", {
+  fn: async ({ csvFile }) => {
+    const file = csvFile.files[0];
+    const content = await file.readContentsAsync();
+    const headers = content
+      .split("\\n")[0]
+      .split(",")
+      .map((h) => h.trim());
+    return { fileName: file.name, headers };
+  },
+});
+
+// Binary file - use 'raw' mode for byte access
+new JavaScript("check_jpeg", {
+  fn: async ({ imageFile }) => {
+    const buf = await imageFile.files[0].readContentsAsync("raw"); // Buffer
+    const isJPEG = buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff;
+    return { isJPEG };
+  },
+});
+\`\`\`
+
+### Python - use sync for single file, async for parallel
+
+\`\`\`python
+# Single file - use sync (simpler)
+content = file.readContents()
+rows = content.split('\\n')
+
+# Check file type by magic bytes
+raw = file.readContents('raw')
+is_pdf = raw[:4] == b'%PDF'
+
+# Multiple files in parallel - use async
+import asyncio
+async def fetch_all(files):
+    return await asyncio.gather(*[f.readContentsAsync() for f in files])
+contents = asyncio.run(fetch_all(files))
+\`\`\`
+
+## Best Practices
+
+1. **Keep blocks focused** - One logical operation per block
+2. **Use descriptive names** - \`calculate_shipping_cost\` not \`calc\`
+3. **Type your inputs** - \`({ userId }: { userId: string })\` not \`({ userId })\`
+4. **Handle edge cases** - Check for null/undefined/empty arrays
+5. **Return clean data** - Only return what's needed downstream
+`;
+//# sourceMappingURL=code-blocks.generated.js.map

package/dist/ai-service/skills/system/superblocks-api/references/code-blocks.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-blocks.generated.js","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/code-blocks.generated.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,mDAAmD;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8QtB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/graphql.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const content = "# GraphQL Integrations\n\nReference documentation for working with GraphQL APIs in Superblocks.\n\n## GraphQL Class\n\n```typescript\nimport { GraphQL } from \"@superblocksteam/library\";\n\nnew GraphQL(\"fetch_users\", \"graphql-integration-id\", {\n  query: `\n    query GetUsers($limit: Int!) {\n      users(limit: $limit) {\n        id\n        name\n        email\n      }\n    }\n  `,\n  variables: { limit: 10 },\n});\n```\n\n## Output Structure\n\n**IMPORTANT**: GraphQL responses have a specific structure:\n\n```typescript\n// GraphQL output format\n{\n  data: {\n    users: [...]\n  },\n  errors?: [...]\n}\n\n// Access query results\nnew JavaScript(\"process\", {\n  fn: ({ fetch_users }) => {\n    const result = fetch_users.output;\n    // Always access via .data property\n    return result.data.users;\n  }\n})\n```\n\n## Dynamic Queries\n\n```typescript\nnew GraphQL(\"search\", \"graphql-id\", {\n  query: `\n    query SearchUsers($term: String!, $limit: Int) {\n      searchUsers(term: $term, limit: $limit) {\n        id\n        name\n        matchScore\n      }\n    }\n  `,\n  variables: ({\n    searchTerm,\n    pageSize,\n  }: {\n    searchTerm: string;\n    pageSize: number;\n  }) => ({\n    term: searchTerm,\n    limit: pageSize,\n  }),\n});\n```\n\n## Mutations\n\n```typescript\nnew GraphQL(\"create_user\", \"graphql-id\", {\n  query: `\n    mutation CreateUser($input: CreateUserInput!) {\n      createUser(input: $input) {\n        id\n        name\n        email\n        createdAt\n      }\n    }\n  `,\n  variables: ({ name, email }: { name: string; email: string }) => ({\n    input: { name, email },\n  }),\n});\n```\n\n## Common Patterns\n\n### Query with Fragments\n\n```typescript\nnew GraphQL(\"complex_query\", \"graphql-id\", {\n  query: `\n    fragment UserFields on User {\n      id\n      name\n      email\n    }\n    \n    query GetUsersAndOrders($userId: ID!) {\n      user(id: $userId) {\n        ...UserFields\n        orders {\n          id\n          total\n          status\n        }\n      }\n    }\n  `,\n  variables: ({ userId }: { userId: string }) => ({ userId }),\n});\n```\n\n### Pagination with Connections\n\n```typescript\nnew GraphQL(\"paginated_list\", \"graphql-id\", {\n  query: `\n    query ListItems($first: Int!, $after: String) {\n      items(first: $first, after: $after) {\n        edges {\n          node {\n            id\n            name\n          }\n          cursor\n        }\n        pageInfo {\n          hasNextPage\n          endCursor\n        }\n      }\n    }\n  `,\n  variables: ({ pageSize, cursor }: { pageSize: number; cursor?: string }) => ({\n    first: pageSize,\n    after: cursor,\n  }),\n});\n```\n\n### Batch Operations\n\n```typescript\nnew GraphQL(\"batch_update\", \"graphql-id\", {\n  query: `\n    mutation BatchUpdateItems($updates: [ItemUpdateInput!]!) {\n      batchUpdateItems(updates: $updates) {\n        success\n        updatedCount\n        errors {\n          itemId\n          message\n        }\n      }\n    }\n  `,\n  variables: ({ items }: { items: Array<{ id: string; status: string }> }) => ({\n    updates: items.map((item) => ({\n      id: item.id,\n      status: item.status,\n    })),\n  }),\n});\n```\n\n## Error Handling\n\nGraphQL can return both data and errors:\n\n```typescript\nnew GraphQL(\"risky_query\", \"graphql-id\", { ... }),\n\nnew JavaScript(\"handle_response\", {\n  fn: ({ risky_query }) => {\n    const result = risky_query.output;\n\n    if (result.errors && result.errors.length > 0) {\n      // Handle partial errors\n      console.error(\"GraphQL errors:\", result.errors);\n    }\n\n    // Data may still be present even with errors\n    return result.data?.items ?? [];\n  }\n})\n```\n\n## Subscriptions\n\n**Note**: GraphQL subscriptions are not directly supported. For real-time data, consider:\n\n1. Polling with Loop blocks\n2. WebSocket integrations if available\n3. REST webhook endpoints\n\n## Best Practices\n\n1. **Always select specific fields** - Don't over-fetch\n2. **Use variables** - Never interpolate strings in queries\n3. **Handle partial responses** - GraphQL can return data with errors\n4. **Access via .data** - Always use `output.data.fieldName`\n5. **Use fragments** - For reusable field selections\n";
+//# sourceMappingURL=graphql.generated.d.ts.map

package/dist/ai-service/skills/system/superblocks-api/references/graphql.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.generated.d.ts","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/graphql.generated.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,2rIAkNnB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/graphql.generated.js

@@ -0,0 +1,214 @@
+// Auto-generated from src/ai-service/skills/system/superblocks-api/references/graphql.md
+// Do not edit directly - edit the .md file instead
+export const content = `# GraphQL Integrations
+
+Reference documentation for working with GraphQL APIs in Superblocks.
+
+## GraphQL Class
+
+\`\`\`typescript
+import { GraphQL } from "@superblocksteam/library";
+
+new GraphQL("fetch_users", "graphql-integration-id", {
+  query: \`
+    query GetUsers($limit: Int!) {
+      users(limit: $limit) {
+        id
+        name
+        email
+      }
+    }
+  \`,
+  variables: { limit: 10 },
+});
+\`\`\`
+
+## Output Structure
+
+**IMPORTANT**: GraphQL responses have a specific structure:
+
+\`\`\`typescript
+// GraphQL output format
+{
+  data: {
+    users: [...]
+  },
+  errors?: [...]
+}
+
+// Access query results
+new JavaScript("process", {
+  fn: ({ fetch_users }) => {
+    const result = fetch_users.output;
+    // Always access via .data property
+    return result.data.users;
+  }
+})
+\`\`\`
+
+## Dynamic Queries
+
+\`\`\`typescript
+new GraphQL("search", "graphql-id", {
+  query: \`
+    query SearchUsers($term: String!, $limit: Int) {
+      searchUsers(term: $term, limit: $limit) {
+        id
+        name
+        matchScore
+      }
+    }
+  \`,
+  variables: ({
+    searchTerm,
+    pageSize,
+  }: {
+    searchTerm: string;
+    pageSize: number;
+  }) => ({
+    term: searchTerm,
+    limit: pageSize,
+  }),
+});
+\`\`\`
+
+## Mutations
+
+\`\`\`typescript
+new GraphQL("create_user", "graphql-id", {
+  query: \`
+    mutation CreateUser($input: CreateUserInput!) {
+      createUser(input: $input) {
+        id
+        name
+        email
+        createdAt
+      }
+    }
+  \`,
+  variables: ({ name, email }: { name: string; email: string }) => ({
+    input: { name, email },
+  }),
+});
+\`\`\`
+
+## Common Patterns
+
+### Query with Fragments
+
+\`\`\`typescript
+new GraphQL("complex_query", "graphql-id", {
+  query: \`
+    fragment UserFields on User {
+      id
+      name
+      email
+    }
+    
+    query GetUsersAndOrders($userId: ID!) {
+      user(id: $userId) {
+        ...UserFields
+        orders {
+          id
+          total
+          status
+        }
+      }
+    }
+  \`,
+  variables: ({ userId }: { userId: string }) => ({ userId }),
+});
+\`\`\`
+
+### Pagination with Connections
+
+\`\`\`typescript
+new GraphQL("paginated_list", "graphql-id", {
+  query: \`
+    query ListItems($first: Int!, $after: String) {
+      items(first: $first, after: $after) {
+        edges {
+          node {
+            id
+            name
+          }
+          cursor
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  \`,
+  variables: ({ pageSize, cursor }: { pageSize: number; cursor?: string }) => ({
+    first: pageSize,
+    after: cursor,
+  }),
+});
+\`\`\`
+
+### Batch Operations
+
+\`\`\`typescript
+new GraphQL("batch_update", "graphql-id", {
+  query: \`
+    mutation BatchUpdateItems($updates: [ItemUpdateInput!]!) {
+      batchUpdateItems(updates: $updates) {
+        success
+        updatedCount
+        errors {
+          itemId
+          message
+        }
+      }
+    }
+  \`,
+  variables: ({ items }: { items: Array<{ id: string; status: string }> }) => ({
+    updates: items.map((item) => ({
+      id: item.id,
+      status: item.status,
+    })),
+  }),
+});
+\`\`\`
+
+## Error Handling
+
+GraphQL can return both data and errors:
+
+\`\`\`typescript
+new GraphQL("risky_query", "graphql-id", { ... }),
+
+new JavaScript("handle_response", {
+  fn: ({ risky_query }) => {
+    const result = risky_query.output;
+
+    if (result.errors && result.errors.length > 0) {
+      // Handle partial errors
+      console.error("GraphQL errors:", result.errors);
+    }
+
+    // Data may still be present even with errors
+    return result.data?.items ?? [];
+  }
+})
+\`\`\`
+
+## Subscriptions
+
+**Note**: GraphQL subscriptions are not directly supported. For real-time data, consider:
+
+1. Polling with Loop blocks
+2. WebSocket integrations if available
+3. REST webhook endpoints
+
+## Best Practices
+
+1. **Always select specific fields** - Don't over-fetch
+2. **Use variables** - Never interpolate strings in queries
+3. **Handle partial responses** - GraphQL can return data with errors
+4. **Access via .data** - Always use \`output.data.fieldName\`
+5. **Use fragments** - For reusable field selections
+`;
+//# sourceMappingURL=graphql.generated.js.map

package/dist/ai-service/skills/system/superblocks-api/references/graphql.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.generated.js","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/graphql.generated.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,mDAAmD;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkNtB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/rest-apis.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const content = "# REST API Integrations\n\nReference documentation for working with REST APIs and OpenAPI integrations in Superblocks.\n\n## REST API vs OpenAPI\n\n**Use RestApi** when:\n\n- Making calls to custom endpoints\n- No OpenAPI spec available\n- Simple GET/POST operations\n\n**Use OpenApi** when:\n\n- Integration metadata shows `spec: \"openapi\"` or `specType: \"OPEN_API_SPEC\"`\n- Working with documented APIs (Stripe, Twilio, etc.)\n- Need type-safe operations\n\n## RestApi Class\n\n```typescript\nimport { RestApi } from \"@superblocksteam/library\";\n\nnew RestApi(\"fetch_data\", \"rest-integration-id\", {\n  method: \"GET\",\n  url: \"https://api.example.com/data\",\n  params: { page: \"1\", limit: \"10\" },\n  headers: { \"X-Custom-Header\": \"value\" },\n});\n```\n\n### Dynamic Configuration\n\n```typescript\nnew RestApi(\"create_item\", \"rest-id\", {\n  method: \"POST\",\n  url: ({ baseUrl }: { baseUrl: string }) => `${baseUrl}/items`,\n  params: ({ page }: { page: number }) => ({ page: String(page) }),\n  headers: ({ authToken }: { authToken: string }) => ({\n    Authorization: `Bearer ${authToken}`,\n    \"Content-Type\": \"application/json\",\n  }),\n  body: ({ itemData }: { itemData: object }) => JSON.stringify(itemData),\n});\n```\n\n### Common REST Patterns\n\n```typescript\n// GET with query params\nnew RestApi(\"search\", \"rest-id\", {\n  method: \"GET\",\n  url: \"https://api.example.com/search\",\n  params: ({ query, page }: { query: string; page: number }) => ({\n    q: query,\n    page: String(page),\n    limit: \"20\",\n  }),\n});\n\n// POST with JSON body\nnew RestApi(\"create\", \"rest-id\", {\n  method: \"POST\",\n  url: \"https://api.example.com/items\",\n  headers: { \"Content-Type\": \"application/json\" },\n  body: ({ data }: { data: object }) => JSON.stringify(data),\n});\n\n// PUT for updates\nnew RestApi(\"update\", \"rest-id\", {\n  method: \"PUT\",\n  url: ({ id }: { id: string }) => `https://api.example.com/items/${id}`,\n  headers: { \"Content-Type\": \"application/json\" },\n  body: ({ data }: { data: object }) => JSON.stringify(data),\n});\n\n// DELETE\nnew RestApi(\"delete\", \"rest-id\", {\n  method: \"DELETE\",\n  url: ({ id }: { id: string }) => `https://api.example.com/items/${id}`,\n});\n```\n\n## OpenApi Class\n\n```typescript\nimport { OpenApi } from \"@superblocksteam/library\";\n\nnew OpenApi(\"list_customers\", \"stripe-integration-id\", {\n  operation: \"listCustomers\",\n  params: { limit: 10 },\n});\n```\n\n### OpenAPI Operations\n\nOperation names are defined by the API spec. Common patterns:\n\n- `list{Resource}` - List all resources\n- `get{Resource}` - Get a single resource\n- `create{Resource}` - Create a resource\n- `update{Resource}` - Update a resource\n- `delete{Resource}` - Delete a resource\n\n### Dynamic OpenAPI Params\n\n```typescript\nnew OpenApi(\"get_customer\", \"stripe-id\", {\n  operation: \"getCustomer\",\n  params: ({ customerId }: { customerId: string }) => ({\n    customer_id: customerId,\n  }),\n});\n```\n\n## Response Handling\n\nREST and OpenAPI responses are available via `.output`:\n\n```typescript\nnew RestApi(\"fetch\", \"rest-id\", { ... }),\n\nnew JavaScript(\"process\", {\n  fn: ({ fetch }) => {\n    const data = fetch.output;\n    // For REST APIs, output is typically the JSON response\n    // For OpenAPI, output structure depends on the operation\n    return data.items.map(item => item.name);\n  }\n})\n```\n\n## Error Handling\n\nHTTP errors (4xx, 5xx) are captured in the output:\n\n```typescript\nnew TryCatch(\"safe_api_call\", {\n  try: [\n    new RestApi(\"risky_call\", \"rest-id\", {\n      method: \"POST\",\n      url: \"https://api.example.com/sensitive\",\n    }),\n  ],\n  catch: [\n    new JavaScript(\"handle_error\", {\n      fn: ({ apiError }) => ({\n        success: false,\n        error: apiError.value.message,\n        statusCode: apiError.value.statusCode,\n      }),\n    }),\n  ],\n  variables: { error: \"apiError\" },\n});\n```\n\n## Pagination Patterns\n\n### Cursor-Based Pagination\n\n```typescript\n(new Variables(\"state\", [\n  { key: \"allItems\", value: () => [] },\n  { key: \"cursor\", value: () => null },\n  { key: \"hasMore\", value: () => true },\n]),\n  new Loop(\"paginate\", {\n    type: \"TYPE_FOREACH\",\n    over: () => [...Array(100).keys()],\n    variables: { item: \"_\", index: \"i\" },\n    blocks: [\n      new Conditional(\"check_done\", {\n        if: {\n          when: ({ hasMore }) => !hasMore.value,\n          then: [new Break(\"exit\", { condition: () => true })],\n        },\n      }),\n      new RestApi(\"fetch_page\", \"rest-id\", {\n        method: \"GET\",\n        url: \"https://api.example.com/items\",\n        params: ({ cursor }) => (cursor.value ? { cursor: cursor.value } : {}),\n      }),\n      new JavaScript(\"accumulate\", {\n        fn: ({ fetch_page, allItems, cursor, hasMore }) => {\n          const response = fetch_page.output;\n          allItems.set([...allItems.value, ...response.items]);\n          cursor.set(response.nextCursor);\n          hasMore.set(!!response.nextCursor);\n          return allItems.value;\n        },\n      }),\n    ],\n  }));\n```\n\n### Offset-Based Pagination\n\n```typescript\n(new Variables(\"state\", [\n  { key: \"allItems\", value: () => [] },\n  { key: \"page\", value: () => 0 },\n  { key: \"hasMore\", value: () => true },\n]),\n  new Loop(\"paginate\", {\n    type: \"TYPE_WHILE\",\n    condition: ({ hasMore }) => hasMore.value,\n    blocks: [\n      new RestApi(\"fetch_page\", \"rest-id\", {\n        method: \"GET\",\n        url: \"https://api.example.com/items\",\n        params: ({ page }) => ({\n          offset: String(page.value * 100),\n          limit: \"100\",\n        }),\n      }),\n      new JavaScript(\"accumulate\", {\n        fn: ({ fetch_page, allItems, page, hasMore }) => {\n          const items = fetch_page.output.items;\n          allItems.set([...allItems.value, ...items]);\n          page.set(page.value + 1);\n          hasMore.set(items.length === 100);\n          return allItems.value;\n        },\n      }),\n    ],\n  }));\n```\n\n## Authentication Patterns\n\n### Bearer Token\n\n```typescript\nnew RestApi(\"authenticated_call\", \"rest-id\", {\n  method: \"GET\",\n  url: \"https://api.example.com/secure\",\n  headers: ({ token }: { token: string }) => ({\n    Authorization: `Bearer ${token}`,\n  }),\n});\n```\n\n### API Key\n\n```typescript\nnew RestApi(\"api_key_call\", \"rest-id\", {\n  method: \"GET\",\n  url: \"https://api.example.com/data\",\n  headers: ({ apiKey }: { apiKey: string }) => ({\n    \"X-API-Key\": apiKey,\n  }),\n});\n```\n\n### Basic Auth\n\n```typescript\nnew RestApi(\"basic_auth_call\", \"rest-id\", {\n  method: \"GET\",\n  url: \"https://api.example.com/data\",\n  headers: ({\n    username,\n    password,\n  }: {\n    username: string;\n    password: string;\n  }) => ({\n    Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString(\"base64\")}`,\n  }),\n});\n```\n";
+//# sourceMappingURL=rest-apis.generated.d.ts.map

package/dist/ai-service/skills/system/superblocks-api/references/rest-apis.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-apis.generated.d.ts","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/rest-apis.generated.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,03NAgRnB,CAAC"}