codeant-cli 0.3.3 → 0.3.5

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);
+}

package/src/scm/gitlab/getCodeReview.js

@@ -0,0 +1,18 @@
+import { getClient, projectId } from './client.js';
+
+export async function getCodeReview({ name, prNumber, reviewId }) {
+  const api = getClient();
+
+  const note = await api.MergeRequestNotes.show(projectId(name), prNumber, reviewId);
+
+  return {
+    id: note.id,
+    user: note.author?.username,
+    state: note.resolved ? 'APPROVED' : 'COMMENTED',
+    body: note.body,
+    submittedAt: note.created_at,
+    path: note.position?.new_path || null,
+    line: note.position?.new_line || null,
+    comments: [],
+  };
+}

package/src/scm/gitlab/getPullRequest.js

@@ -0,0 +1,24 @@
+import { getClient, projectId } from './client.js';
+
+export async function getPullRequest({ name, prNumber }) {
+  const api = getClient();
+
+  const mr = await api.MergeRequests.show(projectId(name), prNumber);
+  const approvals = await api.MergeRequestApprovals.configuration(projectId(name), { mergerequestIid: prNumber }).catch(() => null);
+
+  return {
+    number: mr.iid,
+    title: mr.title,
+    state: mr.state === 'opened' ? 'open' : mr.state,
+    merged: mr.state === 'merged',
+    author: mr.author?.username,
+    sourceBranch: mr.source_branch,
+    targetBranch: mr.target_branch,
+    body: mr.description,
+    createdAt: mr.created_at,
+    updatedAt: mr.updated_at,
+    url: mr.web_url,
+    additions: mr.changes_count,
+    reviewSummary: approvals?.approved_by?.map(a => ({ user: a.user?.username, state: 'APPROVED' })) || [],
+  };
+}

package/src/scm/gitlab/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/gitlab/listCodeReviews.js

@@ -0,0 +1,21 @@
+import { getClient, projectId } from './client.js';
+
+export async function listCodeReviews({ name, prNumber, limit = 20, offset = 0 }) {
+  const api = getClient();
+
+  // GitLab doesn't have "reviews" like GitHub — use notes + approvals
+  const notes = await api.MergeRequestNotes.all(projectId(name), prNumber, {
+    perPage: limit,
+    page: Math.floor(offset / Math.max(limit, 1)) + 1,
+  });
+
+  const reviewNotes = notes.filter(n => !n.system);
+
+  return reviewNotes.map(n => ({
+    id: n.id,
+    user: n.author?.username,
+    state: n.resolved ? 'APPROVED' : 'COMMENTED',
+    body: n.body,
+    submittedAt: n.created_at,
+  }));
+}

package/src/scm/gitlab/listPullRequestComments.js

@@ -0,0 +1,44 @@
+import { getClient, projectId } from './client.js';
+
+export async function listPullRequestComments({ name, prNumber, codeantGenerated, createdAfter, createdBefore }) {
+  const api = getClient();
+
+  const [notes, discussions] = await Promise.all([
+    api.MergeRequestNotes.all(projectId(name), prNumber, { perPage: 100 }),
+    api.MergeRequestDiscussions.all(projectId(name), prNumber, { perPage: 100 }),
+  ]);
+
+  let comments = notes.map(n => ({
+    id: n.id,
+    type: n.type === 'DiffNote' ? 'review' : 'issue',
+    author: n.author?.username,
+    body: n.body,
+    path: n.position?.new_path || null,
+    line: n.position?.new_line || null,
+    createdAt: n.created_at,
+    updatedAt: n.updated_at,
+    isCodeantComment: n.author?.username?.includes('codeant') || n.body?.includes('Suggestion'),
+    resolved: n.resolved || false,
+    discussionId: null,
+  }));
+
+  // Enrich with discussion context
+  for (const disc of discussions) {
+    for (const note of disc.notes || []) {
+      const match = comments.find(c => c.id === note.id);
+      if (match) match.discussionId = disc.id;
+    }
+  }
+
+  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/gitlab/listPullRequests.js

@@ -0,0 +1,26 @@
+import { getClient, projectId } from './client.js';
+
+export async function listPullRequests({ name, sourceBranch, authorLogin, state = 'open', limit = 20, offset = 0 }) {
+  const api = getClient();
+
+  const params = { perPage: limit, page: Math.floor(offset / limit) + 1, orderBy: 'updated_at', sort: 'desc' };
+  if (state === 'open') params.state = 'opened';
+  else if (state === 'closed') params.state = 'closed';
+  if (sourceBranch) params.sourceBranch = sourceBranch;
+  if (authorLogin) params.authorUsername = authorLogin;
+
+  const mrs = await api.MergeRequests.all({ projectId: projectId(name), ...params });
+
+  return mrs.map(mr => ({
+    number: mr.iid,
+    title: mr.title,
+    state: mr.state === 'opened' ? 'open' : mr.state,
+    merged: mr.state === 'merged',
+    author: mr.author?.username,
+    sourceBranch: mr.source_branch,
+    targetBranch: mr.target_branch,
+    createdAt: mr.created_at,
+    updatedAt: mr.updated_at,
+    url: mr.web_url,
+  }));
+}

package/src/scm/gitlab/resolveConversation.js

@@ -0,0 +1,14 @@
+import { getClient, projectId } from './client.js';
+
+/**
+ * Resolve a discussion (conversation) on a GitLab merge request.
+ */
+export async function resolveConversation({ name, prNumber, discussionId }) {
+  if (!discussionId) throw new Error('discussionId is required to resolve a GitLab discussion');
+
+  const api = getClient();
+
+  await api.MergeRequestDiscussions.edit(projectId(name), prNumber, discussionId, { resolved: true });
+
+  return { success: true };
+}

package/src/scm/gitlab/searchComments.js

@@ -0,0 +1,28 @@
+import { getClient, projectId } from './client.js';
+
+export async function searchComments({ name, query, limit = 10 }) {
+  const api = getClient();
+
+  const mrs = await api.MergeRequests.all({ projectId: projectId(name), perPage: 10, orderBy: 'updated_at', sort: 'desc', state: 'all' });
+
+  let allComments = [];
+  for (const mr of mrs) {
+    const notes = await api.MergeRequestNotes.all(projectId(name), mr.iid, { perPage: 50 });
+    allComments.push(...notes.filter(n => !n.system).map(n => ({
+      prNumber: mr.iid,
+      prTitle: mr.title,
+      id: n.id,
+      author: n.author?.username,
+      body: n.body,
+      path: n.position?.new_path || null,
+      line: n.position?.new_line || null,
+      createdAt: n.created_at,
+      isCodeantComment: n.author?.username?.includes('codeant'),
+    })));
+  }
+
+  const q = query.toLowerCase();
+  allComments = allComments.filter(c => c.body?.toLowerCase().includes(q));
+
+  return allComments.slice(0, limit);
+}

package/src/scm/index.js

@@ -0,0 +1,97 @@
+import { execSync } from 'child_process';
+import * as github from './github/index.js';
+import * as gitlab from './gitlab/index.js';
+import * as bitbucket from './bitbucket/index.js';
+import * as azure from './azure/index.js';
+
+const platforms = { github, gitlab, bitbucket, azure };
+
+function getProvider(remote) {
+  const provider = platforms[remote];
+  if (!provider) throw new Error(`Unknown remote "${remote}". Supported: github, gitlab, bitbucket, azure`);
+  return provider;
+}
+
+// ─── Shared origin parsing (single source of truth) ───
+
+function parseOriginUrl(origin) {
+  // Parse host from SSH (git@host:owner/repo) or HTTPS (https://host/owner/repo)
+  let host = null;
+  const sshMatch = origin.match(/^[^@]+@([^:]+):/);
+  const httpsMatch = origin.match(/^https?:\/\/([^/]+)/);
+  if (sshMatch) host = sshMatch[1];
+  else if (httpsMatch) host = httpsMatch[1];
+  return host;
+}
+
+const HOST_TO_PLATFORM = {
+  'github.com': 'github',
+  'gitlab.com': 'gitlab',
+  'bitbucket.org': 'bitbucket',
+  'dev.azure.com': 'azure',
+  'visualstudio.com': 'azure',
+};
+
+function detectPlatformFromHost(host) {
+  if (!host) return null;
+  // Exact match or subdomain match against known hosts
+  for (const [publicHost, platform] of Object.entries(HOST_TO_PLATFORM)) {
+    if (host === publicHost || host.endsWith('.' + publicHost)) return platform;
+  }
+  // Heuristic for self-hosted: check if hostname contains platform name
+  if (host.includes('github')) return 'github';
+  if (host.includes('gitlab')) return 'gitlab';
+  if (host.includes('bitbucket')) return 'bitbucket';
+  if (host.includes('azure') || host.includes('visualstudio')) return 'azure';
+  return null;
+}
+
+function getOrigin() {
+  try {
+    return execSync('git remote get-url origin', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {}
+  return null;
+}
+
+// Auto-detect remote from git origin URL
+export function detectRemote() {
+  const origin = getOrigin();
+  if (!origin) return null;
+  const host = parseOriginUrl(origin);
+  return detectPlatformFromHost(host);
+}
+
+// Auto-detect repo name from git origin URL
+export function detectRepoName() {
+  const origin = getOrigin();
+  if (!origin) return null;
+  // Handle SSH: git@github.com:owner/repo.git
+  // Handle HTTPS: https://github.com/owner/repo.git
+  const match = origin.match(/[/:]([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+  return match ? match[1] : null;
+}
+
+// Auto-detect default branch
+export function detectDefaultBranch() {
+  try {
+    const ref = execSync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    return ref.replace('refs/remotes/origin/', '');
+  } catch {}
+  try {
+    execSync('git show-ref --verify refs/heads/main', { stdio: ['pipe', 'pipe', 'pipe'] });
+    return 'main';
+  } catch {}
+  try {
+    execSync('git show-ref --verify refs/heads/master', { stdio: ['pipe', 'pipe', 'pipe'] });
+    return 'master';
+  } catch {}
+  return null;
+}
+
+export function listPullRequests(opts) { return getProvider(opts.remote).listPullRequests(opts); }
+export function getPullRequest(opts) { return getProvider(opts.remote).getPullRequest(opts); }
+export function listPullRequestComments(opts) { return getProvider(opts.remote).listPullRequestComments(opts); }
+export function listCodeReviews(opts) { return getProvider(opts.remote).listCodeReviews(opts); }
+export function getCodeReview(opts) { return getProvider(opts.remote).getCodeReview(opts); }
+export function searchComments(opts) { return getProvider(opts.remote).searchComments(opts); }
+export function resolveConversation(opts) { return getProvider(opts.remote).resolveConversation(opts); }

package/src/tools/executeTool.js

@@ -0,0 +1,31 @@
+import { readTool } from './readTool.js';
+import { globTool } from './globTool.js';
+import { grepTool } from './grepTool.js';
+import { lsTool } from './lsTool.js';
+
+export async function executeTool(toolCall, cwd) {
+  const { name, args } = toolCall;
+
+  try {
+    if (name === 'Read') {
+      return await readTool(args, cwd);
+    }
+
+    if (name === 'Glob') {
+      return await globTool(args, cwd);
+    }
+
+    if (name === 'Grep') {
+      return await grepTool(args, cwd);
+    }
+
+    if (name === 'LS') {
+      return await lsTool(args, cwd);
+    }
+
+    // Bash tool intentionally removed to prevent arbitrary command execution
+    return `Unknown tool: ${name}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}

package/src/tools/globTool.js

@@ -0,0 +1,9 @@
+import path from 'path';
+
+export async function globTool(args, cwd) {
+  const { globSync } = await import('glob');
+  const pattern = path.resolve(cwd, args.pattern);
+  const matches = globSync(pattern);
+  if (!matches.length) return 'No files found';
+  return matches.map(m => path.relative(cwd, m)).join('\n');
+}

package/src/tools/grepTool.js

@@ -0,0 +1,18 @@
+import { spawn } from 'child_process';
+import path from 'path';
+
+export async function grepTool(args, cwd) {
+  const target = args.path ? path.resolve(cwd, args.path) : cwd;
+  const result = await new Promise((resolve) => {
+    const proc = spawn('grep', ['-rn', args.pattern, target], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 30000,
+    });
+    let stdout = '';
+    proc.stdout.on('data', (data) => { stdout += data; });
+    proc.on('close', () => resolve(stdout.trim() || 'No matches found'));
+    proc.on('error', () => resolve('No matches found'));
+  });
+  return result;
+}

package/src/tools/lsTool.js

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function lsTool(args, cwd) {
+  const dirPath = args.path ? path.resolve(cwd, args.path) : cwd;
+  return fs.readdirSync(dirPath).sort().join('\n');
+}

package/src/tools/readTool.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function readTool(args, cwd) {
+  const filePath = path.resolve(cwd, args.file_path);
+  const content = await fs.promises.readFile(filePath, 'utf8');
+  const lines = content.split('\n');
+  const offset = args.offset || 1;
+  const limit = args.limit || lines.length;
+  const selected = lines.slice(offset - 1, offset - 1 + limit);
+  return selected.map((line, i) => `     ${offset + i}\t${line}`).join('\n');
+}

package/src/utils/analytics.js

@@ -0,0 +1,56 @@
+import { PostHog } from 'posthog-node';
+import { getConfigValue } from './config.js';
+
+const POSTHOG_API_KEY = 'phc_TpsLE5AMwHYsrSQIYgI7uqvorzlDMsin3lDvTEv2DxO';
+const POSTHOG_HOST = 'https://r.codeant.ai';
+
+let client = null;
+
+/** Check if telemetry is disabled via env var or config. */
+export function isTelemetryDisabled() {
+  const envVal = process.env.CODEANT_TELEMETRY_DISABLED;
+  if (envVal !== undefined) {
+    return envVal === '1' || envVal.toLowerCase() === 'true';
+  }
+  return getConfigValue('telemetryEnabled') === false;
+}
+
+function getClient() {
+  if (!client) {
+    client = new PostHog(POSTHOG_API_KEY, { host: POSTHOG_HOST, flushAt: 1, flushInterval: 0 });
+  }
+  return client;
+}
+
+/** Use the API key directly as distinct ID */
+function getDistinctId() {
+  return process.env.CODEANT_API_TOKEN || getConfigValue('apiKey') || 'anonymous';
+}
+
+/**
+ * Track an analytics event. Fire-and-forget — never throws or blocks the CLI.
+ * Respects telemetry opt-out via config or CODEANT_TELEMETRY_DISABLED env var.
+ * @param {string} event - Event name (e.g. 'review_triggered')
+ * @param {Object} [properties={}] - Event properties
+ */
+export function track(event, properties = {}) {
+  try {
+    if (isTelemetryDisabled()) return;
+    getClient().capture({
+      distinctId: getDistinctId(),
+      event,
+      properties: { source: 'cli', cli_version: process.env.npm_package_version || 'unknown', ...properties },
+    });
+  } catch (_) {
+    // Analytics should never break the CLI
+  }
+}
+
+/** Flush pending events. Call before process exits. */
+export async function shutdown() {
+  try {
+    if (client) await client.shutdown();
+  } catch (_) {
+    // noop
+  }
+}

package/src/utils/baseUrl.js

@@ -0,0 +1,11 @@
+import { getConfigValue } from './config.js';
+
+const NEW_BASE_URL = 'https://service.codeant.ai';
+
+const getBaseUrl = () => {
+  const url = process.env.CODEANT_API_URL || getConfigValue('baseUrl') || NEW_BASE_URL;
+  if (url === 'https://api.codeant.ai') return NEW_BASE_URL;
+  return url;
+};
+
+export { getBaseUrl };