@almadar/integrations 2.0.2 → 2.0.3

package/dist/integrations/github/index.js

@@ -0,0 +1,756 @@
+import { integratorsRegistry } from '@almadar/patterns';
+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/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;
+}
+async function getCurrentBranch(workDir) {
+  try {
+    const { stdout } = await execGit(["branch", "--show-current"], workDir);
+    return stdout.trim();
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to get current branch: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { error }
+    );
+  }
+}
+async function hasUncommittedChanges(workDir) {
+  try {
+    const { stdout } = await execGit(["status", "--porcelain"], workDir);
+    return stdout.trim().length > 0;
+  } catch (error) {
+    throw new IntegrationError(
+      `Failed to check git status: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { error }
+    );
+  }
+}
+
+// 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 };
+}
+async function getRateLimit(config) {
+  const endpoint = "/rate_limit";
+  const { data } = await githubFetch(endpoint, config);
+  return data.rate;
+}
+async function listCommits(config, options) {
+  const params = new URLSearchParams();
+  if (options?.path) params.set("path", options.path);
+  if (options?.perPage) params.set("per_page", options.perPage.toString());
+  if (options?.page) params.set("page", options.page.toString());
+  const queryStr = params.toString();
+  const endpoint = `/repos/${config.owner}/${config.repo}/commits${queryStr ? `?${queryStr}` : ""}`;
+  const { data } = await githubFetch(endpoint, config);
+  return data.map((item) => ({
+    sha: item.sha,
+    message: item.commit.message,
+    author: item.commit.author,
+    stats: item.stats
+  }));
+}
+async function getCommitDiff(config, sha) {
+  const url = `https://api.github.com/repos/${config.owner}/${config.repo}/commits/${sha}`;
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+      Accept: "application/vnd.github.diff",
+      "X-GitHub-Api-Version": "2022-11-28"
+    }
+  });
+  if (!response.ok) {
+    throw new IntegrationError(
+      `GitHub API request failed: ${response.statusText}`,
+      "SERVICE_ERROR",
+      { status: response.status }
+    );
+  }
+  return response.text();
+}
+async function getFileAtCommit(config, path, sha) {
+  const endpoint = `/repos/${config.owner}/${config.repo}/contents/${path}?ref=${sha}`;
+  try {
+    const response = await fetch(`https://api.github.com${endpoint}`, {
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+        Accept: "application/vnd.github.raw+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) return null;
+      throw new Error(`${response.status}: ${response.statusText}`);
+    }
+    return response.text();
+  } catch (error) {
+    if (error instanceof IntegrationError) throw error;
+    throw new IntegrationError(
+      `Failed to get file at commit: ${error instanceof Error ? error.message : String(error)}`,
+      "SERVICE_ERROR",
+      { path, sha, error }
+    );
+  }
+}
+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
+    };
+  }
+};
+
+export { GitHubIntegration, cloneRepo, commit, createBranch, createPR, getCommitDiff, getCurrentBranch, getFileAtCommit, getIssue, getPRComments, getRateLimit, hasUncommittedChanges, listCommits, listIssues, parseRepoUrl, push };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map