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

package/node_modules/@switchboard/core/src/packet-integrity.ts

@@ -1,302 +0,0 @@
-import type {
-  LoopContract,
-  PacketFinding,
-  PacketFindingSeverity,
-  PacketFindingType,
-  PacketIntegrityResult,
-  ProjectContract,
-} from "./types";
-import { packetIntegrityResultSchema } from "./types";
-
-const VALIDATOR_VERSION = "1.0.0";
-
-// ---------------------------------------------------------------------------
-// Placeholder / reference patterns
-// ---------------------------------------------------------------------------
-
-const PLACEHOLDER_PATTERNS = [
-  /\bTODO\b/,
-  /\bTBC\b/,
-  /\bTBD\b/,
-  /\[attach\]/i,
-  /\[insert\]/i,
-  /\[placeholder\]/i,
-  /\[FILL\s*IN\]/i,
-  /\bXXX\b/,
-  /\{\{[^}]+\}\}/,
-];
-
-const REFERENCE_PATTERNS = {
-  screenshot: /\b(?:see|attach(?:ed)?|refer(?:ence)?(?:\s+to)?)\s+(?:the\s+)?screenshot/i,
-  file: /\b(?:see|attach(?:ed)?|refer(?:ence)?(?:\s+to)?)\s+(?:the\s+)?(?:file|document|pdf|image)/i,
-  repo: /\b(?:use|clone|pull|existing)\s+(?:the\s+)?repo(?:sitory)?\b/i,
-  previous: /\b(?:continue|resume|from)\s+(?:the\s+)?(?:previous|prior|last)\s+(?:output|run|result|artifact)/i,
-};
-
-// ---------------------------------------------------------------------------
-// Finding builder
-// ---------------------------------------------------------------------------
-
-function finding(
-  type: PacketFindingType,
-  severity: PacketFindingSeverity,
-  field: string,
-  detail: string,
-): PacketFinding {
-  return { type, severity, field, detail };
-}
-
-// ---------------------------------------------------------------------------
-// Individual checks
-// ---------------------------------------------------------------------------
-
-function checkEmptyRequiredFields(
-  contract: ProjectContract,
-  loop: LoopContract,
-  prompt: string,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-
-  if (!contract.title.trim()) {
-    findings.push(finding("empty_required_field", "blocking", "contract.title", "Contract title is empty."));
-  }
-  if (!contract.desired_v1_outcome.trim()) {
-    findings.push(finding("empty_required_field", "blocking", "contract.desired_v1_outcome", "V1 outcome is empty."));
-  }
-  if (!contract.target_user.trim()) {
-    findings.push(finding("empty_required_field", "blocking", "contract.target_user", "Target user is empty."));
-  }
-  if (contract.non_goals.length === 0) {
-    findings.push(finding("empty_required_field", "blocking", "contract.non_goals", "Non-goals are empty — no protected boundaries."));
-  }
-  if (!loop.objective.trim()) {
-    findings.push(finding("empty_required_field", "blocking", "loop.objective", "Loop objective is empty."));
-  }
-  if (loop.scope_in.length === 0) {
-    findings.push(finding("empty_required_field", "blocking", "loop.scope_in", "Scope-in is empty — no bounded work defined."));
-  }
-  if (loop.done_when.length === 0) {
-    findings.push(finding("empty_required_field", "blocking", "loop.done_when", "Done-when is empty — no completion criteria."));
-  }
-  if (loop.success_criteria.length === 0) {
-    findings.push(finding("empty_required_field", "caution", "loop.success_criteria", "Success criteria are empty."));
-  }
-  if (!prompt || prompt.length < 50) {
-    findings.push(finding("empty_required_field", "blocking", "prompt", "Execution prompt is missing or too short."));
-  }
-
-  return findings;
-}
-
-function checkRepoBinding(
-  contract: ProjectContract,
-  loop: LoopContract,
-  prompt: string,
-  specMarkdown: string,
-  repoExists: boolean,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-  const combined = `${prompt}\n${specMarkdown}\n${loop.objective}\n${loop.scope_in.join(" ")}`;
-
-  // Does the content reference a repo?
-  const referencesRepo = REFERENCE_PATTERNS.repo.test(combined) ||
-    /\b(?:src\/|\.tsx?|\.jsx?|package\.json|\.git)\b/.test(combined);
-
-  if (referencesRepo && !repoExists) {
-    // Caution, not blocking — first execution creates the repo
-    findings.push(finding(
-      "missing_repo_binding",
-      "caution",
-      "contract.repo_status",
-      "Packet references repository files or paths but no repo is bound yet. First execution will create the working directory.",
-    ));
-  }
-
-  return findings;
-}
-
-function checkReferencedArtifacts(
-  prompt: string,
-  specMarkdown: string,
-  specExists: boolean,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-  const combined = `${prompt}\n${specMarkdown}`;
-
-  // Check for screenshot/file references without attachments
-  if (REFERENCE_PATTERNS.screenshot.test(combined)) {
-    findings.push(finding(
-      "missing_referenced_artifact",
-      "blocking",
-      "prompt",
-      'Prompt references a screenshot ("see attached screenshot") but no screenshot is linked.',
-    ));
-  }
-
-  if (REFERENCE_PATTERNS.file.test(combined)) {
-    findings.push(finding(
-      "missing_referenced_artifact",
-      "caution",
-      "prompt",
-      "Prompt references an attached file or document. Verify it is accessible in the working directory.",
-    ));
-  }
-
-  // Check for canonical brief reference
-  if (!specExists) {
-    findings.push(finding(
-      "missing_referenced_artifact",
-      "blocking",
-      "spec_markdown",
-      "Canonical brief (SB_SPEC.md) is missing or empty.",
-    ));
-  }
-
-  return findings;
-}
-
-function checkParentContext(
-  prompt: string,
-  specMarkdown: string,
-  hasActiveHandoff: boolean,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-  const combined = `${prompt}\n${specMarkdown}`;
-
-  if (REFERENCE_PATTERNS.previous.test(combined) && !hasActiveHandoff) {
-    findings.push(finding(
-      "missing_parent_context",
-      "blocking",
-      "prompt",
-      'Prompt references previous run/output/artifact but no parent handoff or prior execution is linked.',
-    ));
-  }
-
-  return findings;
-}
-
-function checkUnresolvedPlaceholders(
-  prompt: string,
-  specMarkdown: string,
-  loop: LoopContract,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-
-  const fieldsToCheck = [
-    { name: "prompt", value: prompt },
-    { name: "spec_markdown", value: specMarkdown },
-    { name: "loop.objective", value: loop.objective },
-    ...loop.scope_in.map((s, i) => ({ name: `loop.scope_in[${i}]`, value: s })),
-    ...loop.done_when.map((s, i) => ({ name: `loop.done_when[${i}]`, value: s })),
-  ];
-
-  for (const { name, value } of fieldsToCheck) {
-    for (const pattern of PLACEHOLDER_PATTERNS) {
-      if (pattern.test(value)) {
-        findings.push(finding(
-          "unresolved_placeholder",
-          name === "prompt" || name === "loop.objective" ? "blocking" : "caution",
-          name,
-          `Unresolved placeholder "${value.match(pattern)?.[0] ?? "unknown"}" found in ${name}.`,
-        ));
-        break; // one finding per field
-      }
-    }
-  }
-
-  return findings;
-}
-
-function checkContractMismatch(
-  contract: ProjectContract,
-  loop: LoopContract,
-  specMarkdown: string,
-): PacketFinding[] {
-  const findings: PacketFinding[] = [];
-
-  // Check that non-goals are represented in scope_out
-  if (contract.non_goals.length > 0 && loop.scope_out.length === 0) {
-    findings.push(finding(
-      "packet_contract_mismatch",
-      "caution",
-      "loop.scope_out",
-      `Contract has ${contract.non_goals.length} non-goal(s) but loop scope_out is empty.`,
-    ));
-  }
-
-  // Check spec covers the objective
-  if (specMarkdown && loop.objective) {
-    const objWords = loop.objective.toLowerCase().split(/\s+/).filter(w => w.length > 4);
-    const specLower = specMarkdown.toLowerCase();
-    const covered = objWords.filter(w => specLower.includes(w));
-    if (objWords.length > 3 && covered.length / objWords.length < 0.2) {
-      findings.push(finding(
-        "packet_contract_mismatch",
-        "caution",
-        "loop.objective",
-        "Loop objective has low overlap with canonical brief. Brief may be outdated.",
-      ));
-    }
-  }
-
-  // Check contract required inputs (task_clauses) are not empty when expected
-  if (contract.task_clauses) {
-    if (contract.task_clauses.scope_in.length > 0 && loop.scope_in.length === 0) {
-      findings.push(finding(
-        "missing_required_contract_input",
-        "blocking",
-        "loop.scope_in",
-        "Contract task_clauses define scope_in but loop scope_in is empty.",
-      ));
-    }
-  }
-
-  return findings;
-}
-
-// ---------------------------------------------------------------------------
-// Main validator
-// ---------------------------------------------------------------------------
-
-export function validateDispatchPacket(input: {
-  contract: ProjectContract;
-  loop: LoopContract;
-  prompt: string;
-  specMarkdown: string;
-  specExists: boolean;
-  repoExists: boolean;
-  hasActiveHandoff: boolean;
-}): PacketIntegrityResult {
-  const { contract, loop, prompt, specMarkdown, specExists, repoExists, hasActiveHandoff } = input;
-
-  const allFindings: PacketFinding[] = [
-    ...checkEmptyRequiredFields(contract, loop, prompt),
-    ...checkRepoBinding(contract, loop, prompt, specMarkdown, repoExists),
-    ...checkReferencedArtifacts(prompt, specMarkdown, specExists),
-    ...checkParentContext(prompt, specMarkdown, hasActiveHandoff),
-    ...checkUnresolvedPlaceholders(prompt, specMarkdown, loop),
-    ...checkContractMismatch(contract, loop, specMarkdown),
-  ];
-
-  const blocking = allFindings.filter(f => f.severity === "blocking").length;
-  const cautions = allFindings.filter(f => f.severity === "caution").length;
-
-  let outcome: "ready" | "ready_with_cautions" | "blocked";
-  if (blocking > 0) {
-    outcome = "blocked";
-  } else if (cautions > 0) {
-    outcome = "ready_with_cautions";
-  } else {
-    outcome = "ready";
-  }
-
-  return packetIntegrityResultSchema.parse({
-    outcome,
-    findings: allFindings,
-    blocking_findings_count: blocking,
-    caution_findings_count: cautions,
-    checked_at: new Date().toISOString(),
-    checked_against_contract_version: contract.project_id,
-    validator_version: VALIDATOR_VERSION,
-  });
-}

package/node_modules/@switchboard/core/src/parallel-conflict.ts

@@ -1,268 +0,0 @@
-import { z } from "zod";
-import { SYSTEM_PATTERNS } from "./canonical-delta";
-
-// ---------------------------------------------------------------------------
-// Parallel Dispatch Conflict Guard
-// ---------------------------------------------------------------------------
-//
-// Prevents unsafe parallel loop execution by comparing a candidate dispatch's
-// declared systems/areas against already-active dispatches. Uses the same
-// SYSTEM_PATTERNS from canonical-delta as the single source of truth for
-// system detection.
-//
-// Classification:
-//   parallel_safe    — no material overlap; safe to dispatch in parallel
-//   parallel_risky   — overlapping readout/config/scope areas; operator should review
-//   parallel_blocked — overlapping write domains; unsafe to dispatch in parallel
-//
-
-// ---------------------------------------------------------------------------
-// Conflict domain classification — which system labels are write-critical
-// ---------------------------------------------------------------------------
-
-/** Systems where concurrent writes from two dispatches would corrupt state. */
-const WRITE_CRITICAL_DOMAINS = new Set([
-  "Supabase / Database",
-  "Database migrations",
-  "Auth",
-  "Payment / Billing",
-  "Redis",
-  "Storage / uploads",
-]);
-
-/** Systems where concurrent access risks evidence/config corruption but isn't guaranteed destructive. */
-const RISKY_OVERLAP_DOMAINS = new Set([
-  "Config",
-  "Middleware",
-  "API routes",
-  "Tests",
-]);
-
-/** Systems that are inherently parallel-safe (read-heavy, isolated). */
-const SAFE_OVERLAP_DOMAINS = new Set([
-  "UI components",
-  "Library / utilities",
-  "Styles",
-]);
-
-// ---------------------------------------------------------------------------
-// Schemas
-// ---------------------------------------------------------------------------
-
-export const parallelConflictClassificationSchema = z.enum([
-  "parallel_safe",
-  "parallel_risky",
-  "parallel_blocked",
-]);
-
-export const parallelConflictReasonSchema = z.object({
-  domain: z.string(),
-  severity: z.enum(["blocked", "risky"]),
-  detail: z.string(),
-});
-
-export const parallelConflictResultSchema = z.object({
-  classification: parallelConflictClassificationSchema,
-  candidate_systems: z.array(z.string()),
-  active_systems: z.array(z.string()),
-  overlapping_systems: z.array(z.string()),
-  conflict_reasons: z.array(parallelConflictReasonSchema),
-  checked_at: z.string(),
-  active_dispatch_id: z.string().default(""),
-});
-
-export type ParallelConflictClassification = z.infer<typeof parallelConflictClassificationSchema>;
-export type ParallelConflictReason = z.infer<typeof parallelConflictReasonSchema>;
-export type ParallelConflictResult = z.infer<typeof parallelConflictResultSchema>;
-
-// ---------------------------------------------------------------------------
-// Active dispatch descriptor — what the guard checks against
-// ---------------------------------------------------------------------------
-
-export type ActiveDispatchDescriptor = {
-  dispatch_id: string;
-  systems_in_play: string[];
-  scope: string[];
-  slice_id: string;
-};
-
-// ---------------------------------------------------------------------------
-// Core conflict evaluation
-// ---------------------------------------------------------------------------
-
-/**
- * Evaluate whether a candidate dispatch can safely run in parallel with
- * already-active dispatches.
- *
- * @param candidateSystems  - systems the candidate dispatch expects to touch
- * @param candidateScope    - scope areas (file path hints, module names) for the candidate
- * @param activeDispatches  - descriptors for currently-active dispatches
- * @returns structured conflict result with classification and reasons
- */
-export function evaluateParallelConflict(
-  candidateSystems: string[],
-  candidateScope: string[],
-  activeDispatches: ActiveDispatchDescriptor[],
-): ParallelConflictResult {
-  if (activeDispatches.length === 0) {
-    return parallelConflictResultSchema.parse({
-      classification: "parallel_safe",
-      candidate_systems: candidateSystems,
-      active_systems: [],
-      overlapping_systems: [],
-      conflict_reasons: [],
-      checked_at: new Date().toISOString(),
-    });
-  }
-
-  // Aggregate all systems from active dispatches
-  const allActiveSystems = new Set<string>();
-  for (const d of activeDispatches) {
-    for (const s of d.systems_in_play) allActiveSystems.add(s);
-  }
-
-  // Also detect systems from scope hints (file path patterns)
-  const candidateDetected = detectSystemsFromScope(candidateScope);
-  const allCandidateSystems = new Set([...candidateSystems, ...candidateDetected]);
-
-  const activeDetected = new Set<string>();
-  for (const d of activeDispatches) {
-    for (const s of detectSystemsFromScope(d.scope)) activeDetected.add(s);
-  }
-  const allActive = new Set([...allActiveSystems, ...activeDetected]);
-
-  // Find overlapping systems
-  const overlapping = [...allCandidateSystems].filter(s => allActive.has(s));
-
-  // Classify each overlap — track which dispatch caused it
-  const reasons: ParallelConflictReason[] = [];
-  let conflictSourceId = "";
-
-  for (const system of overlapping) {
-    // Find which active dispatch owns this system overlap
-    const sourceDispatch = findConflictSource(system, activeDispatches);
-
-    if (WRITE_CRITICAL_DOMAINS.has(system)) {
-      if (!conflictSourceId && sourceDispatch) conflictSourceId = sourceDispatch.dispatch_id;
-      reasons.push({
-        domain: system,
-        severity: "blocked",
-        detail: `Both dispatches touch "${system}" — concurrent writes to this domain risk state corruption.`,
-      });
-    } else if (RISKY_OVERLAP_DOMAINS.has(system)) {
-      if (!conflictSourceId && sourceDispatch) conflictSourceId = sourceDispatch.dispatch_id;
-      reasons.push({
-        domain: system,
-        severity: "risky",
-        detail: `Both dispatches touch "${system}" — concurrent changes could cause merge conflicts or inconsistent state.`,
-      });
-    }
-    // SAFE_OVERLAP_DOMAINS: no conflict reason generated
-  }
-
-  // Also check for direct scope overlap (file path prefix collisions)
-  const scopeConflicts = detectScopeOverlap(candidateScope, activeDispatches);
-  reasons.push(...scopeConflicts);
-
-  // Determine classification from the worst severity
-  let classification: ParallelConflictClassification = "parallel_safe";
-  if (reasons.some(r => r.severity === "risky")) classification = "parallel_risky";
-  if (reasons.some(r => r.severity === "blocked")) classification = "parallel_blocked";
-
-  // active_dispatch_id: the dispatch that caused the highest-severity conflict,
-  // falling back to the first active dispatch if no system-level conflict was found
-  if (!conflictSourceId && activeDispatches.length > 0) {
-    const first = activeDispatches.at(0);
-    if (first?.dispatch_id) conflictSourceId = first.dispatch_id;
-  }
-
-  return parallelConflictResultSchema.parse({
-    classification,
-    candidate_systems: [...allCandidateSystems],
-    active_systems: [...allActive],
-    overlapping_systems: overlapping,
-    conflict_reasons: reasons,
-    checked_at: new Date().toISOString(),
-    active_dispatch_id: conflictSourceId,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Conflict source attribution — find the dispatch that owns the overlap
-// ---------------------------------------------------------------------------
-
-function findConflictSource(
-  system: string,
-  dispatches: ActiveDispatchDescriptor[],
-): ActiveDispatchDescriptor | undefined {
-  // Check explicit systems_in_play first
-  for (const d of dispatches) {
-    if (d.systems_in_play.includes(system)) return d;
-  }
-  // Check scope-detected systems
-  for (const d of dispatches) {
-    const detected = detectSystemsFromScope(d.scope);
-    if (detected.includes(system)) return d;
-  }
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Scope overlap detection — file path prefix collisions
-// ---------------------------------------------------------------------------
-
-function detectScopeOverlap(
-  candidateScope: string[],
-  activeDispatches: ActiveDispatchDescriptor[],
-): ParallelConflictReason[] {
-  const reasons: ParallelConflictReason[] = [];
-
-  // Normalize scope entries to common path prefixes
-  const candidatePrefixes = scopeToPrefixes(candidateScope);
-  for (const dispatch of activeDispatches) {
-    const activePrefixes = scopeToPrefixes(dispatch.scope);
-    for (const cp of candidatePrefixes) {
-      for (const ap of activePrefixes) {
-        if (cp === ap || cp.startsWith(ap + "/") || ap.startsWith(cp + "/")) {
-          // Check if this is a write-critical path
-          const isCritical = isWriteCriticalPath(cp) || isWriteCriticalPath(ap);
-          reasons.push({
-            domain: `scope:${cp}`,
-            severity: isCritical ? "blocked" : "risky",
-            detail: `Candidate scope "${cp}" overlaps with active dispatch scope "${ap}"${isCritical ? " in a write-critical area" : ""}.`,
-          });
-        }
-      }
-    }
-  }
-
-  return reasons;
-}
-
-/** Extract meaningful path prefixes from scope entries. */
-function scopeToPrefixes(scope: string[]): string[] {
-  return scope
-    .map(s => s.trim())
-    .filter(s => s.includes("/") || s.includes("."))
-    .map(s => s.replace(/\/[^/]+$/, "")) // drop filename, keep directory
-    .filter(Boolean);
-}
-
-/** Check if a path prefix is in a write-critical area. */
-function isWriteCriticalPath(prefix: string): boolean {
-  return /supabase|migration|auth|payment|billing|stripe|redis/i.test(prefix);
-}
-
-// ---------------------------------------------------------------------------
-// System detection from scope hints — reuses SYSTEM_PATTERNS
-// ---------------------------------------------------------------------------
-
-function detectSystemsFromScope(scope: string[]): string[] {
-  const systems = new Set<string>();
-  for (const entry of scope) {
-    for (const [pattern, label] of SYSTEM_PATTERNS) {
-      if (pattern.test(entry)) systems.add(label);
-    }
-  }
-  return [...systems];
-}