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

package/node_modules/@switchboard/core/src/project-charter.ts

@@ -0,0 +1,193 @@
+import type {
+  ComplexityClassification,
+  ProjectCharter,
+  ProjectContract,
+  SynthesizedSeed,
+} from "./types";
+import { projectCharterSchema } from "./types";
+
+// ---------------------------------------------------------------------------
+// System detection from seed + constraints
+// ---------------------------------------------------------------------------
+
+const SYSTEM_KEYWORDS: [RegExp, string][] = [
+  [/\bsupabase\b/i, "Supabase"],
+  [/\bpostgres\b/i, "Postgres"],
+  [/\bredis\b/i, "Redis"],
+  [/\bauth\b/i, "Auth"],
+  [/\bapi\s+route\b|\bendpoint\b/i, "API routes"],
+  [/\bmiddleware\b/i, "Middleware"],
+  [/\bnext\.?js\b/i, "Next.js"],
+  [/\btailwind\b/i, "Tailwind CSS"],
+  [/\bnotion\b/i, "Notion"],
+  [/\bclaude\b|\bllm\b|\bai\s+api\b/i, "AI / LLM"],
+  [/\bserver\s+(?:actions?|components?)\b/i, "Server components"],
+  [/\bCSV\b/i, "CSV"],
+  [/\bfile\s+upload\b|\bstorage\b/i, "Storage / uploads"],
+  [/\bcli\b/i, "CLI"],
+  [/\bnode\b/i, "Node.js"],
+];
+
+function detectSystemsFromText(text: string): string[] {
+  const systems = new Set<string>();
+  for (const [pattern, label] of SYSTEM_KEYWORDS) {
+    if (pattern.test(text)) systems.add(label);
+  }
+  return [...systems];
+}
+
+function dedupeSimilarLines(lines: string[]): string[] {
+  const out: string[] = [];
+  const keys: string[] = [];
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t) continue;
+    const k = t.toLowerCase().replace(/\s+/g, " ");
+    let dup = false;
+    for (const ex of keys) {
+      if (k === ex) {
+        dup = true;
+        break;
+      }
+      if (k.length > 24 && ex.length > 24 && (k.includes(ex) || ex.includes(k))) {
+        dup = true;
+        break;
+      }
+    }
+    if (dup) continue;
+    keys.push(k);
+    out.push(t);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Derive project charter from activation output
+// ---------------------------------------------------------------------------
+
+export function deriveProjectCharter(input: {
+  contract: ProjectContract;
+  seed: SynthesizedSeed;
+  complexity: ComplexityClassification | null;
+  rawIdea: string;
+  constraints: string;
+}): ProjectCharter {
+  const { contract, seed, complexity, rawIdea, constraints } = input;
+  const combined = `${rawIdea}\n${constraints}\n${seed.proposed_solution}\n${seed.v1_outcome}`;
+
+  // Intent: what change is being requested
+  const intent = seed.task_type === "implementation-request"
+    ? `Implement: ${seed.proposed_solution || seed.v1_outcome}`
+    : `Build: ${seed.proposed_solution || seed.one_liner}`;
+
+  // Scope in: from task clauses or inferred (never repeat the same line as direction / outcome)
+  const scope_in = dedupeSimilarLines(
+    contract.task_clauses.scope_in.length > 0
+      ? contract.task_clauses.scope_in
+      : seed.first_build_slice
+        ? [seed.first_build_slice]
+        : [seed.v1_outcome],
+  );
+
+  // Scope out: from task clauses + non-goals
+  const scope_out = contract.task_clauses.scope_out.length > 0
+    ? contract.task_clauses.scope_out
+    : contract.non_goals.slice(0, 5);
+
+  // Protected boundaries: non-goals are the protection layer
+  const protected_boundaries = contract.non_goals;
+
+  // Systems: from task clauses or inferred from text
+  const systems_touched = contract.task_clauses.systems_expected.length > 0
+    ? contract.task_clauses.systems_expected
+    : detectSystemsFromText(combined);
+
+  // Repo binding
+  const repo_binding = contract.repo_status === "repo-present"
+    ? "Bound to existing repository."
+    : "No repository yet — will be created on first execution.";
+
+  // Unresolved assumptions: from missing_inputs + open_questions
+  const unresolved_assumptions = [
+    ...seed.missing_inputs.filter(Boolean),
+    ...seed.open_questions.filter(Boolean),
+  ];
+
+  // Missingness: what's weak or absent
+  const missingness: string[] = [];
+  if (!seed.first_build_slice) missingness.push("First build slice not specified.");
+  if (seed.confidence === "low") missingness.push("Low confidence in extracted intent.");
+  if (seed.missing_inputs.length > 0) missingness.push(`${seed.missing_inputs.length} missing input(s).`);
+  if (complexity?.mode === "governance") missingness.push("Scope too broad — governance mode engaged.");
+  if (seed.target_user.toLowerCase().includes("developer") && seed.task_type === "product-idea") {
+    missingness.push("Target user may be too generic — consider narrowing.");
+  }
+
+  return projectCharterSchema.parse({
+    title: contract.title,
+    intent,
+    target_user: contract.target_user,
+    first_bounded_slice: seed.first_build_slice || "",
+    scope_in,
+    scope_out,
+    protected_boundaries,
+    systems_touched,
+    repo_binding,
+    unresolved_assumptions,
+    missingness,
+    confidence: seed.confidence,
+    task_type: seed.task_type ?? "unknown",
+    created_at: new Date().toISOString(),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Populate task clauses from activation context
+// ---------------------------------------------------------------------------
+
+export function deriveTaskClauses(input: {
+  seed: SynthesizedSeed;
+  rawIdea: string;
+  constraints: string;
+  repoExists: boolean;
+}): ProjectContract["task_clauses"] {
+  const { seed, rawIdea, constraints, repoExists } = input;
+  const combined = `${rawIdea}\n${constraints}\n${seed.proposed_solution}`;
+
+  // Scope in — one bounded line per slot; drop duplicates of the same substantive text
+  const scope_in = dedupeSimilarLines(
+    [seed.first_build_slice, seed.v1_outcome].filter(Boolean) as string[],
+  );
+
+  // Scope out — derive from non-goals (first 3)
+  const scope_out = seed.non_goals.slice(0, 3);
+
+  // Systems expected
+  const systems_expected = detectSystemsFromText(combined);
+
+  // Must not widen — strongest non-goals
+  const must_not_widen = seed.non_goals.filter(ng =>
+    /\bnot\b|\bno\b|\bwithout\b|\bonly\b/i.test(ng)
+  ).slice(0, 3);
+
+  // Build constraints from explicit constraints input
+  const build_constraints: string[] = [];
+  if (constraints.trim()) {
+    for (const line of constraints.split(/[.\n]+/)) {
+      const trimmed = line.trim();
+      if (trimmed.length > 5) build_constraints.push(trimmed);
+    }
+  }
+  if (!repoExists) {
+    build_constraints.push("Repository does not exist yet — first execution creates it.");
+  }
+
+  return {
+    scope_in,
+    scope_out,
+    systems_expected,
+    files_allowed: [], // populated post-execution when file patterns are known
+    must_not_widen,
+    build_constraints: build_constraints.slice(0, 5),
+  };
+}

package/node_modules/@switchboard/core/src/proof-capture.ts

@@ -0,0 +1,319 @@
+import { createHash, randomBytes } from "crypto";
+import { mkdir, writeFile, readFile, readdir, stat } from "fs/promises";
+import { join } from "path";
+import YAML from "yaml";
+import type {
+  EvaluationResult,
+  ProofArtifact,
+  ProofArtifactKind,
+  ProofManifest,
+  ProvenanceLabel,
+} from "./types";
+import {
+  evaluationResultSchema,
+  proofArtifactSchema,
+  proofManifestSchema,
+} from "./types";
+
+// ---------------------------------------------------------------------------
+// Run proof folder — lifecycle
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a run-scoped proof folder.  Returns the absolute path.
+ *
+ * Layout:
+ *   .runs/<dispatchId>/proof/
+ *     manifest.yaml          — proof manifest (written at close)
+ *     transcript.txt         — raw execution transcript
+ *     dispatch-metadata.yaml — what was sent
+ *     structured-return.yaml — parsed return
+ *     ...additional artifacts
+ */
+export async function createRunProofFolder(
+  repoRoot: string,
+  dispatchId: string,
+): Promise<string> {
+  const proofDir = join(repoRoot, ".runs", dispatchId, "proof");
+  await mkdir(proofDir, { recursive: true });
+  return proofDir;
+}
+
+// ---------------------------------------------------------------------------
+// Content hashing
+// ---------------------------------------------------------------------------
+
+function hashContent(content: string | Buffer): string {
+  const buf = typeof content === "string" ? Buffer.from(content, "utf8") : content;
+  return createHash("sha256").update(buf).digest("hex").slice(0, 16);
+}
+
+// ---------------------------------------------------------------------------
+// Capture a single proof artifact
+// ---------------------------------------------------------------------------
+
+export async function captureProofArtifact(input: {
+  proofDir: string;
+  kind: ProofArtifactKind;
+  provenance: ProvenanceLabel;
+  filename: string;
+  content: string;
+  description?: string;
+}): Promise<ProofArtifact> {
+  const filePath = join(input.proofDir, input.filename);
+  await writeFile(filePath, input.content, "utf8");
+
+  const sizeBytes = Buffer.byteLength(input.content, "utf8");
+  const contentHash = hashContent(input.content);
+
+  return proofArtifactSchema.parse({
+    artifact_id: `prf-${randomBytes(6).toString("hex")}`,
+    kind: input.kind,
+    provenance: input.provenance,
+    filename: input.filename,
+    captured_at: new Date().toISOString(),
+    size_bytes: sizeBytes,
+    content_hash: contentHash,
+    description: input.description ?? "",
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Convenience: capture dispatch metadata as proof
+// ---------------------------------------------------------------------------
+
+export async function captureDispatchMetadata(input: {
+  proofDir: string;
+  dispatchId: string;
+  surface: string;
+  model: string;
+  prompt: string;
+  packetHash: string;
+  promptHash: string;
+}): Promise<ProofArtifact> {
+  const metadata = {
+    dispatch_id: input.dispatchId,
+    surface: input.surface,
+    model: input.model,
+    packet_hash: input.packetHash,
+    prompt_hash: input.promptHash,
+    prompt_length: input.prompt.length,
+    captured_at: new Date().toISOString(),
+  };
+
+  return captureProofArtifact({
+    proofDir: input.proofDir,
+    kind: "dispatch-metadata",
+    provenance: "captured",
+    filename: "dispatch-metadata.yaml",
+    content: YAML.stringify(metadata),
+    description: `Dispatch ${input.dispatchId} to ${input.surface} (${input.model})`,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Convenience: capture raw execution transcript
+// ---------------------------------------------------------------------------
+
+export async function captureExecutionTranscript(input: {
+  proofDir: string;
+  rawOutput: string;
+  model: string;
+  durationMs: number;
+}): Promise<ProofArtifact> {
+  const header = [
+    `# Execution Transcript`,
+    `# Model: ${input.model}`,
+    `# Duration: ${input.durationMs}ms`,
+    `# Captured: ${new Date().toISOString()}`,
+    `# Length: ${input.rawOutput.length} chars`,
+    `---`,
+    ``,
+  ].join("\n");
+
+  return captureProofArtifact({
+    proofDir: input.proofDir,
+    kind: "execution-transcript",
+    provenance: "captured",
+    filename: "transcript.txt",
+    content: header + input.rawOutput,
+    description: `Raw execution output (${input.rawOutput.length} chars, ${input.durationMs}ms)`,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Convenience: capture the structured return as proof
+// ---------------------------------------------------------------------------
+
+export async function captureStructuredReturn(input: {
+  proofDir: string;
+  structuredReturn: Record<string, unknown>;
+}): Promise<ProofArtifact> {
+  return captureProofArtifact({
+    proofDir: input.proofDir,
+    kind: "return-structured",
+    provenance: "derived",
+    filename: "structured-return.yaml",
+    content: YAML.stringify(input.structuredReturn),
+    description: "Parsed structured return from execution output",
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Build and write the proof manifest
+// ---------------------------------------------------------------------------
+
+export function buildProofManifest(input: {
+  dispatchId: string;
+  runFolder: string;
+  artifacts: ProofArtifact[];
+}): ProofManifest {
+  const capturedCount = input.artifacts.filter(a => a.provenance === "captured").length;
+  const reconstructedCount = input.artifacts.filter(a => a.provenance === "reconstructed").length;
+  const derivedCount = input.artifacts.filter(a => a.provenance === "derived").length;
+  const totalSizeBytes = input.artifacts.reduce((sum, a) => sum + a.size_bytes, 0);
+
+  return proofManifestSchema.parse({
+    manifest_id: `mfst-${randomBytes(6).toString("hex")}`,
+    dispatch_id: input.dispatchId,
+    run_folder: input.runFolder,
+    created_at: new Date().toISOString(),
+    artifacts: input.artifacts,
+    provenance_summary: {
+      captured_count: capturedCount,
+      reconstructed_count: reconstructedCount,
+      derived_count: derivedCount,
+      total_size_bytes: totalSizeBytes,
+    },
+  });
+}
+
+export async function writeProofManifest(
+  proofDir: string,
+  manifest: ProofManifest,
+): Promise<void> {
+  await writeFile(
+    join(proofDir, "manifest.yaml"),
+    YAML.stringify(manifest),
+    "utf8",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Scan an existing proof folder to enumerate artifacts
+// ---------------------------------------------------------------------------
+
+export async function scanProofFolder(proofDir: string): Promise<{
+  files: Array<{ name: string; size_bytes: number; content_hash: string }>;
+  totalBytes: number;
+}> {
+  try {
+    const entries = await readdir(proofDir);
+    let totalBytes = 0;
+    const files: Array<{ name: string; size_bytes: number; content_hash: string }> = [];
+    for (const entry of entries) {
+      const filePath = join(proofDir, entry);
+      const s = await stat(filePath).catch(() => null);
+      if (s?.isFile()) {
+        totalBytes += s.size;
+        // Read file to compute real content hash
+        const content = await readFile(filePath).catch(() => null);
+        const hash = content ? hashContent(content) : "";
+        files.push({ name: entry, size_bytes: s.size, content_hash: hash });
+      }
+    }
+    return { files, totalBytes };
+  } catch {
+    return { files: [], totalBytes: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Load a proof manifest from disk
+// ---------------------------------------------------------------------------
+
+export async function loadProofManifest(
+  repoRoot: string,
+  dispatchId: string,
+): Promise<ProofManifest | null> {
+  try {
+    const manifestPath = join(repoRoot, ".runs", dispatchId, "proof", "manifest.yaml");
+    const raw = await readFile(manifestPath, "utf8");
+    const parsed = YAML.parse(raw);
+    return proofManifestSchema.parse(parsed);
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Derive provenance summary suitable for deriveRunSnapshot input
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Evaluation result persistence — alongside proof artifacts
+// ---------------------------------------------------------------------------
+
+/**
+ * Persist an EvaluationResult as a YAML file in the run's proof folder.
+ * Layout: .runs/<dispatchId>/proof/evaluation-<evaluation_id>.yaml
+ */
+export async function persistEvaluationResult(
+  repoRoot: string,
+  dispatchId: string,
+  evaluation: EvaluationResult,
+): Promise<string> {
+  const proofDir = join(repoRoot, ".runs", dispatchId, "proof");
+  await mkdir(proofDir, { recursive: true });
+  const filename = `evaluation-${evaluation.evaluation_id}.yaml`;
+  const filePath = join(proofDir, filename);
+  await writeFile(filePath, YAML.stringify(evaluation), "utf8");
+  return filePath;
+}
+
+/**
+ * Load all EvaluationResults from a run's proof folder.
+ */
+export async function loadEvaluationResults(
+  repoRoot: string,
+  dispatchId: string,
+): Promise<EvaluationResult[]> {
+  const proofDir = join(repoRoot, ".runs", dispatchId, "proof");
+  try {
+    const entries = await readdir(proofDir);
+    const results: EvaluationResult[] = [];
+    for (const entry of entries) {
+      if (entry.startsWith("evaluation-") && entry.endsWith(".yaml")) {
+        const raw = await readFile(join(proofDir, entry), "utf8");
+        const parsed = YAML.parse(raw);
+        results.push(evaluationResultSchema.parse(parsed));
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Derive provenance summary suitable for deriveRunSnapshot input
+// ---------------------------------------------------------------------------
+
+export function deriveProofProvenance(manifest: ProofManifest | null): {
+  captured_count: number;
+  reconstructed_count: number;
+  derived_count: number;
+  has_execution_transcript: boolean;
+  proof_folder?: string;
+} | undefined {
+  if (!manifest) return undefined;
+  return {
+    captured_count: manifest.provenance_summary.captured_count,
+    reconstructed_count: manifest.provenance_summary.reconstructed_count,
+    derived_count: manifest.provenance_summary.derived_count,
+    has_execution_transcript: manifest.artifacts.some(
+      a => a.kind === "execution-transcript" && a.provenance === "captured",
+    ),
+    proof_folder: manifest.run_folder,
+  };
+}

package/node_modules/@switchboard/core/src/provider-registry.ts

@@ -0,0 +1,163 @@
+import type { CompilerSelection, ProviderEntry, ProviderId } from "./types";
+
+// ---------------------------------------------------------------------------
+// Provider registry
+//
+// Maps Switchboard's routing/compiler decisions to actual surface providers.
+// Each provider has: id, name, capability (compile|execute), whether it's
+// automated, current availability status, and required env vars.
+//
+// This is the boundary between Switchboard's control-plane decisions and
+// real execution surfaces. No consumer chat UI puppeteering.
+// ---------------------------------------------------------------------------
+
+export const PROVIDER_REGISTRY: ProviderEntry[] = [
+  // Automated execution
+  {
+    id: "claude-code-sdk",
+    name: "Claude Code (SDK)",
+    capability: "execute",
+    automated: true,
+    status: "needs-setup",
+    requires_env: ["ANTHROPIC_API_KEY"],
+  },
+
+  // Automated compile + execution via OpenAI Chat Completions
+  {
+    id: "openai-api",
+    name: "OpenAI API (ChatGPT)",
+    capability: "compile",
+    automated: true,
+    status: "available",
+    requires_env: ["OPENAI_API_KEY"],
+  },
+
+  // Automated execution via Codex (OpenAI Codex CLI)
+  {
+    id: "codex",
+    name: "Codex (execution)",
+    capability: "execute",
+    automated: true,
+    status: "needs-setup",
+    requires_env: ["OPENAI_API_KEY"],
+  },
+
+  // ChatGPT auto — compile + execute via OpenAI API (replaces former manual)
+  {
+    id: "chatgpt-auto",
+    name: "ChatGPT (auto)",
+    capability: "compile",
+    automated: true,
+    status: "available",
+    requires_env: ["OPENAI_API_KEY"],
+  },
+  {
+    id: "cursor-manual",
+    name: "Cursor (manual)",
+    capability: "execute",
+    automated: false,
+    status: "available",
+    requires_env: [],
+  },
+
+  // Internal fallback
+  {
+    id: "internal-fallback",
+    name: "Switchboard internal",
+    capability: "compile",
+    automated: true,
+    status: "available",
+    requires_env: [],
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Provider selection — map compiler decisions to real providers
+// ---------------------------------------------------------------------------
+
+export function selectProvider(
+  compiler: CompilerSelection,
+  capability: "compile" | "execute",
+): { primary: ProviderEntry; fallback: ProviderEntry } {
+  // For execution
+  if (capability === "execute") {
+    const claudeSDK = PROVIDER_REGISTRY.find((p) => p.id === "claude-code-sdk")!;
+    const chatgptAuto = PROVIDER_REGISTRY.find((p) => p.id === "chatgpt-auto")!;
+    const cursorManual = PROVIDER_REGISTRY.find((p) => p.id === "cursor-manual")!;
+    const codexProvider = PROVIDER_REGISTRY.find((p) => p.id === "codex")!;
+
+    // Claude Code SDK is the primary automated execution surface
+    if (compiler.recommended_surface === "claude-code") {
+      return { primary: claudeSDK, fallback: codexProvider };
+    }
+
+    // Codex: autonomous sandboxed execution
+    if (compiler.recommended_surface === "codex") {
+      return { primary: codexProvider, fallback: claudeSDK };
+    }
+
+    // Cursor: human-in-the-loop IDE editing
+    if (compiler.recommended_surface === "cursor") {
+      return { primary: cursorManual, fallback: claudeSDK };
+    }
+
+    // Default: Claude Code SDK
+    return { primary: claudeSDK, fallback: chatgptAuto };
+  }
+
+  // For compile
+  const openai = PROVIDER_REGISTRY.find((p) => p.id === "openai-api")!;
+  const chatgptAuto = PROVIDER_REGISTRY.find((p) => p.id === "chatgpt-auto")!;
+  const internalFallback = PROVIDER_REGISTRY.find((p) => p.id === "internal-fallback")!;
+
+  if (compiler.compiler_type === "fidelity-first") {
+    // Prefer OpenAI API if available, fall back to manual ChatGPT
+    return { primary: openai, fallback: internalFallback };
+  }
+
+  if (compiler.compiler_type === "internal-fallback") {
+    return { primary: internalFallback, fallback: chatgptAuto };
+  }
+
+  return { primary: chatgptAuto, fallback: internalFallback };
+}
+
+// ---------------------------------------------------------------------------
+// Check provider readiness
+// ---------------------------------------------------------------------------
+
+export function checkProviderReady(provider: ProviderEntry): {
+  ready: boolean;
+  missing: string[];
+} {
+  if (provider.status === "stub") {
+    return { ready: false, missing: [`${provider.name} is not yet implemented.`] };
+  }
+
+  const missingEnv = provider.requires_env.filter(
+    (key) => !process.env[key],
+  );
+
+  if (missingEnv.length > 0) {
+    return {
+      ready: false,
+      missing: missingEnv.map((k) => `Missing environment variable: ${k}`),
+    };
+  }
+
+  return { ready: true, missing: [] };
+}
+
+// ---------------------------------------------------------------------------
+// Provider display helpers
+// ---------------------------------------------------------------------------
+
+export function providerDisplayName(id: ProviderId): string {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === id);
+  return entry?.name ?? id;
+}
+
+export function isAutomatedProvider(id: ProviderId): boolean {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === id);
+  return entry?.automated ?? false;
+}