codereview-aia 0.1.2 → 0.1.4

package/src/runtime/ui/screens/AuthScreen.tsx

@@ -1,128 +0,0 @@
-import React, { useCallback, useEffect, useState } from 'react';
-import type { SessionUser } from '../../auth/types';
-import { authenticate } from '../../auth/service';
-import { saveSession } from '../../auth/session';
-import { useLayout } from '../Layout';
-import { getInk, getInkSpinner, getInkTextInput } from '../inkModules';
-
-interface AuthScreenProps {
-  onAuth: (user: SessionUser) => void;
-}
-
-export function AuthScreen({ onAuth }: AuthScreenProps) {
-  const { frameWidth } = useLayout();
-  const { Box, Text, useInput } = getInk();
-  const Spinner = getInkSpinner();
-  const TextInput = getInkTextInput();
-  const [username, setUsername] = useState('');
-  const [password, setPassword] = useState('');
-  const [error, setError] = useState<string | null>(null);
-  const [submitting, setSubmitting] = useState(false);
-  const [step, setStep] = useState<'username' | 'password'>('username');
-
-  const handleSubmit = useCallback(async () => {
-    if (submitting) return;
-
-    if (!username.trim() || !password.trim()) {
-      setError('Username and password are required');
-      return;
-    }
-
-    try {
-      setSubmitting(true);
-      setError(null);
-      const result = await authenticate(username.trim(), password.trim());
-      saveSession(result.token);
-      process.env.CR_AIA_PROXY_SESSION_TOKEN = result.token;
-      onAuth(result.user);
-    } catch (authError) {
-      const message = authError instanceof Error ? authError.message : 'Authentication failed';
-      setError(message);
-      setSubmitting(false);
-    }
-  }, [username, password, submitting, onAuth]);
-
-  const handleAdvance = useCallback(() => {
-    if (step === 'password') {
-      return;
-    }
-    if (!username.trim()) {
-      setError('Username is required');
-      return;
-    }
-    setError(null);
-    setStep('password');
-  }, [step, username]);
-
-  useInput((input, key) => {
-    if (key.return) {
-      if (step === 'username') {
-        handleAdvance();
-      } else {
-        handleSubmit();
-      }
-    }
-  });
-
-  useEffect(() => {
-    setError(null);
-  }, [username, password]);
-
-  return (
-    <Box
-      width={frameWidth}
-      flexDirection="column"
-      borderStyle="round"
-      borderColor="cyan"
-      paddingX={2}
-      paddingY={1}
-      gap={1}
-    >
-      <Text color="cyan" bold>
-        Sign in
-      </Text>
-      <Text dimColor>
-        {step === 'username' ? 'Type your username, press Enter.' : 'Type your password, press Enter to submit.'}
-      </Text>
-
-      <Box flexDirection="column" gap={1}>
-        <Box flexDirection="column">
-          <Text dimColor>Username</Text>
-          <TextInput
-            value={username}
-            onChange={setUsername}
-            placeholder="username"
-            focus={step === 'username' && !submitting}
-          />
-        </Box>
-
-        <Box flexDirection="column">
-          <Text dimColor>Password</Text>
-          <TextInput
-            value={password}
-            onChange={setPassword}
-            mask="*"
-            placeholder={step === 'password' ? 'password' : 'Press Enter after username'}
-            focus={step === 'password' && !submitting}
-            showCursor={step === 'password'}
-          />
-        </Box>
-      </Box>
-
-      {submitting && (
-        <Box>
-          <Text>
-            <Spinner type="dots" /> Authenticating…
-          </Text>
-        </Box>
-      )}
-
-      {error && (
-        <Box>
-          <Text color="red">{error}</Text>
-        </Box>
-      )}
-    </Box>
-  );
-}
-

package/src/runtime/ui/screens/ModeSelection.tsx

@@ -1,185 +0,0 @@
-import React, { useCallback, useState } from 'react';
-import { getInk, getInkSelectInput, getInkTextInput } from '../inkModules';
-import { useLayout } from '../Layout';
-import type { ReviewMode } from '../../reviewPipeline';
-
-interface ModeSelectionProps {
-  onSelect: (mode: ReviewMode, extras?: { targetUrl?: string }) => void;
-  debugEnabled: boolean;
-  onToggleDebug: () => void;
-}
-
-interface ModeOption {
-  label: string;
-  value: ReviewMode;
-  description: string;
-  requiresUrl?: boolean;
-}
-
-const OPTIONS: ModeOption[] = [
-  {
-    label: 'Review uncommitted changes',
-    value: 'uncommitted',
-    description: 'Scan staged and unstaged changes only',
-  },
-  {
-    label: 'Pre-production review',
-    value: 'preprod',
-    description: 'Scan the entire workspace and trigger website checks',
-    requiresUrl: true,
-  },
-];
-
-export function ModeSelection({ onSelect, debugEnabled, onToggleDebug }: ModeSelectionProps) {
-  const { Box, Text, useInput } = getInk();
-  const SelectInput = getInkSelectInput();
-  const TextInput = getInkTextInput();
-  const { frameWidth } = useLayout();
-  const [phase, setPhase] = useState<'list' | 'preprodUrl'>('list');
-  const [pendingMode, setPendingMode] = useState<ReviewMode>('preprod');
-  const [highlighted, setHighlighted] = useState<ReviewMode>('uncommitted');
-  const [urlValue, setUrlValue] = useState('');
-  const [urlError, setUrlError] = useState<string | null>(null);
-
-  const resetUrlState = useCallback(() => {
-    setUrlValue('');
-    setUrlError(null);
-  }, []);
-
-  const handleModeSelect = useCallback(
-    (mode: ReviewMode) => {
-      const option = OPTIONS.find((opt) => opt.value === mode);
-      if (!option) {
-        return;
-      }
-
-      if (option.requiresUrl) {
-        setPendingMode(option.value);
-        resetUrlState();
-        setPhase('preprodUrl');
-        return;
-      }
-
-      onSelect(option.value);
-    },
-    [onSelect, resetUrlState],
-  );
-
-  const submitUrl = useCallback(() => {
-    if (phase !== 'preprodUrl') {
-      return;
-    }
-
-    const trimmed = urlValue.trim();
-    if (!trimmed) {
-      setUrlError('URL is required');
-      return;
-    }
-
-    try {
-      const parsed = new URL(trimmed);
-      if (!['http:', 'https:'].includes(parsed.protocol)) {
-        throw new Error('invalid');
-      }
-      setUrlError(null);
-      onSelect(pendingMode, { targetUrl: parsed.toString() });
-    } catch {
-      setUrlError('Enter a valid URL starting with http:// or https://');
-    }
-  }, [onSelect, pendingMode, phase, urlValue]);
-
-  useInput((input, key) => {
-    const normalizedInput = input.toLowerCase();
-    if (normalizedInput === 'd' && !key.ctrl && !key.meta) {
-      onToggleDebug();
-      return;
-    }
-
-    if (phase !== 'preprodUrl') {
-      return;
-    }
-
-    if (key.escape) {
-      setPhase('list');
-      resetUrlState();
-      return;
-    }
-
-    if (key.return) {
-      submitUrl();
-    }
-  });
-
-  if (phase === 'preprodUrl') {
-    return (
-      <Box
-        width={frameWidth}
-        flexDirection="column"
-        borderStyle="round"
-        borderColor="cyan"
-        paddingX={2}
-        paddingY={1}
-        gap={1}
-      >
-        <Text color="cyan" bold>
-          Pre-production review
-        </Text>
-        <Text dimColor>Enter the full website URL. We will trigger ai.enki.si and scan every file here.</Text>
-        <Box flexDirection="column">
-          <Text dimColor>Target URL</Text>
-          <TextInput
-            value={urlValue}
-            onChange={(value) => {
-              setUrlValue(value);
-              if (urlError) {
-                setUrlError(null);
-              }
-            }}
-            placeholder="https://example.com"
-            focus
-          />
-        </Box>
-        {urlError && (
-          <Text color="red">{urlError}</Text>
-        )}
-        <Box justifyContent="space-between">
-          <Text dimColor>Press Enter to start · Esc to go back</Text>
-          <Text dimColor>Debug: {debugEnabled ? 'On' : 'Off'} (press D)</Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  return (
-    <Box
-      width={frameWidth}
-      flexDirection="column"
-      borderStyle="round"
-      borderColor="green"
-      paddingX={2}
-      paddingY={1}
-      gap={1}
-    >
-      <Box justifyContent="space-between" alignItems="center">
-        <Text color="green" bold>
-          Choose review mode
-        </Text>
-        <Text dimColor>Debug: {debugEnabled ? 'On' : 'Off'} (press D)</Text>
-      </Box>
-      <Text dimColor>Use arrow keys, press Enter to start.</Text>
-      <SelectInput
-        items={OPTIONS.map((option) => ({
-          label: option.label,
-          value: option.value,
-        }))}
-        onHighlight={(item) => setHighlighted(item.value as ReviewMode)}
-        onSelect={(item) => handleModeSelect(item.value as ReviewMode)}
-      />
-      <Box flexDirection="column" marginTop={1}>
-        <Text dimColor>
-          · {OPTIONS.find((option) => option.value === highlighted)?.description}
-        </Text>
-      </Box>
-    </Box>
-  );
-}

package/src/runtime/ui/screens/ProgressScreen.tsx

@@ -1,62 +0,0 @@
-import React, { useMemo } from 'react';
-import { useLayout } from '../Layout';
-import type { ReviewStage } from '../../reviewPipeline';
-import { getInk, getInkSpinner } from '../inkModules';
-
-interface ProgressScreenProps {
-  stage: ReviewStage;
-  filesFound?: number;
-}
-
-const STAGE_TEXT: Record<ReviewStage, { title: string; detail: string }> = {
-  preparing: {
-    title: 'Preparing run',
-    detail: 'Triggering website checks and configuring the reviewer',
-  },
-  collecting: {
-    title: 'Collecting files',
-    detail: 'Inspecting your working tree',
-  },
-  reviewing: {
-    title: 'Running AI review',
-    detail: 'Streaming code to the reviewer',
-  },
-  merging: {
-    title: 'Merging reports',
-    detail: 'Normalizing findings and cost data',
-  },
-};
-
-export function ProgressScreen({ stage, filesFound }: ProgressScreenProps) {
-  const { Box, Text } = getInk();
-  const Spinner = getInkSpinner();
-  const { frameWidth } = useLayout();
-
-  const meta = useMemo(() => STAGE_TEXT[stage], [stage]);
-  const fileStatus =
-    stage === 'collecting' && typeof filesFound === 'number' && filesFound >= 0
-      ? `${filesFound} files queued`
-      : stage === 'collecting'
-        ? 'Preparing file list…'
-        : '';
-
-  return (
-    <Box
-      width={frameWidth}
-      flexDirection="column"
-      borderStyle="round"
-      borderColor="cyan"
-      paddingX={2}
-      paddingY={1}
-      gap={1}
-    >
-      <Box gap={1}>
-        <Text>
-          <Spinner type="line" /> {meta.title}
-        </Text>
-      </Box>
-      <Text dimColor>{meta.detail}</Text>
-      {fileStatus && <Text dimColor>{fileStatus}</Text>}
-    </Box>
-  );
-}

package/src/runtime/ui/screens/ResultsScreen.tsx

@@ -1,83 +0,0 @@
-import React, { useMemo } from 'react';
-import type { ReviewResult } from '../../reviewPipeline';
-import { useLayout } from '../Layout';
-import { getInk } from '../inkModules';
-
-interface ResultsScreenProps {
-  result: ReviewResult;
-  debugLogPath?: string | null;
-}
-
-export function ResultsScreen({ result, debugLogPath }: ResultsScreenProps) {
-  const { Box, Text } = getInk();
-  const { frameWidth } = useLayout();
-
-  const severityRows = useMemo(() => {
-    const totals = result.totals || { critical: 0, high: 0, medium: 0, low: 0 };
-    return [
-      { label: 'Critical', value: totals.critical ?? 0 },
-      { label: 'High', value: totals.high ?? 0 },
-      { label: 'Medium', value: totals.medium ?? 0 },
-      { label: 'Low', value: totals.low ?? 0 },
-    ];
-  }, [result.totals]);
-
-  return (
-    <Box
-      width={frameWidth}
-      flexDirection="column"
-      borderStyle="round"
-      borderColor="green"
-      paddingX={2}
-      paddingY={1}
-      gap={1}
-    >
-      <Text color="green" bold>
-        Review complete for {result.repo}
-      </Text>
-      <Text dimColor>Duration: {result.duration}s — Files reviewed: {result.filesReviewed}</Text>
-
-      <Box flexDirection="column" marginTop={1}>
-        {severityRows.map((row) => (
-          <Box key={row.label}>
-            <Text>
-              {row.label}: {row.value}
-            </Text>
-          </Box>
-        ))}
-      </Box>
-
-      {result.findings.length === 0 ? (
-        <Text dimColor>No findings reported.</Text>
-      ) : (
-        <Box flexDirection="column" marginTop={1}>
-          <Text bold>Sample findings</Text>
-          {result.findings.slice(0, 5).map((finding, index) => (
-            <Text key={`${finding.filePath}-${index}`} dimColor>
-              · {finding.filePath ?? finding.file ?? 'unknown'} {finding.priority ? `(${finding.priority})` : ''}
-            </Text>
-          ))}
-          {result.findings.length > 5 && (
-            <Text dimColor>…and {result.findings.length - 5} more in the saved report.</Text>
-          )}
-        </Box>
-      )}
-
-      {result.reportPath && (
-        <Box marginTop={1}>
-          <Text dimColor>Report saved to: {result.reportPath}</Text>
-        </Box>
-      )}
-
-      {debugLogPath && (
-        <Box marginTop={1}>
-          <Text dimColor>Debug logs saved to: {debugLogPath}</Text>
-        </Box>
-      )}
-
-      <Box marginTop={1}>
-        <Text dimColor>Press Enter to return to mode selection.</Text>
-      </Box>
-    </Box>
-  );
-}

package/src/strategies/ArchitecturalReviewStrategy.ts

@@ -1,54 +0,0 @@
-/**
- * @fileoverview Architectural review strategy implementation.
- *
- * This module implements the architectural review strategy, which analyzes the entire
- * codebase structure and design patterns to provide high-level feedback.
- */
-
-import type { ApiClientConfig } from '../core/ApiClientSelector';
-import { generateReview } from '../core/ReviewGenerator';
-import type { FileInfo, ReviewOptions, ReviewResult /* , ReviewType */ } from '../types/review'; // ReviewType not used
-import logger from '../utils/logger';
-import type { ProjectDocs } from '../utils/projectDocs';
-import { BaseReviewStrategy } from './ReviewStrategy';
-
-/**
- * Strategy for architectural reviews
- */
-export class ArchitecturalReviewStrategy extends BaseReviewStrategy {
-  /**
-   * Create a new architectural review strategy
-   */
-  constructor() {
-    super('architectural');
-  }
-
-  /**
-   * Execute the architectural review strategy
-   * @param files Files to review
-   * @param projectName Project name
-   * @param projectDocs Project documentation
-   * @param options Review options
-   * @param apiClientConfig API client configuration
-   * @returns Promise resolving to the review result
-   */
-  async execute(
-    files: FileInfo[],
-    projectName: string,
-    projectDocs: ProjectDocs | null,
-    options: ReviewOptions,
-    apiClientConfig: ApiClientConfig,
-  ): Promise<ReviewResult> {
-    logger.info('Executing architectural review strategy...');
-
-    // Generate the review using the selected API client
-    return generateReview(
-      files,
-      projectName,
-      this.reviewType,
-      projectDocs,
-      options,
-      apiClientConfig,
-    );
-  }
-}