codeant-cli 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeant-cli",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Code review CLI tool",
   "type": "module",
   "bin": {

package/src/commands/getDashboardUrl.js

@@ -0,0 +1,49 @@
+import React, { useState, useEffect } from 'react';
+import { Text, Box, useApp } from 'ink';
+import { getConfigValue } from '../utils/config.js';
+import { getBaseUrl, getDashboardUrl as resolveDashboardUrl } from '../utils/baseUrl.js';
+
+export default function GetDashboardUrl() {
+  const { exit } = useApp();
+  const [state, setState] = useState({ status: 'loading' });
+
+  const envValue = process.env.CODEANT_DASHBOARD_URL;
+  const configValue = getConfigValue('dashboardUrl');
+  const source = envValue ? 'env' : configValue ? 'config' : 'upstream (queried from API base URL)';
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const url = await resolveDashboardUrl();
+        setState({ status: 'resolved', url });
+      } catch (err) {
+        setState({ status: 'error', message: err.message });
+      }
+      exit();
+    })();
+  }, []);
+
+  if (state.status === 'loading') {
+    return React.createElement(
+      Box,
+      { flexDirection: 'column', padding: 1 },
+      React.createElement(Text, null, 'Querying dashboard URL...')
+    );
+  }
+
+  if (state.status === 'error') {
+    return React.createElement(
+      Box,
+      { flexDirection: 'column', padding: 1 },
+      React.createElement(Text, { color: 'red' }, '✗ ', state.message),
+      React.createElement(Text, { color: 'gray' }, 'Base URL: ', getBaseUrl())
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', padding: 1 },
+    React.createElement(Text, { bold: true }, 'Dashboard URL: ', state.url),
+    React.createElement(Text, { color: 'gray' }, 'Source: ', source)
+  );
+}

package/src/commands/login.js

@@ -30,7 +30,15 @@ export default function Login() {
     let timeoutId;
 
     (async () => {
-      const dashboardUrl = await getDashboardUrl();
+      let dashboardUrl;
+      try {
+        dashboardUrl = await getDashboardUrl();
+      } catch (err) {
+        setError(err.message);
+        setStatus('error');
+        setTimeout(() => exit(err), 100);
+        return;
+      }
       const loginUrl = `${dashboardUrl}?ideLoginToken=${token}`;
       setLoginUrl(loginUrl);
 

package/src/commands/removeDashboardUrl.js

@@ -0,0 +1,31 @@
+import React, { useEffect } from 'react';
+import { Text, Box, useApp } from 'ink';
+import { getConfigValue, setConfigValue } from '../utils/config.js';
+
+export default function RemoveDashboardUrl() {
+  const { exit } = useApp();
+
+  const hadValue = !!getConfigValue('dashboardUrl');
+
+  useEffect(() => {
+    if (hadValue) {
+      setConfigValue('dashboardUrl', null);
+    }
+    exit();
+  }, []);
+
+  if (!hadValue) {
+    return React.createElement(
+      Box,
+      { flexDirection: 'column', padding: 1 },
+      React.createElement(Text, { color: 'yellow' }, 'No dashboard URL override was set.')
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', padding: 1 },
+    React.createElement(Text, { color: 'green' }, '✓ Dashboard URL override removed.'),
+    React.createElement(Text, { color: 'gray' }, 'It will be auto-detected from the API base URL on next login.')
+  );
+}

package/src/commands/review.js

@@ -81,24 +81,39 @@ export default function Review({ scanType = 'all', lastNCommits = 1, failOn = 'C
 
         // ── Split into per-file requests ───────────────────────────────────
         const perFileRequests = ReviewApiHelper.splitIntoPerFileRequests(requestBody);
+        let riskHypotheses = '';
+        try {
+          setCurrentMessage('Planning review risks...');
+          const plannerResult = await runTurnLoop(
+            {
+              diff_content: requestBody.diff_content,
+              prompt_template_name: 'risk_planner',
+            },
+            gitRoot,
+            () => cancelled,
+            () => {},
+            false
+          );
+          riskHypotheses = plannerResult.finalOutput?.risk_hypotheses || '';
+        } catch (plannerError) {
+          console.error(`Risk planner failed; continuing without hypotheses: ${plannerError.message}`);
+        }
+
+        if (cancelled) return;
 
         // ── Per-file agent turn loops (parallel) ──────────────────────────
         setCurrentMessage(`Analyzing ${perFileRequests.length} file${perFileRequests.length !== 1 ? 's' : ''} in parallel...`);
 
         const perFileResults = await Promise.all(
           perFileRequests.map((fileReq) => {
-            const filename = fileReq._filename;
-            delete fileReq._filename;
-
-            // Convert file_contents dict → file_content/file_path for API
-            if (fileReq.file_contents?.[filename]) {
-              fileReq.file_content = fileReq.file_contents[filename];
-              fileReq.file_path = filename;
-            }
-            delete fileReq.file_contents;
+            const payload = {
+              ...fileReq,
+              extra_variables: { risk_hypotheses: riskHypotheses },
+            };
+            delete payload._filenames;
 
             return runTurnLoop(
-              fileReq,
+              payload,
               gitRoot,
               () => cancelled,
               () => {},
@@ -110,21 +125,23 @@ export default function Review({ scanType = 'all', lastNCommits = 1, failOn = 'C
         // Pair each file's suggestions with its own diff — skip files with no real suggestions
         const perFileWithSuggestions = perFileRequests.map((fileReq, i) => ({
           diff_content: fileReq.diff_content,
-          suggestions: perFileResults[i].finalMessage?.content,
-          output: perFileResults[i].finalOutput,
-        })).filter(r => r.output?.code_suggestions?.length > 0);
+          file_contents: fileReq.file_contents,
+          generator_output: perFileResults[i].finalOutput,
+          rejector_input: perFileResults[i].rejectorInput,
+        })).filter(r => r.generator_output?.code_suggestions?.length > 0);
 
         if (cancelled) return;
 
-        // ── Per-file reflector loops (parallel) ─────────────────────────────
-        setCurrentMessage('Running reflector...');
-        const reflectorResults = await Promise.all(
-          perFileWithSuggestions.map(({ diff_content, suggestions }) =>
+        // ── Per-batch rejector loops (parallel) ─────────────────────────────
+        setCurrentMessage('Running rejector...');
+        const rejectorResults = await Promise.all(
+          perFileWithSuggestions.map(({ diff_content, file_contents, rejector_input }) =>
             runTurnLoop(
               {
                 diff_content,
-                prompt_template_name: 'reflector',
-                extra_variables: { suggestion_str: suggestions },
+                file_contents,
+                prompt_template_name: 'rejector',
+                extra_variables: rejector_input,
               },
               gitRoot,
               () => cancelled,
@@ -136,11 +153,23 @@ export default function Review({ scanType = 'all', lastNCommits = 1, failOn = 'C
 
         if (cancelled) return;
 
-        const reviewIssues = reflectorResults.flatMap(r =>
-          (r.finalOutput?.code_suggestions || []).map(issue => ({
-            issue_content: issue.issue_content || '',
+        const finalizedResults = await Promise.all(
+          rejectorResults.map((result, i) => fetchApi(
+            '/extension/pr-review/agent/finalize',
+            'POST',
+            {
+              diff_content: perFileWithSuggestions[i].diff_content,
+              generator_output: perFileWithSuggestions[i].generator_output,
+              rejector_output: result.finalOutput || { code_suggestions: [] },
+            }
+          ))
+        );
+
+        const reviewIssues = finalizedResults.flatMap(r =>
+          (r.output?.code_suggestions || []).map(issue => ({
+            issue_content: issue.suggestion_content || issue.one_sentence_summary || '',
             relevant_file: issue.relevant_file || 'Unknown',
-            start_line: issue.start_line || 0,
+            start_line: issue.relevant_lines_start || 0,
             label: issue.label || 'Code Quality',
           }))
         );
@@ -213,10 +242,11 @@ export default function Review({ scanType = 'all', lastNCommits = 1, failOn = 'C
 
 // ── Turn loop ──────────────────────────────────────────────────────────────
 
-async function runTurnLoop(initialPayload, gitRoot, isCancelled, onMessage, isReflectorLoop) {
+async function runTurnLoop(initialPayload, gitRoot, isCancelled, onMessage, isRejectorLoop) {
   let nextPayload = initialPayload;
   let finalMessage = null;
   let finalOutput = null;
+  let rejectorInput = null;
 
   for (let turn = 0; turn < MAX_TURNS; turn+=1) {
     if (isCancelled()) break;
@@ -239,10 +269,11 @@ async function runTurnLoop(initialPayload, gitRoot, isCancelled, onMessage, isRe
 
     finalMessage = assistantMsg;
     if (resp.output) finalOutput = resp.output;
+    if (resp.rejector_input) rejectorInput = resp.rejector_input;
 
     if (done) {
-      // Handle parsing errors in final message by dumping response content (only on reflector loop)
-      if (isReflectorLoop && resp.parsing_error) {
+      // Preserve malformed rejector output for debugging.
+      if (isRejectorLoop && resp.parsing_error) {
         const dumpDir = path.join(gitRoot, '.codeant', 'codeSuggestions');
         const dumpFile = path.join(dumpDir, `code_suggestions_${Date.now()}.txt`);
         let dumpContent = resp.response?.content || JSON.stringify(resp, null, 2);
@@ -289,6 +320,5 @@ async function runTurnLoop(initialPayload, gitRoot, isCancelled, onMessage, isRe
     nextPayload = { session_id: sessionId, tool_results: toolResults };
   }
 
-  return { finalMessage, finalOutput };
+  return { finalMessage, finalOutput, rejectorInput };
 }
-

package/src/commands/setDashboardUrl.js

@@ -0,0 +1,37 @@
+import React, { useEffect } from 'react';
+import { Text, Box, useApp } from 'ink';
+import { setConfigValue, CONFIG_FILE } from '../utils/config.js';
+
+export default function SetDashboardUrl({ url }) {
+  const { exit } = useApp();
+
+  useEffect(() => {
+    if (!url) {
+      exit(new Error('URL is required'));
+      return;
+    }
+
+    try {
+      setConfigValue('dashboardUrl', url);
+      exit();
+    } catch (err) {
+      exit(err);
+    }
+  }, []);
+
+  if (!url) {
+    return React.createElement(
+      Box,
+      { flexDirection: 'column', padding: 1 },
+      React.createElement(Text, { color: 'red' }, '✗ Error: URL is required'),
+      React.createElement(Text, { color: 'gray' }, 'Usage: codeant set-dashboard-url <url>')
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', padding: 1 },
+    React.createElement(Text, { color: 'green' }, '✓ Dashboard URL set to: ', url),
+    React.createElement(Text, { color: 'gray' }, 'Saved to: ', CONFIG_FILE)
+  );
+}

package/src/components/ReviewUI.js

@@ -180,7 +180,7 @@ export function renderFetchingDiff(startTime) {
 }
 
 export function renderReviewing(currentMessage, startTime, meta) {
-  const step = currentMessage?.toLowerCase().includes('reflector') ? 3 : 2;
+  const step = currentMessage?.toLowerCase().includes('rejector') ? 3 : 2;
   return React.createElement(ReviewLoading, {
     message: currentMessage || 'Analyzing code...',
     step,

package/src/index.js

@@ -7,6 +7,9 @@ import { createRequire } from 'module';
 import Secrets from './commands/secrets.js';
 import SetBaseUrl from './commands/setBaseUrl.js';
 import GetBaseUrl from './commands/getBaseUrl.js';
+import SetDashboardUrl from './commands/setDashboardUrl.js';
+import GetDashboardUrl from './commands/getDashboardUrl.js';
+import RemoveDashboardUrl from './commands/removeDashboardUrl.js';
 import SetApiKey from './commands/setApiKey.js';
 import GetApiKey from './commands/getApiKey.js';
 import Login from './commands/login.js';
@@ -188,6 +191,27 @@ program
       render(React.createElement(GetBaseUrl));
     });
 
+  program
+    .command('set-dashboard-url <url>')
+    .description('Set the web app dashboard URL used for login')
+    .action((url) => {
+      render(React.createElement(SetDashboardUrl, { url }));
+    });
+
+  program
+    .command('get-dashboard-url')
+    .description('Show the current dashboard URL override')
+    .action(() => {
+      render(React.createElement(GetDashboardUrl));
+    });
+
+  program
+    .command('remove-dashboard-url')
+    .description('Remove the dashboard URL override')
+    .action(() => {
+      render(React.createElement(RemoveDashboardUrl));
+    });
+
   program
     .command('set-codeant-api-key <key>')
     .description('Set the CodeAnt API key')

package/src/reviewHeadless.js

@@ -7,12 +7,13 @@ import { track } from './utils/analytics.js';
 const MAX_TURNS = 5;
 
 /**
- * Run a single agent turn loop (per-file or reflector).
+ * Run a single agent turn loop (planner, generator, or rejector).
  */
-async function runTurnLoop(initialPayload, gitRoot, isReflectorLoop) {
+async function runTurnLoop(initialPayload, gitRoot, isRejectorLoop) {
   let nextPayload = initialPayload;
   let finalMessage = null;
   let finalOutput = null;
+  let rejectorInput = null;
 
   for (let turn = 0; turn < MAX_TURNS; turn += 1) {
     const resp = await fetchApi('/extension/pr-review/agent/turn', 'POST', nextPayload);
@@ -31,10 +32,11 @@ async function runTurnLoop(initialPayload, gitRoot, isReflectorLoop) {
 
     finalMessage = assistantMsg;
     if (resp.output) finalOutput = resp.output;
+    if (resp.rejector_input) rejectorInput = resp.rejector_input;
 
     if (done) {
-      if (isReflectorLoop && resp.parsing_error) {
-        console.error('Warning: parsing error in reflector response');
+      if (isRejectorLoop && resp.parsing_error) {
+        console.error('Warning: parsing error in rejector response');
       }
       break;
     }
@@ -52,7 +54,7 @@ async function runTurnLoop(initialPayload, gitRoot, isReflectorLoop) {
     nextPayload = { session_id: sessionId, tool_results: toolResults };
   }
 
-  return { finalMessage, finalOutput };
+  return { finalMessage, finalOutput, rejectorInput };
 }
 
 /**
@@ -126,29 +128,38 @@ export async function runReviewHeadless(options = {}) {
     const perFileRequests = ReviewApiHelper.splitIntoPerFileRequests(requestBody);
 
     const totalFiles = perFileRequests.reduce((n, r) => n + (r._filenames?.length || 0), 0);
+    let riskHypotheses = '';
+    try {
+      onProgress(`Planning risks across ${totalFiles} file${totalFiles !== 1 ? 's' : ''}...`);
+      const plannerResult = await runTurnLoop(
+        {
+          diff_content: requestBody.diff_content,
+          prompt_template_name: 'risk_planner',
+        },
+        gitRoot,
+        false
+      );
+      riskHypotheses = plannerResult.finalOutput?.risk_hypotheses || '';
+    } catch (err) {
+      console.error(`[warning] Risk planner failed; continuing without hypotheses: ${err.message}`);
+    }
     onProgress(`Analyzing ${totalFiles} file${totalFiles !== 1 ? 's' : ''}...`);
 
     // ── Per-batch agent turn loops (parallel, fault-tolerant) ────────────
-    // Each batch covers up to 5 files; backend reviews the multi-file diff
-    // in a single session (matches pragent's FileBatcher).
+    // Each review session covers a batch of up to five files.
     const perFileResults = await Promise.all(
       perFileRequests.map(async (fileReq) => {
         const filenames = fileReq._filenames || [];
-        delete fileReq._filenames;
+        const payload = {
+          ...fileReq,
+          extra_variables: { risk_hypotheses: riskHypotheses },
+        };
+        delete payload._filenames;
         const label = filenames.join(', ');
 
-        // Single-file batch: still pass file_content/file_path so backend can
-        // build head_file_str. Multi-file batches drop these (head_file_str
-        // becomes empty; agent gathers context via tools instead).
-        if (filenames.length === 1 && fileReq.file_contents?.[filenames[0]]) {
-          fileReq.file_content = fileReq.file_contents[filenames[0]];
-          fileReq.file_path = filenames[0];
-        }
-        delete fileReq.file_contents;
-
         try {
           onProgress(`Reviewing ${label}...`);
-          const result = await runTurnLoop(fileReq, gitRoot, false);
+          const result = await runTurnLoop(payload, gitRoot, false);
           onProgress(`Done reviewing ${label}`);
           return result;
         } catch (err) {
@@ -161,65 +172,59 @@ export async function runReviewHeadless(options = {}) {
     // Pair each file's suggestions with its own diff — skip files with no real suggestions
     const perFileWithSuggestions = perFileRequests.map((fileReq, i) => ({
       diff_content: fileReq.diff_content,
-      suggestions: perFileResults[i].finalMessage?.content,
-      output: perFileResults[i].finalOutput,
-    })).filter(r => r.output?.code_suggestions?.length > 0);
+      file_contents: fileReq.file_contents,
+      generator_output: perFileResults[i].finalOutput,
+      rejector_input: perFileResults[i].rejectorInput,
+    })).filter(r => r.generator_output?.code_suggestions?.length > 0);
 
     const filesWithSuggestions = new Set(
       perFileWithSuggestions.flatMap(r =>
-        (r.output?.code_suggestions || []).map(s => (s.relevant_file || '').trim()).filter(Boolean)
+        (r.generator_output?.code_suggestions || []).map(s => (s.relevant_file || '').trim()).filter(Boolean)
       )
     ).size;
-    onProgress(`${filesWithSuggestions} file${filesWithSuggestions !== 1 ? 's' : ''} have suggestions, running reflector...`);
+    onProgress(`${filesWithSuggestions} file${filesWithSuggestions !== 1 ? 's' : ''} have suggestions, running rejector...`);
 
-    // ── Per-file reflector loops (parallel, fault-tolerant) ──────────────
-    const reflectorResults = await Promise.all(
-      perFileWithSuggestions.map(async ({ diff_content, suggestions }, i) => {
+    // ── Per-batch rejector loops (parallel, fault-tolerant) ──────────────
+    const rejectorResults = await Promise.all(
+      perFileWithSuggestions.map(async ({ diff_content, file_contents, rejector_input }, i) => {
         try {
           return await runTurnLoop(
             {
               diff_content,
-              prompt_template_name: 'reflector',
-              extra_variables: { suggestion_str: suggestions },
+              file_contents,
+              prompt_template_name: 'rejector',
+              extra_variables: rejector_input,
             },
             gitRoot,
             true
           );
         } catch (err) {
-          console.error(`[error] Reflector failed for file ${i}: ${err.message}`);
+          console.error(`[error] Rejector failed for batch ${i}: ${err.message}`);
           return { finalMessage: null, finalOutput: null };
         }
       })
     );
 
-    // ── Parse results, carrying generator labels through reflector ──────
-    // Pragent's rejector schema drops `label`; preserve it by matching the
-    // reflector's per-issue (file, start_line) back to the generator's output.
-    const issues = reflectorResults.flatMap((r, i) => {
-      const genSuggestions = perFileWithSuggestions[i]?.output?.code_suggestions || [];
-      const norm = (v) => (typeof v === 'string' ? v.trim() : v);
-      const labelFor = (issue) => {
-        if (norm(issue.label)) return norm(issue.label);
-        // Match by summary (pragent's primary strategy): rejector's
-        // suggestion_summary (renamed to issue_content server-side) is
-        // "Repeated from the input" — i.e. the generator's one_sentence_summary.
-        const summary = norm(issue.issue_content);
-        if (summary) {
-          const exact = genSuggestions.find(g => norm(g.one_sentence_summary) === summary);
-          if (norm(exact?.label)) return norm(exact.label);
+    const finalizedResults = await Promise.all(
+      rejectorResults.map((result, i) => fetchApi(
+        '/extension/pr-review/agent/finalize',
+        'POST',
+        {
+          diff_content: perFileWithSuggestions[i].diff_content,
+          generator_output: perFileWithSuggestions[i].generator_output,
+          rejector_output: result.finalOutput || { code_suggestions: [] },
         }
-        // Fallback: first generator suggestion in the same file with a label.
-        const file = norm(issue.relevant_file);
-        const sameFile = genSuggestions.find(g => norm(g.relevant_file) === file && norm(g.label));
-        return norm(sameFile?.label) || 'Code Quality';
-      };
-      return (r.finalOutput?.code_suggestions || []).map((issue) => ({
-        issue_content: issue.issue_content || '',
+      ))
+    );
+
+    const issues = finalizedResults.flatMap(r =>
+      (r.output?.code_suggestions || []).map(issue => ({
+        issue_content: issue.suggestion_content || issue.one_sentence_summary || '',
         relevant_file: issue.relevant_file || 'Unknown',
-        start_line: issue.start_line || 0,
-        label: labelFor(issue),
-      }));
-    });
+        start_line: issue.relevant_lines_start || 0,
+        label: issue.label || 'Code Quality',
+      }))
+    );
 
     const labelCounts = {};
     for (const i of issues) { labelCounts[i.label] = (labelCounts[i.label] || 0) + 1; }

package/src/utils/baseUrl.js

@@ -2,6 +2,11 @@ import { getConfigValue } from './config.js';
 
 //
 const NEW_BASE_URL = 'https://service.codeant.ai';
+const DEFAULT_BASE_URLS = new Set([
+  'https://service.codeant.ai',
+  'https://api.codeant.ai',
+  'https://dev-api.codeant.ai',
+]);
 
 const getBaseUrl = () => {
   const url = process.env.CODEANT_API_URL || getConfigValue('baseUrl') || NEW_BASE_URL;
@@ -9,15 +14,34 @@ const getBaseUrl = () => {
   return url;
 };
 
+const isDefaultBaseUrl = () => {
+  const configuredUrl = process.env.CODEANT_API_URL || getConfigValue('baseUrl');
+  return !configuredUrl || DEFAULT_BASE_URLS.has(configuredUrl);
+};
+
 const getDashboardUrl = async () => {
+  const override = process.env.CODEANT_DASHBOARD_URL || getConfigValue('dashboardUrl');
+  if (override) return override;
+
+  const usingDefaultBaseUrl = isDefaultBaseUrl();
+
   try {
     const response = await fetch(`${getBaseUrl()}/extension/get/dashboard`);
-    // console.log('Fetching dashboard URL from:', `${getBaseUrl()}/extension/get/dashboard`);
     const data = await response.json();
-    return data.dashboard_url || 'https://app.codeant.ai';
+    // On a custom base URL, never silently trust an auto-detected app.codeant.ai —
+    // that's the SaaS dashboard, and a self-hosted instance's OAuth apps won't
+    // recognize it as a valid redirect target. Require an explicit override instead.
+    if (data.dashboard_url && (usingDefaultBaseUrl || data.dashboard_url !== 'https://app.codeant.ai')) {
+      return data.dashboard_url;
+    }
   } catch {
-    return 'https://app.codeant.ai';
+    // fall through to the error below
   }
+
+  throw new Error(
+    `Could not determine the dashboard URL for base URL "${getBaseUrl()}". ` +
+    `Set it explicitly with: codeant set-dashboard-url <your web app URL>`
+  );
 };
 
 export { getBaseUrl, getDashboardUrl };

package/src/utils/reviewApiHelper.js

@@ -266,8 +266,8 @@ class ReviewApiHelper extends CommonApiHelper {
 
   /**
    * Split a combined review request into batched payloads.
-   * Files are grouped in chunks of up to FILES_PER_BATCH so each backend
-   * session reviews multiple files at once (matches pragent's batching).
+   * Files are grouped in chunks of up to FILES_PER_BATCH so each review
+   * session can process multiple files together.
    */
   static splitIntoPerFileRequests(requestBody, batchSize = 5) {
     if (!requestBody?.diff_content?.length) return [];
@@ -280,6 +280,7 @@ class ReviewApiHelper extends CommonApiHelper {
       if (!nameMatch) continue;
       perFile.push({ section, filename: nameMatch[1] });
     }
+    perFile.sort((a, b) => (a.filename < b.filename ? -1 : a.filename > b.filename ? 1 : 0));
 
     const batches = [];
     for (let i = 0; i < perFile.length; i += batchSize) {