opensentinel 3.1.1 → 3.6.1

package/dist/chunk-HKOPRRDJ.js

@@ -0,0 +1,1021 @@
+import {
+  providerRegistry
+} from "./chunk-HTF2GIQC.js";
+import {
+  env
+} from "./chunk-PUNIMPMY.js";
+
+// src/integrations/github/client.ts
+import { Octokit } from "octokit";
+var octokitInstance = null;
+function getOctokit(config) {
+  const token = config?.token || env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error("GitHub token is required. Set GITHUB_TOKEN environment variable.");
+  }
+  if (!octokitInstance || config?.token) {
+    octokitInstance = new Octokit({
+      auth: token,
+      baseUrl: config?.baseUrl
+    });
+  }
+  return octokitInstance;
+}
+function createOctokit(config) {
+  const token = config.token || env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error("GitHub token is required.");
+  }
+  return new Octokit({
+    auth: token,
+    baseUrl: config.baseUrl
+  });
+}
+async function getAuthenticatedUser(config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.users.getAuthenticated();
+  return {
+    login: data.login,
+    id: data.id,
+    name: data.name,
+    email: data.email,
+    avatarUrl: data.avatar_url
+  };
+}
+async function getRateLimit(config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.rateLimit.get();
+  return {
+    limit: data.rate.limit,
+    remaining: data.rate.remaining,
+    reset: new Date(data.rate.reset * 1e3),
+    used: data.rate.used
+  };
+}
+function parseRepoString(repoString) {
+  if (repoString.includes("github.com")) {
+    const match = repoString.match(/github\.com[/:]([\w.-]+)\/([\w.-]+)/);
+    if (match) {
+      return { owner: match[1], repo: match[2].replace(/\.git$/, "") };
+    }
+  }
+  const parts = repoString.split("/");
+  if (parts.length === 2) {
+    return { owner: parts[0], repo: parts[1] };
+  }
+  throw new Error(`Invalid repository string: ${repoString}. Expected format: owner/repo or GitHub URL`);
+}
+
+// src/integrations/github/pull-requests.ts
+async function listPullRequests(repoString, options = {}, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: options.state || "open",
+    head: options.head,
+    base: options.base,
+    sort: options.sort || "created",
+    direction: options.direction || "desc",
+    per_page: options.perPage || 30,
+    page: options.page || 1
+  });
+  return data.map(mapPullRequest);
+}
+async function getPullRequest(repoString, prNumber, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: prNumber
+  });
+  return mapPullRequest(data);
+}
+async function createPullRequest(repoString, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.create({
+    owner,
+    repo,
+    title: options.title,
+    body: options.body,
+    head: options.head,
+    base: options.base,
+    draft: options.draft,
+    maintainer_can_modify: options.maintainerCanModify
+  });
+  return mapPullRequest(data);
+}
+async function updatePullRequest(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.update({
+    owner,
+    repo,
+    pull_number: prNumber,
+    title: options.title,
+    body: options.body,
+    state: options.state,
+    base: options.base,
+    maintainer_can_modify: options.maintainerCanModify
+  });
+  return mapPullRequest(data);
+}
+async function closePullRequest(repoString, prNumber, config) {
+  return updatePullRequest(repoString, prNumber, { state: "closed" }, config);
+}
+async function reopenPullRequest(repoString, prNumber, config) {
+  return updatePullRequest(repoString, prNumber, { state: "open" }, config);
+}
+async function markReadyForReview(repoString, prNumber, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.graphql(`
+    mutation($pullRequestId: ID!) {
+      markPullRequestReadyForReview(input: {pullRequestId: $pullRequestId}) {
+        pullRequest {
+          id
+        }
+      }
+    }
+  `, {
+    pullRequestId: `PR_${Buffer.from(`010:PullRequest${await getPullRequestNodeId(octokit, owner, repo, prNumber)}`).toString("base64")}`
+  }).catch(async () => {
+    const pr = await getPullRequest(repoString, prNumber, config);
+    console.log("PR may already be ready for review or permissions are insufficient");
+  });
+}
+async function convertToDraft(repoString, prNumber, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { repository } = await octokit.graphql(`
+    query($owner: String!, $repo: String!, $number: Int!) {
+      repository(owner: $owner, name: $repo) {
+        pullRequest(number: $number) {
+          id
+        }
+      }
+    }
+  `, { owner, repo, number: prNumber });
+  await octokit.graphql(`
+    mutation($pullRequestId: ID!) {
+      convertPullRequestToDraft(input: {pullRequestId: $pullRequestId}) {
+        pullRequest {
+          id
+        }
+      }
+    }
+  `, { pullRequestId: repository.pullRequest.id });
+}
+async function requestReviewers(repoString, prNumber, reviewers, teamReviewers, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.requestReviewers({
+    owner,
+    repo,
+    pull_number: prNumber,
+    reviewers,
+    team_reviewers: teamReviewers
+  });
+  return mapPullRequest(data);
+}
+async function removeReviewRequest(repoString, prNumber, reviewers, teamReviewers, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.removeRequestedReviewers({
+    owner,
+    repo,
+    pull_number: prNumber,
+    reviewers,
+    team_reviewers: teamReviewers
+  });
+  return mapPullRequest(data);
+}
+async function listReviews(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.listReviews({
+    owner,
+    repo,
+    pull_number: prNumber,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.map(mapReview);
+}
+async function createReview(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.createReview({
+    owner,
+    repo,
+    pull_number: prNumber,
+    commit_id: options.commitId,
+    body: options.body,
+    event: options.event,
+    comments: options.comments
+  });
+  return mapReview(data);
+}
+async function approvePullRequest(repoString, prNumber, body, config) {
+  return createReview(repoString, prNumber, {
+    event: "APPROVE",
+    body
+  }, config);
+}
+async function requestChanges(repoString, prNumber, body, config) {
+  return createReview(repoString, prNumber, {
+    event: "REQUEST_CHANGES",
+    body
+  }, config);
+}
+async function submitReview(repoString, prNumber, reviewId, event, body, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.submitReview({
+    owner,
+    repo,
+    pull_number: prNumber,
+    review_id: reviewId,
+    event,
+    body
+  });
+  return mapReview(data);
+}
+async function dismissReview(repoString, prNumber, reviewId, message, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.dismissReview({
+    owner,
+    repo,
+    pull_number: prNumber,
+    review_id: reviewId,
+    message
+  });
+  return mapReview(data);
+}
+async function listReviewComments(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.listReviewComments({
+    owner,
+    repo,
+    pull_number: prNumber,
+    sort: options?.sort,
+    direction: options?.direction,
+    since: options?.since,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.map(mapReviewComment);
+}
+async function createReviewComment(repoString, prNumber, body, commitId, path, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.createReviewComment({
+    owner,
+    repo,
+    pull_number: prNumber,
+    body,
+    commit_id: commitId,
+    path,
+    position: options?.position,
+    line: options?.line,
+    side: options?.side,
+    start_line: options?.startLine,
+    start_side: options?.startSide,
+    in_reply_to: options?.inReplyTo
+  });
+  return mapReviewComment(data);
+}
+async function replyToReviewComment(repoString, prNumber, commentId, body, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.createReplyForReviewComment({
+    owner,
+    repo,
+    pull_number: prNumber,
+    comment_id: commentId,
+    body
+  });
+  return mapReviewComment(data);
+}
+async function listFiles(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.listFiles({
+    owner,
+    repo,
+    pull_number: prNumber,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.map(mapPullRequestFile);
+}
+async function listCommits(repoString, prNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.listCommits({
+    owner,
+    repo,
+    pull_number: prNumber,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.map((commit) => ({
+    sha: commit.sha,
+    message: commit.commit.message,
+    author: commit.commit.author ? {
+      name: commit.commit.author.name || "",
+      email: commit.commit.author.email || "",
+      date: commit.commit.author.date || ""
+    } : null,
+    committer: commit.commit.committer ? {
+      name: commit.commit.committer.name || "",
+      email: commit.commit.committer.email || "",
+      date: commit.commit.committer.date || ""
+    } : null,
+    htmlUrl: commit.html_url
+  }));
+}
+async function checkMergeability(repoString, prNumber, config) {
+  const pr = await getPullRequest(repoString, prNumber, config);
+  return {
+    mergeable: pr.mergeable,
+    mergeableState: pr.mergeableState,
+    merged: pr.merged
+  };
+}
+async function mergePullRequest(repoString, prNumber, options = {}, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.merge({
+    owner,
+    repo,
+    pull_number: prNumber,
+    commit_title: options.commitTitle,
+    commit_message: options.commitMessage,
+    sha: options.sha,
+    merge_method: options.mergeMethod || "merge"
+  });
+  return {
+    sha: data.sha,
+    merged: data.merged,
+    message: data.message
+  };
+}
+async function updateBranch(repoString, prNumber, expectedHeadSha, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.pulls.updateBranch({
+    owner,
+    repo,
+    pull_number: prNumber,
+    expected_head_sha: expectedHeadSha
+  });
+  return {
+    message: data.message || "",
+    url: data.url || ""
+  };
+}
+async function getPullRequestNodeId(octokit, owner, repo, prNumber) {
+  const { repository } = await octokit.graphql(`
+    query($owner: String!, $repo: String!, $number: Int!) {
+      repository(owner: $owner, name: $repo) {
+        pullRequest(number: $number) {
+          id
+        }
+      }
+    }
+  `, { owner, repo, number: prNumber });
+  return repository.pullRequest.id;
+}
+function mapPullRequest(data) {
+  return {
+    id: data.id,
+    number: data.number,
+    title: data.title,
+    body: data.body,
+    state: data.state,
+    htmlUrl: data.html_url,
+    diffUrl: data.diff_url,
+    patchUrl: data.patch_url,
+    draft: data.draft || false,
+    merged: data.merged || false,
+    mergeable: data.mergeable,
+    mergeableState: data.mergeable_state || "unknown",
+    mergedAt: data.merged_at,
+    mergedBy: data.merged_by ? {
+      login: data.merged_by.login,
+      id: data.merged_by.id,
+      avatarUrl: data.merged_by.avatar_url
+    } : null,
+    user: data.user ? {
+      login: data.user.login,
+      id: data.user.id,
+      avatarUrl: data.user.avatar_url
+    } : null,
+    head: {
+      ref: data.head.ref,
+      sha: data.head.sha,
+      repo: data.head.repo ? {
+        fullName: data.head.repo.full_name,
+        cloneUrl: data.head.repo.clone_url
+      } : null
+    },
+    base: {
+      ref: data.base.ref,
+      sha: data.base.sha,
+      repo: data.base.repo ? {
+        fullName: data.base.repo.full_name,
+        cloneUrl: data.base.repo.clone_url
+      } : null
+    },
+    labels: data.labels?.map((label) => ({
+      id: label.id,
+      name: label.name,
+      color: label.color,
+      description: label.description
+    })) || [],
+    assignees: data.assignees?.map((assignee) => ({
+      login: assignee.login,
+      id: assignee.id,
+      avatarUrl: assignee.avatar_url
+    })) || [],
+    requestedReviewers: data.requested_reviewers?.map((reviewer) => ({
+      login: reviewer.login,
+      id: reviewer.id,
+      avatarUrl: reviewer.avatar_url
+    })) || [],
+    requestedTeams: data.requested_teams?.map((team) => ({
+      id: team.id,
+      name: team.name,
+      slug: team.slug
+    })) || [],
+    milestone: data.milestone ? {
+      id: data.milestone.id,
+      number: data.milestone.number,
+      title: data.milestone.title,
+      state: data.milestone.state
+    } : null,
+    additions: data.additions || 0,
+    deletions: data.deletions || 0,
+    changedFiles: data.changed_files || 0,
+    commits: data.commits || 0,
+    comments: data.comments || 0,
+    reviewComments: data.review_comments || 0,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    closedAt: data.closed_at
+  };
+}
+function mapReview(data) {
+  return {
+    id: data.id,
+    user: data.user ? {
+      login: data.user.login,
+      id: data.user.id,
+      avatarUrl: data.user.avatar_url
+    } : null,
+    body: data.body,
+    state: data.state,
+    htmlUrl: data.html_url,
+    submittedAt: data.submitted_at,
+    commitId: data.commit_id
+  };
+}
+function mapReviewComment(data) {
+  return {
+    id: data.id,
+    pullRequestReviewId: data.pull_request_review_id,
+    diffHunk: data.diff_hunk,
+    path: data.path,
+    position: data.position,
+    originalPosition: data.original_position,
+    commitId: data.commit_id,
+    originalCommitId: data.original_commit_id,
+    user: data.user ? {
+      login: data.user.login,
+      id: data.user.id,
+      avatarUrl: data.user.avatar_url
+    } : null,
+    body: data.body,
+    htmlUrl: data.html_url,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    line: data.line,
+    side: data.side || "RIGHT",
+    startLine: data.start_line,
+    startSide: data.start_side,
+    inReplyToId: data.in_reply_to_id
+  };
+}
+function mapPullRequestFile(data) {
+  return {
+    sha: data.sha,
+    filename: data.filename,
+    status: data.status,
+    additions: data.additions,
+    deletions: data.deletions,
+    changes: data.changes,
+    blobUrl: data.blob_url,
+    rawUrl: data.raw_url,
+    contentsUrl: data.contents_url,
+    patch: data.patch,
+    previousFilename: data.previous_filename
+  };
+}
+
+// src/integrations/github/code-review.ts
+async function reviewPullRequest(repoString, prNumber, options = {}) {
+  const { owner, repo } = parseRepoString(repoString);
+  const maxFiles = options.maxFiles || 20;
+  const [pr, files, commits] = await Promise.all([
+    getPullRequest(repoString, prNumber, options.githubConfig),
+    listFiles(repoString, prNumber, { perPage: maxFiles }, options.githubConfig),
+    listCommits(repoString, prNumber, { perPage: 10 }, options.githubConfig)
+  ]);
+  const reviewableFiles = files.filter((f) => {
+    if (!f.patch) return false;
+    if (f.patch.length > 5e4) return false;
+    if (isGeneratedFile(f.filename)) return false;
+    return true;
+  });
+  const diffContexts = reviewableFiles.map((file) => ({
+    file,
+    patch: file.patch
+  }));
+  const totalLines = reviewableFiles.reduce(
+    (sum, f) => sum + f.additions + f.deletions,
+    0
+  );
+  const prompt = buildReviewPrompt(pr, diffContexts, commits, options);
+  const provider = providerRegistry.getDefault();
+  const response = await provider.createMessage({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 8192,
+    system: getSystemPrompt(options),
+    messages: [{ role: "user", content: prompt }]
+  });
+  const reviewContent = response.content[0]?.type === "text" ? response.content[0].text || "" : "";
+  const reviewResult = parseReviewResponse(
+    reviewContent,
+    pr,
+    reviewableFiles.length,
+    totalLines
+  );
+  if (options.autoSubmit) {
+    const reviewOptions = buildReviewOptions(reviewResult);
+    const review = await createReview(
+      repoString,
+      prNumber,
+      reviewOptions,
+      options.githubConfig
+    );
+    reviewResult.reviewSubmitted = true;
+    reviewResult.reviewId = review.id;
+  }
+  return reviewResult;
+}
+async function reviewFile(repoString, prNumber, filename, options = {}) {
+  const files = await listFiles(repoString, prNumber, { perPage: 100 }, options.githubConfig);
+  const file = files.find((f) => f.filename === filename);
+  if (!file) {
+    throw new Error(`File not found in pull request: ${filename}`);
+  }
+  if (!file.patch) {
+    throw new Error(`No diff available for file: ${filename}`);
+  }
+  const prompt = buildSingleFileReviewPrompt(file, options);
+  const provider = providerRegistry.getDefault();
+  const response = await provider.createMessage({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    system: getSystemPrompt(options),
+    messages: [{ role: "user", content: prompt }]
+  });
+  const reviewContent = response.content[0]?.type === "text" ? response.content[0].text || "" : "";
+  return parseSingleFileReview(reviewContent, filename);
+}
+async function summarizeChanges(repoString, prNumber, options) {
+  const [pr, files, commits] = await Promise.all([
+    getPullRequest(repoString, prNumber, options?.githubConfig),
+    listFiles(repoString, prNumber, { perPage: 50 }, options?.githubConfig),
+    listCommits(repoString, prNumber, { perPage: 20 }, options?.githubConfig)
+  ]);
+  const prompt = `Analyze this pull request and provide a summary:
+
+**Pull Request:** ${pr.title}
+**Description:** ${pr.body || "No description provided"}
+**Author:** ${pr.user?.login || "Unknown"}
+**Commits:** ${commits.length}
+**Files Changed:** ${files.length}
+**Lines Changed:** +${pr.additions} / -${pr.deletions}
+
+**Commit Messages:**
+${commits.map((c) => `- ${c.message.split("\n")[0]}`).join("\n")}
+
+**Files Changed:**
+${files.map((f) => `- ${f.filename} (${f.status}: +${f.additions}/-${f.deletions})`).join("\n")}
+
+Provide your analysis in the following JSON format:
+{
+  "summary": "A concise 2-3 sentence summary of what this PR does",
+  "keyChanges": ["Key change 1", "Key change 2"],
+  "impactAreas": ["Area that might be affected"],
+  "breakingChanges": ["Any breaking changes, or empty array if none"],
+  "testingRecommendations": ["What should be tested"]
+}`;
+  const provider = providerRegistry.getDefault();
+  const response = await provider.createMessage({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 2048,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const content = response.content[0]?.type === "text" ? response.content[0].text || "" : "";
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+  }
+  return {
+    summary: content,
+    keyChanges: [],
+    impactAreas: [],
+    breakingChanges: [],
+    testingRecommendations: []
+  };
+}
+async function securityScan(repoString, prNumber, options) {
+  const files = await listFiles(repoString, prNumber, { perPage: 50 }, options?.githubConfig);
+  const reviewableFiles = files.filter((f) => f.patch && !isGeneratedFile(f.filename));
+  const prompt = `Perform a security analysis of these code changes.
+
+**Files Changed:**
+${reviewableFiles.map(
+    (f) => `
+### ${f.filename}
+\`\`\`diff
+${f.patch?.slice(0, 5e3) || ""}
+\`\`\`
+`
+  ).join("\n")}
+
+Look for:
+1. SQL injection vulnerabilities
+2. XSS vulnerabilities
+3. Authentication/authorization issues
+4. Hardcoded secrets or credentials
+5. Insecure dependencies
+6. Path traversal vulnerabilities
+7. Command injection
+8. Insecure deserialization
+9. Sensitive data exposure
+10. Security misconfigurations
+
+Respond in JSON format:
+{
+  "vulnerabilities": [
+    {
+      "severity": "high",
+      "type": "SQL Injection",
+      "file": "path/to/file.ts",
+      "line": 42,
+      "description": "Description of the issue",
+      "recommendation": "How to fix it"
+    }
+  ],
+  "securityScore": 85,
+  "summary": "Overall security assessment"
+}`;
+  const provider = providerRegistry.getDefault();
+  const response = await provider.createMessage({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    system: "You are a security expert reviewing code for vulnerabilities. Be thorough but avoid false positives.",
+    messages: [{ role: "user", content: prompt }]
+  });
+  const content = response.content[0]?.type === "text" ? response.content[0].text || "" : "";
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+  }
+  return {
+    vulnerabilities: [],
+    securityScore: 100,
+    summary: "Unable to parse security scan results"
+  };
+}
+function getSystemPrompt(options) {
+  let prompt = `You are an expert code reviewer with deep knowledge of software engineering best practices.
+Your task is to review pull requests and provide constructive, actionable feedback.
+
+Guidelines:
+- Be specific and constructive in your feedback
+- Prioritize issues by severity (error > warning > info)
+- Include code suggestions when possible
+- Consider the context and purpose of the changes
+- Acknowledge good practices when you see them`;
+  if (options.focusAreas?.length) {
+    prompt += `
+
+Focus especially on: ${options.focusAreas.join(", ")}`;
+  }
+  if (options.language) {
+    prompt += `
+
+This codebase uses ${options.language}. Apply language-specific best practices.`;
+  }
+  if (options.customGuidelines) {
+    prompt += `
+
+Custom Review Guidelines:
+${options.customGuidelines}`;
+  }
+  return prompt;
+}
+function buildReviewPrompt(pr, contexts, commits, options) {
+  let prompt = `Review this pull request:
+
+**Title:** ${pr.title}
+**Author:** ${pr.user?.login || "Unknown"}
+**Description:**
+${pr.body || "No description provided"}
+
+**Commits (${commits.length}):**
+${commits.slice(0, 5).map((c) => `- ${c.message.split("\n")[0]}`).join("\n")}
+${commits.length > 5 ? `... and ${commits.length - 5} more commits` : ""}
+
+**Changes:**
+- Files changed: ${contexts.length}
+- Additions: ${pr.additions}
+- Deletions: ${pr.deletions}
+
+**File Diffs:**
+`;
+  for (const ctx of contexts) {
+    prompt += `
+### ${ctx.file.filename} (${ctx.file.status}: +${ctx.file.additions}/-${ctx.file.deletions})
+\`\`\`diff
+${ctx.patch?.slice(0, 8e3) || "No diff available"}
+\`\`\`
+`;
+  }
+  prompt += `
+
+Please provide your review in the following JSON format:
+{
+  "summary": "A brief summary of the overall changes and their quality",
+  "issues": [
+    {
+      "severity": "error|warning|info",
+      "file": "path/to/file.ts",
+      "line": 42,
+      "endLine": 45,
+      "message": "Description of the issue",
+      "suggestion": "Code or explanation of how to fix it",
+      "category": "security|performance|maintainability|readability|testing|documentation|error-handling|best-practices"
+    }
+  ],
+  "overallAssessment": "approve|request-changes|comment",
+  "recommendations": ["General recommendation 1", "General recommendation 2"],
+  "metrics": {
+    "securityScore": 85,
+    "maintainabilityScore": 90,
+    "readabilityScore": 88,
+    "overallScore": 87
+  }
+}`;
+  return prompt;
+}
+function buildSingleFileReviewPrompt(file, options) {
+  return `Review this file change:
+
+**File:** ${file.filename}
+**Status:** ${file.status}
+**Changes:** +${file.additions}/-${file.deletions}
+
+\`\`\`diff
+${file.patch || "No diff available"}
+\`\`\`
+
+Provide your review in JSON format:
+{
+  "issues": [
+    {
+      "severity": "error|warning|info",
+      "line": 42,
+      "message": "Issue description",
+      "suggestion": "How to fix",
+      "category": "category"
+    }
+  ],
+  "suggestions": ["General improvement suggestion"],
+  "summary": "Brief summary of the file changes"
+}`;
+}
+function parseReviewResponse(content, pr, filesReviewed, linesReviewed) {
+  const defaultResult = {
+    pullRequest: {
+      number: pr.number,
+      title: pr.title,
+      author: pr.user?.login || null,
+      url: pr.htmlUrl
+    },
+    summary: "",
+    issues: [],
+    filesReviewed,
+    linesReviewed,
+    overallAssessment: "comment",
+    recommendations: [],
+    metrics: {
+      securityScore: 0,
+      maintainabilityScore: 0,
+      readabilityScore: 0,
+      overallScore: 0
+    },
+    reviewSubmitted: false
+  };
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        ...defaultResult,
+        summary: parsed.summary || "",
+        issues: parsed.issues || [],
+        overallAssessment: parsed.overallAssessment || "comment",
+        recommendations: parsed.recommendations || [],
+        metrics: parsed.metrics || defaultResult.metrics
+      };
+    }
+  } catch (e) {
+    return {
+      ...defaultResult,
+      summary: content.slice(0, 500)
+    };
+  }
+  return defaultResult;
+}
+function parseSingleFileReview(content, filename) {
+  const defaultResult = {
+    issues: [],
+    suggestions: [],
+    summary: content.slice(0, 300)
+  };
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        issues: (parsed.issues || []).map((issue) => ({
+          ...issue,
+          file: filename
+        })),
+        suggestions: parsed.suggestions || [],
+        summary: parsed.summary || ""
+      };
+    }
+  } catch (e) {
+  }
+  return defaultResult;
+}
+function buildReviewOptions(result) {
+  const comments = [];
+  for (const issue of result.issues) {
+    if (issue.line) {
+      comments.push({
+        path: issue.file,
+        line: issue.line,
+        body: `**${issue.severity.toUpperCase()}** (${issue.category}): ${issue.message}${issue.suggestion ? `
+
+**Suggestion:** ${issue.suggestion}` : ""}`
+      });
+    }
+  }
+  let event;
+  switch (result.overallAssessment) {
+    case "approve":
+      event = "APPROVE";
+      break;
+    case "request-changes":
+      event = "REQUEST_CHANGES";
+      break;
+    default:
+      event = "COMMENT";
+  }
+  let body = `## AI Code Review
+
+${result.summary}
+
+`;
+  if (result.issues.length > 0) {
+    body += `### Issues Found (${result.issues.length})
+
+`;
+    const errorCount = result.issues.filter((i) => i.severity === "error").length;
+    const warningCount = result.issues.filter((i) => i.severity === "warning").length;
+    const infoCount = result.issues.filter((i) => i.severity === "info").length;
+    body += `- Errors: ${errorCount}
+- Warnings: ${warningCount}
+- Info: ${infoCount}
+
+`;
+  }
+  if (result.recommendations.length > 0) {
+    body += `### Recommendations
+
+`;
+    for (const rec of result.recommendations) {
+      body += `- ${rec}
+`;
+    }
+    body += "\n";
+  }
+  body += `### Metrics
+
+`;
+  body += `| Metric | Score |
+|--------|-------|
+`;
+  body += `| Security | ${result.metrics.securityScore}/100 |
+`;
+  body += `| Maintainability | ${result.metrics.maintainabilityScore}/100 |
+`;
+  body += `| Readability | ${result.metrics.readabilityScore}/100 |
+`;
+  body += `| **Overall** | **${result.metrics.overallScore}/100** |
+`;
+  body += `
+---
+*Reviewed by OpenSentinel AI*`;
+  return {
+    event,
+    body,
+    comments: comments.length > 0 ? comments : void 0
+  };
+}
+function isGeneratedFile(filename) {
+  const generatedPatterns = [
+    /\.min\.(js|css)$/,
+    /\.bundle\.(js|css)$/,
+    /package-lock\.json$/,
+    /yarn\.lock$/,
+    /bun\.lockb$/,
+    /\.d\.ts$/,
+    /\.map$/,
+    /dist\//,
+    /build\//,
+    /node_modules\//,
+    /vendor\//,
+    /generated\//,
+    /\.pb\.(go|ts|js)$/,
+    /\.g\.(dart|swift|kt)$/
+  ];
+  return generatedPatterns.some((pattern) => pattern.test(filename));
+}
+
+export {
+  Octokit,
+  getOctokit,
+  createOctokit,
+  getAuthenticatedUser,
+  getRateLimit,
+  parseRepoString,
+  listPullRequests,
+  getPullRequest,
+  createPullRequest,
+  updatePullRequest,
+  closePullRequest,
+  reopenPullRequest,
+  markReadyForReview,
+  convertToDraft,
+  requestReviewers,
+  removeReviewRequest,
+  listReviews,
+  createReview,
+  approvePullRequest,
+  requestChanges,
+  submitReview,
+  dismissReview,
+  listReviewComments,
+  createReviewComment,
+  replyToReviewComment,
+  listFiles,
+  listCommits,
+  checkMergeability,
+  mergePullRequest,
+  updateBranch,
+  reviewPullRequest,
+  reviewFile,
+  summarizeChanges,
+  securityScan
+};
+//# sourceMappingURL=chunk-HKOPRRDJ.js.map