Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

16.4 KB
Raw Blame
import { useCallback, useEffect, useRef, useState } from 'react';
import { useLocation, useNavigate, useSearchParams } from 'react-router';
import { CircleHelp, ListTree, ScanSearch } from 'lucide-react';
import toast from '../ui/Toast';
import Banner from '../ui/Banner';
import Drawer from '../Drawer';
import TabPills from '../ui/TabPills';
import * as api from '../../services/api';
import ReviewerGroupsEditor from '../cos/ReviewerGroupsEditor';
import GoalFidelityControls from './GoalFidelityControls';
import CodeReviewHelp from './CodeReviewHelp';
import useReviewerModelOptions from '../../hooks/useReviewerModelOptions';
import { reviewerModelsFromDefaults, reviewerModelsToDefaults, reviewerEffortsFromDefaults, reviewerEffortsToDefaults } from '../../lib/reviewerModels';
import { DEFAULT_GOAL_FIDELITY_FOLLOW_UP_TRIGGER } from '../../lib/reviewerPins';
import {
  DEFAULT_REVIEW_STOP_MODE,
} from '../cos/constants';

// Global Code Review Defaults — the chain the Review Loop uses when a task or
// task-type config didn't pin its own reviewers. Owns Models → Code Reviewers.
// Every per-reviewer control (model, `~opt`, `~max`) lives in the shared
// ReviewerPicker table (#3133), so this tab owns the fetch of the model option
// lists (via useReviewerModelOptions), the save, and which task view is open.
//
// Review chain and Follow-up are route-backed task views. The help drawer holds
// the tier rules once; the cards themselves stay the controls.

const REVIEW_VIEWS = [
  { id: 'chain', label: 'Review chain', icon: ListTree },
  { id: 'follow-up', label: 'Follow-up', icon: ScanSearch },
];
const CHAIN_PATH = '/models/code-reviewers';
const FOLLOW_UP_PATH = '/models/code-reviewers/follow-up';

const CONFIG_FAULT_REMEDIES = {
  NO_MODEL: 'Select a model on Review chain.',
  REVIEWER_COMMAND_PERMISSION_DENIED: 'Use a compatible non-interactive review transport or supported tool-free vendor configuration; keep command, network and write permissions disabled.',
  REVIEWER_ACCESS_DENIED: 'Select an accessible service or model, or correct provider access.',
  REVIEWER_UNSUPPORTED: 'Set its command or switch it to API mode in AI Providers.',
};

// `null` when the URL is not this page (unit tests render the panel alone).
// A slug under the page that is not a known view is returned so the caller can
// replace it with the chain.
function viewFromPath(pathname) {
  const path = String(pathname || '').replace(/\/+$/, '');
  if (path === CHAIN_PATH) return 'chain';
  if (!path.startsWith(`${CHAIN_PATH}/`)) return null;
  return path.slice(CHAIN_PATH.length + 1).split('/')[0] || 'chain';
}

export default function CodeReviewersTab({ view } = {}) {
  const location = useLocation();
  const navigate = useNavigate();
  const [searchParams, setSearchParams] = useSearchParams();
  const pathView = viewFromPath(location.pathname);
  const requested = pathView ?? (view === 'follow-up' ? 'follow-up' : 'chain');
  const activeView = requested === 'follow-up' ? 'follow-up' : 'chain';
  const helpOpen = searchParams.get('help') === '1';
  const [loading, setLoading] = useState(true);
  const [loadError, setLoadError] = useState(false);
  const [saving, setSaving] = useState(false);
  const [usernames, setUsernames] = useState([]);
  const [optionalReviewers, setOptionalReviewers] = useState([]);
  const [reviewerMaxRounds, setReviewerMaxRounds] = useState({});
  const [reviewerModels, setReviewerModels] = useState({});
  const [reviewerEfforts, setReviewerEfforts] = useState({});
  const [stopMode, setStopMode] = useState(DEFAULT_REVIEW_STOP_MODE);
  const [reviewerApplies, setReviewerApplies] = useState(false);
  const [goalFidelity, setGoalFidelity] = useState({
    enabled: true, backend: null, model: null, effort: null,
    fileIssue: false, queueTask: false, followUpOn: DEFAULT_GOAL_FIDELITY_FOLLOW_UP_TRIGGER,
  });
  const [installed, setInstalled] = useState({});
  const [providerReviewUnsupported, setProviderReviewUnsupported] = useState({});
  const [reviewerHealth, setReviewerHealth] = useState({});
  const [reviewerConfigFaults, setReviewerConfigFaults] = useState({});
  const [reviewerIdentities, setReviewerIdentities] = useState([]);
  const [reviewerFallbackGroups, setReviewerFallbackGroups] = useState([]);
  const modelOptions = useReviewerModelOptions();
  const loadVersion = useRef(0);
  const saveInFlight = useRef(false);

  const loadDefaults = useCallback(() => {
    setLoading(true);
    setLoadError(false);
    const version = ++loadVersion.current;
    api.getCodeReviewDefaults({ silent: true })
      .then((defaults) => {
        if (version !== loadVersion.current) return;
        const groups = defaults?.reviewerFallbackGroups;
        const validList = value => Array.isArray(value) && value.every(token => typeof token === 'string' && !token.startsWith('@'));
        if (defaults && (groups === undefined ? validList(defaults.reviewers) : Array.isArray(groups) && groups.every(validList))) {
          setUsernames(Array.isArray(defaults.usernames) ? defaults.usernames : []);
          setOptionalReviewers(Array.isArray(defaults.optionalReviewers) ? defaults.optionalReviewers : []);
          setReviewerMaxRounds(defaults.reviewerMaxRounds && typeof defaults.reviewerMaxRounds === 'object' && !Array.isArray(defaults.reviewerMaxRounds)
            ? defaults.reviewerMaxRounds
            : {});
          setReviewerModels(reviewerModelsFromDefaults(defaults));
          setReviewerEfforts(reviewerEffortsFromDefaults(defaults));
          setStopMode(defaults.stopMode || DEFAULT_REVIEW_STOP_MODE);
          setReviewerApplies(defaults.reviewerApplies === true);
          // `enabled` defaults ON, so an absent block must read as on — not as a
          // stored `false` the next save would then persist.
          setGoalFidelity({
            enabled: defaults.goalFidelity?.enabled !== false,
            backend: defaults.goalFidelity?.backend || null,
            model: defaults.goalFidelity?.model || null,
            effort: defaults.goalFidelity?.effort || null,
            // Both follow-up actions default OFF — filing on a tracker and
            // spawning an unattended run are each opt-in — so an absent block
            // must read as off, the mirror image of `enabled` above.
            fileIssue: defaults.goalFidelity?.fileIssue === true,
            queueTask: defaults.goalFidelity?.queueTask === true,
            followUpOn: defaults.goalFidelity?.followUpOn || DEFAULT_GOAL_FIDELITY_FOLLOW_UP_TRIGGER,
          });
          setInstalled(defaults.installed && typeof defaults.installed === 'object' && !Array.isArray(defaults.installed) ? defaults.installed : {});
          setProviderReviewUnsupported(defaults.providerReviewUnsupported && typeof defaults.providerReviewUnsupported === 'object' && !Array.isArray(defaults.providerReviewUnsupported) ? defaults.providerReviewUnsupported : {});
          setReviewerHealth(defaults.reviewerHealth && typeof defaults.reviewerHealth === 'object' && !Array.isArray(defaults.reviewerHealth) ? defaults.reviewerHealth : {});
          setReviewerConfigFaults(defaults.reviewerConfigFaults && typeof defaults.reviewerConfigFaults === 'object' && !Array.isArray(defaults.reviewerConfigFaults) ? defaults.reviewerConfigFaults : {});
          // Persisted priority is independent of defaults.reviewers, which is
          // the currently healthy tier for execution consumers.
          const configured = groups ?? (defaults.reviewers.length ? [defaults.reviewers] : []);
          setReviewerFallbackGroups(configured.map((reviewers, index) => ({ id: `tier-${index}`, reviewers })));
        } else {
          setLoadError(true);
        }
        setLoading(false);
      })
      .catch(() => {
        if (version !== loadVersion.current) return;
        setLoadError(true);
        setLoading(false);
      });
  }, []);

  useEffect(() => {
    loadDefaults();
    return () => { loadVersion.current += 1; };
  }, [loadDefaults]);

  // Existence of the saved @login/@team reviewers on the forge. Lookups run
  // server-side and are cached, so this is a one-shot read after load and after
  // a save (the roster only changes through those), never a poll. A failed read
  // leaves the list empty: no warning is better than a fabricated one.
  const loadIdentities = useCallback(() => {
    // Same-reference bail-out when nothing changed (the common empty case).
    const apply = (next) => setReviewerIdentities((prev) => (prev.length === 0 && next.length === 0 ? prev : next));
    api.getReviewerIdentities({ silent: true })
      .then((result) => apply(Array.isArray(result?.identities) ? result.identities : []))
      .catch(() => apply([]));
  }, []);
  useEffect(() => {
    if (!loading && !loadError) loadIdentities();
  }, [loading, loadError, loadIdentities]);

  useEffect(() => {
    if (pathView && pathView !== 'chain' && pathView !== 'follow-up') {
      navigate({ pathname: CHAIN_PATH, search: location.search }, { replace: true });
    }
  }, [location.search, navigate, pathView]);

  const openView = (next) => {
    navigate({ pathname: next === 'follow-up' ? FOLLOW_UP_PATH : CHAIN_PATH, search: location.search });
  };
  const setHelp = (open) => {
    setSearchParams((prev) => {
      const next = new URLSearchParams(prev);
      if (open) next.set('help', '1');
      else next.delete('help');
      return next;
    }, { replace: true });
  };

  const handleSave = async () => {
    if (saveInFlight.current || loading || loadError) return;
    saveInFlight.current = true;
    setSaving(true);
    const groups = reviewerFallbackGroups.filter(group => group.reviewers.length);
    const payload = {
      reviewers: groups[0]?.reviewers || [],
      reviewerFallbackGroups: groups.map(group => group.reviewers),
      usernames,
      optionalReviewers,
      reviewerMaxRounds,
      stopMode,
      reviewerApplies,
      ...reviewerModelsToDefaults(reviewerModels),
      ...reviewerEffortsToDefaults(reviewerEfforts),
      // Absent keys are dropped rather than sent as null: the schema treats an
      // absent scalar as "inherit", and persisting an explicit null would be a
      // pin the resolver can't tell from a deliberate one.
      goalFidelity: {
        enabled: goalFidelity.enabled,
        ...(goalFidelity.backend ? { backend: goalFidelity.backend } : {}),
        ...(goalFidelity.model ? { model: goalFidelity.model } : {}),
        ...(goalFidelity.effort ? { effort: goalFidelity.effort } : {}),
        // Booleans always ride: unlike the scalars above, `false` here is the
        // user turning an action OFF, not "inherit", so dropping it would make
        // the switch un-clearable once it had been on. The trigger is the other
        // way round — it only means something once an action is armed, so an
        // install that never armed one is left inheriting the shipped default
        // rather than pinned to today's value forever.
        fileIssue: goalFidelity.fileIssue === true,
        queueTask: goalFidelity.queueTask === true,
        ...(goalFidelity.fileIssue || goalFidelity.queueTask ? { followUpOn: goalFidelity.followUpOn } : {}),
      },
    };
    const ok = await api.updateSettings({ codeReview: payload }, { silent: true })
      .then(() => true)
      .catch((err) => { toast.error(`Failed to save Code Review Defaults: ${err?.message || 'Save failed'}`); return false; });
    saveInFlight.current = false;
    setSaving(false);
    if (ok) {
      setReviewerFallbackGroups(groups);
      toast.success('Code Review Defaults saved');
      loadIdentities();
    }
  };

  return (
    <div className="space-y-4 min-w-0">
      <div className="flex flex-wrap items-center justify-between gap-3">
        <TabPills
          tabs={REVIEW_VIEWS}
          activeTab={activeView}
          onChange={openView}
          ariaLabel="Code review tasks"
          controlsIdPrefix="code-review-task"
          mobileCompact
        />
        <div className="flex flex-wrap items-center gap-2">
          <button
            type="button"
            onClick={() => setHelp(true)}
            className="inline-flex min-h-11 items-center gap-1.5 px-3 text-sm text-gray-300 border border-port-border rounded hover:text-white hover:border-port-accent"
          >
            <CircleHelp size={16} aria-hidden="true" />
            How this works
          </button>
          {!loading && (
            <button
              type="button"
              onClick={handleSave}
              disabled={saving || loadError}
              className="min-h-11 px-3 text-sm bg-port-accent hover:bg-port-accent/80 disabled:opacity-50 text-white rounded transition-colors"
            >
              {saving ? 'Saving…' : 'Save defaults'}
            </button>
          )}
        </div>
      </div>
      <p className="text-sm text-gray-400">
        {activeView === 'follow-up'
          ? 'After a run ships, compare its diff with the task it was given.'
          : 'Primary runs first. One paused reviewer skips that whole tier. Tasks with their own reviewers keep that override.'}
      </p>

      {loadError && (
        <Banner
          tone="error"
          size="sm"
          align="center"
          actions={
            <button
              type="button"
              onClick={loadDefaults}
              className="px-2.5 py-1 text-xs font-medium bg-port-error/20 hover:bg-port-error/30 text-port-error rounded transition-colors"
            >
              Retry
            </button>
          }
        >
          Failed to load code review defaults.
        </Banner>
      )}

      {loading ? (
        <div className="text-xs text-gray-500">Loading defaults…</div>
      ) : (
        <>
          {Object.entries(reviewerConfigFaults).map(([reviewer, fault]) => (
            <Banner key={`config-${reviewer}`} tone="warning" size="sm" align="left">
              {reviewer}: the last review attempt failed ({fault.code}). {CONFIG_FAULT_REMEDIES[fault.code] || 'Enable or configure the reviewer in Settings → Code Reviewers.'} The next successful review clears this warning.
            </Banner>
          ))}
          {reviewerIdentities.filter((entry) => entry.status === 'missing').map((entry) => (
            <Banner key={`identity-${entry.token}`} tone="warning" size="sm" align="left">
              @{entry.token}: {entry.reason}. {entry.required
                ? 'It is a required reviewer, so review-loop runs that use it are refused until you correct or remove this entry.'
                : 'It is optional, so runs skip it and continue without its review.'} Your saved list is unchanged.
            </Banner>
          ))}
          {activeView === 'chain' ? (
            <div role="tabpanel" id="code-review-task-chain" aria-labelledby="tab-chain">
              <ReviewerGroupsEditor
                groups={reviewerFallbackGroups}
                onGroupsChange={setReviewerFallbackGroups}
                reviewerHealth={reviewerHealth}
                usernames={usernames}
                optionalReviewers={optionalReviewers}
                reviewerMaxRounds={reviewerMaxRounds}
                reviewerModels={reviewerModels}
                reviewerEfforts={reviewerEfforts}
                modelOptions={modelOptions}
                installed={installed}
                providerReviewUnsupported={providerReviewUnsupported}
                stopMode={stopMode}
                reviewerApplies={reviewerApplies}
                disabled={saving || loadError}
                onChange={({ usernames: u, optionalReviewers: o, reviewerMaxRounds: m, reviewerModels: dm, reviewerEfforts: de, stopMode: s, reviewerApplies: a }) => {
                  setUsernames(u);
                  setOptionalReviewers(o);
                  setReviewerMaxRounds(m);
                  setReviewerModels(dm);
                  setReviewerEfforts(de);
                  setStopMode(s);
                  setReviewerApplies(a);
                }}
              />
            </div>
          ) : (
            <div role="tabpanel" id="code-review-task-follow-up" aria-labelledby="tab-follow-up">
              <GoalFidelityControls
                value={goalFidelity}
                modelOptions={modelOptions}
                disabled={saving || loadError}
                onChange={setGoalFidelity}
              />
            </div>
          )}
        </>
      )}
      <Drawer
        open={helpOpen}
        onClose={() => setHelp(false)}
        title="How code review works"
        closeLabel="Close how code review works"
        size="md"
      >
        <CodeReviewHelp />
      </Drawer>
    </div>
  );
}