flags.ts

import type { ProviderFromEnvName } from "@adaptif/server";

export interface EvalFlags {
  questionIds: string[];
  repeats: number;
  concurrency: number;
  isDryRun: boolean;
  isVerbose: boolean;
  /** Runs against a mock that answers from signals alone, to check the scoring catches mirroring. */
  isSignalStub: boolean;
  provider: ProviderFromEnvName | null;
  model: string | null;
}

const ProviderNames: readonly ProviderFromEnvName[] = ["typesafe", "openrouter", "vercel"];

export function parseFlags(args: readonly string[]): EvalFlags {
  const flags: EvalFlags = {
    questionIds: [],
    repeats: 3,
    concurrency: 4,
    isDryRun: false,
    isVerbose: false,
    isSignalStub: false,
    provider: null,
    model: null,
  };
  for (let index = 0; index < args.length; index++) {
    const flag = args[index];
    const readValue = () => {
      const value = args[++index];
      if (value === undefined) throw new Error(`${flag} needs a value.`);
      return value;
    };
    if (flag === "--question") flags.questionIds.push(readValue());
    else if (flag === "--repeats") flags.repeats = parsePositiveInteger(flag, readValue());
    else if (flag === "--concurrency") flags.concurrency = parsePositiveInteger(flag, readValue());
    else if (flag === "--dry-run") flags.isDryRun = true;
    else if (flag === "--verbose") flags.isVerbose = true;
    else if (flag === "--stub-signal") flags.isSignalStub = true;
    else if (flag === "--provider") flags.provider = parseProviderName(readValue());
    else if (flag === "--model") flags.model = readValue();
    else throw new Error(`Unknown flag ${flag}.`);
  }
  return flags;
}

function parsePositiveInteger(flag: string, value: string): number {
  const parsed = Number(value);
  if (!Number.isInteger(parsed) || parsed < 1) {
    throw new Error(`${flag} must be a positive integer.`);
  }
  return parsed;
}

function parseProviderName(value: string): ProviderFromEnvName {
  const providerName = ProviderNames.find((name) => name === value);
  if (providerName === undefined) {
    throw new Error(`--provider must be one of ${ProviderNames.join(", ")}.`);
  }
  return providerName;
}