switchboard-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/node_modules/@switchboard/core/src/router.ts

@@ -1,207 +0,0 @@
-import type { LoopContract, RoutingInput, RoutingResult, Surface } from "./types";
-import { routingInputSchema, routingResultSchema } from "./types";
-
-const DECISION_KEYWORDS = ["decision", "unclear", "clarify", "positioning", "scope choice", "direction"];
-const EXPANDED_KEYWORDS = ["expanded unexpectedly", "expanded", "scope creep", "too big", "too broad", "wiring explosion"];
-const UI_KEYWORDS = ["ui", "visual", "taste", "polish", "layout", "spacing", "copy", "styling", "interaction"];
-const IMPLEMENTATION_KEYWORDS = [
-  "build",
-  "implement",
-  "scaffold",
-  "wire",
-  "test",
-  "fix",
-  "schema",
-  "api",
-  "repo",
-  "refactor",
-  "integration",
-  "bundle",
-  "multi-file",
-];
-
-// Codex is best for bounded, sandboxed code tasks that don't require
-// broad repo context or interactive human input.
-const SANDBOXED_KEYWORDS = [
-  "isolated",
-  "self-contained",
-  "sandboxed",
-  "standalone",
-  "module",
-  "unit test",
-  "migration",
-  "script",
-  "utility",
-  "helper",
-  "lint",
-  "format",
-  "type-check",
-];
-
-function includesAny(text: string, keywords: string[]) {
-  return keywords.some((keyword) => text.includes(keyword));
-}
-
-function compact(text: string) {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-function truncate(text: string, limit = 140) {
-  return text.length <= limit ? text : `${text.slice(0, limit - 1).trimEnd()}…`;
-}
-
-function buildResult(
-  primary: Surface,
-  fallback: Surface,
-  rationale: string,
-  nextObjective: string,
-  returnCondition: string,
-): RoutingResult {
-  return routingResultSchema.parse({
-    primary_recommendation: primary,
-    fallback_surface: fallback,
-    rationale,
-    next_objective: compact(nextObjective),
-    return_condition: compact(returnCondition),
-  });
-}
-
-export function chooseRecommendedSurface(rawInput: RoutingInput): RoutingResult {
-  const input = routingInputSchema.parse(rawInput);
-  const task = compact(input.task);
-  const reasonText = compact(`${task} ${input.last_return_reason ?? ""}`).toLowerCase();
-
-  // Governance mode: hard-force narrowing surface regardless of keywords.
-  // The project is too complex / dangerous — implementation routing is premature.
-  if (input.process_mode === "governance") {
-    return buildResult(
-      "chatgpt",
-      "claude-code",
-      "Governance mode: scope must be narrowed before implementation. The next move is structured clarification to freeze one user, one workflow, and one bounded first slice.",
-      `Narrow the scope and freeze the first V1 loop: ${truncate(task)}`,
-      "Return with one frozen user, one frozen workflow, one bounded first slice, and any unresolved decisions made explicit.",
-    );
-  }
-
-  if (input.last_return_status === "blocked" && includesAny(reasonText, DECISION_KEYWORDS)) {
-    return buildResult(
-      "chatgpt",
-      "claude-code",
-      "The last handoff blocked on an unclear product decision, so the next move is structured clarification before more repo execution.",
-      `Clarify the blocking product decision and narrow the next build slice: ${truncate(task)}`,
-      "Return with one resolved decision, one crisp next slice, and any scope changes made explicit.",
-    );
-  }
-
-  if (input.last_return_status === "blocked" && includesAny(reasonText, EXPANDED_KEYWORDS)) {
-    return buildResult(
-      "claude-code",
-      "codex",
-      "The last handoff expanded unexpectedly, so the next move is disciplined repo execution that cuts the work back to a shippable slice. Codex is the fallback for a narrower, sandboxed cut.",
-      `Reduce the scope and finish the repo-bound implementation slice: ${truncate(task)}`,
-      "Return when the narrowed implementation is complete, checks are run, and any remaining blockers are listed explicitly.",
-    );
-  }
-
-  if (input.last_return_status === "blocked" && includesAny(reasonText, UI_KEYWORDS)) {
-    return buildResult(
-      "cursor",
-      "claude-code",
-      "The last handoff became mostly visual or taste-heavy, so the next move needs close-control editing rather than more broad scaffolding.",
-      `Refine the visual or taste-heavy slice with tight human control: ${truncate(task)}`,
-      "Return when the edited experience is coherent, exact changes are listed, and any unresolved taste calls are documented.",
-    );
-  }
-
-  if (!input.repo_present) {
-    // High-confidence seed with no research needed: bootstrap directly in Claude Code
-    if (
-      input.seed_confidence === "high" &&
-      input.research_needed === false &&
-      includesAny(reasonText, IMPLEMENTATION_KEYWORDS)
-    ) {
-      return buildResult(
-        "claude-code",
-        "chatgpt",
-        "No repo yet, but the seed is high-confidence and research is not needed. The next move is to bootstrap the repo and implement the first build slice.",
-        `Bootstrap the repo and implement the first build slice: ${truncate(task)}`,
-        "Return when the repo is scaffolded, the first slice is implemented, relevant checks are run, and any blockers are listed.",
-      );
-    }
-
-    return buildResult(
-      "chatgpt",
-      "claude-code",
-      "There is no repo yet, so the next move should shape the product and produce a repo-ready build slice before code-heavy execution.",
-      `Clarify the project seed and prepare a repo-ready first slice: ${truncate(task)}`,
-      "Return with a sharper product definition, a narrowed implementation target, and any assumptions called out explicitly.",
-    );
-  }
-
-  // When the task has both implementation and UI keywords, implementation wins
-  // if it's multi-file work. Cursor is for pure taste/polish, not feature builds.
-  const hasImpl = includesAny(reasonText, IMPLEMENTATION_KEYWORDS);
-  const hasUI = includesAny(reasonText, UI_KEYWORDS);
-  const hasSandboxed = includesAny(reasonText, SANDBOXED_KEYWORDS);
-
-  // Codex branch: bounded, sandboxed implementation with no UI component.
-  // Codex is preferred when the task is self-contained, doesn't need broad
-  // repo traversal, and benefits from isolated execution.
-  if (hasImpl && hasSandboxed && !hasUI) {
-    return buildResult(
-      "codex",
-      "claude-code",
-      "This task is a bounded, self-contained implementation slice that benefits from sandboxed execution. Codex handles isolated code tasks; Claude Code is the fallback for broader repo work.",
-      `Execute the sandboxed implementation slice: ${truncate(task)}`,
-      "Return when the bounded code change is complete, tests pass in the sandbox, and any broader repo dependencies are listed.",
-    );
-  }
-
-  if (hasImpl && hasUI) {
-    // Implementation + UI = feature build → Claude Code with Cursor as fallback
-    return buildResult(
-      "claude-code",
-      "cursor",
-      "This task involves both implementation and UI work across multiple files. Claude Code handles the full build; Cursor is the fallback for taste-heavy refinement.",
-      `Execute the repo-bound implementation slice: ${truncate(task)}`,
-      "Return when the requested files are changed, relevant checks are run, and the implementation status is explicit.",
-    );
-  }
-
-  if (hasUI) {
-    return buildResult(
-      "cursor",
-      "claude-code",
-      "This task is close-control, visual, or taste-heavy, which fits a tighter human-in-the-loop editing surface.",
-      `Iterate on the visual or interaction-heavy slice: ${truncate(task)}`,
-      "Return when the UI changes are coherent, the changed files are listed, and any taste-sensitive decisions are captured.",
-    );
-  }
-
-  if (hasImpl) {
-    return buildResult(
-      "claude-code",
-      "codex",
-      "This is repo-native implementation work across multiple files. Claude Code handles the full build; Codex is the fallback for more bounded slices.",
-      `Execute the repo-bound implementation slice: ${truncate(task)}`,
-      "Return when the requested files are changed, relevant checks are run, and the implementation status is explicit.",
-    );
-  }
-
-  return buildResult(
-    "chatgpt",
-    "claude-code",
-    "The task still looks more like shaping or decision clarification than direct repo execution, so the safest first move is structured planning.",
-    `Clarify the exact scope and success bar for the next slice: ${truncate(task)}`,
-    "Return with one clear decision, one exact next objective, and any narrowed scope boundaries.",
-  );
-}
-
-export function refineRoutingResultWithLoop(route: RoutingResult, loop: LoopContract): RoutingResult {
-  const verifyLine = loop.verify_with[0] ? ` Verification should start with: ${loop.verify_with[0]}` : "";
-
-  return routingResultSchema.parse({
-    ...route,
-    rationale: `${route.rationale} This loop returns when ${loop.return_when.toLowerCase()}.${verifyLine}`.trim(),
-  });
-}

package/node_modules/@switchboard/core/src/routing-v2.ts

@@ -1,214 +0,0 @@
-import type {
-  ProviderId,
-  RoutingCandidate,
-  RoutingConstraints,
-  RoutingDecision,
-  VerificationPath,
-} from "./types";
-import { routingDecisionSchema } from "./types";
-import { PROVIDER_REGISTRY, checkProviderReady } from "./provider-registry";
-
-// ---------------------------------------------------------------------------
-// Scoring weights
-// ---------------------------------------------------------------------------
-
-const WEIGHTS = {
-  capability_match: 30,
-  readiness: 25,
-  mode_fit: 15,
-  task_fit: 10,
-  automation: 10,
-  blast_radius: 10,
-};
-
-// ---------------------------------------------------------------------------
-// Provider scoring
-// ---------------------------------------------------------------------------
-
-function scoreProvider(
-  providerId: ProviderId,
-  constraints: RoutingConstraints,
-): RoutingCandidate {
-  const entry = PROVIDER_REGISTRY.find(p => p.id === providerId);
-  if (!entry) {
-    return { provider_id: providerId, score: 0, disqualified: true, disqualification_reason: "Provider not found.", verification_path: "none" };
-  }
-
-  let score = 0;
-  let disqualified = false;
-  let disqualification_reason = "";
-  const reasons: string[] = [];
-
-  // Capability match
-  if (entry.capability === constraints.capability_needed) {
-    score += WEIGHTS.capability_match;
-    reasons.push("capability match");
-  } else {
-    disqualified = true;
-    disqualification_reason = `Needs ${constraints.capability_needed}, provider offers ${entry.capability}.`;
-    return { provider_id: providerId, score: 0, disqualified, disqualification_reason, verification_path: "none" };
-  }
-
-  // Readiness
-  const isReady = constraints.provider_readiness[providerId] ?? checkProviderReady(entry).ready;
-  if (isReady) {
-    score += WEIGHTS.readiness;
-    reasons.push("ready");
-  } else if (entry.status === "stub") {
-    disqualified = true;
-    disqualification_reason = "Provider is not yet implemented.";
-    return { provider_id: providerId, score: 0, disqualified, disqualification_reason, verification_path: "none" };
-  } else {
-    // Not ready but not stub — penalize, don't disqualify (manual fallback possible)
-    reasons.push("not ready (-15)");
-    score -= 15;
-  }
-
-  // Mode fit
-  if (constraints.process_mode === "governance" && providerId === "chatgpt-auto") {
-    score += WEIGHTS.mode_fit; // Governance → fidelity-first for narrowing
-    reasons.push("governance → fidelity-first");
-  } else if (constraints.process_mode === "structured" && entry.automated) {
-    score += WEIGHTS.mode_fit;
-    reasons.push("structured + automated");
-  } else if (constraints.process_mode === "minimal" && providerId === "internal-fallback") {
-    score += WEIGHTS.mode_fit;
-    reasons.push("minimal → internal");
-  }
-
-  // Task fit
-  if (constraints.task_type === "implementation-request" && providerId === "claude-code-sdk") {
-    score += WEIGHTS.task_fit;
-    reasons.push("impl → claude-code");
-  } else if (constraints.task_type === "product-idea" && (providerId === "openai-api" || providerId === "chatgpt-auto")) {
-    score += WEIGHTS.task_fit;
-    reasons.push("product-idea → fidelity-first");
-  }
-
-  // Automation bonus
-  if (entry.automated) {
-    score += WEIGHTS.automation;
-    reasons.push("automated");
-  }
-
-  // Blast radius penalty
-  if (constraints.blast_radius === "high" && entry.automated) {
-    score -= 10;
-    reasons.push("high blast radius → automation penalty");
-  }
-
-  // Verification path
-  const vp = determineVerificationPath(providerId, constraints);
-
-  return { provider_id: providerId, score, disqualified, disqualification_reason, verification_path: vp };
-}
-
-// ---------------------------------------------------------------------------
-// Verification path determination
-// ---------------------------------------------------------------------------
-
-function determineVerificationPath(
-  providerId: ProviderId,
-  constraints: RoutingConstraints,
-): VerificationPath {
-  const hasApiFlag = constraints.non_functional_flags.some(f =>
-    /api|endpoint|external\s+service|third.?party/i.test(f),
-  );
-  const hasDependencyFlag = constraints.non_functional_flags.some(f =>
-    /dependency|package|library|npm|install/i.test(f),
-  );
-  const hasSecurityFlag = constraints.non_functional_flags.some(f =>
-    /security|auth|encrypt|token|credential/i.test(f),
-  );
-
-  if (hasApiFlag) return "documentation-required";
-  if (hasDependencyFlag) return "dependency-verification";
-  if (hasSecurityFlag && constraints.blast_radius !== "low") return "reduced-tool-surface";
-
-  return "none";
-}
-
-// ---------------------------------------------------------------------------
-// Main routing scheduler
-// ---------------------------------------------------------------------------
-
-export function routeV2(constraints: RoutingConstraints): RoutingDecision {
-  // Score all providers for the needed capability
-  const candidates: RoutingCandidate[] = PROVIDER_REGISTRY
-    .map(p => scoreProvider(p.id, constraints))
-    .sort((a, b) => b.score - a.score);
-
-  const eligible = candidates.filter(c => !c.disqualified);
-  const constraintsApplied: string[] = [];
-
-  constraintsApplied.push(`capability: ${constraints.capability_needed}`);
-  constraintsApplied.push(`mode: ${constraints.process_mode}`);
-  constraintsApplied.push(`task: ${constraints.task_type}`);
-  if (constraints.blast_radius !== "low") constraintsApplied.push(`blast radius: ${constraints.blast_radius}`);
-  if (constraints.non_functional_flags.length > 0) constraintsApplied.push(`nf flags: ${constraints.non_functional_flags.join(", ")}`);
-
-  if (eligible.length === 0) {
-    // No eligible providers — fall back to internal
-    const fallbackCandidate: RoutingCandidate = {
-      provider_id: "internal-fallback",
-      score: 0,
-      disqualified: false,
-      disqualification_reason: "",
-      verification_path: "none",
-    };
-    return routingDecisionSchema.parse({
-      selected: fallbackCandidate,
-      candidates,
-      rationale: "No eligible providers for the requested capability. Using internal fallback.",
-      constraints_applied: constraintsApplied,
-      verification_path: "none",
-    });
-  }
-
-  const selected = eligible[0]!;
-  const fallback = eligible.length > 1 ? eligible[1] : undefined;
-
-  // Build rationale
-  const disqualified = candidates.filter(c => c.disqualified);
-  const rationale = buildRationale(selected, fallback, disqualified, constraints);
-
-  return routingDecisionSchema.parse({
-    selected,
-    fallback,
-    candidates,
-    rationale,
-    constraints_applied: constraintsApplied,
-    verification_path: selected.verification_path,
-  });
-}
-
-function buildRationale(
-  selected: RoutingCandidate,
-  fallback: RoutingCandidate | undefined,
-  disqualified: RoutingCandidate[],
-  constraints: RoutingConstraints,
-): string {
-  const parts: string[] = [];
-
-  const entry = PROVIDER_REGISTRY.find(p => p.id === selected.provider_id);
-  parts.push(`Selected ${entry?.name ?? selected.provider_id} (score: ${selected.score}).`);
-
-  if (fallback) {
-    const fb = PROVIDER_REGISTRY.find(p => p.id === fallback.provider_id);
-    parts.push(`Fallback: ${fb?.name ?? fallback.provider_id} (score: ${fallback.score}).`);
-  }
-
-  if (disqualified.length > 0) {
-    parts.push(`Disqualified: ${disqualified.map(d => `${d.provider_id} (${d.disqualification_reason.slice(0, 40)})`).join(", ")}.`);
-  }
-
-  if (selected.verification_path !== "none") {
-    parts.push(`Verification path: ${selected.verification_path}.`);
-  }
-
-  if (constraints.process_mode === "governance") {
-    parts.push("Governance mode: narrowing before execution.");
-  }
-
-  return parts.join(" ");
-}