agent-nuvira 1.87.0 → 1.88.0

package/.agents/skills/a11y-audit/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: a11y-audit
+description: Audit web applications for accessibility (WCAG 2.1 AA compliance): check color contrast, keyboard navigation, screen-reader compatibility, ARIA attributes, and semantic HTML. Use when the goal asks to audit, fix, or improve accessibility.
+version: 1.0.0
+---
+
+# a11y-audit
+
+Audit web applications for accessibility (WCAG 2.1 AA compliance): check color contrast, keyboard navigation, screen-reader compatibility, ARIA attributes, and semantic HTML. Use when the goal asks to audit, fix, or improve accessibility.
+
+## Goal pattern
+
+accessibility a11y wcag audit screen reader keyboard nav aria contrast wcag
+
+## Parameters
+
+- scope (choice [default: full]): Audit scope
+
+## Steps
+
+1. [analyst] Scan the codebase for accessibility issues: run automated tools (axe-core, pa11y, lighthouse) or inspect JSX for missing alt text, labels, ARIA roles, and semantic landmarks.
+
+2. [analyst] Categorize issues by severity: critical (blocks users), serious (hard to use), moderate (annoying), minor (cosmetic). Map to WCAG success criteria. (after: step-1)
+
+3. [analyst] Fix critical and serious issues: add missing alt text, labels, ARIA attributes, keyboard handlers, focus management, and color contrast adjustments. (after: step-2)
+
+4. [analyst] Test fixes: verify keyboard-only navigation, screen-reader output, and color contrast ratios. Re-run automated scanner. (after: step-3)
+
+5. [analyst] Write an accessibility report: WCAG 2.1 AA conformance status, remaining issues by severity, and an accessibility statement for the project. (after: step-4)

package/.agents/skills/academic-research/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: academic-research
+description: Conduct academic literature research: paper discovery, citation analysis, systematic reviews, and research summaries. Use when the goal is to review academic literature on a topic.
+version: 1.0.0
+---
+
+# academic-research
+
+Conduct academic literature research: paper discovery, citation analysis, systematic reviews, and research summaries. Use when the goal is to review academic literature on a topic.
+
+## Goal pattern
+
+academic research literature review paper citation systematic review arxiv pubmed scholar
+
+## Steps
+
+0. [context-gatherer] Map the research topic: what field? What search terms? What databases (arXiv, PubMed, Google Scholar)? What time range? What inclusion criteria?
+
+1. [planner] Plan the literature review:
+1. Search strategy: keywords, boolean operators, databases
+2. Screening: title/abstract → full text selection
+3. Data extraction: methods, findings, quality assessment
+4. Synthesis: thematic analysis, meta-analysis if quantitative
+5. Citation analysis: key papers, influential authors
+6. Reporting: structured summary with gaps identified (after: 'step-0')
+
+2. [runner] Execute the review:
+1. Search databases with query strategy
+2. Screen results (title/abstract)
+3. Full-text review of selected papers
+4. Extract key findings
+5. Synthesize across papers
+6. Identify research gaps (after: 'step-1')
+
+3. [reviewer] Review: verify search completeness, check extraction accuracy, validate synthesis, ensure citations are correct. (after: 'step-2')

package/.agents/skills/accounting-integration/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: accounting-integration
+description: Integrate accounting software: QuickBooks, Xero, or FreshBooks API integration for invoices, expenses, and financial reporting. Use when the goal is to sync financial data with an accounting system.
+version: 1.0.0
+---
+
+# accounting-integration
+
+Integrate accounting software: QuickBooks, Xero, or FreshBooks API integration for invoices, expenses, and financial reporting. Use when the goal is to sync financial data with an accounting system.
+
+## Goal pattern
+
+accounting quickbooks xero freshbooks invoice expense financial reporting integration API
+
+## Steps
+
+0. [context-gatherer] Map the integration: what accounting platform? What data to sync (invoices, expenses, customers, products)? Sync direction (bidirectional, push, pull)? Frequency?
+
+1. [planner] Design the integration:
+1. Auth: OAuth2 flow for API access
+2. Data mapping: your models → accounting platform models
+3. Sync: create/update invoices, expenses, contacts
+4. Webhooks: receive updates from accounting platform
+5. Error handling: retry, conflict resolution
+6. Reporting: pull financial data for dashboards (after: 'step-0')
+
+2. [runner] Implement the integration:
+1. Set up OAuth2 authentication
+2. Create API client for the accounting platform
+3. Implement data sync functions
+4. Add webhook handlers
+5. Build conflict resolution logic
+6. Test with sandbox account (after: 'step-1')
+
+3. [reviewer] Verify: create invoice via API, verify it appears in accounting platform, test expense sync, verify financial reports pull correctly. (after: 'step-2')

package/.agents/skills/api-call/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: api-call
+description: Make API calls with authentication, retry logic, and response parsing
+runtime: node
+required_environment_variables:
+  - API_BASE_URL
+tags:
+  - api
+  - http
+  - integration
+parameters:
+  - name: endpoint
+    description: API endpoint path (e.g., /users, /posts)
+    required: true
+    type: string
+  - name: method
+    description: HTTP method (GET, POST, PUT, DELETE)
+    required: false
+    type: string
+    default: GET
+  - name: data
+    description: JSON data for POST/PUT requests
+    required: false
+    type: string
+  - name: headers
+    description: Additional HTTP headers as JSON
+    required: false
+    type: string
+---
+
+# API Call Skill
+
+Make API calls with authentication, retry logic, and response parsing. This skill demonstrates the execution engine's ability to run Node.js scripts.
+
+## How It Works
+
+1. Receives endpoint, method, and optional data/headers
+2. Makes HTTP request to API_BASE_URL + endpoint
+3. Handles authentication via API_KEY environment variable
+4. Implements retry logic with exponential backoff
+5. Returns structured response
+
+## Usage
+
+When the user needs to make an API call, execute this skill with the endpoint and method.
+
+## Security
+
+- API keys are injected via environment variables
+- Base URL is configured via API_BASE_URL
+- Retry logic prevents excessive requests

package/.agents/skills/api-call/call.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * API Call Skill — Demonstrates Node.js skill execution.
+ * 
+ * This script is executed by the skill-executor.ts module when the agent
+ * calls: skill tool → execute: { skill: "api-call", args: { endpoint: "/users" } }
+ * 
+ * The executor:
+ * 1. Detects runtime: node (from shebang or frontmatter)
+ * 2. Parses required_environment_variables: [API_BASE_URL, API_KEY]
+ * 3. Injects API_BASE_URL and API_KEY from process.env (if registered)
+ * 4. Spawns: node /tmp/skill-exec/abc123/call.js
+ * 5. Captures stdout/stderr/exit code
+ */
+
+const https = require('https');
+const http = require('http');
+const url = require('url');
+
+// Parse command-line arguments
+function parseArgs(args) {
+  const parsed = {
+    endpoint: null,
+    method: 'GET',
+    data: null,
+    headers: {}
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--endpoint':
+      case '-e':
+        parsed.endpoint = args[++i];
+        break;
+      case '--method':
+      case '-m':
+        parsed.method = args[++i].toUpperCase();
+        break;
+      case '--data':
+      case '-d':
+        parsed.data = args[++i];
+        break;
+      case '--headers':
+      case '-H':
+        try {
+          parsed.headers = JSON.parse(args[++i]);
+        } catch (e) {
+          console.error(`Error: Invalid JSON for headers: ${args[i]}`, process.stderr);
+          process.exit(1);
+        }
+        break;
+    }
+  }
+
+  return parsed;
+}
+
+// Make HTTP request with retry logic
+async function makeRequest(options, retries = 3, delay = 1000) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const response = await executeRequest(options);
+      return response;
+    } catch (error) {
+      if (attempt === retries) {
+        throw error;
+      }
+      
+      console.error(`Attempt ${attempt} failed: ${error.message}. Retrying in ${delay}ms...`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+      delay *= 2; // Exponential backoff
+    }
+  }
+}
+
+function executeRequest(options) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new url.URL(options.url);
+    const isHttps = parsedUrl.protocol === 'https:';
+    const client = isHttps ? https : http;
+
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: options.method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+      }
+    };
+
+    const req = client.request(reqOptions, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      res.on('end', () => {
+        try {
+          const jsonData = JSON.parse(data);
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            data: jsonData
+          });
+        } catch {
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            data: data
+          });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(10000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (options.body) {
+      req.write(options.body);
+    }
+
+    req.end();
+  });
+}
+
+// Main execution
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  
+  if (!args.endpoint) {
+    console.error('Error: --endpoint is required');
+    console.error('Usage: node call.js --endpoint /users --method GET');
+    process.exit(1);
+  }
+
+  const baseUrl = process.env.API_BASE_URL;
+  if (!baseUrl) {
+    console.error('Error: API_BASE_URL environment variable is not set');
+    console.error('Set it with: export API_BASE_URL=https://api.example.com');
+    process.exit(1);
+  }
+
+  const apiKey = process.env.API_KEY;
+  if (apiKey) {
+    args.headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+
+  const fullUrl = baseUrl + args.endpoint;
+  console.log(`Making ${args.method} request to: ${fullUrl}`);
+  
+  if (args.data) {
+    console.log(`Request body: ${args.data}`);
+  }
+
+  try {
+    const response = await makeRequest({
+      url: fullUrl,
+      method: args.method,
+      body: args.data,
+      headers: args.headers
+    });
+
+    console.log(`\n✅ Request successful!`);
+    console.log(`📊 Status: ${response.status}`);
+    console.log(`\nResponse:`);
+    console.log(JSON.stringify(response.data, null, 2));
+    
+    // Return structured result
+    const result = {
+      success: true,
+      status: response.status,
+      data: response.data
+    };
+    console.log(`\n${JSON.stringify(result, null, 2)}`);
+  } catch (error) {
+    console.error(`\n❌ Request failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/.agents/skills/api-call/call.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * API Call Skill — Demonstrates Node.js skill execution.
+ * 
+ * This script is executed by the skill-executor.ts module when the agent
+ * calls: skill tool → execute: { skill: "api-call", args: { endpoint: "/users" } }
+ * 
+ * The executor:
+ * 1. Detects runtime: node (from shebang or frontmatter)
+ * 2. Parses required_environment_variables: [API_BASE_URL, API_KEY]
+ * 3. Injects API_BASE_URL and API_KEY from process.env (if registered)
+ * 4. Spawns: node /tmp/skill-exec/abc123/call.mjs
+ * 5. Captures stdout/stderr/exit code
+ */
+
+import https from 'https';
+import http from 'http';
+import { URL } from 'url';
+
+// Parse command-line arguments
+function parseArgs(args) {
+  const parsed = {
+    endpoint: null,
+    method: 'GET',
+    data: null,
+    headers: {}
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--endpoint':
+      case '-e':
+        parsed.endpoint = args[++i];
+        break;
+      case '--method':
+      case '-m':
+        parsed.method = args[++i].toUpperCase();
+        break;
+      case '--data':
+      case '-d':
+        parsed.data = args[++i];
+        break;
+      case '--headers':
+      case '-H':
+        try {
+          parsed.headers = JSON.parse(args[++i]);
+        } catch (e) {
+          console.error(`Error: Invalid JSON for headers: ${args[i]}`);
+          process.exit(1);
+        }
+        break;
+    }
+  }
+
+  return parsed;
+}
+
+// Make HTTP request with retry logic
+async function makeRequest(options, retries = 3, delay = 1000) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const response = await executeRequest(options);
+      return response;
+    } catch (error) {
+      if (attempt === retries) {
+        throw error;
+      }
+      
+      console.error(`Attempt ${attempt} failed: ${error.message}. Retrying in ${delay}ms...`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+      delay *= 2; // Exponential backoff
+    }
+  }
+}
+
+function executeRequest(options) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(options.url);
+    const isHttps = parsedUrl.protocol === 'https:';
+    const client = isHttps ? https : http;
+
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: options.method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+      }
+    };
+
+    const req = client.request(reqOptions, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      res.on('end', () => {
+        try {
+          const jsonData = JSON.parse(data);
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            data: jsonData
+          });
+        } catch {
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            data: data
+          });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(10000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (options.body) {
+      req.write(options.body);
+    }
+
+    req.end();
+  });
+}
+
+// Main execution
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  
+  if (!args.endpoint) {
+    console.error('Error: --endpoint is required');
+    console.error('Usage: node call.mjs --endpoint /users --method GET');
+    process.exit(1);
+  }
+
+  const baseUrl = process.env.API_BASE_URL;
+  if (!baseUrl) {
+    console.error('Error: API_BASE_URL environment variable is not set');
+    console.error('Set it with: export API_BASE_URL=https://api.example.com');
+    process.exit(1);
+  }
+
+  const apiKey = process.env.API_KEY;
+  if (apiKey) {
+    args.headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+
+  const fullUrl = baseUrl + args.endpoint;
+  console.log(`Making ${args.method} request to: ${fullUrl}`);
+  
+  if (args.data) {
+    console.log(`Request body: ${args.data}`);
+  }
+
+  try {
+    const response = await makeRequest({
+      url: fullUrl,
+      method: args.method,
+      body: args.data,
+      headers: args.headers
+    });
+
+    console.log(`\n✅ Request successful!`);
+    console.log(`📊 Status: ${response.status}`);
+    console.log(`\nResponse:`);
+    console.log(JSON.stringify(response.data, null, 2));
+    
+    // Return structured result
+    const result = {
+      success: true,
+      status: response.status,
+      data: response.data
+    };
+    console.log(`\n${JSON.stringify(result, null, 2)}`);
+  } catch (error) {
+    console.error(`\n❌ Request failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/.agents/skills/api-creation/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: api-creation
+description: Create a complete API: design endpoints, implement routes, add auth/rate-limiting, write tests, generate OpenAPI docs, and deploy. Use when the goal asks to create an API, build a backend service, or scaffold an HTTP server with routes.
+version: 1.0.0
+---
+
+# api-creation
+
+Create a complete API: design endpoints, implement routes, add auth/rate-limiting, write tests, generate OpenAPI docs, and deploy. Use when the goal asks to create an API, build a backend service, or scaffold an HTTP server with routes.
+
+## Goal pattern
+
+API create build backend service REST GraphQL HTTP server routes endpoints implement deploy
+
+## Parameters
+
+- framework (choice [default: auto]): HTTP framework — express, fastify, hono, flask, fastapi, spring, auto
+- database (choice [default: auto]): Database — postgresql, mongodb, sqlite, mysql, in-memory, auto
+- auth (choice [default: jwt]): Authentication method — jwt, api-key, oauth2, session, none
+
+## Steps
+
+1. [context-gatherer] Analyze the project and API requirements:
+   - Read package.json / pyproject.toml for framework (Express, Fastify, Hono, Flask, FastAPI, Spring Boot)
+   - Identify resources (nouns → endpoints) and operations (CRUD)
+   - Note auth requirements (API key, JWT, OAuth2)
+   - Note database (PostgreSQL, MongoDB, SQLite, in-memory)
+   - Note deployment target (local, Docker, cloud)
+   Produce: resource list, framework choice, auth strategy, and database plan.
+
+2. [writer] Implement the API:
+   - Set up the project structure (routes/, models/, middleware/, utils/)
+   - Implement route handlers for each resource
+   - Add input validation (Joi, Zod, Pydantic, express-validator)
+   - Add error handling middleware (consistent error response format)
+   - Add auth middleware (JWT verification, API key check)
+   - Add rate limiting (express-rate-limit, slowapi)
+   - Wire everything into the app entry point
+   Follow REST conventions: proper HTTP methods, status codes, and response shapes.
+
+3. [writer] Generate OpenAPI/Swagger documentation:
+   - Create openapi.yaml or openapi.json with all endpoints
+   - Define request/response schemas
+   - Add authentication definitions
+   - Add example requests and responses
+   - Set up Swagger UI (if web framework supports it)
+   The spec is the contract — implementation must match it exactly.
+
+4. [tester] Write and run integration tests:
+   - Test each endpoint: happy path, error paths (400, 401, 404, 500)
+   - Test auth: unauthenticated → 401, unauthorized → 403
+   - Test validation: invalid input → 400 with error details
+   - Test edge cases: empty body, missing fields, duplicate resources
+   - Run the full test suite: `npm test` or `pytest`
+   All tests must pass before proceeding.
+
+5. [runner] Set up deployment:
+   - Create Dockerfile (multi-stage build)
+   - Create docker-compose.yml (if database needed)
+   - Add health check endpoint (GET /health)
+   - Add environment variable configuration
+   - Create a README with API documentation and usage examples
+   - Verify the app starts and responds to requests