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

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

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

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

@@ -1,163 +0,0 @@
-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;
-}