@bluefly/openstandardagents 0.4.3 → 0.4.5

package/examples/gitlab-agents/mr-reviewer/README.md

@@ -0,0 +1,98 @@
+# mr-reviewer
+
+Comprehensive MR review agent that analyzes code quality, architecture, security, and performance. Posts detailed review comments and auto-approves if all checks pass.
+
+
+## Generated from OSSA Manifest
+
+This agent was auto-generated from an OSSA v0.4.1 manifest using:
+
+```bash
+ossa export agents/gitlab/mr-reviewer.ossa.yaml --platform gitlab-agent --output ./mr-reviewer
+```
+
+## Installation
+
+1. Install dependencies:
+
+```bash
+npm install
+```
+
+2. Copy `.env.example` to `.env` and fill in your credentials:
+
+```bash
+cp .env.example .env
+```
+
+3. Build the agent:
+
+```bash
+npm run build
+```
+
+4. Run the agent:
+
+```bash
+npm start
+```
+
+## Development
+
+Run in development mode with hot reload:
+
+```bash
+npm run dev
+```
+
+## Deployment
+
+### Docker
+
+Build and run with Docker:
+
+```bash
+docker build -t mr-reviewer .
+docker run -p 9090:9090 --env-file .env mr-reviewer
+```
+
+### Kubernetes
+
+Deploy to Kubernetes:
+
+```bash
+kubectl apply -f k8s/deployment.yaml
+```
+
+## GitLab Webhook Configuration
+
+Configure the webhook in your GitLab project:
+
+1. Go to **Settings** → **Webhooks**
+2. Add webhook URL: `http://mesh.blueflyagents.com/webhook/mr-reviewer`
+3. Set secret token (from .env WEBHOOK_SECRET)
+4. Select events: Merge requests
+5. Save webhook
+
+Test the webhook:
+
+```bash
+curl -X POST http://localhost:9090/webhook/mr-reviewer \
+  -H "Content-Type: application/json" \
+  -H "X-Gitlab-Token: your-secret" \
+  -d @test-event.json
+```
+
+
+## Health Checks
+
+- Health: `GET /health`
+- Ready: `GET /ready`
+
+## Monitoring
+
+The agent exposes Prometheus metrics and OpenTelemetry traces.
+
+## License
+
+MIT

package/examples/gitlab-agents/mr-reviewer/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@bluefly/mr-reviewer",
+  "version": "1.0.0",
+  "description": "Comprehensive MR review agent that analyzes code quality, architecture, security, and performance. Posts detailed review comments and auto-approves if all checks pass.\n",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "test": "echo \"No tests yet\""
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "@gitbeaker/rest": "^40.0.0",
+    "@anthropic-ai/sdk": "^0.32.1",
+    "pino": "^8.19.0",
+    "pino-pretty": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.19",
+    "typescript": "^5.3.3",
+    "tsx": "^4.7.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/examples/gitlab-agents/mr-reviewer/src/gitlab-client.ts

@@ -0,0 +1,136 @@
+import { Gitlab } from '@gitbeaker/rest';
+import type { Logger } from 'pino';
+
+export interface GitLabClientConfig {
+  token: string;
+  baseUrl?: string;
+}
+
+export class GitLabClient {
+  private gitlab: InstanceType<typeof Gitlab>;
+
+  constructor(config: GitLabClientConfig) {
+    this.gitlab = new Gitlab({
+      host: config.baseUrl || 'https://gitlab.com',
+      token: config.token,
+    });
+  }
+
+  /**
+   * Get all file changes in the MR
+   */
+  async getMRChanges(projectId: string, mrIid: number) {
+    const changes = await this.gitlab.MergeRequests.allDiffs(projectId, mrIid);
+    return changes.map((diff: any) => ({
+      oldPath: diff.old_path,
+      newPath: diff.new_path,
+      diff: diff.diff,
+      newFile: diff.new_file,
+      renamedFile: diff.renamed_file,
+      deletedFile: diff.deleted_file,
+    }));
+  }
+
+  /**
+   * Run production-grade audit on changed files
+   */
+  async runAudit(projectId: string, mrIid: number) {
+    const changes = await this.getMRChanges(projectId, mrIid);
+    const findings: Array<{ file: string; severity: string; message: string }> = [];
+
+    for (const change of changes) {
+      if (change.deletedFile) continue;
+
+      // Check for common issues in diffs
+      if (change.diff?.includes('console.log')) {
+        findings.push({
+          file: change.newPath,
+          severity: 'warning',
+          message: 'Contains console.log statement - consider removing for production',
+        });
+      }
+      if (change.diff?.includes('TODO') || change.diff?.includes('FIXME')) {
+        findings.push({
+          file: change.newPath,
+          severity: 'info',
+          message: 'Contains TODO/FIXME comment',
+        });
+      }
+      if (change.diff?.includes('password') || change.diff?.includes('secret')) {
+        findings.push({
+          file: change.newPath,
+          severity: 'critical',
+          message: 'Potential credential exposure detected',
+        });
+      }
+    }
+
+    return {
+      totalFiles: changes.length,
+      findings,
+      passed: !findings.some((f) => f.severity === 'critical'),
+    };
+  }
+
+  /**
+   * Run security scan on dependencies
+   */
+  async runSecurityScan(projectId: string, branch: string) {
+    // Fetch package.json to check dependencies
+    const vulnerabilities: Array<{ dependency: string; severity: string; advisory: string }> = [];
+
+    try {
+      const file = await this.gitlab.RepositoryFiles.show(projectId, 'package.json', branch);
+      const packageJson = JSON.parse(Buffer.from(file.content, 'base64').toString('utf-8'));
+      const allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+      };
+
+      // Flag known patterns that indicate insecure version ranges
+      for (const [dep, version] of Object.entries(allDeps)) {
+        const versionStr = String(version);
+        if (versionStr === '*' || versionStr === 'latest') {
+          vulnerabilities.push({
+            dependency: dep,
+            severity: 'warning',
+            advisory: `Unpinned dependency version: ${versionStr}`,
+          });
+        }
+      }
+    } catch {
+      // package.json not found or not parseable - skip dependency check
+    }
+
+    return {
+      scannedAt: new Date().toISOString(),
+      branch,
+      vulnerabilities,
+      passed: !vulnerabilities.some((v) => v.severity === 'critical'),
+    };
+  }
+
+  /**
+   * Post comment to merge request
+   */
+  async postMRComment(projectId: string, mrIid: number, body: string, replyToId?: number) {
+    return await this.gitlab.MergeRequestNotes.create(projectId, mrIid, body, {
+      ...(replyToId && { reply_to: replyToId }),
+    });
+  }
+
+  /**
+   * Approve merge request
+   */
+  async approveMR(projectId: string, mrIid: number) {
+    return await this.gitlab.MergeRequestApprovals.approve(projectId, mrIid);
+  }
+
+  /**
+   * Block MR with required changes by posting a blocking comment
+   */
+  async blockMR(projectId: string, mrIid: number, reason: string) {
+    const blockComment = `**Changes Requested**\n\nThis MR cannot be merged until the following issues are resolved:\n\n${reason}`;
+    return await this.gitlab.MergeRequestNotes.create(projectId, mrIid, blockComment);
+  }
+}

package/examples/gitlab-agents/mr-reviewer/src/index.ts

@@ -0,0 +1,103 @@
+import express from 'express';
+import pino from 'pino';
+import { GitLabClient } from './gitlab-client.js';
+import { LLMClient } from './llm-client.js';
+import { WorkflowExecutor } from './workflow.js';
+import type { WebhookEvent } from './types.js';
+
+const app = express();
+app.use(express.json());
+
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+    },
+  },
+});
+
+// Initialize clients
+const gitlabClient = new GitLabClient({
+  token: process.env.GITLAB_API_TOKEN!,
+  baseUrl: process.env.GITLAB_API_URL || 'https://gitlab.com/api/v4',
+});
+
+const llmClient = new LLMClient({
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+  model: 'claude-sonnet-4-5',
+});
+
+const workflowExecutor = new WorkflowExecutor({
+  gitlabClient,
+  llmClient,
+  logger,
+});
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'healthy', agent: 'mr-reviewer' });
+});
+
+// Ready check endpoint
+app.get('/ready', (req, res) => {
+  res.json({ status: 'ready', agent: 'mr-reviewer' });
+});
+
+// Webhook endpoint
+app.post('/webhook/mr-reviewer', async (req, res) => {
+  const event: WebhookEvent = req.body;
+
+  // Validate webhook token
+  const webhookToken = req.headers['x-gitlab-token'];
+  if (webhookToken !== process.env.WEBHOOK_SECRET) {
+    logger.warn({ event: event.object_kind }, 'Invalid webhook token');
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  logger.info({ event: event.object_kind }, 'Webhook received');
+
+  try {
+    // Check if event matches filter
+    if (!matchesFilter(event, {"action":["opened","reopened","updated"]})) {
+      logger.info({ event: event.object_kind }, 'Event filtered out');
+      return res.status(200).json({ skipped: true });
+    }
+
+    // Execute workflow
+    const result = await workflowExecutor.execute(event);
+
+    logger.info({ result }, 'Workflow completed successfully');
+    return res.status(200).json(result);
+  } catch (error) {
+    logger.error({ err: error }, 'Workflow execution failed');
+    return res.status(500).json({
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+});
+
+function matchesFilter(event: WebhookEvent, filter: any): boolean {
+  // Implement filter matching logic based on manifest
+  
+  if (filter.note_author && event.object_attributes?.author?.username !== filter.note_author) {
+    return false;
+  }
+
+  if (filter.note_contains && Array.isArray(filter.note_contains)) {
+    const noteBody = event.object_attributes?.note || '';
+    const matches = filter.note_contains.some((keyword: string) =>
+      noteBody.toLowerCase().includes(keyword.toLowerCase())
+    );
+    if (!matches) return false;
+  }
+  
+
+  return true;
+}
+
+const PORT = process.env.PORT || 9090;
+app.listen(PORT, () => {
+  logger.info(`Agent '${agentName}' listening on port ${PORT}`);
+});

package/examples/gitlab-agents/mr-reviewer/src/llm-client.ts

@@ -0,0 +1,95 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { Logger } from 'pino';
+
+export interface LLMClientConfig {
+  apiKey: string;
+  model?: string;
+}
+
+export class LLMClient {
+  private anthropic: Anthropic;
+  private model: string;
+
+  constructor(config: LLMClientConfig) {
+    this.anthropic = new Anthropic({
+      apiKey: config.apiKey,
+    });
+    this.model = config.model || 'claude-sonnet-4-5';
+  }
+
+  /**
+   * Invoke LLM with prompt
+   */
+  async invoke(prompt: string, systemPrompt?: string): Promise<string> {
+    const response = await this.anthropic.messages.create({
+      model: this.model,
+      max_tokens: 16384,
+      temperature: 0.2,
+      system: systemPrompt || `You are an expert code reviewer for the OSSA project.
+
+Review criteria:
+1. Code Quality
+   - DRY principle violations
+   - SOLID principle adherence
+   - Complexity (cyclomatic, cognitive)
+   - Code smells
+
+2. Architecture
+   - API-First pattern compliance
+   - Dependency injection usage
+   - Module boundaries
+   - Type safety
+
+3. Security
+   - Credentials in code
+   - SQL injection risks
+   - XSS vulnerabilities
+   - Dependency vulnerabilities
+
+4. Performance
+   - N+1 queries
+   - Memory leaks
+   - Inefficient algorithms
+   - Bundle size impact
+
+5. Production-Grade
+   - Structured logging (Pino)
+   - Error handling (OssaError)
+   - Configuration externalization
+   - Test coverage
+
+Provide:
+- Clear, actionable feedback
+- Code examples for improvements
+- Severity ratings (critical, high, medium, low)
+- Blocking vs non-blocking issues
+`,
+      messages: [
+        {
+          role: 'user',
+          content: prompt,
+        },
+      ],
+    });
+
+    const content = response.content[0];
+    if (content.type === 'text') {
+      return content.text;
+    }
+
+    throw new Error('Unexpected response type from LLM');
+  }
+
+  /**
+   * Invoke LLM and parse JSON response
+   */
+  async invokeJSON<T = any>(prompt: string, systemPrompt?: string): Promise<T> {
+    const response = await this.invoke(prompt, systemPrompt);
+
+    // Extract JSON from markdown code blocks if present
+    const jsonMatch = response.match(/```json\n([\s\S]*?)\n```/);
+    const jsonStr = jsonMatch ? jsonMatch[1] : response;
+
+    return JSON.parse(jsonStr);
+  }
+}

package/examples/gitlab-agents/mr-reviewer/src/types.ts

@@ -0,0 +1,22 @@
+export interface WebhookEvent {
+  object_kind: string;
+  project?: {
+    id: string | number;
+    name: string;
+  };
+  project_id?: string | number;
+  merge_request?: {
+    iid: number;
+    source_branch: string;
+    target_branch: string;
+  };
+  object_attributes?: any;
+  commit?: any;
+  ref?: string;
+}
+
+export interface WorkflowContext {
+  event: WebhookEvent;
+  variables: Record<string, any>;
+  outputs: Record<string, any>;
+}

package/examples/gitlab-agents/mr-reviewer/src/workflow.ts

@@ -0,0 +1,144 @@
+import type { GitLabClient } from './gitlab-client.js';
+import type { LLMClient } from './llm-client.js';
+import type { Logger } from 'pino';
+import type { WebhookEvent, WorkflowContext } from './types.js';
+
+export interface WorkflowExecutorConfig {
+  gitlabClient: GitLabClient;
+  llmClient: LLMClient;
+  logger: Logger;
+}
+
+export class WorkflowExecutor {
+  private gitlabClient: GitLabClient;
+  private llmClient: LLMClient;
+  private logger: Logger;
+
+  constructor(config: WorkflowExecutorConfig) {
+    this.gitlabClient = config.gitlabClient;
+    this.llmClient = config.llmClient;
+    this.logger = config.logger;
+  }
+
+  /**
+   * Execute workflow
+   */
+  async execute(event: WebhookEvent): Promise<any> {
+    const context: WorkflowContext = {
+      event,
+      variables: this.extractVariables(event),
+      outputs: {},
+    };
+
+    this.logger.info({ context }, 'Starting workflow execution');
+
+    try {
+      // Step 1: Fetch MR Changes
+      this.logger.info('Executing step: Fetch MR Changes');
+      context.outputs.fetch-changes = await this.gitlabClient.getMRChanges(
+        context.variables.PROJECT_ID, context.variables.MR_IID
+      );
+
+
+      // Step 2: Run Production-Grade Audit
+      this.logger.info('Executing step: Run Production-Grade Audit');
+      context.outputs.run-audit = await this.gitlabClient.runAudit(
+        context.variables.PROJECT_ID, context.variables.MR_IID
+      );
+
+
+      // Step 3: Run Security Scan
+      this.logger.info('Executing step: Run Security Scan');
+      context.outputs.security-scan = await this.gitlabClient.runSecurityScan(
+        context.variables.PROJECT_ID, context.variables.SOURCE_BRANCH
+      );
+
+
+      // Step 4: Comprehensive Code Review
+      this.logger.info('Executing step: Comprehensive Code Review');
+      const prompt = `Review this merge request:
+
+Changes:
+${JSON.stringify(changes, null, 2)}
+
+Audit Results:
+Score: ${auditResult.score}/100
+Violations: ${auditResult.violations.length}
+
+Security Scan:
+${JSON.stringify(securityResult, null, 2)}
+
+Provide comprehensive review in JSON:
+{
+  "summary": "Brief overview",
+  "score": number (0-100),
+  "blocking_issues": [
+    {
+      "severity": "critical",
+      "category": "security|quality|architecture|performance",
+      "file": "path",
+      "line": number,
+      "issue": "description",
+      "suggestion": "how to fix"
+    }
+  ],
+  "non_blocking_issues": [...],
+  "improvements": [...],
+  "positive_points": [...],
+  "recommendation": "approve|changes_required|hold"
+}
+`;
+      context.outputs.llm-review = await this.llmClient.invokeJSON(prompt);
+
+
+      // Step 5: Post Review Comment
+      this.logger.info('Executing step: Post Review Comment');
+      context.outputs.post-review = await this.gitlabClient.postMRComment(
+        context.variables.PROJECT_ID, context.variables.MR_IID, "## 🤖 Agent Review Summary\n\n**Production-Grade Score**: ${auditResult.score}/100\n\n**Recommendation**: ${review.recommendation === 'approve' ? '✅ Approve' : '⚠️ Changes Required'}\n\n### Summary\n${review.summary}\n\n${review.blocking_issues.length > 0 ? `\n### 🚫 Blocking Issues\n${review.blocking_issues.map(i => `\n**${i.severity.toUpperCase()}**: ${i.category}\n- File: \\`${i.file}:${i.line}\\`\n- Issue: ${i.issue}\n- Fix: ${i.suggestion}\n`).join('\\n')}\n` : ''}\n\n${review.non_blocking_issues.length > 0 ? `\n### ⚠️ Non-Blocking Issues\n${review.non_blocking_issues.map(i => `\n- **${i.category}**: ${i.issue} (\\`${i.file}\\`)\n`).join('\\n')}\n` : ''}\n\n${review.improvements.length > 0 ? `\n### 💡 Suggested Improvements\n${review.improvements.map(i => `- ${i}`).join('\\n')}\n` : ''}\n\n${review.positive_points.length > 0 ? `\n### ✅ Positive Points\n${review.positive_points.map(p => `- ${p}`).join('\\n')}\n` : ''}\n\n---\n🔗 [Full Audit Report](${CI_PROJECT_URL}/-/merge_requests/${MR_IID}/pipelines) | 🤖 Reviewed by: mr-reviewer\n"
+      );
+
+
+      // Step 6: Approve MR
+      this.logger.info('Executing step: Approve MR');
+      if (review.recommendation === 'approve' && review.blocking_issues.length === 0) {
+      context.outputs.approve-mr = await this.gitlabClient.approveMR(
+        context.variables.PROJECT_ID, context.variables.MR_IID
+      );
+      }
+
+
+      // Step 7: Block MR
+      this.logger.info('Executing step: Block MR');
+      if (review.blocking_issues.length > 0) {
+      context.outputs.block-mr = await this.gitlabClient.blockMR(
+        context.variables.PROJECT_ID, context.variables.MR_IID, "Blocking issues found - see review comment"
+      );
+      }
+
+
+      this.logger.info({ outputs: context.outputs }, 'Workflow completed');
+      return context.outputs;
+    } catch (error) {
+      this.logger.error({ err: error }, 'Workflow execution failed');
+      throw error;
+    }
+  }
+
+  /**
+   * Extract variables from webhook event
+   */
+  private extractVariables(event: WebhookEvent): Record<string, any> {
+    return {
+      PROJECT_ID: event.project?.id || event.project_id,
+      MR_IID: event.merge_request?.iid || event.object_attributes?.iid,
+      PIPELINE_ID: event.object_attributes?.id,
+      COMMIT_SHA: event.object_attributes?.sha || event.commit?.id,
+      REF: event.object_attributes?.ref || event.ref,
+      SOURCE_BRANCH: event.merge_request?.source_branch,
+      TARGET_BRANCH: event.merge_request?.target_branch,
+      DUO_COMMENT_ID: event.object_attributes?.id,
+      DUO_COMMENT_BODY: event.object_attributes?.note,
+      // Add more as needed
+    };
+  }
+}

package/examples/gitlab-agents/mr-reviewer/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "lib": [
+      "ES2022"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/examples/gitlab-agents/mr-reviewer/webhook-config.json

@@ -0,0 +1,11 @@
+{
+  "url": "http://mesh.blueflyagents.com/webhook/mr-reviewer",
+  "token": "${WEBHOOK_SECRET}",
+  "enable_ssl_verification": false,
+  "push_events": false,
+  "issues_events": false,
+  "merge_requests_events": true,
+  "note_events": false,
+  "pipeline_events": false,
+  "wiki_page_events": false
+}

package/examples/gitlab-agents/pipeline-auto-fix/.env.example

@@ -0,0 +1,14 @@
+# GitLab Agent Environment Variables
+
+# GitLab Configuration
+GITLAB_API_TOKEN=glpat-your-token-here
+GITLAB_API_URL=https://gitlab.com/api/v4
+WEBHOOK_SECRET=your-webhook-secret
+
+# LLM Configuration
+ANTHROPIC_API_KEY=sk-ant-your-key-here
+
+# Server Configuration
+PORT=9090
+NODE_ENV=production
+LOG_LEVEL=info