codeant-cli 0.3.3 → 0.3.4

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

package/src/utils/commonApiHelper.js

@@ -0,0 +1,143 @@
+import GitDiffHelper from './gitDiffHelper.js';
+
+/**
+ * Common base class for API helpers that transform git diff data
+ * Contains shared functionality for filtering and retrieving files
+ */
+class CommonApiHelper {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.gitHelper = new GitDiffHelper(workspacePath);
+  }
+
+  async init() {
+    await this.gitHelper.init();
+  }
+
+  /**
+   * Get staged files formatted for the API
+   * This is used for pre-commit hooks
+   */
+  async getStagedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'staged-only' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get all changed files formatted for the API
+   */
+  async getChangedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'branch-diff' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get uncommitted files formatted for the API
+   */
+  async getUncommittedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'uncommitted' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get last commit files formatted for the API
+   */
+  async getLastCommitFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'last-commit' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get last n commits files formatted for the API
+   * @param {number} n - Number of commits to include
+   */
+  async getLastNCommitsFilesForApi(n = 1) {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({
+      type: 'last-n-commits',
+      commits: n
+    });
+
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Transform diff info array to API format
+   * Must be implemented by subclasses
+   */
+  _transformDiffsToApiFormat(diffs) {
+    throw new Error('_transformDiffsToApiFormat must be implemented by subclass');
+  }
+
+
+  /**
+   * Get committed (unpushed) files formatted for the API
+   */
+  async getCommittedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'committed' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get all changes (committed + uncommitted) formatted for the API
+   */
+  async getAllChangesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'all' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get diff against a specific base branch formatted for the API
+   */
+  async getBaseBranchDiffForApi(branch) {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'base-branch', baseBranch: branch });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get diff against a specific base commit formatted for the API
+   */
+  async getBaseCommitDiffForApi(commit) {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'base-commit', baseCommit: commit });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get files based on scan type
+   * Returns the raw array - child classes handle filtering and wrapping
+   * @param {string} type - Type of scan (staged-only, branch-diff, etc.)
+   * @param {Object} options - Additional options
+   * @param {number} options.lastNCommits - Number of commits for last-n-commits type
+   * @param {string} options.baseBranch - Base branch for base-branch type
+   * @param {string} options.baseCommit - Base commit for base-commit type
+   */
+  async getFilesForType(type = 'all', options = {}) {
+    switch (type) {
+      case 'staged-only':
+        return await this.getStagedFilesForApi();
+      case 'branch-diff':
+        return await this.getChangedFilesForApi();
+      case 'uncommitted':
+        return await this.getUncommittedFilesForApi();
+      case 'committed':
+        return await this.getCommittedFilesForApi();
+      case 'all':
+        return await this.getAllChangesForApi();
+      case 'last-commit':
+        return await this.getLastCommitFilesForApi();
+      case 'last-n-commits':
+        return await this.getLastNCommitsFilesForApi(options.lastNCommits || 1);
+      case 'base-branch':
+        return await this.getBaseBranchDiffForApi(options.baseBranch);
+      case 'base-commit':
+        return await this.getBaseCommitDiffForApi(options.baseCommit);
+      default:
+        return await this.getAllChangesForApi();
+    }
+  }
+
+  getGitRoot() {
+    return this.gitHelper.getGitRoot();
+  }
+}
+
+export default CommonApiHelper;

package/src/utils/config.js

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.codeant');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const ensureConfigDir = () => {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+};
+
+const loadConfig = () => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (err) {
+    console.error('Error loading config:', err.message);
+  }
+  return {};
+};
+
+const saveConfig = (config) => {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+};
+
+const getConfigValue = (key) => {
+  const config = loadConfig();
+  return config[key];
+};
+
+const setConfigValue = (key, value) => {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+};
+
+export { loadConfig, saveConfig, getConfigValue, setConfigValue, CONFIG_FILE };

package/src/utils/fetchApi.js

@@ -0,0 +1,39 @@
+import { getConfigValue } from './config.js';
+import { getBaseUrl } from './baseUrl.js';
+
+const fetchApi = async (endpoint, method = 'GET', body = null) => {
+  const url = endpoint.startsWith('http') ? endpoint : `${getBaseUrl()}${endpoint}`;
+
+  const options = {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  };
+
+  // Add auth token from config or env
+  const token = process.env.CODEANT_API_TOKEN || getConfigValue('apiKey');
+  if (token) {
+    options.headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  if (body && method !== 'GET') {
+    options.body = JSON.stringify(body);
+  }
+
+  try {
+    const response = await fetch(url, options);
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || `HTTP error ${response.status}`);
+    }
+
+    return data;
+  } catch (err) {
+    console.error(`API Error: ${err.message}`);
+    throw err;
+  }
+};
+
+export { fetchApi };