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

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

@@ -0,0 +1,181 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Preflight check schema — structured environment/readiness assessment
+// ---------------------------------------------------------------------------
+
+export const preflightCheckKindSchema = z.enum([
+  "env_var",
+  "cli_tool",
+  "project_linkage",
+  "config_file",
+  "service_reachable",
+  "file_exists",
+]);
+
+export const preflightCheckSchema = z.object({
+  kind: preflightCheckKindSchema,
+  name: z.string(),
+  required: z.boolean().default(true),
+  present: z.boolean(),
+  detail: z.string().default(""),
+});
+
+export const preflightResultSchema = z.object({
+  passed: z.boolean(),
+  checked_at: z.string(),
+  checks: z.array(preflightCheckSchema),
+  blocking_reasons: z.array(z.string()),
+});
+
+export type PreflightCheckKind = z.infer<typeof preflightCheckKindSchema>;
+export type PreflightCheck = z.infer<typeof preflightCheckSchema>;
+export type PreflightResult = z.infer<typeof preflightResultSchema>;
+
+// ---------------------------------------------------------------------------
+// Preflight rule registry — extensible, not task-specific
+// ---------------------------------------------------------------------------
+
+export type PreflightRule = {
+  kind: PreflightCheckKind;
+  name: string;
+  /** When does this rule apply? Return true if the rule is relevant. */
+  appliesWhen: (ctx: PreflightContext) => boolean;
+  /** Check whether the prerequisite is present. */
+  check: (ctx: PreflightContext) => boolean;
+  /** Human-readable reason if missing. */
+  reason: string;
+};
+
+export type PreflightContext = {
+  /** Systems the slice expects to touch */
+  systemsInPlay: string[];
+  /** The repo root path */
+  repoRoot: string;
+  /** Environment variables available */
+  env: Record<string, string | undefined>;
+  /** Function to check file existence */
+  fileExists: (path: string) => boolean;
+  /** Function to check command availability */
+  commandExists: (cmd: string) => boolean;
+};
+
+// ---------------------------------------------------------------------------
+// Built-in rules — generalizable, not benchmark-specific
+// ---------------------------------------------------------------------------
+
+const BUILTIN_RULES: PreflightRule[] = [
+  // Supabase-family checks
+  {
+    kind: "env_var",
+    name: "NEXT_PUBLIC_SUPABASE_URL",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /supabase|database/i.test(s)),
+    check: ctx => !!ctx.env.NEXT_PUBLIC_SUPABASE_URL?.trim(),
+    reason: "NEXT_PUBLIC_SUPABASE_URL is required for Supabase API access.",
+  },
+  {
+    kind: "env_var",
+    name: "NEXT_PUBLIC_SUPABASE_ANON_KEY",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /supabase|database/i.test(s)),
+    check: ctx => !!ctx.env.NEXT_PUBLIC_SUPABASE_ANON_KEY?.trim(),
+    reason: "NEXT_PUBLIC_SUPABASE_ANON_KEY is required for Supabase API access.",
+  },
+  {
+    kind: "config_file",
+    name: "supabase/config.toml",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /supabase|database|migration/i.test(s)),
+    check: ctx => ctx.fileExists("supabase/config.toml"),
+    reason: "supabase/config.toml is required for Supabase project configuration.",
+  },
+
+  // Auth-family checks
+  {
+    kind: "env_var",
+    name: "DATABASE_URL",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /database|postgres/i.test(s)) && !ctx.env.NEXT_PUBLIC_SUPABASE_URL,
+    check: ctx => !!ctx.env.DATABASE_URL?.trim(),
+    reason: "DATABASE_URL is required for direct database access when Supabase URL is not set.",
+  },
+
+  // Generic deployment checks
+  {
+    kind: "env_var",
+    name: "ANTHROPIC_API_KEY",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /llm|ai|claude|anthropic/i.test(s)),
+    check: ctx => !!ctx.env.ANTHROPIC_API_KEY?.trim(),
+    reason: "ANTHROPIC_API_KEY is required for LLM/AI operations.",
+  },
+
+  // Supabase CLI (for migration push / db operations)
+  {
+    kind: "cli_tool",
+    name: "supabase",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /supabase|migration/i.test(s)),
+    check: ctx => ctx.commandExists("supabase"),
+    reason: "Supabase CLI is required for migration push and database operations. Install with: brew install supabase/tap/supabase",
+  },
+
+  // Node.js (for build / test / execution)
+  {
+    kind: "cli_tool",
+    name: "node",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /ui|components|middleware|api/i.test(s)),
+    check: ctx => ctx.commandExists("node"),
+    reason: "Node.js is required for build and test operations.",
+  },
+
+  // Stripe checks
+  {
+    kind: "env_var",
+    name: "STRIPE_SECRET_KEY",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /payment|billing|stripe/i.test(s)),
+    check: ctx => !!ctx.env.STRIPE_SECRET_KEY?.trim(),
+    reason: "STRIPE_SECRET_KEY is required for payment operations.",
+  },
+
+  // Redis checks
+  {
+    kind: "env_var",
+    name: "REDIS_URL",
+    appliesWhen: ctx => ctx.systemsInPlay.some(s => /redis|cache/i.test(s)),
+    check: ctx => !!ctx.env.REDIS_URL?.trim(),
+    reason: "REDIS_URL is required for Redis/cache operations.",
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Run preflight checks
+// ---------------------------------------------------------------------------
+
+export function checkDispatchPreflight(
+  ctx: PreflightContext,
+  extraRules: PreflightRule[] = [],
+): PreflightResult {
+  const allRules = [...BUILTIN_RULES, ...extraRules];
+  const checks: PreflightCheck[] = [];
+  const blocking: string[] = [];
+
+  for (const rule of allRules) {
+    if (!rule.appliesWhen(ctx)) continue;
+
+    const present = rule.check(ctx);
+    checks.push({
+      kind: rule.kind,
+      name: rule.name,
+      required: true,
+      present,
+      detail: present ? "" : rule.reason,
+    });
+
+    if (!present) {
+      blocking.push(rule.reason);
+    }
+  }
+
+  return preflightResultSchema.parse({
+    passed: blocking.length === 0,
+    checked_at: new Date().toISOString(),
+    checks,
+    blocking_reasons: blocking,
+  });
+}

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/src/pressure-assessment.ts

@@ -0,0 +1,265 @@
+import type {
+  EvidenceSufficiencyOutcome,
+  PressureAssessment,
+  PressureSignal,
+  PressureSignalType,
+  ReconcileReport,
+  ReturnReport,
+} from "./types";
+import { pressureAssessmentSchema } from "./types";
+
+// ---------------------------------------------------------------------------
+// Pressure signal detection — deterministic, provider-agnostic
+// ---------------------------------------------------------------------------
+
+function signal(type: PressureSignalType, detail: string): PressureSignal {
+  return { type, detail };
+}
+
+export function detectPressureSignals(input: {
+  report: ReturnReport;
+  taskType: string;
+  reconcile: ReconcileReport | null;
+}): PressureSignal[] {
+  const { report, taskType } = input;
+  const signals: PressureSignal[] = [];
+  const isImpl = taskType === "implementation-request";
+  const isRepoBound = taskType === "repo-bound-shaping" || isImpl;
+
+  // 1. objective_partial — objective not fully met
+  if (report.objective_met === "partial") {
+    signals.push(signal("objective_partial", "Objective only partially met."));
+  }
+  if (report.objective_met === "no") {
+    signals.push(signal("objective_partial", "Objective not met."));
+  }
+
+  // 2. claimed_implementation_without_artifact_change
+  if (isRepoBound && report.status === "done" && report.changed_files.length === 0 && report.artifacts_created.filter(Boolean).length === 0) {
+    signals.push(signal(
+      "claimed_implementation_without_artifact_change",
+      "Repo-bound task claims done but zero files changed and no artifacts created.",
+    ));
+  }
+
+  // 3. missing_required_evidence — claims done but no verification + no evidence
+  if ((report.status === "done" || report.objective_met === "yes") &&
+      report.verification_run.length === 0 && report.evidence.length === 0) {
+    signals.push(signal(
+      "missing_required_evidence",
+      "Claims completion but provides no verification runs and no evidence items.",
+    ));
+  }
+
+  // 4. test_failure_or_absent_tests_when_expected
+  if (isRepoBound && report.verification_run.length === 0 && report.status === "done") {
+    signals.push(signal(
+      "test_failure_or_absent_tests_when_expected",
+      "Repo-bound task completed with no verification checks run.",
+    ));
+  }
+
+  // 5. missing_context_encountered — blockers suggest missing context
+  const contextMarkers = ["missing", "not found", "does not exist", "no access", "undefined", "cannot find"];
+  for (const b of report.blockers) {
+    if (contextMarkers.some(m => b.toLowerCase().includes(m))) {
+      signals.push(signal("missing_context_encountered", `Blocker suggests missing context: ${b}`));
+      break;
+    }
+  }
+
+  // 6. execution_error_or_tool_failure — escalations with error language
+  const errorMarkers = ["error", "fail", "crash", "exception", "broken", "timeout"];
+  for (const e of report.escalations) {
+    if (errorMarkers.some(m => e.toLowerCase().includes(m))) {
+      signals.push(signal("execution_error_or_tool_failure", `Escalation suggests tool failure: ${e}`));
+      break;
+    }
+  }
+
+  // 7. suspicious_return_shape_for_task_type
+  if (isRepoBound && report.status === "done" && report.decisions_made.length === 0 && report.changed_files.length === 0) {
+    signals.push(signal(
+      "suspicious_return_shape_for_task_type",
+      "Repo-bound task done with no decisions made and no files changed — return shape inconsistent with task type.",
+    ));
+  }
+
+  // 8. repeated_failed_attempts / repeated_retry_loop
+  // These are detected from multiple blockers or escalations suggesting retry
+  const retryMarkers = ["retry", "again", "attempt", "re-run", "second try"];
+  const allText = [...report.blockers, ...report.escalations, ...report.evidence].join(" ").toLowerCase();
+  if (retryMarkers.some(m => allText.includes(m))) {
+    signals.push(signal("repeated_retry_loop", "Evidence or blockers suggest retry/re-attempt behavior."));
+  }
+
+  return signals;
+}
+
+// ---------------------------------------------------------------------------
+// Evidence policy — task-type-aware requirements
+// ---------------------------------------------------------------------------
+
+type EvidenceRequirement = {
+  name: string;
+  check: (report: ReturnReport) => boolean;
+};
+
+const IMPL_REQUIREMENTS: EvidenceRequirement[] = [
+  { name: "file_or_artifact_change", check: r => r.changed_files.length > 0 || r.artifacts_created.filter(Boolean).length > 0 },
+  { name: "verification_or_test_run", check: r => r.verification_run.length > 0 },
+  { name: "evidence_items_present", check: r => r.evidence.length > 0 },
+  // Scope check: at least one success criterion met AND the return references
+  // boundary preservation (not just "Done." — must mention what was checked)
+  { name: "scope_boundary_check", check: r => r.success_criteria_met.length > 0 && r.evidence.length > 0 },
+];
+
+// Repo-bound shaping — lighter than impl but heavier than pure shaping
+const REPO_BOUND_SHAPING_REQUIREMENTS: EvidenceRequirement[] = [
+  { name: "evidence_items_present", check: r => r.evidence.length > 0 },
+  // File change OR explicit "no changes needed" rationale in decisions
+  // Rationale must reference why no files changed (not just any decision)
+  { name: "file_or_artifact_change_or_rationale", check: r =>
+    r.changed_files.length > 0 ||
+    r.artifacts_created.filter(Boolean).length > 0 ||
+    r.decisions_made.some(d =>
+      /no.*(file|change|artifact|code)/i.test(d) ||
+      /clarif|decision|approach|design/i.test(d)
+    )
+  },
+];
+
+const SHAPING_REQUIREMENTS: EvidenceRequirement[] = [
+  // Evidence items required — decisions alone are not sufficient (a single
+  // unsupported design assertion should not pass the gate)
+  { name: "evidence_items_present", check: r => r.evidence.length > 0 },
+  { name: "structured_outcome", check: r => r.decisions_made.length > 0 || r.success_criteria_met.length > 0 },
+];
+
+/**
+ * Return-time task type reclassification.
+ *
+ * If the return shows implementation evidence (file changes, artifact diffs)
+ * but the seed classified as product-idea, the actual work was implementation.
+ * The evidence bar should match the actual work, not the seed classification.
+ */
+export function deriveEffectiveTaskType(seedTaskType: string, report: ReturnReport, repoExists: boolean): string {
+  // If return has file changes or artifacts, it's implementation regardless of seed
+  if (report.changed_files.length > 0 || report.artifacts_created.filter(Boolean).length > 0) {
+    return "implementation-request";
+  }
+
+  // If seed says product-idea but repo exists, use heavier policy
+  if (seedTaskType === "product-idea" && repoExists) {
+    return "repo-bound-shaping";
+  }
+
+  return seedTaskType;
+}
+
+function getRequirementsForTaskType(taskType: string): EvidenceRequirement[] {
+  if (taskType === "implementation-request") return IMPL_REQUIREMENTS;
+  if (taskType === "repo-bound-shaping") return REPO_BOUND_SHAPING_REQUIREMENTS;
+  return SHAPING_REQUIREMENTS;
+}
+
+// ---------------------------------------------------------------------------
+// Evidence sufficiency check
+// ---------------------------------------------------------------------------
+
+export function checkEvidenceSufficiency(input: {
+  report: ReturnReport;
+  taskType: string;
+  pressureSignals: PressureSignal[];
+}): {
+  requirements: string[];
+  present: string[];
+  missing: string[];
+  outcome: EvidenceSufficiencyOutcome;
+} {
+  const { report, taskType, pressureSignals } = input;
+  const reqs = getRequirementsForTaskType(taskType);
+
+  const requirements = reqs.map(r => r.name);
+  const present: string[] = [];
+  const missing: string[] = [];
+
+  for (const req of reqs) {
+    if (req.check(report)) {
+      present.push(req.name);
+    } else {
+      missing.push(req.name);
+    }
+  }
+
+  // Determine outcome
+  let outcome: EvidenceSufficiencyOutcome;
+
+  if (missing.length === 0) {
+    outcome = "sufficient";
+  } else if (present.length > 0 && missing.length <= present.length) {
+    outcome = "partial";
+  } else {
+    outcome = "insufficient";
+  }
+
+  // Pressure tightens the bar: partial + pressure = insufficient
+  if (outcome === "partial" && pressureSignals.length > 0) {
+    const hasHardPressure = pressureSignals.some(s =>
+      s.type === "claimed_implementation_without_artifact_change" ||
+      s.type === "missing_required_evidence" ||
+      s.type === "suspicious_return_shape_for_task_type"
+    );
+    if (hasHardPressure) {
+      outcome = "insufficient";
+    }
+  }
+
+  return { requirements, present, missing, outcome };
+}
+
+// ---------------------------------------------------------------------------
+// Full pressure assessment
+// ---------------------------------------------------------------------------
+
+export function assessPressure(input: {
+  report: ReturnReport;
+  taskType: string;
+  reconcile: ReconcileReport | null;
+  repoExists?: boolean;
+}): PressureAssessment {
+  const { report, reconcile } = input;
+  const repoExists = input.repoExists ?? false;
+
+  // Effective task type — reclassified at return time based on actual evidence
+  const effectiveTaskType = deriveEffectiveTaskType(input.taskType, report, repoExists);
+
+  const signals = detectPressureSignals({ report, taskType: effectiveTaskType, reconcile });
+  const sufficiency = checkEvidenceSufficiency({ report, taskType: effectiveTaskType, pressureSignals: signals });
+
+  // Decision reason
+  let reason: string;
+  if (signals.length === 0 && sufficiency.outcome === "sufficient") {
+    reason = "No pressure signals. Evidence sufficient for task type.";
+  } else if (signals.length === 0 && sufficiency.outcome !== "sufficient") {
+    reason = `No pressure signals but evidence ${sufficiency.outcome}: missing ${sufficiency.missing.join(", ")}.`;
+  } else if (signals.length > 0 && sufficiency.outcome === "sufficient") {
+    reason = `${signals.length} pressure signal(s) detected but evidence is sufficient.`;
+  } else if (signals.length > 0 && sufficiency.outcome === "partial") {
+    reason = `${signals.length} pressure signal(s) with partial evidence. Missing: ${sufficiency.missing.join(", ")}.`;
+  } else {
+    reason = `${signals.length} pressure signal(s) with insufficient evidence. Missing: ${sufficiency.missing.join(", ")}.`;
+  }
+
+  return pressureAssessmentSchema.parse({
+    signals,
+    pressure_detected: signals.length > 0,
+    evidence_requirements: sufficiency.requirements,
+    evidence_items_present: sufficiency.present,
+    evidence_items_missing: sufficiency.missing,
+    evidence_sufficiency: sufficiency.outcome,
+    acceptance_decision_reason: reason,
+    task_type_basis: effectiveTaskType,
+    checked_at: new Date().toISOString(),
+  });
+}

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/src/product-objects.ts

@@ -0,0 +1,99 @@
+/**
+ * Product Objects: Ask → Compile → Run
+ *
+ * These are thin wrappers that give identity and lifecycle to existing
+ * data structures. They do NOT replace the underlying schemas — they
+ * reference them by ID.
+ *
+ * Internal-only for now. Future UI concept once the model is stable.
+ */
+import type {
+  ActivationInput,
+  Ask,
+  Compile,
+  Run,
+} from "./types";
+import { askSchema, compileSchema, runSchema } from "./types";
+import { randomBytes } from "crypto";
+
+// ---------------------------------------------------------------------------
+// Ask — from ActivationInput
+// ---------------------------------------------------------------------------
+
+export function createAsk(
+  input: ActivationInput,
+  source: "operator" | "next-slice" | "re-dispatch" = "operator",
+): Ask {
+  return askSchema.parse({
+    ask_id: `ask-${randomBytes(8).toString("hex")}`,
+    raw_idea: input.raw_idea,
+    repo_exists: input.repo_exists,
+    what_do_you_want_next: input.what_do_you_want_next,
+    constraints: input.constraints,
+    created_at: new Date().toISOString(),
+    source,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Compile — from CompiledProject
+// ---------------------------------------------------------------------------
+
+export function createCompile(input: {
+  askId: string;
+  contractId: string;
+  taskType: string;
+  complexityMode: string;
+  routeSurface: string;
+  lockReadiness: string;
+}): Compile {
+  return compileSchema.parse({
+    compile_id: `cmp-${randomBytes(8).toString("hex")}`,
+    ask_id: input.askId,
+    contract_id: input.contractId,
+    task_type: input.taskType,
+    complexity_mode: input.complexityMode,
+    route_surface: input.routeSurface,
+    compiled_at: new Date().toISOString(),
+    lock_readiness: input.lockReadiness,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Run — from Handoff + Dispatch
+// ---------------------------------------------------------------------------
+
+export function createRun(input: {
+  askId: string;
+  compileId: string;
+  handoffId: string;
+  dispatchId: string;
+  receiptId?: string;
+  surface: string;
+  objective: string;
+}): Run {
+  return runSchema.parse({
+    run_id: `run-${randomBytes(8).toString("hex")}`,
+    ask_id: input.askId,
+    compile_id: input.compileId,
+    handoff_id: input.handoffId,
+    dispatch_id: input.dispatchId,
+    receipt_id: input.receiptId ?? "",
+    surface: input.surface,
+    objective: input.objective,
+    dispatched_at: new Date().toISOString(),
+  });
+}
+
+export function completeRun(
+  run: Run,
+  input: { returnId: string; deltaId: string; gateOutcome: string },
+): Run {
+  return runSchema.parse({
+    ...run,
+    return_id: input.returnId,
+    delta_id: input.deltaId,
+    gate_outcome: input.gateOutcome,
+    completed_at: new Date().toISOString(),
+  });
+}