@almadar/integrations 1.0.0

package/dist/index.js

@@ -0,0 +1,1336 @@
+import integratorsRegistry from '@almadar/patterns/integrators-registry.json';
+import Stripe from 'stripe';
+import { google } from 'googleapis';
+import twilio from 'twilio';
+import sgMail from '@sendgrid/mail';
+import { Resend } from 'resend';
+import { spawn } from 'child_process';
+import { promises } from 'fs';
+import { join } from 'path';
+
+// src/core/logger.ts
+var ConsoleLogger = class {
+  constructor(level = "info") {
+    this.level = level;
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug(`[DEBUG] ${message}`, meta || "");
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.log(`[INFO] ${message}`, meta || "");
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn(`[WARN] ${message}`, meta || "");
+    }
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      console.error(`[ERROR] ${message}`, meta || "");
+    }
+  }
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error"];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+};
+function validateParams(integration, action, params) {
+  const registry = integratorsRegistry.integrators[integration];
+  if (!registry) {
+    return {
+      valid: false,
+      errors: [
+        {
+          param: "integration",
+          message: `Unknown integration: ${integration}`
+        }
+      ]
+    };
+  }
+  const actionDef = registry.actions.find((a) => a.name === action);
+  if (!actionDef) {
+    return {
+      valid: false,
+      errors: [{ param: "action", message: `Unknown action: ${action}` }]
+    };
+  }
+  const errors = [];
+  for (const paramDef of actionDef.params) {
+    if (paramDef.required && !(paramDef.name in params)) {
+      errors.push({
+        param: paramDef.name,
+        message: `Missing required parameter: ${paramDef.name}`
+      });
+    }
+    if (paramDef.name in params) {
+      const value = params[paramDef.name];
+      const expectedType = paramDef.type;
+      const actualType = typeof value;
+      if (expectedType === "number" && actualType !== "number") {
+        errors.push({
+          param: paramDef.name,
+          message: `Expected ${expectedType}, got ${actualType}`
+        });
+      }
+      if (expectedType === "string" && actualType !== "string") {
+        errors.push({
+          param: paramDef.name,
+          message: `Expected ${expectedType}, got ${actualType}`
+        });
+      }
+      if (expectedType === "array" && !Array.isArray(value)) {
+        errors.push({
+          param: paramDef.name,
+          message: `Expected array, got ${actualType}`
+        });
+      }
+      if (expectedType === "object" && (actualType !== "object" || Array.isArray(value) || value === null)) {
+        errors.push({
+          param: paramDef.name,
+          message: `Expected object, got ${actualType}`
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/core/retry.ts
+async function withRetry(fn, config) {
+  const {
+    maxAttempts,
+    backoffMs,
+    maxBackoffMs = 3e4,
+    retryableErrors
+  } = config;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (error && typeof error === "object" && "code" in error && retryableErrors) {
+        const integrationError = error;
+        if (!retryableErrors.includes(integrationError.code)) {
+          throw error;
+        }
+      }
+      if (attempt === maxAttempts) {
+        throw error;
+      }
+      const delay = Math.min(
+        backoffMs * Math.pow(2, attempt - 1),
+        maxBackoffMs
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/core/BaseIntegration.ts
+var BaseIntegration = class {
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger || new ConsoleLogger();
+  }
+  /**
+   * Validate action params against registry
+   */
+  validateParams(action, params) {
+    return validateParams(this.config.name, action, params);
+  }
+  /**
+   * Handle errors uniformly
+   */
+  handleError(action, error) {
+    this.logger.error(`Integration error in ${this.config.name}.${action}`, {
+      error
+    });
+    const integrationError = error instanceof Error ? error : new Error(String(error));
+    return {
+      success: false,
+      error: integrationError,
+      metadata: this.createMetadata(action, 0, 0)
+    };
+  }
+  /**
+   * Create metadata for result
+   */
+  createMetadata(action, duration, retries = 0) {
+    return {
+      integration: this.config.name,
+      action,
+      duration,
+      retries,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Execute with retry logic
+   */
+  async executeWithRetry(fn) {
+    if (!this.config.retry) {
+      return fn();
+    }
+    return withRetry(fn, {
+      maxAttempts: this.config.retry.maxAttempts,
+      backoffMs: this.config.retry.backoffMs,
+      maxBackoffMs: this.config.retry.maxBackoffMs,
+      retryableErrors: [
+        "TIMEOUT_ERROR",
+        "NETWORK_ERROR",
+        "RATE_LIMIT_ERROR"
+      ]
+    });
+  }
+};
+
+// src/registry.ts
+var INTEGRATION_REGISTRY = {};
+function registerIntegration(name, constructor) {
+  INTEGRATION_REGISTRY[name] = constructor;
+}
+function getIntegration(name) {
+  return INTEGRATION_REGISTRY[name];
+}
+function isKnownIntegration(name) {
+  return name in INTEGRATION_REGISTRY;
+}
+function getRegisteredIntegrations() {
+  return Object.keys(INTEGRATION_REGISTRY);
+}
+
+// src/factory.ts
+var IntegrationFactory = class {
+  constructor() {
+    this.instances = /* @__PURE__ */ new Map();
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Configure an integration (doesn't instantiate yet)
+   */
+  configure(name, config) {
+    this.configs.set(name, { name, ...config });
+  }
+  /**
+   * Get or create an integration instance
+   */
+  get(name) {
+    if (this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    const Constructor = getIntegration(name);
+    if (!Constructor) {
+      throw new Error(`Unknown integration: ${name}. Make sure it's imported.`);
+    }
+    const config = this.configs.get(name);
+    if (!config) {
+      throw new Error(
+        `Integration not configured: ${name}. Call configure() first.`
+      );
+    }
+    const instance = new Constructor(config);
+    this.instances.set(name, instance);
+    return instance;
+  }
+  /**
+   * Execute an action on an integration
+   */
+  async execute(integration, action, params) {
+    const instance = this.get(integration);
+    return await instance.execute(action, params);
+  }
+  /**
+   * Check if integration is configured
+   */
+  isConfigured(name) {
+    return this.configs.has(name);
+  }
+  /**
+   * Clear all instances (useful for testing)
+   */
+  clear() {
+    this.instances.clear();
+  }
+  /**
+   * Clear all instances and configs
+   */
+  reset() {
+    this.instances.clear();
+    this.configs.clear();
+  }
+};
+var StripeIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    const apiKey = config.env.STRIPE_SECRET_KEY;
+    if (!apiKey) {
+      throw new Error("STRIPE_SECRET_KEY not configured");
+    }
+    this.client = new Stripe(apiKey, {
+      apiVersion: "2025-02-24.acacia"
+    });
+    this.logger.info("Stripe integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "createPaymentIntent":
+          data = await this.executeWithRetry(
+            () => this.createPaymentIntent(params)
+          );
+          break;
+        case "confirmPayment":
+          data = await this.executeWithRetry(() => this.confirmPayment(params));
+          break;
+        case "refund":
+          data = await this.executeWithRetry(() => this.refund(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async createPaymentIntent(params) {
+    const { amount, currency, metadata } = params;
+    this.logger.debug("Creating payment intent", { amount, currency });
+    return await this.client.paymentIntents.create({
+      amount,
+      currency,
+      metadata
+    });
+  }
+  async confirmPayment(params) {
+    const { paymentIntentId } = params;
+    this.logger.debug("Confirming payment", { paymentIntentId });
+    return await this.client.paymentIntents.confirm(paymentIntentId);
+  }
+  async refund(params) {
+    const { paymentIntentId, amount } = params;
+    this.logger.debug("Creating refund", { paymentIntentId, amount });
+    return await this.client.refunds.create({
+      payment_intent: paymentIntentId,
+      amount
+    });
+  }
+};
+registerIntegration("stripe", StripeIntegration);
+var YouTubeIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    const apiKey = config.env.YOUTUBE_API_KEY;
+    if (!apiKey) {
+      throw new Error("YOUTUBE_API_KEY not configured");
+    }
+    this.client = google.youtube({
+      version: "v3",
+      auth: apiKey
+    });
+    this.logger.info("YouTube integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "search":
+          data = await this.executeWithRetry(() => this.search(params));
+          break;
+        case "getVideo":
+          data = await this.executeWithRetry(() => this.getVideo(params));
+          break;
+        case "getChannel":
+          data = await this.executeWithRetry(() => this.getChannel(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async search(params) {
+    const { query, maxResults, type } = params;
+    this.logger.debug("Searching YouTube", { query, maxResults, type });
+    const response = await this.client.search.list({
+      part: ["snippet"],
+      q: query,
+      maxResults: maxResults || 10,
+      type: type ? [type] : void 0
+    });
+    return response.data.items?.map((item) => ({
+      videoId: item.id?.videoId,
+      title: item.snippet?.title,
+      thumbnail: item.snippet?.thumbnails?.default?.url,
+      description: item.snippet?.description
+    }));
+  }
+  async getVideo(params) {
+    const { videoId } = params;
+    this.logger.debug("Getting video details", { videoId });
+    const response = await this.client.videos.list({
+      part: ["snippet", "statistics"],
+      id: [videoId]
+    });
+    const video = response.data.items?.[0];
+    if (!video) {
+      throw new Error(`Video not found: ${videoId}`);
+    }
+    return {
+      title: video.snippet?.title,
+      description: video.snippet?.description,
+      viewCount: video.statistics?.viewCount,
+      likeCount: video.statistics?.likeCount
+    };
+  }
+  async getChannel(params) {
+    const { channelId } = params;
+    this.logger.debug("Getting channel details", { channelId });
+    const response = await this.client.channels.list({
+      part: ["snippet", "statistics"],
+      id: [channelId]
+    });
+    const channel = response.data.items?.[0];
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelId}`);
+    }
+    return {
+      name: channel.snippet?.title,
+      description: channel.snippet?.description,
+      subscriberCount: channel.statistics?.subscriberCount
+    };
+  }
+};
+registerIntegration("youtube", YouTubeIntegration);
+var TwilioIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    const accountSid = config.env.TWILIO_ACCOUNT_SID;
+    const authToken = config.env.TWILIO_AUTH_TOKEN;
+    this.phoneNumber = config.env.TWILIO_PHONE_NUMBER || "";
+    if (!accountSid || !authToken) {
+      throw new Error("TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN not configured");
+    }
+    this.client = twilio(accountSid, authToken);
+    this.logger.info("Twilio integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "sendSMS":
+          data = await this.executeWithRetry(() => this.sendSMS(params));
+          break;
+        case "sendWhatsApp":
+          data = await this.executeWithRetry(() => this.sendWhatsApp(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async sendSMS(params) {
+    const { to, body } = params;
+    this.logger.debug("Sending SMS", { to });
+    const message = await this.client.messages.create({
+      from: this.phoneNumber,
+      to,
+      body
+    });
+    return {
+      sid: message.sid,
+      status: message.status
+    };
+  }
+  async sendWhatsApp(params) {
+    const { to, body } = params;
+    this.logger.debug("Sending WhatsApp message", { to });
+    const message = await this.client.messages.create({
+      from: `whatsapp:${this.phoneNumber}`,
+      to: `whatsapp:${to}`,
+      body
+    });
+    return {
+      sid: message.sid,
+      status: message.status
+    };
+  }
+};
+registerIntegration("twilio", TwilioIntegration);
+var EmailIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.provider = config.env.PROVIDER || "sendgrid";
+    this.fromEmail = config.env.FROM_EMAIL || "noreply@example.com";
+    if (this.provider === "sendgrid") {
+      const apiKey = config.env.SENDGRID_API_KEY;
+      if (!apiKey) {
+        throw new Error("SENDGRID_API_KEY not configured");
+      }
+      sgMail.setApiKey(apiKey);
+    } else if (this.provider === "resend") {
+      const apiKey = config.env.RESEND_API_KEY;
+      if (!apiKey) {
+        throw new Error("RESEND_API_KEY not configured");
+      }
+      this.resendClient = new Resend(apiKey);
+    }
+    this.logger.info(`Email integration initialized (${this.provider})`);
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "send":
+          data = await this.executeWithRetry(() => this.send(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async send(params) {
+    const { to, subject, body, from } = params;
+    this.logger.debug("Sending email", { to, subject, provider: this.provider });
+    if (this.provider === "sendgrid") {
+      return await this.sendViaSendGrid(
+        to,
+        subject,
+        body,
+        from || this.fromEmail
+      );
+    } else if (this.provider === "resend") {
+      return await this.sendViaResend(
+        to,
+        subject,
+        body,
+        from || this.fromEmail
+      );
+    }
+    throw new Error(`Unknown email provider: ${this.provider}`);
+  }
+  async sendViaSendGrid(to, subject, body, from) {
+    const msg = {
+      to,
+      from,
+      subject,
+      html: body
+    };
+    const response = await sgMail.send(msg);
+    return {
+      id: response[0].headers["x-message-id"],
+      status: "sent"
+    };
+  }
+  async sendViaResend(to, subject, body, from) {
+    if (!this.resendClient) {
+      throw new Error("Resend client not initialized");
+    }
+    const response = await this.resendClient.emails.send({
+      from,
+      to,
+      subject,
+      html: body
+    });
+    return {
+      id: response.data?.id,
+      status: "sent"
+    };
+  }
+};
+registerIntegration("email", EmailIntegration);
+
+// src/integrations/llm/index.ts
+var LLMIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.provider = config.env.PROVIDER || "anthropic";
+    try {
+      this.client = this.createLLMClient(config.env);
+      this.logger.info(`LLM integration initialized (${this.provider})`);
+    } catch (error) {
+      throw new Error(`Failed to initialize LLM client: ${error}`);
+    }
+  }
+  createLLMClient(env) {
+    return {
+      provider: this.provider,
+      apiKey: env.ANTHROPIC_API_KEY || env.OPENAI_API_KEY
+    };
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "generate":
+          data = await this.executeWithRetry(() => this.generate(params));
+          break;
+        case "classify":
+          data = await this.executeWithRetry(() => this.classify(params));
+          break;
+        case "extract":
+          data = await this.executeWithRetry(() => this.extract(params));
+          break;
+        case "summarize":
+          data = await this.executeWithRetry(() => this.summarize(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async generate(params) {
+    const { systemPrompt, userPrompt, model, temperature, maxTokens } = params;
+    this.logger.debug("Generating content", { model, temperature });
+    return {
+      content: "Generated content placeholder",
+      usage: { tokens: 0 }
+    };
+  }
+  async classify(params) {
+    const { text, categories, model } = params;
+    this.logger.debug("Classifying text", { categories });
+    return {
+      category: categories[0],
+      confidence: 0.95,
+      reasoning: "Classification reasoning placeholder"
+    };
+  }
+  async extract(params) {
+    const { text, schema, model } = params;
+    this.logger.debug("Extracting structured data", { schema });
+    return {
+      data: {},
+      confidence: 0.9
+    };
+  }
+  async summarize(params) {
+    const { text, maxLength, style, model } = params;
+    this.logger.debug("Summarizing text", { maxLength, style });
+    return {
+      summary: "Summary placeholder",
+      keyPoints: []
+    };
+  }
+};
+registerIntegration("llm", LLMIntegration);
+
+// src/integrations/deepagent/index.ts
+var DeepAgentIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.apiUrl = config.env.DEEPAGENT_API_URL || "http://localhost:3000";
+    this.apiKey = config.env.DEEPAGENT_API_KEY || "";
+    this.logger.info("DeepAgent integration initialized", { apiUrl: this.apiUrl });
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "sendMessage":
+          data = await this.executeWithRetry(() => this.sendMessage(params));
+          break;
+        case "cancelGeneration":
+          data = await this.executeWithRetry(
+            () => this.cancelGeneration(params)
+          );
+          break;
+        case "validateSchema":
+          data = await this.executeWithRetry(() => this.validateSchema(params));
+          break;
+        case "compileSchema":
+          data = await this.executeWithRetry(() => this.compileSchema(params));
+          break;
+        case "getThreadHistory":
+          data = await this.executeWithRetry(
+            () => this.getThreadHistory(params)
+          );
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async sendMessage(params) {
+    const { message, threadId, skill, context } = params;
+    this.logger.debug("Sending message to DeepAgent", { threadId, skill });
+    const response = await this.request("/api/agent/message", {
+      message,
+      threadId,
+      skill,
+      context
+    });
+    return response;
+  }
+  async cancelGeneration(params) {
+    const { threadId } = params;
+    this.logger.debug("Cancelling generation", { threadId });
+    const response = await this.request("/api/agent/cancel", {
+      threadId
+    });
+    return response;
+  }
+  async validateSchema(params) {
+    const { schema } = params;
+    this.logger.debug("Validating schema");
+    const response = await this.request("/api/schema/validate", {
+      schema
+    });
+    return response;
+  }
+  async compileSchema(params) {
+    const { schema, shell } = params;
+    this.logger.debug("Compiling schema", { shell });
+    const response = await this.request("/api/schema/compile", {
+      schema,
+      shell
+    });
+    return response;
+  }
+  async getThreadHistory(params) {
+    const { threadId } = params;
+    this.logger.debug("Getting thread history", { threadId });
+    const response = await this.request("/api/agent/history", {
+      threadId
+    });
+    return response;
+  }
+  async request(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `DeepAgent request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    return await response.json();
+  }
+};
+registerIntegration("deepagent", DeepAgentIntegration);
+
+// src/types.ts
+var IntegrationError = class extends Error {
+  constructor(message, code = "UNKNOWN_ERROR", details) {
+    super(message);
+    this.name = "IntegrationError";
+    this.code = code;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      integration: this.integration,
+      action: this.action,
+      details: this.details
+    };
+  }
+};
+
+// src/integrations/github/github-git.ts
+async function execGit(args, cwd, env) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("git", args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(
+          new IntegrationError(
+            `Git command failed: ${args.join(" ")}
+${stderr}`,
+            "SERVICE_ERROR",
+            { code, stderr }
+          )
+        );
+      }
+    });
+    proc.on("error", (error) => {
+      reject(
+        new IntegrationError(
+          `Failed to execute git: ${error.message}`,
+          "SERVICE_ERROR",
+          { error }
+        )
+      );
+    });
+  });
+}
+async function cloneRepo(params, token) {
+  const { repoUrl, targetDir, branch, depth = 1 } = params;
+  const authUrl = injectTokenIntoUrl(repoUrl, token);
+  const args = ["clone"];
+  if (depth > 0) {
+    args.push("--depth", depth.toString());
+  }
+  if (branch) {
+    args.push("--branch", branch);
+  }
+  args.push(authUrl, targetDir);
+  try {
+    await execGit(args, process.cwd());
+    await scrubTokenFromRemote(targetDir, repoUrl);
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { repoUrl, error }
+    );
+  }
+}
+async function createBranch(params, workDir) {
+  const { branchName, baseBranch } = params;
+  const cwd = params.workDir || workDir;
+  try {
+    if (baseBranch) {
+      await execGit(["checkout", baseBranch], cwd);
+    }
+    await execGit(["checkout", "-b", branchName], cwd);
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to create branch: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { branchName, baseBranch, error }
+    );
+  }
+}
+async function commit(params, workDir) {
+  const { message, files } = params;
+  const cwd = params.workDir || workDir;
+  try {
+    if (files && files.length > 0) {
+      await execGit(["add", ...files], cwd);
+    } else {
+      await execGit(["add", "."], cwd);
+    }
+    await execGit(["commit", "-m", message], cwd);
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to commit: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { message, error }
+    );
+  }
+}
+async function push(params, workDir, token) {
+  const { branchName, force = false } = params;
+  const cwd = params.workDir || workDir;
+  const protectedBranches = ["main", "master", "production", "prod"];
+  if (force && protectedBranches.includes(branchName.toLowerCase())) {
+    throw new IntegrationError(
+      `Force push to protected branch '${branchName}' is not allowed`,
+      "VALIDATION_ERROR"
+    );
+  }
+  try {
+    const credHelper = await createTempCredentialHelper(token);
+    const args = ["push"];
+    if (force) {
+      args.push("--force");
+    }
+    args.push("-u", "origin", branchName);
+    await execGit(args, cwd, {
+      GIT_ASKPASS: credHelper,
+      GIT_TERMINAL_PROMPT: "0"
+    });
+    await promises.unlink(credHelper);
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to push: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { branchName, error }
+    );
+  }
+}
+function injectTokenIntoUrl(repoUrl, token) {
+  const url = new URL(repoUrl);
+  url.username = "x-access-token";
+  url.password = token;
+  return url.toString();
+}
+async function scrubTokenFromRemote(workDir, originalUrl) {
+  try {
+    const url = new URL(originalUrl);
+    url.username = "";
+    url.password = "";
+    const cleanUrl = url.toString();
+    await execGit(["remote", "set-url", "origin", cleanUrl], workDir);
+  } catch (error) {
+    console.error("Warning: Failed to scrub token from remote URL:", error);
+  }
+}
+async function createTempCredentialHelper(token) {
+  const tmpDir = process.env.TMPDIR || "/tmp";
+  const helperPath = join(tmpDir, `git-cred-${Date.now()}.sh`);
+  const script = `#!/bin/sh
+echo "${token}"`;
+  await promises.writeFile(helperPath, script, { mode: 448 });
+  return helperPath;
+}
+
+// src/integrations/github/github-api.ts
+async function githubFetch(endpoint, config, options = {}) {
+  const url = `https://api.github.com${endpoint}`;
+  const headers = {
+    "Authorization": `Bearer ${config.token}`,
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...options.headers
+  };
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    const rateLimit = {
+      remaining: parseInt(response.headers.get("x-ratelimit-remaining") || "0", 10),
+      limit: parseInt(response.headers.get("x-ratelimit-limit") || "5000", 10),
+      reset: parseInt(response.headers.get("x-ratelimit-reset") || "0", 10)
+    };
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      if (response.status === 429) {
+        throw new IntegrationError(
+          "GitHub API rate limit exceeded",
+          "RATE_LIMIT_ERROR",
+          { rateLimit, error }
+        );
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw new IntegrationError(
+          `GitHub API authentication failed: ${error.message || response.statusText}`,
+          "AUTH_ERROR",
+          { status: response.status, error }
+        );
+      }
+      throw new IntegrationError(
+        `GitHub API request failed: ${error.message || response.statusText}`,
+        "SERVICE_ERROR",
+        { status: response.status, error }
+      );
+    }
+    const data = await response.json();
+    return { data, rateLimit };
+  } catch (error) {
+    if (error instanceof IntegrationError) {
+      throw error;
+    }
+    throw new IntegrationError(
+      `GitHub API request failed: ${error instanceof Error ? error.message : String(error)}`,
+      "NETWORK_ERROR",
+      { error }
+    );
+  }
+}
+async function createPR(params, config) {
+  const { title, body, baseBranch, headBranch, draft = false } = params;
+  const endpoint = `/repos/${config.owner}/${config.repo}/pulls`;
+  const { data } = await githubFetch(endpoint, config, {
+    method: "POST",
+    body: JSON.stringify({
+      title,
+      body,
+      base: baseBranch,
+      head: headBranch,
+      draft
+    })
+  });
+  return data;
+}
+async function getPRComments(params, config) {
+  const { prNumber } = params;
+  const endpoint = `/repos/${config.owner}/${config.repo}/pulls/${prNumber}/comments`;
+  const { data } = await githubFetch(endpoint, config);
+  return data;
+}
+async function listIssues(params, config) {
+  const { state = "open", labels = [], limit = 30 } = params;
+  const queryParams = new URLSearchParams({
+    state,
+    per_page: Math.min(limit, 100).toString()
+  });
+  if (labels.length > 0) {
+    queryParams.append("labels", labels.join(","));
+  }
+  const endpoint = `/repos/${config.owner}/${config.repo}/issues?${queryParams}`;
+  const { data } = await githubFetch(endpoint, config);
+  return data;
+}
+async function getIssue(params, config) {
+  const { issueNumber } = params;
+  const issueEndpoint = `/repos/${config.owner}/${config.repo}/issues/${issueNumber}`;
+  const { data: issue } = await githubFetch(issueEndpoint, config);
+  const commentsEndpoint = `/repos/${config.owner}/${config.repo}/issues/${issueNumber}/comments`;
+  const { data: comments } = await githubFetch(commentsEndpoint, config);
+  return { issue, comments };
+}
+function parseRepoUrl(repoUrl) {
+  try {
+    const url = new URL(repoUrl);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    if (pathParts.length < 2) {
+      throw new Error("Invalid repository URL format");
+    }
+    const owner = pathParts[0];
+    const repo = pathParts[1].replace(/\.git$/, "");
+    return { owner, repo };
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to parse repository URL: ${repoUrl}`,
+      "VALIDATION_ERROR",
+      { error }
+    );
+  }
+}
+
+// src/integrations/github/index.ts
+var GitHubIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.token = config.env.GITHUB_TOKEN;
+    if (!this.token) {
+      throw new Error("GITHUB_TOKEN not configured");
+    }
+    this.owner = config.env.GITHUB_OWNER || "";
+    this.repo = config.env.GITHUB_REPO || "";
+    this.workDir = config.env.GITHUB_WORK_DIR || process.cwd();
+    this.logger.info("GitHub integration initialized", {
+      owner: this.owner,
+      repo: this.repo
+    });
+  }
+  /**
+   * Execute a GitHub action
+   */
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    let retries = 0;
+    try {
+      let data;
+      switch (action) {
+        case "cloneRepo":
+          data = await this.executeWithRetry(
+            () => this.cloneRepo(params)
+          );
+          break;
+        case "createBranch":
+          data = await this.executeWithRetry(
+            () => this.createBranch(params)
+          );
+          break;
+        case "commit":
+          data = await this.executeWithRetry(
+            () => this.commit(params)
+          );
+          break;
+        case "push":
+          data = await this.executeWithRetry(
+            () => this.push(params)
+          );
+          break;
+        case "createPR":
+          data = await this.executeWithRetry(
+            () => this.createPR(params)
+          );
+          break;
+        case "getPRComments":
+          data = await this.executeWithRetry(
+            () => this.getPRComments(params)
+          );
+          break;
+        case "listIssues":
+          data = await this.executeWithRetry(
+            () => this.listIssues(params)
+          );
+          break;
+        case "getIssue":
+          data = await this.executeWithRetry(
+            () => this.getIssue(params)
+          );
+          break;
+        default:
+          throw new Error(`Unknown GitHub action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime, retries)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  /**
+   * Clone a repository
+   */
+  async cloneRepo(params) {
+    this.logger.debug("Cloning repository", { repoUrl: params.repoUrl });
+    if (!this.owner || !this.repo) {
+      const parsed = parseRepoUrl(params.repoUrl);
+      this.owner = parsed.owner;
+      this.repo = parsed.repo;
+    }
+    await cloneRepo(params, this.token);
+    return {
+      message: `Successfully cloned ${params.repoUrl} to ${params.targetDir}`
+    };
+  }
+  /**
+   * Create a branch
+   */
+  async createBranch(params) {
+    this.logger.debug("Creating branch", { branchName: params.branchName });
+    await createBranch(params, this.workDir);
+    return {
+      message: `Successfully created branch: ${params.branchName}`
+    };
+  }
+  /**
+   * Commit changes
+   */
+  async commit(params) {
+    this.logger.debug("Committing changes", { message: params.message });
+    await commit(params, this.workDir);
+    return {
+      message: `Successfully committed changes: ${params.message}`
+    };
+  }
+  /**
+   * Push branch
+   */
+  async push(params) {
+    this.logger.debug("Pushing branch", { branchName: params.branchName });
+    await push(params, this.workDir, this.token);
+    return {
+      message: `Successfully pushed branch: ${params.branchName}`
+    };
+  }
+  /**
+   * Create a pull request
+   */
+  async createPR(params) {
+    this.logger.debug("Creating pull request", { title: params.title });
+    const apiConfig = this.getAPIConfig();
+    const pr = await createPR(params, apiConfig);
+    this.logger.info("Pull request created", { number: pr.number, url: pr.url });
+    return pr;
+  }
+  /**
+   * Get PR comments
+   */
+  async getPRComments(params) {
+    this.logger.debug("Getting PR comments", { prNumber: params.prNumber });
+    const apiConfig = this.getAPIConfig();
+    const comments = await getPRComments(params, apiConfig);
+    return { comments };
+  }
+  /**
+   * List issues
+   */
+  async listIssues(params) {
+    this.logger.debug("Listing issues", params);
+    const apiConfig = this.getAPIConfig();
+    const issues = await listIssues(params, apiConfig);
+    return { issues };
+  }
+  /**
+   * Get issue details
+   */
+  async getIssue(params) {
+    this.logger.debug("Getting issue", { issueNumber: params.issueNumber });
+    const apiConfig = this.getAPIConfig();
+    const result = await getIssue(params, apiConfig);
+    return result;
+  }
+  /**
+   * Get API config for GitHub API calls
+   */
+  getAPIConfig() {
+    if (!this.owner || !this.repo) {
+      throw new Error(
+        "GitHub owner and repo must be configured. Either set GITHUB_OWNER/GITHUB_REPO or clone a repository first."
+      );
+    }
+    return {
+      token: this.token,
+      owner: this.owner,
+      repo: this.repo
+    };
+  }
+};
+registerIntegration("github", GitHubIntegration);
+
+export { BaseIntegration, ConsoleLogger, DeepAgentIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getRegisteredIntegrations, isKnownIntegration, registerIntegration, validateParams, withRetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map