switchboard-cli 0.1.0-alpha.1 → 0.1.0-alpha.3

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

@@ -0,0 +1,207 @@
+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/projections/node_modules/@switchboard/core/src/routing-v2.ts

@@ -0,0 +1,214 @@
+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(" ");
+}