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

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

@@ -1,181 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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

@@ -1,99 +0,0 @@
-/**
- * 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(),
-  });
-}