codeant-cli 0.3.3 → 0.3.4

package/src/scm/azure/listCodeReviews.js

@@ -0,0 +1,17 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function listCodeReviews({ name, prNumber, limit = 20 }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const pr = await gitApi.getPullRequest(repo, prNumber, project);
+
+  return (pr.reviewers || []).slice(0, limit).map(r => ({
+    id: r.id,
+    user: r.displayName || r.uniqueName,
+    state: r.vote > 0 ? 'APPROVED' : r.vote < 0 ? 'REJECTED' : 'PENDING',
+    body: null,
+    submittedAt: null,
+  }));
+}

package/src/scm/azure/listPullRequestComments.js

@@ -0,0 +1,41 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function listPullRequestComments({ name, prNumber, codeantGenerated, createdAfter, createdBefore }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const threads = await gitApi.getThreads(repo, prNumber, project);
+
+  let comments = [];
+  for (const thread of (threads || [])) {
+    for (const comment of (thread.comments || [])) {
+      if (comment.commentType === 'system') continue;
+      comments.push({
+        id: comment.id,
+        threadId: thread.id,
+        type: thread.threadContext?.filePath ? 'review' : 'issue',
+        author: comment.author?.displayName || comment.author?.uniqueName,
+        body: comment.content,
+        path: thread.threadContext?.filePath || null,
+        line: thread.threadContext?.rightFileStart?.line || null,
+        createdAt: comment.publishedDate,
+        updatedAt: comment.lastUpdatedDate,
+        isCodeantComment: (comment.author?.displayName || '').toLowerCase().includes('codeant') || comment.content?.includes('Suggestion'),
+        resolved: thread.status === 2, // Fixed
+      });
+    }
+  }
+
+  if (codeantGenerated !== undefined) {
+    comments = comments.filter(c => c.isCodeantComment === codeantGenerated);
+  }
+  if (createdAfter) {
+    comments = comments.filter(c => new Date(c.createdAt) >= new Date(createdAfter));
+  }
+  if (createdBefore) {
+    comments = comments.filter(c => new Date(c.createdAt) <= new Date(createdBefore));
+  }
+
+  return comments;
+}

package/src/scm/azure/listPullRequests.js

@@ -0,0 +1,26 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function listPullRequests({ name, sourceBranch, authorLogin, state = 'open', limit = 20 }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const statusMap = { open: 1 /* Active */, closed: 3 /* Completed */ };
+  const searchCriteria = { status: statusMap[state] || 1 };
+  if (sourceBranch) searchCriteria.sourceRefName = `refs/heads/${sourceBranch}`;
+  if (authorLogin) searchCriteria.creatorId = authorLogin;
+
+  const prs = await gitApi.getPullRequests(repo, searchCriteria, project, undefined, undefined, limit);
+
+  return (prs || []).map(pr => ({
+    number: pr.pullRequestId,
+    title: pr.title,
+    state: pr.status === 1 ? 'open' : pr.status === 3 ? 'closed' : 'unknown',
+    merged: pr.status === 3 && pr.closedBy != null,
+    author: pr.createdBy?.displayName || pr.createdBy?.uniqueName,
+    sourceBranch: pr.sourceRefName?.replace('refs/heads/', ''),
+    targetBranch: pr.targetRefName?.replace('refs/heads/', ''),
+    createdAt: pr.creationDate,
+    url: pr.url,
+  }));
+}

package/src/scm/azure/resolveConversation.js

@@ -0,0 +1,22 @@
+import { getConnection, splitRepo } from './client.js';
+
+/**
+ * Resolve a comment thread on an Azure DevOps pull request.
+ * Azure uses thread status: 1 = Active, 2 = Fixed (resolved), 3 = WontFix, 4 = Closed, 5 = ByDesign, 6 = Pending
+ */
+export async function resolveConversation({ name, prNumber, threadId }) {
+  if (!threadId) throw new Error('threadId is required to resolve an Azure DevOps thread');
+
+  const parsedThreadId = Number(threadId);
+  if (!Number.isInteger(parsedThreadId) || parsedThreadId <= 0) {
+    throw new Error('threadId must be a positive integer for Azure DevOps');
+  }
+
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  await gitApi.updateThread({ status: 2 }, repo, prNumber, parsedThreadId, project);
+
+  return { success: true };
+}

package/src/scm/azure/searchComments.js

@@ -0,0 +1,35 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function searchComments({ name, query, limit = 10 }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const prs = await gitApi.getPullRequests(repo, { status: 1 }, project, undefined, undefined, 10);
+
+  let allComments = [];
+  for (const pr of (prs || [])) {
+    const threads = await gitApi.getThreads(repo, pr.pullRequestId, project);
+    for (const thread of (threads || [])) {
+      for (const comment of (thread.comments || [])) {
+        if (comment.commentType === 'system') continue;
+        allComments.push({
+          prNumber: pr.pullRequestId,
+          prTitle: pr.title,
+          id: comment.id,
+          author: comment.author?.displayName,
+          body: comment.content,
+          path: thread.threadContext?.filePath || null,
+          line: thread.threadContext?.rightFileStart?.line || null,
+          createdAt: comment.publishedDate,
+          isCodeantComment: (comment.author?.displayName || '').toLowerCase().includes('codeant'),
+        });
+      }
+    }
+  }
+
+  const q = query.toLowerCase();
+  allComments = allComments.filter(c => c.body?.toLowerCase().includes(q));
+
+  return allComments.slice(0, limit);
+}

package/src/scm/bitbucket/client.js

@@ -0,0 +1,18 @@
+import pkg from 'bitbucket';
+const { Bitbucket } = pkg;
+import { getBitbucketToken, getBitbucketBaseUrl } from '../../utils/scmAuth.js';
+
+export function getClient() {
+  const token = getBitbucketToken();
+  if (!token) throw new Error('Bitbucket token not found. Set BITBUCKET_TOKEN env var or run `codeant set-token bitbucket <token>`.');
+  const opts = { auth: { token } };
+  const baseUrl = getBitbucketBaseUrl();
+  if (baseUrl) opts.baseUrl = baseUrl.replace(/\/+$/, '');
+  return new Bitbucket(opts);
+}
+
+export function splitRepo(name) {
+  const [workspace, repo_slug] = name.split('/');
+  if (!workspace || !repo_slug) throw new Error(`Invalid repo name "${name}". Use workspace/repo format.`);
+  return { workspace, repo_slug };
+}

package/src/scm/bitbucket/getCodeReview.js

@@ -0,0 +1,3 @@
+export async function getCodeReview() {
+  throw new Error('Bitbucket does not support individual code review retrieval. Use `pr comments` instead.');
+}

package/src/scm/bitbucket/getPullRequest.js

@@ -0,0 +1,26 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function getPullRequest({ name, prNumber }) {
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  const { data: pr } = await client.repositories.getPullRequest({ workspace, repo_slug, pull_request_id: prNumber });
+
+  return {
+    number: pr.id,
+    title: pr.title,
+    state: pr.state?.toLowerCase(),
+    merged: pr.state === 'MERGED',
+    author: pr.author?.display_name || pr.author?.nickname,
+    sourceBranch: pr.source?.branch?.name,
+    targetBranch: pr.destination?.branch?.name,
+    body: pr.description,
+    createdAt: pr.created_on,
+    updatedAt: pr.updated_on,
+    url: pr.links?.html?.href,
+    reviewSummary: pr.participants?.filter(p => p.role === 'REVIEWER').map(p => ({
+      user: p.user?.display_name || p.user?.nickname,
+      state: p.approved ? 'APPROVED' : 'PENDING',
+    })) || [],
+  };
+}

package/src/scm/bitbucket/index.js

@@ -0,0 +1,7 @@
+export { listPullRequests } from './listPullRequests.js';
+export { getPullRequest } from './getPullRequest.js';
+export { listPullRequestComments } from './listPullRequestComments.js';
+export { listCodeReviews } from './listCodeReviews.js';
+export { getCodeReview } from './getCodeReview.js';
+export { searchComments } from './searchComments.js';
+export { resolveConversation } from './resolveConversation.js';

package/src/scm/bitbucket/listCodeReviews.js

@@ -0,0 +1,17 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listCodeReviews({ name, prNumber, limit = 20 }) {
+  // Bitbucket doesn't have discrete "reviews" — participants with reviewer role are the equivalent
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  const { data: pr } = await client.repositories.getPullRequest({ workspace, repo_slug, pull_request_id: prNumber });
+
+  return (pr.participants || []).filter(p => p.role === 'REVIEWER').slice(0, limit).map(p => ({
+    id: null,
+    user: p.user?.display_name || p.user?.nickname,
+    state: p.approved ? 'APPROVED' : 'PENDING',
+    body: null,
+    submittedAt: null,
+  }));
+}

package/src/scm/bitbucket/listPullRequestComments.js

@@ -0,0 +1,33 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listPullRequestComments({ name, prNumber, codeantGenerated, createdAfter, createdBefore }) {
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  const { data } = await client.repositories.listPullRequestComments({ workspace, repo_slug, pull_request_id: prNumber, pagelen: 100 });
+
+  let comments = (data.values || []).map(c => ({
+    id: c.id,
+    type: c.inline ? 'review' : 'issue',
+    author: c.user?.display_name || c.user?.nickname,
+    body: c.content?.raw || c.content?.markup || '',
+    path: c.inline?.path || null,
+    line: c.inline?.to || null,
+    createdAt: c.created_on,
+    updatedAt: c.updated_on,
+    isCodeantComment: (c.user?.display_name || c.user?.nickname || '').toLowerCase().includes('codeant') || (c.content?.raw || c.content?.markup || '').includes('Suggestion'),
+    resolved: c.resolved || false,
+  }));
+
+  if (codeantGenerated !== undefined) {
+    comments = comments.filter(c => c.isCodeantComment === codeantGenerated);
+  }
+  if (createdAfter) {
+    comments = comments.filter(c => new Date(c.createdAt) >= new Date(createdAfter));
+  }
+  if (createdBefore) {
+    comments = comments.filter(c => new Date(c.createdAt) <= new Date(createdBefore));
+  }
+
+  return comments;
+}

package/src/scm/bitbucket/listPullRequests.js

@@ -0,0 +1,33 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listPullRequests({ name, sourceBranch, authorLogin, state = 'open', limit = 20 }) {
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  const stateMap = { open: 'OPEN', closed: 'MERGED,DECLINED,SUPERSEDED' };
+  const { data } = await client.repositories.listPullRequests({ workspace, repo_slug, state: stateMap[state] || 'OPEN', pagelen: limit });
+
+  let prs = (data.values || []).map(pr => ({
+    number: pr.id,
+    title: pr.title,
+    state: pr.state?.toLowerCase(),
+    merged: pr.state === 'MERGED',
+    author: pr.author?.display_name || pr.author?.nickname,
+    sourceBranch: pr.source?.branch?.name,
+    targetBranch: pr.destination?.branch?.name,
+    createdAt: pr.created_on,
+    updatedAt: pr.updated_on,
+    url: pr.links?.html?.href,
+  }));
+
+  if (sourceBranch) {
+    const sb = sourceBranch.toLowerCase();
+    prs = prs.filter(pr => pr.sourceBranch?.toLowerCase().includes(sb));
+  }
+  if (authorLogin) {
+    const author = authorLogin.toLowerCase();
+    prs = prs.filter(pr => pr.author?.toLowerCase().includes(author));
+  }
+
+  return prs;
+}

package/src/scm/bitbucket/resolveConversation.js

@@ -0,0 +1,21 @@
+import { getClient, splitRepo } from './client.js';
+
+/**
+ * Resolve a comment (conversation) on a Bitbucket pull request.
+ */
+export async function resolveConversation({ name, prNumber, commentId }) {
+  if (!commentId) throw new Error('commentId is required to resolve a Bitbucket comment');
+
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  await client.repositories.updatePullRequestComment({
+    workspace,
+    repo_slug,
+    pull_request_id: prNumber,
+    comment_id: commentId,
+    _body: { resolved: true },
+  });
+
+  return { success: true };
+}

package/src/scm/bitbucket/searchComments.js

@@ -0,0 +1,29 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function searchComments({ name, query, limit = 10 }) {
+  const client = getClient();
+  const { workspace, repo_slug } = splitRepo(name);
+
+  const { data: prsData } = await client.repositories.listPullRequests({ workspace, repo_slug, state: 'OPEN', pagelen: 10 });
+
+  let allComments = [];
+  for (const pr of (prsData.values || [])) {
+    const { data: commentsData } = await client.repositories.listPullRequestComments({ workspace, repo_slug, pull_request_id: pr.id, pagelen: 50 });
+    allComments.push(...(commentsData.values || []).map(c => ({
+      prNumber: pr.id,
+      prTitle: pr.title,
+      id: c.id,
+      author: c.user?.display_name || c.user?.nickname,
+      body: c.content?.raw || '',
+      path: c.inline?.path || null,
+      line: c.inline?.to || null,
+      createdAt: c.created_on,
+      isCodeantComment: (c.user?.display_name || '').toLowerCase().includes('codeant'),
+    })));
+  }
+
+  const q = query.toLowerCase();
+  allComments = allComments.filter(c => c.body?.toLowerCase().includes(q));
+
+  return allComments.slice(0, limit);
+}

package/src/scm/github/client.js

@@ -0,0 +1,17 @@
+import { Octokit } from '@octokit/rest';
+import { getGitHubToken, getGitHubBaseUrl } from '../../utils/scmAuth.js';
+
+export function getClient() {
+  const token = getGitHubToken();
+  if (!token) throw new Error('GitHub token not found. Set GITHUB_TOKEN env var, login via `gh auth login`, or run `codeant set-token github <token>`.');
+  const opts = { auth: token };
+  const baseUrl = getGitHubBaseUrl();
+  if (baseUrl) opts.baseUrl = baseUrl.replace(/\/+$/, '') + '/api/v3';
+  return new Octokit(opts);
+}
+
+export function splitRepo(name) {
+  const [owner, repo] = name.split('/');
+  if (!owner || !repo) throw new Error(`Invalid repo name "${name}". Use owner/repo format.`);
+  return { owner, repo };
+}

package/src/scm/github/getCodeReview.js

@@ -0,0 +1,26 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function getCodeReview({ name, prNumber, reviewId }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  const [{ data: review }, { data: reviewComments }] = await Promise.all([
+    octokit.pulls.getReview({ owner, repo, pull_number: prNumber, review_id: reviewId }),
+    octokit.pulls.listCommentsForReview({ owner, repo, pull_number: prNumber, review_id: reviewId, per_page: 100 }),
+  ]);
+
+  return {
+    id: review.id,
+    user: review.user?.login,
+    state: review.state,
+    body: review.body,
+    submittedAt: review.submitted_at,
+    comments: reviewComments.map(c => ({
+      id: c.id,
+      path: c.path,
+      line: c.line || c.original_line,
+      body: c.body,
+      createdAt: c.created_at,
+    })),
+  };
+}

package/src/scm/github/getPullRequest.js

@@ -0,0 +1,27 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function getPullRequest({ name, prNumber }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number: prNumber });
+  const { data: reviews } = await octokit.pulls.listReviews({ owner, repo, pull_number: prNumber });
+
+  return {
+    number: pr.number,
+    title: pr.title,
+    state: pr.state,
+    merged: pr.merged_at !== null,
+    author: pr.user?.login,
+    sourceBranch: pr.head?.ref,
+    targetBranch: pr.base?.ref,
+    body: pr.body,
+    createdAt: pr.created_at,
+    updatedAt: pr.updated_at,
+    url: pr.html_url,
+    additions: pr.additions,
+    deletions: pr.deletions,
+    changedFiles: pr.changed_files,
+    reviewSummary: reviews.map(r => ({ user: r.user?.login, state: r.state, submittedAt: r.submitted_at })),
+  };
+}

package/src/scm/github/index.js

@@ -0,0 +1,7 @@
+export { listPullRequests } from './listPullRequests.js';
+export { getPullRequest } from './getPullRequest.js';
+export { listPullRequestComments } from './listPullRequestComments.js';
+export { listCodeReviews } from './listCodeReviews.js';
+export { getCodeReview } from './getCodeReview.js';
+export { searchComments } from './searchComments.js';
+export { resolveConversation } from './resolveConversation.js';

package/src/scm/github/listCodeReviews.js

@@ -0,0 +1,17 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listCodeReviews({ name, prNumber, limit = 20, offset = 0 }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  const { data } = await octokit.pulls.listReviews({ owner, repo, pull_number: prNumber, per_page: limit, page: Math.floor(offset / limit) + 1 });
+
+  return data.map(r => ({
+    id: r.id,
+    user: r.user?.login,
+    state: r.state,
+    body: r.body,
+    submittedAt: r.submitted_at,
+    url: r.html_url,
+  }));
+}

package/src/scm/github/listPullRequestComments.js

@@ -0,0 +1,51 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listPullRequestComments({ name, prNumber, codeantGenerated, addressed, createdAfter, createdBefore }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  // Get both review comments (inline) and issue comments (general)
+  const [{ data: reviewComments }, { data: issueComments }] = await Promise.all([
+    octokit.pulls.listReviewComments({ owner, repo, pull_number: prNumber, per_page: 100 }),
+    octokit.issues.listComments({ owner, repo, issue_number: prNumber, per_page: 100 }),
+  ]);
+
+  let comments = [
+    ...reviewComments.map(c => ({
+      id: c.id,
+      type: 'review',
+      author: c.user?.login,
+      body: c.body,
+      path: c.path,
+      line: c.line || c.original_line,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at,
+      isCodeantComment: c.user?.login?.includes('codeant') || c.body?.includes('Suggestion'),
+      inReplyToId: c.in_reply_to_id || null,
+    })),
+    ...issueComments.map(c => ({
+      id: c.id,
+      type: 'issue',
+      author: c.user?.login,
+      body: c.body,
+      path: null,
+      line: null,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at,
+      isCodeantComment: c.user?.login?.includes('codeant') || c.body?.includes('Suggestion'),
+      inReplyToId: null,
+    })),
+  ];
+
+  if (codeantGenerated !== undefined) {
+    comments = comments.filter(c => c.isCodeantComment === codeantGenerated);
+  }
+  if (createdAfter) {
+    comments = comments.filter(c => new Date(c.createdAt) >= new Date(createdAfter));
+  }
+  if (createdBefore) {
+    comments = comments.filter(c => new Date(c.createdAt) <= new Date(createdBefore));
+  }
+
+  return comments;
+}

package/src/scm/github/listPullRequests.js

@@ -0,0 +1,32 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function listPullRequests({ name, sourceBranch, authorLogin, state = 'open', limit = 20, offset = 0 }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  const perPage = Math.max(limit, 1);
+  const params = { owner, repo, state: state === 'closed' ? 'closed' : 'open', per_page: perPage, page: Math.floor(offset / perPage) + 1, sort: 'updated', direction: 'desc' };
+  if (sourceBranch) params.head = sourceBranch.includes(':') ? sourceBranch : `${owner}:${sourceBranch}`;
+
+  const { data } = await octokit.pulls.list(params);
+
+  let prs = data.map(pr => ({
+    number: pr.number,
+    title: pr.title,
+    state: pr.state,
+    merged: pr.merged_at !== null,
+    author: pr.user?.login,
+    sourceBranch: pr.head?.ref,
+    targetBranch: pr.base?.ref,
+    createdAt: pr.created_at,
+    updatedAt: pr.updated_at,
+    url: pr.html_url,
+  }));
+
+  if (authorLogin) {
+    const author = authorLogin.toLowerCase();
+    prs = prs.filter(pr => pr.author?.toLowerCase().includes(author));
+  }
+
+  return prs;
+}

package/src/scm/github/resolveConversation.js

@@ -0,0 +1,85 @@
+import { getClient, splitRepo } from './client.js';
+
+/**
+ * Resolve a review conversation on GitHub.
+ * GitHub doesn't have a native "resolve conversation" API for individual comments.
+ * We use the GraphQL API to minimize (hide) the comment, which is the closest equivalent.
+ * For review comments that are part of a PR review thread, we resolve via GraphQL resolveReviewThread.
+ */
+export async function resolveConversation({ name, prNumber, commentId, threadId }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  // If a threadId (graphql node_id of the review thread) is provided, resolve the thread
+  if (threadId) {
+    await octokit.graphql(
+      `mutation($threadId: ID!) {
+        resolveReviewThread(input: { threadId: $threadId }) {
+          thread { isResolved }
+        }
+      }`,
+      { threadId }
+    );
+    return { success: true };
+  }
+
+  // Otherwise, try to find the review comment and resolve its thread via node_id
+  if (commentId) {
+    // Fetch the review comment to get its node_id for the thread
+    const { data: comment } = await octokit.pulls.getReviewComment({
+      owner, repo, comment_id: commentId,
+    });
+
+    if (comment.node_id) {
+      // Attempt to resolve the thread this comment belongs to
+      // The comment's node_id is not the thread node_id, so we need to query for the thread
+      const { repository } = await octokit.graphql(
+        `query($owner: String!, $repo: String!, $prNumber: Int!) {
+          repository(owner: $owner, name: $repo) {
+            pullRequest(number: $prNumber) {
+              reviewThreads(first: 100) {
+                nodes {
+                  id
+                  isResolved
+                  comments(first: 1) {
+                    nodes { databaseId }
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { owner, repo, prNumber }
+      );
+
+      const threads = repository?.pullRequest?.reviewThreads?.nodes;
+      if (!threads) {
+        throw new Error(`Pull request ${prNumber} was not found or is not accessible`);
+      }
+
+      const thread = threads.find(
+        t => t.comments.nodes.some(c => c.databaseId === commentId)
+      );
+
+      if (thread && !thread.isResolved) {
+        await octokit.graphql(
+          `mutation($threadId: ID!) {
+            resolveReviewThread(input: { threadId: $threadId }) {
+              thread { isResolved }
+            }
+          }`,
+          { threadId: thread.id }
+        );
+        return { success: true };
+      }
+
+      if (thread?.isResolved) {
+        return { success: true, message: 'Thread already resolved' };
+      }
+    }
+
+    throw new Error(`Could not find a review thread for comment ${commentId}`);
+  }
+
+  throw new Error('Either commentId or threadId is required');
+}

package/src/scm/github/searchComments.js

@@ -0,0 +1,30 @@
+import { getClient, splitRepo } from './client.js';
+
+export async function searchComments({ name, query, limit = 10, includeAddressed = false }) {
+  const octokit = getClient();
+  const { owner, repo } = splitRepo(name);
+
+  // GitHub doesn't have a native comment search API, so we fetch recent PR comments and filter
+  const { data: prs } = await octokit.pulls.list({ owner, repo, state: 'all', per_page: 10, sort: 'updated' });
+
+  let allComments = [];
+  for (const pr of prs) {
+    const { data: comments } = await octokit.pulls.listReviewComments({ owner, repo, pull_number: pr.number, per_page: 50 });
+    allComments.push(...comments.map(c => ({
+      prNumber: pr.number,
+      prTitle: pr.title,
+      id: c.id,
+      author: c.user?.login,
+      body: c.body,
+      path: c.path,
+      line: c.line || c.original_line,
+      createdAt: c.created_at,
+      isCodeantComment: c.user?.login?.includes('codeant'),
+    })));
+  }
+
+  const q = query.toLowerCase();
+  allComments = allComments.filter(c => c.body?.toLowerCase().includes(q));
+
+  return allComments.slice(0, limit);
+}

package/src/scm/gitlab/client.js

@@ -0,0 +1,16 @@
+import { Gitlab } from '@gitbeaker/rest';
+import { getGitLabToken, getGitLabBaseUrl } from '../../utils/scmAuth.js';
+
+export function getClient() {
+  const token = getGitLabToken();
+  if (!token) throw new Error('GitLab token not found. Set GITLAB_TOKEN env var, login via `glab auth login`, or run `codeant set-token gitlab <token>`.');
+  const opts = { token };
+  const host = getGitLabBaseUrl();
+  if (host) opts.host = host.replace(/\/+$/, '');
+  return new Gitlab(opts);
+}
+
+// GitLab uses project ID or "owner/repo" encoded as "owner%2Frepo"
+export function projectId(name) {
+  return encodeURIComponent(name);
+}