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

package/src/commands/packet.ts

@@ -1,408 +0,0 @@
-/**
- * switchboard packet <surface>
- *
- * Compiles an execution harness from canonical state, runs the meta-harness
- * compile pass automatically when eligible, validates packet integrity,
- * and writes the formatted dispatch packet to .switchboard/packets/.
- *
- * Supports all four V1 surfaces: claude, chatgpt, cursor, codex.
- *
- * Uses the best existing output shape for each surface:
- * - claude-code: sdk_prompt packet (written as markdown dispatch file)
- * - chatgpt:     sdk_prompt packet (written as markdown dispatch file)
- * - cursor:      clipboard packet (paste-ready markdown with operating notes)
- * - codex:       sdk_prompt packet (written as markdown dispatch file)
- *
- * Additionally generates a Claude runtime projection when targeting claude-code,
- * and an SBX bundle for cursor.
- *
- * Does not require the hosted web app, Supabase, or a running server.
- */
-
-import { randomBytes } from "crypto";
-import { existsSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import type { Command } from "commander";
-import {
-  compileExecutionHarness,
-  compileMetaHarness,
-  augmentPromptWithHarnessContext,
-  validateDispatchPacket,
-  formatFromHarness,
-  compileLoopContract,
-  getSurfacePlaybook,
-  handoffRecordSchema,
-  routingResultSchema,
-  type Surface,
-  type LoopContract,
-  type RoutingResult,
-  type DispatchPacket,
-  type PacketIntegrityResult,
-  type HandoffRecord,
-} from "@switchboard/core";
-import { generateSbxBundle } from "@switchboard/projections";
-import { generateClaudeRuntimeProjection } from "@switchboard/projections";
-import { requireRepoRoot, packetsDir } from "../lib/paths";
-import {
-  loadContract,
-  loadCurrentState,
-  loadSpec,
-  specExists as checkSpecExists,
-  writePacket,
-} from "../store/filesystem-store";
-import * as out from "../lib/output";
-import { withCliErrors } from "../lib/errors";
-import { enforceDriftGuard } from "../lib/drift-guard";
-
-// ---------------------------------------------------------------------------
-// Surface alias normalization
-// ---------------------------------------------------------------------------
-
-const SURFACE_ALIASES: Record<string, Surface> = {
-  claude: "claude-code",
-  "claude-code": "claude-code",
-  chatgpt: "chatgpt",
-  gpt: "chatgpt",
-  cursor: "cursor",
-  codex: "codex",
-};
-
-function resolveSurface(raw: string): Surface | null {
-  return SURFACE_ALIASES[raw.toLowerCase()] ?? null;
-}
-
-// ---------------------------------------------------------------------------
-// Forced-surface route builder
-// ---------------------------------------------------------------------------
-
-/** Surface-specific defaults for fallback, rationale, and return contract. */
-const SURFACE_ROUTE_DEFAULTS: Record<Surface, {
-  fallback: Surface;
-  rationale: string;
-  return_condition: string;
-}> = {
-  "claude-code": {
-    fallback: "codex",
-    rationale: "Operator-selected surface: Claude Code. Repo-native implementation with structured return.",
-    return_condition: "Return when the requested files are changed, relevant checks are run, and the implementation status is explicit.",
-  },
-  chatgpt: {
-    fallback: "claude-code",
-    rationale: "Operator-selected surface: ChatGPT. Structured clarification or compile pass.",
-    return_condition: "Return with one clear decision, one exact next objective, and any narrowed scope boundaries.",
-  },
-  cursor: {
-    fallback: "claude-code",
-    rationale: "Operator-selected surface: Cursor. Close-control, visual, or taste-heavy editing.",
-    return_condition: "Return when the UI changes are coherent, the changed files are listed, and any taste-sensitive decisions are captured.",
-  },
-  codex: {
-    fallback: "claude-code",
-    rationale: "Operator-selected surface: Codex. Bounded, sandboxed implementation slice.",
-    return_condition: "Return when the bounded code change is complete, tests pass in the sandbox, and any broader repo dependencies are listed.",
-  },
-};
-
-/**
- * Build a complete, internally coherent route for a forced surface.
- * Every field is surface-appropriate — no leftover metadata from a
- * different surface's routing decision.
- */
-export function buildForcedSurfaceRoute(surface: Surface, objective: string): RoutingResult {
-  const defaults = SURFACE_ROUTE_DEFAULTS[surface];
-  return routingResultSchema.parse({
-    primary_recommendation: surface,
-    fallback_surface: defaults.fallback,
-    rationale: defaults.rationale,
-    next_objective: objective,
-    return_condition: defaults.return_condition,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Prompt generation from spec + loop
-// ---------------------------------------------------------------------------
-
-function buildDispatchPrompt(
-  specMarkdown: string,
-  loop: LoopContract,
-  surface: Surface,
-): string {
-  const sections: string[] = [];
-
-  sections.push("# Execution Brief\n");
-  sections.push(specMarkdown.trim());
-  sections.push("\n---\n");
-  sections.push("## Objective\n");
-  sections.push(loop.objective);
-  sections.push("\n## Scope In\n");
-  sections.push(loop.scope_in.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Scope Out\n");
-  sections.push(loop.scope_out.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Done When\n");
-  sections.push(loop.done_when.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Success Criteria\n");
-  sections.push(loop.success_criteria.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Verify With\n");
-  sections.push(loop.verify_with.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Return When\n");
-  sections.push(loop.return_when);
-  sections.push("\n## Blocker Escalation\n");
-  sections.push(loop.blocker_escalation.map(s => `- ${s}`).join("\n"));
-
-  return sections.join("\n");
-}
-
-// ---------------------------------------------------------------------------
-// Packet file rendering
-// ---------------------------------------------------------------------------
-
-function renderPacketFile(packet: DispatchPacket, integrityResult: PacketIntegrityResult): string {
-  const sections: string[] = [];
-
-  sections.push("---");
-  sections.push(`dispatch_id: ${packet.metadata.dispatch_id}`);
-  sections.push(`surface: ${packet.surface}`);
-  sections.push(`format: ${packet.format}`);
-  sections.push(`integrity: ${integrityResult.outcome}`);
-  sections.push(`generated_at: ${new Date().toISOString()}`);
-  sections.push("---\n");
-
-  if (packet.format === "clipboard") {
-    sections.push(packet.preamble);
-    sections.push("\n---\n");
-    sections.push(packet.body);
-    sections.push("\n---\n");
-    sections.push(packet.return_instructions);
-  } else if (packet.format === "sdk_prompt") {
-    sections.push(`# Switchboard Dispatch — ${packet.metadata.contract_title}\n`);
-    sections.push(`**Surface:** ${packet.surface}`);
-    sections.push(`**Dispatch ID:** ${packet.metadata.dispatch_id}`);
-    sections.push(`**Objective:** ${packet.metadata.objective}\n`);
-    if (packet.working_directory) {
-      sections.push(`**Working directory:** ${packet.working_directory}\n`);
-    }
-    sections.push("---\n");
-    sections.push(packet.prompt);
-  } else if (packet.format === "file_drop") {
-    sections.push(packet.content);
-  }
-
-  // Integrity findings
-  if (integrityResult.findings.length > 0) {
-    sections.push("\n---\n");
-    sections.push("## Packet Integrity Findings\n");
-    for (const f of integrityResult.findings) {
-      const icon = f.severity === "blocking" ? "BLOCKED" : "CAUTION";
-      sections.push(`- [${icon}] ${f.field}: ${f.detail}`);
-    }
-  }
-
-  return sections.join("\n");
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-export function registerPacketCommand(program: Command): void {
-  program
-    .command("packet")
-    .argument("<surface>", "Target surface: claude, chatgpt, cursor, codex")
-    .description("Generate a governed dispatch packet for a target surface")
-    .option("--force", "Generate even if integrity check has blocking findings")
-    .action(withCliErrors(async (surfaceArg: string, opts: { force?: boolean }) => {
-      const repoRoot = requireRepoRoot();
-      const surface = resolveSurface(surfaceArg);
-
-      if (!surface) {
-        out.fail(`Unknown surface: "${surfaceArg}". Use: claude, chatgpt, cursor, codex`);
-        process.exitCode = 1;
-        return;
-      }
-
-      out.heading(`switchboard packet ${surface}`);
-
-      // 1. Load canonical state
-      const contract = loadContract(repoRoot);
-      const current = loadCurrentState(repoRoot);
-      const spec = loadSpec(repoRoot) ?? "";
-
-      out.success(`Loaded contract: ${contract.title}`);
-
-      // 1b. Drift guard: detect loop.yaml / current.yaml objective mismatch
-      if (!enforceDriftGuard(repoRoot, current, !!opts.force)) {
-        process.exitCode = 1;
-        return;
-      }
-
-      // 2. Build a complete, surface-coherent route for the requested surface.
-      //    Always recompile the loop rather than reusing a cached loop.yaml,
-      //    because loop defaults (done_when, verify_with, success_criteria,
-      //    return_when, fallback_surface) are all surface-sensitive.
-      const route = buildForcedSurfaceRoute(surface, current.next_objective);
-
-      const loop = compileLoopContract({ contract, current, route });
-      out.section("Objective", loop.objective);
-      out.section("Surface", surface);
-
-      // 3. Generate dispatch ID
-      const dispatchId = `dsp-${randomBytes(8).toString("hex")}`;
-
-      const harness = compileExecutionHarness({
-        dispatch_id: dispatchId,
-        contract,
-        loop,
-        route,
-        working_directory: repoRoot,
-      });
-
-      out.success("Compiled execution harness");
-      out.section("Dispatch mode", harness.dispatch_mode);
-      out.section("Packet format", harness.packet_format);
-
-      // 5. Run meta-harness compile pass (backstage, automatic)
-      const metaResult = compileMetaHarness({
-        contract,
-        loop,
-        dispatchId,
-        specMarkdown: spec,
-      });
-
-      if (!metaResult.summary.selection.was_no_op) {
-        out.success(`Meta-harness: +${metaResult.summary.context_chars_added} chars context`);
-      } else {
-        out.info(`Meta-harness: no-op (${metaResult.summary.selection.no_op_reason})`);
-      }
-
-      // 6. Build dispatch prompt (spec + loop scope + meta-harness augmentation)
-      let prompt = buildDispatchPrompt(spec, loop, surface);
-      prompt = augmentPromptWithHarnessContext(prompt, metaResult.contextSections);
-
-      // 7. Validate packet integrity
-      const integrity = validateDispatchPacket({
-        contract,
-        loop,
-        prompt,
-        specMarkdown: spec,
-        specExists: checkSpecExists(repoRoot),
-        repoExists: contract.repo_status === "repo-present",
-        hasActiveHandoff: !!current.active_handoff_id,
-      });
-
-      if (integrity.outcome === "blocked" && !opts.force) {
-        out.fail(`Packet integrity: BLOCKED (${integrity.blocking_findings_count} blocking finding(s))`);
-        for (const f of integrity.findings.filter(f => f.severity === "blocking")) {
-          out.bullet(`${f.field}: ${f.detail}`);
-        }
-        out.info("Fix the blocking findings or use --force to generate anyway.");
-        process.exitCode = 1;
-        return;
-      }
-
-      if (integrity.outcome === "ready_with_cautions") {
-        out.warn(`Packet integrity: ready with ${integrity.caution_findings_count} caution(s)`);
-        for (const f of integrity.findings.filter(f => f.severity === "caution")) {
-          out.bullet(`${f.field}: ${f.detail}`);
-        }
-      } else if (integrity.outcome === "ready") {
-        out.success("Packet integrity: ready");
-      } else if (opts.force) {
-        out.warn(`Packet integrity: BLOCKED (forced)`);
-      }
-
-      // 8. Format the packet using existing dispatch formatter
-      const packet = formatFromHarness(harness, prompt);
-
-      // 9. Write packet file
-      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const packetFilename = `${surface}-${timestamp}-${dispatchId.slice(4, 12)}.md`;
-      const packetContent = renderPacketFile(packet, integrity);
-      const packetPath = writePacket(repoRoot, packetFilename, packetContent);
-
-      out.fileWritten("Dispatch packet", packetPath);
-
-      // 10. Build a HandoffRecord for projection generators
-      const handoff: HandoffRecord = handoffRecordSchema.parse({
-        handoff_id: dispatchId,
-        surface,
-        objective: loop.objective,
-        included_scope: loop.scope_in,
-        excluded_scope: loop.scope_out,
-        done_when: loop.done_when,
-        return_condition: loop.return_when,
-        loop,
-        readiness: { status: "ready" as const, issues: [] },
-        bundle_version: "SBX-v1" as const,
-        launched_at: new Date().toISOString(),
-      });
-
-      // 11. Surface-specific extras
-      if (surface === "claude-code") {
-        // Generate Claude runtime projection (CLAUDE.md + rules)
-        try {
-          const playbook = getSurfacePlaybook(surface);
-          const projection = generateClaudeRuntimeProjection({
-            contract,
-            current,
-            spec_markdown: spec,
-            handoff,
-            playbook,
-          });
-
-          const projDir = join(packetsDir(repoRoot), `claude-projection-${dispatchId.slice(4, 12)}`);
-          if (!existsSync(projDir)) mkdirSync(projDir, { recursive: true });
-
-          for (const file of projection.files) {
-            const filePath = join(projDir, file.path);
-            const fileDir = join(projDir, file.path.split("/").slice(0, -1).join("/"));
-            if (fileDir !== projDir && !existsSync(fileDir)) {
-              mkdirSync(fileDir, { recursive: true });
-            }
-            writeFileSync(filePath, file.content, "utf-8");
-          }
-
-          out.fileWritten("Claude runtime projection", projDir);
-        } catch (e) {
-          out.warn(`Could not generate Claude projection: ${e instanceof Error ? e.message : String(e)}`);
-        }
-      }
-
-      if (surface === "cursor") {
-        // Generate SBX bundle files (paste-ready bundle structure)
-        try {
-          const bundle = generateSbxBundle({
-            contract,
-            current,
-            spec_markdown: spec,
-            handoff,
-          });
-
-          const bundleDir = join(packetsDir(repoRoot), `sbx-bundle-${dispatchId.slice(4, 12)}`);
-          if (!existsSync(bundleDir)) mkdirSync(bundleDir, { recursive: true });
-
-          for (const file of bundle.files) {
-            writeFileSync(join(bundleDir, file.path), file.content, "utf-8");
-          }
-
-          out.fileWritten("SBX bundle", bundleDir);
-        } catch (e) {
-          out.warn(`Could not generate SBX bundle: ${e instanceof Error ? e.message : String(e)}`);
-        }
-      }
-
-      // Summary
-      out.heading("Packet ready");
-      out.section("Dispatch ID", dispatchId);
-      out.section("Surface", surface);
-      out.section("Integrity", integrity.outcome);
-
-      if (surface === "cursor") {
-        out.bullet("Copy the packet contents into Cursor or use the SBX bundle files");
-      } else if (surface === "claude-code") {
-        out.bullet("Use the Claude runtime projection or paste the packet into Claude Code");
-      } else {
-        out.bullet("Copy the packet contents into the target surface");
-      }
-    }));
-}