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

4.6 KB
Raw Blame
import { isProviderReviewer } from './reviewerPins';
import { EFFORT_LEVELS } from '../../../server/lib/providerModels.js';
import {
  MODEL_SELECTABLE_REVIEWERS,
  MAX_REVIEWER_MODEL_LENGTH,
  EFFORT_SELECTABLE_REVIEWERS,
  reviewerEffortLevels,
  sanitizeReviewerModelInput
} from '../components/cos/constants';

/**
 * Adapters between the two shapes a per-reviewer pin takes — model ids and
 * reasoning-effort tiers alike.
 *
 * The Code Review Defaults settings slice persists ONE SCALAR PER REVIEWER
 * (`codexModel`, `claudeModel`, `lmstudioModel`, `ollamaModel`, and the matching
 * `<reviewer>Effort` scalars) and stays that way — the encoding crosses installs,
 * so legacy scalars remain readable. Configured-provider pins are additive in
 * `providerModels` / `providerEfforts`, keyed by `provider:<id>`. Everything else (the
 * ReviewerPicker table, per-task metadata, the slashdo token builders) speaks the
 * token-keyed MAP shape the `~opt` / `~max` controls already use, so the two need
 * one documented conversion point rather than a hand-rolled loop in each consumer.
 *
 * Server mirror: `reviewerModelsFromDefaults` / `reviewerEffortsFromDefaults` in
 * `server/lib/reviewerConfig.js`.
 */

/**
 * Build the scalar↔map adapter pair for ONE pin kind. The two pins differ on
 * exactly three axes — which reviewers can carry the pin, the scalar's key
 * suffix, and how a single value is validated — so they're parameters here
 * rather than a second hand-copied pair of loops. Twin of the server's
 * `keyedReviewerPinNormalizer` factory.
 *
 * `fromDefaults` OMITS anything `validateOne` rejects: settings.json is
 * hand-editable and a reviewer's accepted values move with its CLI, so a stored
 * value the server's normalizer would drop must not surface as a pin the picker
 * DISPLAYS but no reviewer ever receives.
 *
 * `toDefaults` gives EVERY reviewer in the roster a key, so an unpinned one
 * sends `undefined` and the schema's `emptyToUndefined` preprocess CLEARS the
 * stored scalar. Omitting absent keys instead would leave a stale value
 * persisted after the user cleared the field.
 *
 * @param {readonly string[]} roster - reviewers that can carry this pin.
 * @param {string} suffix - scalar key suffix (`'Model'` → `codexModel`).
 * @param {(raw: string, reviewer: string) => string|undefined} validateOne
 */
function pinScalarAdapters(roster, suffix, validateOne) {
  const providerKey = suffix === 'Model' ? 'providerModels' : 'providerEfforts';
  return {
    fromDefaults: (defaults) => {
      const out = {};
      for (const [key, raw] of Object.entries(defaults?.[providerKey] || {})) {
        if (!isProviderReviewer(key) || typeof raw !== 'string') continue;
        const value = validateOne(raw, key);
        if (value) out[key] = value;
      }
      for (const reviewer of roster) {
        const raw = defaults?.[`${reviewer}${suffix}`];
        if (typeof raw !== 'string') continue;
        const value = validateOne(raw, reviewer);
        if (value) out[reviewer] = value;
      }
      return out;
    },
    toDefaults: (pins) => ({
      ...Object.fromEntries(roster.map((reviewer) => [`${reviewer}${suffix}`, pins?.[reviewer] || undefined])),
      [providerKey]: Object.fromEntries(Object.entries(pins || {}).filter(([key]) => isProviderReviewer(key)))
    })
  };
}

// A model id survives only if it round-trips the sanitizer unchanged — a value
// carrying a structural delimiter (or an over-long one) is what the server's
// token builders would drop.
const modelAdapters = pinScalarAdapters(MODEL_SELECTABLE_REVIEWERS, 'Model', (raw) => {
  const model = sanitizeReviewerModelInput(raw).trim();
  return model && model.length <= MAX_REVIEWER_MODEL_LENGTH && model === raw.trim() ? model : undefined;
});

// An effort is re-checked against that reviewer's OWN ladder, so a level stored
// before the reviewer's CLI dropped it doesn't survive into the picker.
const effortAdapters = pinScalarAdapters(EFFORT_SELECTABLE_REVIEWERS, 'Effort', (raw, reviewer) => {
  const effort = raw.trim().toLowerCase();
  const levels = isProviderReviewer(reviewer) ? EFFORT_LEVELS : reviewerEffortLevels(reviewer);
  return levels?.includes(effort) ? effort : undefined;
});

/** Scalars → `{ codex: 'gpt-…', ollama: 'qwen…' }`. */
export const reviewerModelsFromDefaults = modelAdapters.fromDefaults;

/** Map → scalars, for a settings PATCH. */
export const reviewerModelsToDefaults = modelAdapters.toDefaults;

/** Effort twin: scalars → `{ codex: 'high' }`. */
export const reviewerEffortsFromDefaults = effortAdapters.fromDefaults;

/** Map → scalars, for a settings PATCH. */
export const reviewerEffortsToDefaults = effortAdapters.toDefaults;