codeant-cli 0.2.3 → 0.2.5

package/package.json

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

package/src/commands/secrets.js

@@ -1,34 +1,42 @@
-import React, { useState, useEffect } from 'react';
-import { Text, Box, useApp } from 'ink';
+import { useState, useEffect } from 'react';
+import { useApp } from 'ink';
 import { getConfigValue } from '../utils/config.js';
 import { fetchApi } from '../utils/fetchApi.js';
 import SecretsApiHelper from '../utils/secretsApiHelper.js';
-
-export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH', include = [], exclude = [], lastNCommits = 1 }) {
+import {
+  renderInitializing,
+  renderFetchingDiff,
+  renderScanning,
+  renderNoFiles,
+  renderError,
+  renderNotLoggedIn,
+  renderDone,
+} from '../components/SecretsUI.js';
+
+export default function Secrets({ scanType = 'all', failOn = 'CRITICAL', include = [], exclude = [], lastNCommits = 1, baseBranch = null, baseCommit = null }) {
   const { exit } = useApp();
   const [status, setStatus] = useState('initializing');
   const [secrets, setSecrets] = useState([]);
   const [error, setError] = useState(null);
   const [fileCount, setFileCount] = useState(0);
+  const [scanMeta, setScanMeta] = useState(null);
+  const [startTime] = useState(() => Date.now());
 
   const apiKey = getConfigValue('apiKey');
 
   // Handle not logged in state
   useEffect(() => {
     if (!apiKey) {
+      if (process.stdin.isTTY) {
+        return;
+      }
       const id = setTimeout(() => exit(new Error('Not logged in')), 0);
       return () => clearTimeout(id);
     }
   }, [apiKey, exit]);
 
-  // Check if logged in
   if (!apiKey) {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'red' }, '✗ Not logged in.'),
-      React.createElement(Text, { color: 'gray' }, 'Run "codeant login" to authenticate.')
-    );
+    return renderNotLoggedIn();
   }
 
   // Helper to check if a secret should cause failure based on failOn level
@@ -46,21 +54,30 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH', inc
     async function scanSecrets() {
       try {
         if (cancelled) return;
-        setStatus('scanning');
+        setStatus('fetching_diff');
 
-        // Initialize git helper and get staged files
+        // Initialize git helper and get files
         const helper = new SecretsApiHelper(process.cwd());
         await helper.init();
 
         if (cancelled) return;
-        const requestBody = await helper.buildSecretsApiRequest(scanType, include, exclude, { lastNCommits });
+        const requestBody = await helper.buildSecretsApiRequest(scanType, include, exclude, { lastNCommits, baseBranch, baseCommit });
         if (cancelled) return;
 
+        const meta = requestBody._meta || null;
+        setScanMeta(meta);
+
+        // Strip _meta before sending to API
+        delete requestBody._meta;
+
         if (requestBody.files.length === 0) {
           if (!cancelled) setStatus('no_files');
           return;
         }
 
+        setFileCount(requestBody.files.length);
+        setStatus('scanning');
+
         // Call the secrets detection API
         const response = await fetchApi(
           '/extension/pr-review/secrets-detection',
@@ -93,7 +110,7 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH', inc
     return () => {
       cancelled = true;
     };
-  }, [scanType, include, exclude, lastNCommits]);
+  }, [scanType, include, exclude, lastNCommits, baseBranch, baseCommit]);
 
   // Handle exit after status changes
   useEffect(() => {
@@ -118,151 +135,14 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH', inc
     }
   }, [status, secrets]);
 
-  // Render: Initializing
-  if (status === 'initializing') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'cyan' }, 'Initializing...')
-    );
-  }
-
-  // Render: Scanning
-  if (status === 'scanning') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'cyan' }, `Scanning ${fileCount} file(s) for secrets...`)
-    );
-  }
-
-  // Render: No files to scan
-  if (status === 'no_files') {
-    const noFilesMessages = {
-      'staged-only': 'Stage some changes first with "git add".',
-      'branch-diff': 'No changes found compared to the base branch.',
-      'uncommitted': 'No uncommitted changes found.',
-      'last-commit': 'No files found in the last commit.'
-    };
-
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'yellow' }, 'No files to scan.'),
-      React.createElement(Text, { color: 'gray' }, noFilesMessages[scanType] || 'No files found.')
-    );
-  }
-
-  // Render: Error
-  if (status === 'error') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'red' }, '✗ Error: ', error)
-    );
-  }
-
-  // Render: Done with secrets found
-  if (status === 'done' && secrets.length > 0) {
-    const allSecrets = secrets.flatMap(file =>
-      file.secrets.map(s => ({ ...s, file_path: file.file_path }))
-    );
-
-    const blockingSecrets = allSecrets.filter(s => shouldFailOn(s.confidence_score));
-    const falsePositives = allSecrets.filter(s => !shouldFailOn(s.confidence_score));
-
-    const hasBlockingSecrets = blockingSecrets.length > 0;
+  // ── Renders ──────────────────────────────────────────────────────────────
 
-    // Group by file for display
-    const groupByFile = (secretsList) => {
-      const grouped = {};
-      secretsList.forEach(s => {
-        if (!grouped[s.file_path]) grouped[s.file_path] = [];
-        grouped[s.file_path].push(s);
-      });
-      return grouped;
-    };
-
-    const blockingByFile = groupByFile(blockingSecrets);
-    const falsePositivesByFile = groupByFile(falsePositives);
-
-    const elements = [
-      // Header
-      React.createElement(
-        Text,
-        { key: 'header', color: hasBlockingSecrets ? 'red' : 'yellow', bold: true },
-        hasBlockingSecrets
-          ? `✗ ${blockingSecrets.length} secret(s) found!`
-          : `⚠ ${falsePositives.length} potential secret(s) found (ignored)`
-      ),
-      React.createElement(Text, { key: 'spacer1' }, '')
-    ];
-
-    // Blocking secrets
-    if (blockingSecrets.length > 0) {
-      Object.entries(blockingByFile).forEach(([filePath, fileSecrets]) => {
-        elements.push(
-          React.createElement(Text, { key: `file-${filePath}`, color: 'yellow', bold: true }, filePath)
-        );
-        fileSecrets.forEach((secret, idx) => {
-          elements.push(
-            React.createElement(
-              Text,
-              { key: `secret-${filePath}-${idx}`, color: 'red' },
-              `  Line ${secret.line_number}: ${secret.type} (${secret.confidence_score})`
-            )
-          );
-        });
-      });
-    }
-
-    // False positives / ignored
-    if (falsePositives.length > 0) {
-      if (blockingSecrets.length > 0) {
-        elements.push(React.createElement(Text, { key: 'spacer2' }, ''));
-      }
-      elements.push(
-        React.createElement(Text, { key: 'fp-header', color: 'gray' }, 'Ignored (false positives):')
-      );
-      Object.entries(falsePositivesByFile).forEach(([filePath, fileSecrets]) => {
-        elements.push(
-          React.createElement(Text, { key: `fp-file-${filePath}`, color: 'gray' }, `  ${filePath}`)
-        );
-        fileSecrets.forEach((secret, idx) => {
-          elements.push(
-            React.createElement(
-              Text,
-              { key: `fp-secret-${filePath}-${idx}`, color: 'gray', dimColor: true },
-              `    Line ${secret.line_number}: ${secret.type} (${secret.confidence_score})`
-            )
-          );
-        });
-      });
-    }
-
-    elements.push(React.createElement(Text, { key: 'spacer3' }, ''));
-
-    if (hasBlockingSecrets) {
-      elements.push(
-        React.createElement(Text, { key: 'footer', color: 'gray' }, 'Remove secrets before committing.')
-      );
-    } else {
-      elements.push(
-        React.createElement(Text, { key: 'footer', color: 'green' }, '✓ Commit allowed (only false positives found)')
-      );
-    }
-
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      ...elements
-    );
-  }
+  if (status === 'initializing') return renderInitializing(startTime);
+  if (status === 'fetching_diff') return renderFetchingDiff(startTime);
+  if (status === 'scanning') return renderScanning(startTime, fileCount, scanMeta);
+  if (status === 'no_files') return renderNoFiles(scanType, lastNCommits, baseBranch, baseCommit);
+  if (status === 'error') return renderError(error);
+  if (status === 'done') return renderDone(secrets, failOn, shouldFailOn, startTime, fileCount, scanMeta);
 
-  // Render: Done with no secrets
-  return React.createElement(
-    Box,
-    { flexDirection: 'column', padding: 1 },
-    React.createElement(Text, { color: 'green' }, '✓ No secrets found')
-  );
+  return null;
 }

package/src/components/SecretsUI.js

@@ -0,0 +1,366 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const DIVIDER = '─'.repeat(55);
+const STEPS = ['Init', 'Fetch', 'Scan'];
+
+const CONFIDENCE_COLORS = {
+  HIGH: 'red',
+  MEDIUM: 'yellow',
+  LOW: 'cyan',
+  FALSE_POSITIVE: 'gray',
+};
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function getConfidenceColor(score) {
+  return CONFIDENCE_COLORS[score?.toUpperCase()] || 'gray';
+}
+
+function padEnd(str, len) {
+  return str + ' '.repeat(Math.max(0, len - str.length));
+}
+
+function formatElapsed(startTime) {
+  return ((Date.now() - startTime) / 1000).toFixed(1) + 's';
+}
+
+// ── Animated Components ──────────────────────────────────────────────────────
+
+function Spinner({ color = 'cyan' }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame(f => (f + 1) % SPINNER_FRAMES.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  return React.createElement(Text, { color }, SPINNER_FRAMES[frame]);
+}
+
+function ElapsedTime({ startTime }) {
+  const [, setTick] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => setTick(t => t + 1), 100);
+    return () => clearInterval(timer);
+  }, []);
+  return React.createElement(Text, { color: 'gray' }, formatElapsed(startTime));
+}
+
+function StepProgress({ currentStep }) {
+  const items = STEPS.map((step, i) => {
+    if (i < currentStep) {
+      return React.createElement(Text, { key: step, color: 'green' }, `✓ ${step}`);
+    } else if (i === currentStep) {
+      return React.createElement(
+        Box, { key: step },
+        React.createElement(Spinner, { color: 'cyan' }),
+        React.createElement(Text, { color: 'cyan' }, ` ${step}`),
+      );
+    } else {
+      return React.createElement(Text, { key: step, color: 'gray', dimColor: true }, `· ${step}`);
+    }
+  });
+  return React.createElement(Box, { gap: 2 }, ...items);
+}
+
+// ── Loading Screen ───────────────────────────────────────────────────────────
+
+function SecretsLoading({ message, step, startTime, fileCount, meta }) {
+  const els = [
+    React.createElement(
+      Box, { key: 'status', gap: 1 },
+      React.createElement(Spinner, {}),
+      React.createElement(Text, { color: 'white', bold: true }, message),
+      startTime != null && React.createElement(ElapsedTime, { startTime }),
+    ),
+    React.createElement(
+      Box, { key: 'steps', marginTop: 1 },
+      React.createElement(StepProgress, { currentStep: step }),
+    ),
+  ];
+
+  // Show file list and coverage info when we have metadata (during scan step)
+  if (meta && step >= 2) {
+    const scanned = meta.scanned_files || [];
+    const total = meta.total_changed || 0;
+    const skipped = meta.skipped || [];
+
+    els.push(React.createElement(Text, { key: 'meta-sp' }, ''));
+    els.push(React.createElement(
+      Text, { key: 'meta-hdr', color: 'gray', dimColor: true }, DIVIDER,
+    ));
+
+    // Coverage line
+    if (total > 0) {
+      const coverageColor = scanned.length === total ? 'green' : 'yellow';
+      els.push(React.createElement(
+        Text, { key: 'coverage', color: coverageColor },
+        `Scanning ${scanned.length} of ${total} changed file${total !== 1 ? 's' : ''}`,
+      ));
+    }
+
+    // File list
+    if (scanned.length > 0) {
+      els.push(React.createElement(Text, { key: 'files-sp' }, ''));
+      scanned.forEach((file, i) => {
+        const isLast = i === scanned.length - 1;
+        const branch = isLast ? '└─' : '├─';
+        els.push(React.createElement(
+          Text, { key: `file-${i}`, color: 'white' },
+          `  ${branch} ${file}`,
+        ));
+      });
+    }
+
+    // Skipped summary
+    if (skipped.length > 0) {
+      els.push(React.createElement(Text, { key: 'skip-sp' }, ''));
+      const reasons = {};
+      skipped.forEach(s => {
+        const r = s.reason.split(' (')[0];
+        reasons[r] = (reasons[r] || 0) + 1;
+      });
+      const parts = Object.entries(reasons).map(([r, n]) => `${n} ${r}`);
+      els.push(React.createElement(
+        Text, { key: 'skipped', color: 'gray', dimColor: true },
+        `Skipped: ${parts.join(' · ')}`,
+      ));
+    }
+  }
+
+  return React.createElement(
+    Box, { flexDirection: 'column', paddingX: 1, paddingY: 1 }, ...els,
+  );
+}
+
+// ── Public Render Functions ──────────────────────────────────────────────────
+
+export function renderInitializing(startTime) {
+  return React.createElement(SecretsLoading, {
+    message: 'Initializing...',
+    step: 0,
+    startTime,
+  });
+}
+
+export function renderFetchingDiff(startTime) {
+  return React.createElement(SecretsLoading, {
+    message: 'Fetching changes...',
+    step: 1,
+    startTime,
+  });
+}
+
+export function renderScanning(startTime, fileCount, meta) {
+  return React.createElement(SecretsLoading, {
+    message: 'Scanning for secrets...',
+    step: 2,
+    startTime,
+    fileCount,
+    meta,
+  });
+}
+
+export function renderNoFiles(scanType, lastNCommits, baseBranch, baseCommit) {
+  const hints = {
+    'staged-only': 'Stage some changes first with "git add".',
+    'branch-diff': 'No changes found compared to the base branch.',
+    'uncommitted': 'No uncommitted changes found.',
+    'committed': 'No unpushed commits found.',
+    'all': 'No changes found between your branch and the base.',
+    'last-commit': 'No files found in the last commit.',
+    'last-n-commits': `No changes found in the last ${lastNCommits} commit(s).`,
+    'base-branch': `No changes found compared to ${baseBranch}.`,
+    'base-commit': `No changes found compared to commit ${baseCommit}.`,
+  };
+  return React.createElement(
+    Box, { flexDirection: 'column', paddingX: 1, paddingY: 1 },
+    React.createElement(Text, { color: 'cyan', bold: true }, 'CodeAnt Secrets'),
+    React.createElement(Text, { color: 'gray', dimColor: true }, DIVIDER),
+    React.createElement(Text, {}, ''),
+    React.createElement(Text, { color: 'yellow' }, '  No changes to scan.'),
+    React.createElement(Text, { color: 'gray' }, `  ${hints[scanType] || 'No files found.'}`),
+    React.createElement(Text, {}, ''),
+  );
+}
+
+export function renderError(error) {
+  return React.createElement(
+    Box, { flexDirection: 'column', paddingX: 1, paddingY: 1 },
+    React.createElement(Text, { color: 'cyan', bold: true }, 'CodeAnt Secrets'),
+    React.createElement(Text, { color: 'gray', dimColor: true }, DIVIDER),
+    React.createElement(Text, {}, ''),
+    React.createElement(Text, { color: 'red', bold: true }, `  ✗ ${error}`),
+    React.createElement(Text, {}, ''),
+  );
+}
+
+export function renderNotLoggedIn() {
+  return React.createElement(
+    Box, { flexDirection: 'column', paddingX: 1, paddingY: 1 },
+    React.createElement(Text, { color: 'cyan', bold: true }, 'CodeAnt Secrets'),
+    React.createElement(Text, { color: 'gray', dimColor: true }, DIVIDER),
+    React.createElement(Text, {}, ''),
+    React.createElement(Text, { color: 'red', bold: true }, '  ✗ Not logged in'),
+    React.createElement(Text, { color: 'gray' }, '  Run "codeant login" to authenticate.'),
+    React.createElement(Text, {}, ''),
+  );
+}
+
+export function renderDone(secrets, failOn, shouldFailOn, startTime, fileCount, meta) {
+  const allSecrets = secrets.flatMap(file =>
+    file.secrets.map(s => ({ ...s, file_path: file.file_path }))
+  );
+
+  const blockingSecrets = allSecrets.filter(s => shouldFailOn(s.confidence_score));
+  const hasBlocking = blockingSecrets.length > 0;
+  const elapsed = startTime ? formatElapsed(startTime) : null;
+
+  // Count by confidence
+  const counts = {};
+  allSecrets.forEach(s => {
+    const conf = s.confidence_score?.toUpperCase() || 'UNKNOWN';
+    counts[conf] = (counts[conf] || 0) + 1;
+  });
+
+  // Group by file
+  const grouped = {};
+  allSecrets.forEach(s => {
+    const file = s.file_path || 'Unknown';
+    (grouped[file] ??= []).push(s);
+  });
+  const sortedFiles = Object.keys(grouped).sort();
+  sortedFiles.forEach(f =>
+    grouped[f].sort((a, b) => (a.line_number || 0) - (b.line_number || 0))
+  );
+
+  const els = [];
+
+  // ── Header ──
+  els.push(React.createElement(
+    Box, { key: 'hdr', gap: 1 },
+    React.createElement(Text, { color: 'cyan', bold: true }, 'CodeAnt Secrets'),
+    elapsed && React.createElement(Text, { color: 'gray' }, elapsed),
+  ));
+  els.push(React.createElement(
+    Text, { key: 'div1', color: 'gray', dimColor: true }, DIVIDER,
+  ));
+
+  if (allSecrets.length === 0) {
+    // ── Clean pass ──
+    els.push(React.createElement(Text, { key: 'sp' }, ''));
+    els.push(React.createElement(
+      Text, { key: 'ok', color: 'green', bold: true }, '  ✓ No secrets found',
+    ));
+    els.push(React.createElement(Text, { key: 'sp2' }, ''));
+  } else {
+    // ── Secrets grouped by file ──
+    els.push(React.createElement(Text, { key: 'sp1' }, ''));
+
+    sortedFiles.forEach((file, fi) => {
+      const fileSecrets = grouped[file];
+
+      els.push(React.createElement(
+        Text, { key: `f-${fi}`, color: 'white', bold: true }, `  ${file}`,
+      ));
+
+      fileSecrets.forEach((secret, si) => {
+        const conf = secret.confidence_score?.toUpperCase() || 'UNKNOWN';
+        const confColor = getConfidenceColor(conf);
+        const isBlocking = shouldFailOn(secret.confidence_score);
+        const isLast = si === fileSecrets.length - 1;
+        const branch = isLast ? '└─' : '├─';
+        const lineStr = secret.line_number ? `L${secret.line_number}` : '';
+
+        els.push(React.createElement(
+          Box, { key: `s-${fi}-${si}` },
+          React.createElement(Text, { color: 'gray' }, `    ${branch} `),
+          React.createElement(Text, {
+            color: confColor,
+            bold: isBlocking,
+          }, padEnd(conf, 16)),
+          React.createElement(Text, { color: 'gray' }, padEnd(lineStr, 6)),
+          React.createElement(Text, { color: isBlocking ? 'white' : 'gray', dimColor: !isBlocking }, secret.type || ''),
+        ));
+      });
+
+      els.push(React.createElement(Text, { key: `g-${fi}` }, ''));
+    });
+  }
+
+  // ── Footer ──
+  els.push(React.createElement(
+    Text, { key: 'div2', color: 'gray', dimColor: true }, DIVIDER,
+  ));
+
+  // Coverage line
+  const totalChanged = meta?.total_changed || 0;
+  const scannedCount = meta?.scanned_files?.length || fileCount;
+  if (totalChanged > 0) {
+    const coverageColor = scannedCount === totalChanged ? 'green' : 'yellow';
+    els.push(React.createElement(
+      Text, { key: 'coverage', color: coverageColor },
+      `Scanned ${scannedCount} of ${totalChanged} changed file${totalChanged !== 1 ? 's' : ''}`,
+    ));
+  } else if (fileCount) {
+    els.push(React.createElement(
+      Text, { key: 'coverage', color: 'gray' },
+      `${fileCount} file${fileCount !== 1 ? 's' : ''} scanned`,
+    ));
+  }
+
+  // Skipped files summary
+  const skipped = meta?.skipped || [];
+  if (skipped.length > 0) {
+    const reasons = {};
+    skipped.forEach(s => {
+      const r = s.reason.split(' (')[0];
+      reasons[r] = (reasons[r] || 0) + 1;
+    });
+    const parts = Object.entries(reasons).map(([r, n]) => `${n} ${r}`);
+    els.push(React.createElement(
+      Text, { key: 'skipped', color: 'gray', dimColor: true },
+      `Skipped: ${parts.join(' · ')}`,
+    ));
+  }
+
+  // Secret stats line
+  if (allSecrets.length > 0) {
+    const stats = [`${allSecrets.length} secret${allSecrets.length !== 1 ? 's' : ''} found`];
+    for (const conf of ['HIGH', 'MEDIUM', 'LOW', 'FALSE_POSITIVE']) {
+      if (counts[conf]) {
+        const label = conf === 'FALSE_POSITIVE' ? 'false positive' : conf.toLowerCase();
+        stats.push(`${counts[conf]} ${label}`);
+      }
+    }
+    els.push(React.createElement(
+      Text, { key: 'stats', color: 'gray' }, stats.join('  ·  '),
+    ));
+  }
+
+  // Status line
+  if (hasBlocking) {
+    els.push(React.createElement(
+      Text, { key: 'status', color: 'red', bold: true },
+      `✗ ${blockingSecrets.length} blocking secret${blockingSecrets.length !== 1 ? 's' : ''} — remove before committing`,
+    ));
+  } else if (allSecrets.length > 0) {
+    els.push(React.createElement(
+      Text, { key: 'status', color: 'green', bold: true },
+      '✓ No blocking secrets found',
+    ));
+  } else {
+    els.push(React.createElement(
+      Text, { key: 'status', color: 'green', bold: true },
+      '✓ All clear',
+    ));
+  }
+
+  return React.createElement(
+    Box, { flexDirection: 'column', paddingX: 1, paddingY: 1 }, ...els,
+  );
+}