Enterprise Integrations — CodeSpar AgentGate

CodeSpar AgentGate is the enterprise feature tier within CodeSpar Enterprise. It extends the open source core with production monitoring, issue tracking, and CI/CD integrations. These connectors bridge external services with CodeSpar's agent system, enabling automated incident response and fix workflows.

AgentGate covers the full lifecycle from API discovery to production governance, including the MCP Server Generator, the Repository Index, Integration Connectors, and Governance + Payments (coming soon).

Enterprise integrations are part of the codespar-enterprise repo (commercial license). The open source core includes GitHub webhook integration only. Contact enterprise@codespar.dev for access.

Architecture

Enterprise integrations follow a pipeline architecture where external events flow through a normalized interface into the agent system:

External Service (Sentry, Linear, Jira, ...)
       │
       │  webhook POST
       ▼
┌──────────────────────┐
│ IntegrationConnector  │  Parses webhook, verifies signature,
│                       │  extracts structured data
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  IntegrationEvent     │  Normalized event with severity,
│                       │  stack trace, affected files
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│   Incident Agent      │  Correlates with recent commits,
│                       │  identifies root cause
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│    Dev Agent          │  Proposes fix, creates PR,
│                       │  runs tests
└──────────┬───────────┘
           │
           ▼
        Pull Request

IntegrationConnector Interface

Every connector implements a common interface that normalizes external service data into a format the agent system understands:

interface IntegrationConnector {
  /** Unique identifier for this connector type */
  type: string;
 
  /** Parse an incoming webhook payload into an IntegrationEvent */
  parseWebhook(payload: unknown, headers: Record<string, string>): IntegrationEvent;
 
  /** Verify the webhook signature to prevent spoofing */
  verifySignature(payload: string, signature: string): boolean;
 
  /** Check if the external service is reachable */
  healthCheck(): Promise<{ healthy: boolean; latencyMs: number }>;
}

This uniform interface means the agent system does not need to know the specifics of each external service. The connector handles all the parsing and verification, and the agents work with normalized events.

IntegrationEvent

The normalized event format that all connectors produce:

interface IntegrationEvent {
  /** Source connector type (e.g., "sentry", "linear", "jira") */
  source: string;
 
  /** Event type (e.g., "error", "issue_created", "alert") */
  eventType: string;
 
  /** Severity level */
  severity: "info" | "warning" | "error" | "critical";
 
  /** Human-readable title */
  title: string;
 
  /** Detailed description or error message */
  description: string;
 
  /** Stack trace, if available */
  stackTrace?: string;
 
  /** Files likely affected by this event */
  affectedFiles?: string[];
 
  /** Raw payload from the external service */
  rawPayload: unknown;
 
  /** Timestamp of the original event */
  timestamp: string;
}

MCP Server Generator

The MCP Server Generator scans your source code for API endpoints and produces a complete MCP server, without requiring an OpenAPI spec. It supports Express, Fastify, and Next.js (both App Router and Pages Router).

See the full guide: MCP Server Generator.

Repository Index

The Repository Index is an enterprise feature that provides full codebase indexing with symbol extraction, dependency graph construction, and semantic search. It enables agents to answer structural questions about your codebase and perform cross-repo operations.

Capabilities

• Symbol extraction: indexes functions, classes, interfaces, types, and exports across the entire repository
• Dependency graph: maps import/export relationships between files and packages, including cross-repo dependencies in monorepos
• Semantic search: natural language queries against the indexed codebase (e.g., "where is authentication implemented?")
• Cross-repo refactoring: when multiple repos are indexed, agents can trace usage across repository boundaries and plan coordinated changes
• Framework migration: the index identifies all usages of deprecated APIs, enabling the Planning Agent to generate comprehensive migration plans
• Codebase Q&A: developers can ask the agent structural questions ("which services depend on the User model?") and get accurate, source-linked answers

Example

@codespar where is the payment flow implemented?

🔍 Searching repository index...

Found 4 relevant files:
  src/services/payment-service.ts    (PaymentService class, 3 methods)
  src/api/routes/payments.ts         (REST endpoints: POST /pay, GET /status)
  src/workers/payment-processor.ts   (async queue consumer)
  src/types/payment.ts               (PaymentIntent, PaymentStatus types)

Dependencies: Stripe SDK, UserService, NotificationService

Available Connectors

Sentry Integration

The Sentry connector is the most mature enterprise integration. It demonstrates the full pipeline from external event to automated fix.

Setup

1. Configure a Sentry webhook to point to your CodeSpar instance:

   https://your-codespar-instance.com/api/integrations/sentry/webhook

2. Set the webhook secret in your environment:

   SENTRY_WEBHOOK_SECRET=your-webhook-secret
   SENTRY_DSN=https://...@sentry.io/...

3. Select which Sentry event types to forward (recommended: error, issue).

How It Works

When a new error occurs in your application:

1. Sentry fires a webhook with the error details, stack trace, and affected files
2. SentryConnector parses the webhook, verifies the HMAC signature, and extracts the stack trace and affected file paths
3. IntegrationEvent is created with severity, title, description, stack trace, and affected files
4. Incident Agent receives the event, correlates the stack trace with recent commits (last 24h), and identifies which change likely introduced the error
5. Dev Agent is spawned with the root cause analysis, proposes a fix, creates a branch, and opens a PR
6. Notification is sent to the team's messaging channel with the error summary, root cause, and PR link

Example Flow

Sentry: New error in production
        TypeError: Cannot read property 'email' of undefined
        at UserService.getProfile (src/services/user-service.ts:42)

CodeSpar: 🚨 Production Error (via Sentry)
          ─────────────────
          TypeError: Cannot read property 'email' of undefined
          File: src/services/user-service.ts:42
          First seen: 2 minutes ago
          Events: 14

          🔍 Correlating with recent commits...

          Root cause: commit abc1234 ("refactor: update user model")
          changed the User type to make 'profile' optional but
          getProfile() does not handle the null case.

          🔧 Dev Agent proposing fix...

          ✅ PR #89 opened: "fix: handle null profile in getProfile"
          Files changed: 1 | Lines: +5 / -1

Linear Integration

The Linear connector parses incoming webhooks, verifies HMAC signatures, and maps Linear priorities to CodeSpar severity levels.

Priority Mapping

Setup

1. Configure a Linear webhook to point to your CodeSpar instance:

   https://your-codespar-instance.com/api/integrations/linear/webhook

2. Set the webhook secret in your environment:

   LINEAR_WEBHOOK_SECRET=your-webhook-secret

3. The connector verifies each request using HMAC signature validation against the LINEAR_WEBHOOK_SECRET.

Use Cases

• New issue created -- the Incident Agent analyzes the issue description, identifies relevant code, and either proposes a fix or provides context to the developer
• Issue assigned to CodeSpar -- when an issue is assigned to the CodeSpar bot user, the Dev Agent automatically starts working on it
• Status change -- the agent can react to status transitions (e.g., when an issue moves to "In Progress", the agent starts investigating)

Example

Linear: New issue LIN-342 assigned to CodeSpar
        Title: "API returns 500 when user has no avatar"
        Priority: High (2)

CodeSpar: Issue Received (Linear LIN-342)
          "API returns 500 when user has no avatar"
          Severity: error (mapped from High)

          Investigating...
          Found: src/api/users.ts:67 -- avatar URL is dereferenced
          without null check.

          PR #91 opened: "fix: handle missing avatar in user API"
          Linked to: LIN-342

Jira Integration

The Jira connector parses Jira webhook payloads, maps Jira priority levels to CodeSpar severity, and includes a REST API health check to verify connectivity with your Jira instance.

Priority Mapping

Setup

1. Configure a Jira webhook (System > Webhooks) to point to your CodeSpar instance:

   https://your-codespar-instance.com/api/integrations/jira/webhook

2. Set the connection variables in your environment:

   JIRA_WEBHOOK_SECRET=your-webhook-secret
   JIRA_BASE_URL=https://your-org.atlassian.net
   JIRA_API_TOKEN=your-api-token
   JIRA_USER_EMAIL=bot@your-org.com

3. The connector verifies webhook signatures and uses the REST API credentials for the health check endpoint (/rest/api/3/serverInfo).

Use Cases

• New ticket created -- same flow as Linear: analyze, investigate, propose fix
• Ticket assigned to CodeSpar -- the Dev Agent picks up the ticket and starts working
• Transition events -- react to workflow transitions (e.g., "To Do" to "In Progress")

Framework Upgrade Guides

CodeSpar Enterprise includes a knowledge base of framework upgrade guides that the Planning Agent and Dev Agent use when handling migration tasks. Each guide contains a catalog of breaking changes and automated code transforms.

How It Works

When you request a framework migration, the agent:

1. Consults the upgrade guide to enumerate all breaking changes relevant to the target version
2. Scans the repository index to find every file affected by each breaking change
3. Generates a plan with ordered sub-tasks, each targeting a specific breaking change category
4. Applies code transforms that handle mechanical changes (e.g., adding await to cookies() calls, converting *ngIf to @if)

@codespar plan migrate from Next.js 14 to Next.js 15

The Planning Agent references the Next.js 14-to-15 upgrade guide and produces steps that account for specific breaking changes like the async request APIs, changed caching defaults, and updated configuration format. The repository index identifies all affected files, so the plan covers the full scope of the migration rather than a subset.

Writing a Custom Connector

To add a new integration, implement the IntegrationConnector interface:

import { IntegrationConnector, IntegrationEvent } from '@codespar/types';
 
export class CustomConnector implements IntegrationConnector {
  type = 'custom-service';
 
  parseWebhook(payload: unknown, headers: Record<string, string>): IntegrationEvent {
    // Extract relevant data from the webhook payload
    return {
      source: this.type,
      eventType: 'alert',
      severity: 'warning',
      title: payload.alertName,
      description: payload.message,
      stackTrace: payload.trace,
      affectedFiles: payload.files,
      rawPayload: payload,
      timestamp: new Date().toISOString(),
    };
  }
 
  verifySignature(payload: string, signature: string): boolean {
    // Verify HMAC or other signature scheme
    const expected = computeHmac(payload, process.env.CUSTOM_WEBHOOK_SECRET);
    return timingSafeEqual(expected, signature);
  }
 
  async healthCheck(): Promise<{ healthy: boolean; latencyMs: number }> {
    const start = Date.now();
    const response = await fetch('https://custom-service.com/health');
    return {
      healthy: response.ok,
      latencyMs: Date.now() - start,
    };
  }
}

Register the connector in your CodeSpar configuration:

import { registerConnector } from '@codespar/enterprise';
import { CustomConnector } from './custom-connector';
 
registerConnector(new CustomConnector());

Contact

For enterprise licensing, connector requests, or integration support:

• Email: enterprise@codespar.dev
• Website: codespar.dev/enterprise