cli start scan

Author: pranavcodeant

src/commands/scans/index.js

@@ -4,6 +4,7 @@ import { runHistory } from './history.js';
 import { runGet } from './get.js';
 import { runResults } from './results.js';
 import { runDismissed } from './dismissed.js';
+import { runStartScan } from './start-scan.js';
 import { setQuiet, setNoColor } from './lib/log.js';
 import { setNoColor as tableSetNoColor } from './formatters/table.js';
 
@@ -118,4 +119,28 @@ export default function registerScansCommands(program, { runCmd }) {
     .action((opts) =>
       runCmd(() => runDismissed({ repo: opts.repo, analysisType: opts.analysisType }))
     );
+
+  // ── start-scan ─────────────────────────────────────────────────────────────
+  scans
+    .command('start-scan')
+    .description('Trigger a new analysis run for a repository')
+    .option('--repo <repo>', 'Repository (owner/repo, auto-detected from git remote)')
+    .option('--branch <name>', 'Branch to scan (auto-detected from current checkout)')
+    .option('--commit <sha>', 'Commit SHA to scan (resolved from remote if omitted)')
+    .option('--include <paths>', 'Comma-separated file path glob patterns to include')
+    .option('--exclude <paths>', 'Comma-separated file path glob patterns to exclude')
+    .action(async (opts) => {
+      try {
+        await runStartScan({
+          repo: opts.repo,
+          branch: opts.branch,
+          commit: opts.commit,
+          include: opts.include,
+          exclude: opts.exclude,
+        });
+      } catch (err) {
+        process.stderr.write(JSON.stringify({ error: err.message }) + '\n');
+        process.exit(err.exitCode ?? 1);
+      }
+    });
 }

src/commands/scans/start-scan.js

@@ -0,0 +1,89 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { detectRepoName } from '../../scm/index.js';
+import { startScan } from '../../scans/startScan.js';
+
+const execAsync = promisify(exec);
+
+// Mirrors splitGlobs in src/index.js (not exported) — preserves commas inside {} brace expansions
+function splitGlobs(input) {
+  const parts = [];
+  let current = '';
+  let depth = 0;
+  for (const ch of String(input)) {
+    if (ch === '{') depth++;
+    else if (ch === '}') depth--;
+    if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts.filter(Boolean);
+}
+
+async function resolveCurrentBranch() {
+  try {
+    const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD');
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+async function resolveRemoteCommit(branch) {
+  try {
+    const { stdout } = await execAsync(`git ls-remote origin refs/heads/${branch}`);
+    const sha = stdout.trim().split(/\s+/)[0];
+    if (!sha) {
+      const err = new Error(`Branch "${branch}" not found on remote origin. Pass --commit <sha> explicitly.`);
+      err.exitCode = 1;
+      throw err;
+    }
+    return sha;
+  } catch (err) {
+    if (err.exitCode) throw err;
+    const wrapped = new Error(`Could not resolve commit for branch "${branch}": ${err.message}. Pass --commit <sha> explicitly.`);
+    wrapped.exitCode = 1;
+    throw wrapped;
+  }
+}
+
+export async function runStartScan({ repo, branch, commit, include, exclude } = {}) {
+  const resolvedRepo = repo || detectRepoName();
+  if (!resolvedRepo) {
+    const err = new Error('Could not detect repo name. Use --repo owner/repo');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  const resolvedBranch = branch || await resolveCurrentBranch();
+  if (!resolvedBranch) {
+    const err = new Error('Could not detect current branch. Use --branch <name>');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  const commitId = commit || await resolveRemoteCommit(resolvedBranch);
+
+  const includeFiles = include ? splitGlobs(include) : [];
+  const excludeFiles = exclude ? splitGlobs(exclude) : [];
+
+  const result = await startScan({
+    repo: resolvedRepo,
+    branch: resolvedBranch,
+    commitId,
+    includeFiles: includeFiles.length ? includeFiles : undefined,
+    excludeFiles: excludeFiles.length ? excludeFiles : undefined,
+  });
+
+  if (!result.success) {
+    const err = new Error(result.error || 'Failed to start scan');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  console.log(result.message || 'Analysis started');
+}

src/scans/startScan.js

@@ -0,0 +1,22 @@
+import { fetchApi } from '../utils/fetchApi.js';
+
+export async function startScan({ repo, branch, commitId, includeFiles, excludeFiles }) {
+  try {
+    const body = { repo, branch, commit_id: commitId };
+    if (includeFiles && includeFiles.length > 0) body.include_files = includeFiles;
+    if (excludeFiles && excludeFiles.length > 0) body.exclude_files = excludeFiles;
+
+    const response = await fetchApi('/extension/analysis/run', 'POST', body);
+
+    if (!response) {
+      return { success: false, error: 'Failed to connect to CodeAnt server' };
+    }
+    if (response.status === 'error') {
+      return { success: false, error: response.message || 'Failed to start scan' };
+    }
+
+    return { success: true, ...response };
+  } catch (error) {
+    return { success: false, error: error.message || 'Failed to start scan' };
+  }
+}