rax-flow 0.1.0

package/src/doctor.ts

@@ -0,0 +1,92 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { HostBridgeAdapter } from "@rax-flow/providers";
+import { c } from "./styles.js";
+
+interface DoctorOptions {
+  cwd: string;
+}
+
+interface RaxConfig {
+  defaultProvider?: string;
+  strongProvider?: string;
+  providers?: {
+    host?: { model?: string; mode?: "auto" | "bridge-only" | "mock"; bridgeCommandEnv?: string; timeoutMs?: number };
+  };
+}
+
+async function loadConfig(cwd: string): Promise<RaxConfig | null> {
+  const file = path.join(cwd, ".raxrc");
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw) as RaxConfig;
+  } catch {
+    return null;
+  }
+}
+
+function printLine(ok: boolean, label: string, details?: string) {
+  const icon = ok ? c.green("[ok]") : c.red("[fail]");
+  console.log(`${icon} ${label}${details ? ` - ${details}` : ""}`);
+}
+
+export async function runDoctor(options: DoctorOptions): Promise<number> {
+  console.log(c.blue("RAX-FLOW Doctor"));
+
+  const config = await loadConfig(options.cwd);
+  if (!config) {
+    printLine(false, "Missing .raxrc", "run `rax-flow install` first");
+    return 1;
+  }
+  printLine(true, "Found .raxrc");
+
+  const hostCfg = config.providers?.host;
+  const bridgeCommandEnv = hostCfg?.bridgeCommandEnv ?? "RAX_HOST_BRIDGE_COMMAND";
+  const bridgeCommand = process.env[bridgeCommandEnv];
+  const provider = new HostBridgeAdapter({
+    model: hostCfg?.model ?? "host-managed",
+    mode: hostCfg?.mode ?? "auto",
+    command: bridgeCommand,
+    timeoutMs: hostCfg?.timeoutMs ?? 10000
+  });
+
+  const health = await provider.healthCheck();
+  printLine(health, "Host provider health", `mode=${hostCfg?.mode ?? "auto"}`);
+
+  const hasBridgeFn = typeof (globalThis as Record<string, unknown>).__RAX_HOST_BRIDGE__ === "function";
+  printLine(hasBridgeFn || Boolean(bridgeCommand), "Bridge source", hasBridgeFn ? "global bridge function" : bridgeCommand ? `command via ${bridgeCommandEnv}` : "auto/mock fallback");
+
+  try {
+    const ping = await provider.callModel("doctor ping", { model: hostCfg?.model ?? "host-managed", maxTokens: 32, temperature: 0 });
+    printLine(true, "callModel test", `provider=${ping.provider} model=${ping.model}`);
+  } catch (error) {
+    printLine(false, "callModel test", String(error));
+    return 1;
+  }
+
+  try {
+    const structured = await provider.callStructured(
+      "doctor structured ping",
+      {
+        type: "object",
+        required: ["agent", "success", "confidence", "risks", "logs", "data"],
+        properties: {
+          agent: { type: "string" },
+          success: { type: "boolean" },
+          confidence: { type: "number" },
+          risks: { type: "array" },
+          logs: { type: "array" },
+          data: { type: "object" }
+        }
+      },
+      { model: hostCfg?.model ?? "host-managed", maxTokens: 128, temperature: 0 }
+    );
+    printLine(true, "callStructured test", `model=${structured.model}`);
+  } catch (error) {
+    printLine(false, "callStructured test", String(error));
+    return 1;
+  }
+
+  console.log(c.green("Doctor checks passed."));
+  return 0;
+}

package/src/evolve.ts

@@ -0,0 +1,74 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { c } from "./styles.js";
+
+interface EvolveOptions {
+    cwd: string;
+    history?: boolean;
+}
+
+interface Blueprint {
+    id: string;
+    version: string;
+    createdAt: string;
+    fitnessScore: number;
+    mutationType: string;
+    metadata?: {
+        message?: string;
+        reason?: string;
+    };
+}
+
+export async function showEvolution(options: EvolveOptions): Promise<number> {
+    const evolutionDir = path.join(options.cwd, ".rax-flow", "evolutions");
+
+    try {
+        const files = await readdir(evolutionDir);
+        const blueprintFiles = files.filter(f => f.startsWith("blueprint_") && f.endsWith(".json"));
+
+        if (blueprintFiles.length === 0) {
+            console.log(c.yellow("\nNo evolutions recorded yet. Run more tasks to trigger Darwinian mutations."));
+            return 0;
+        }
+
+        const blueprints: Blueprint[] = [];
+        for (const file of blueprintFiles) {
+            const raw = await readFile(path.join(evolutionDir, file), "utf8");
+            blueprints.push(JSON.parse(raw) as Blueprint);
+        }
+
+        // Sort by creation date
+        blueprints.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+
+        console.log(c.bold(c.magenta(`\n\n--- [GENETIC LINEAGE: RAX-FLOW] ---`)));
+        console.log(c.gray(`Found ${blueprints.length} evolutionary jumps.\n`));
+
+        blueprints.forEach((bp, i) => {
+            const connector = i === blueprints.length - 1 ? "└" : "├";
+            const branch = i === 0 ? "" : `  ${connector}── `;
+
+            const scoreColor = bp.fitnessScore >= 0.8 ? c.green : (bp.fitnessScore >= 0.6 ? c.yellow : c.red);
+
+            console.log(`${branch}${c.bold(bp.id)} ${c.gray(`v${bp.version}`)}`);
+            console.log(`     ${c.gray("Type:")} ${c.cyan(bp.mutationType)}`);
+            console.log(`     ${c.gray("Fitness:")} ${scoreColor(bp.fitnessScore.toFixed(2))}`);
+            if (bp.metadata?.reason || bp.metadata?.message) {
+                console.log(`     ${c.gray("Note:")} ${c.white(bp.metadata.reason || bp.metadata.message || "")}`);
+            }
+            if (i < blueprints.length - 1) {
+                console.log(`     ${c.gray("│")}`);
+            }
+        });
+
+        console.log(c.bold(c.cyan(`\nSurvival of the fittest: Blueprint ${blueprints[blueprints.length - 1]?.id} is currently dominant.`)));
+
+        return 0;
+    } catch (error) {
+        if ((error as any).code === "ENOENT") {
+            console.log(c.yellow("\nNo evolutions directory found. Run tasks first."));
+            return 0;
+        }
+        console.error(c.red(`Failed to read evolution history: ${error}`));
+        return 1;
+    }
+}

package/src/host-init-templates.ts

@@ -0,0 +1,134 @@
+export type HostTarget = "claude-code" | "codex" | "opencode" | "kilo" | "generic";
+
+export interface HostTemplate {
+  id: HostTarget;
+  title: string;
+  envHint: string;
+  chatHint: string;
+  bootstrapPromptBase: string[];
+  quickCommands: string[];
+  autoInjectMode: "native" | "scripted" | "manual";
+  sessionEntryExamples: string[];
+}
+
+export const HOST_TEMPLATES: Record<HostTarget, HostTemplate> = {
+  "claude-code": {
+    id: "claude-code",
+    title: "Claude Code",
+    envHint: "Export RAX_HOST_BRIDGE_COMMAND before starting Claude Code session.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt at the beginning of the chat.",
+    bootstrapPromptBase: [
+      "RAX-FLOW bootstrap (Claude Code)",
+      "- Enable host-native orchestration.",
+      "- Route generation through the configured host bridge.",
+      "- Keep structured JSON outputs for orchestration steps.",
+      "- Execute Verify -> Fix loop when schema validation fails.",
+      "- Report confidence, risk flags, and logs for each step."
+    ],
+    quickCommands: ["npx rax-flow doctor", "npx rax-flow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "scripted",
+    sessionEntryExamples: [
+      "claude-code chat --message-file .rax-flow/host-init/claude-code/BOOTSTRAP_PROMPT.txt",
+      "claude-code (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  codex: {
+    id: "codex",
+    title: "Codex",
+    envHint: "Set RAX_HOST_BRIDGE_COMMAND in the shell running Codex.",
+    chatHint: "Send BOOTSTRAP_PROMPT.txt as first instruction in session.",
+    bootstrapPromptBase: [
+      "RAX-FLOW bootstrap (Codex)",
+      "- Use host-native model execution through the host bridge.",
+      "- Produce strict structured outputs for all agent steps.",
+      "- Apply Verify -> Fix until valid schema or retry cap.",
+      "- Include confidence and risks in every final step."
+    ],
+    quickCommands: ["npx rax-flow doctor", "npx rax-flow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "scripted",
+    sessionEntryExamples: [
+      "codex chat --message-file .rax-flow/host-init/codex/BOOTSTRAP_PROMPT.txt",
+      "codex (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  opencode: {
+    id: "opencode",
+    title: "OpenCode",
+    envHint: "Configure RAX_HOST_BRIDGE_COMMAND in OpenCode terminal/runtime env.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt before requesting implementation.",
+    bootstrapPromptBase: [
+      "RAX-FLOW bootstrap (OpenCode)",
+      "- Activate host bridge orchestration mode.",
+      "- Keep responses compact but structured for agent pipeline.",
+      "- Trigger fix cycles on validation failures automatically.",
+      "- Emit step logs and confidence scores."
+    ],
+    quickCommands: ["npx rax-flow doctor", "npx rax-flow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "opencode chat --message-file .rax-flow/host-init/opencode/BOOTSTRAP_PROMPT.txt",
+      "opencode (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  kilo: {
+    id: "kilo",
+    title: "Kilo Code",
+    envHint: "Set RAX_HOST_BRIDGE_COMMAND in Kilo launch environment.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt as initialization message.",
+    bootstrapPromptBase: [
+      "RAX-FLOW bootstrap (Kilo)",
+      "- Run in host-native orchestration mode.",
+      "- Enforce structured output contract for each stage.",
+      "- Apply Verify -> Fix and escalate when confidence is low.",
+      "- Return actionable logs and risk flags."
+    ],
+    quickCommands: ["npx rax-flow doctor", "npx rax-flow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "kilo chat --message-file .rax-flow/host-init/kilo/BOOTSTRAP_PROMPT.txt",
+      "kilo (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  generic: {
+    id: "generic",
+    title: "Generic Host",
+    envHint: "Provide a bridge command through RAX_HOST_BRIDGE_COMMAND.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt at session start.",
+    bootstrapPromptBase: [
+      "RAX-FLOW bootstrap (Generic)",
+      "- Enable orchestration through host bridge.",
+      "- Return strict JSON for each orchestration step.",
+      "- Retry/fix invalid outputs automatically.",
+      "- Report confidence, risks, and logs."
+    ],
+    quickCommands: ["npx rax-flow doctor", "npx rax-flow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "your-host-cli chat --message-file .rax-flow/host-init/generic/BOOTSTRAP_PROMPT.txt",
+      "open session, then paste BOOTSTRAP_PROMPT.txt"
+    ]
+  }
+};
+
+export function parseHostTarget(value: string | undefined): HostTarget {
+  if (!value) return "generic";
+  if (value in HOST_TEMPLATES) return value as HostTarget;
+  return "generic";
+}
+
+export function listHostTargets(): HostTarget[] {
+  return Object.keys(HOST_TEMPLATES) as HostTarget[];
+}
+
+export function buildBootstrapPrompt(target: HostTarget, task?: string): string {
+  const template = HOST_TEMPLATES[target];
+  const lines = [...template.bootstrapPromptBase];
+
+  if (task && task.trim().length > 0) {
+    lines.push(`- Task context: ${task.trim()}`);
+    lines.push("- Keep orchestration aligned with this task context unless user changes scope.");
+  }
+
+  lines.push("- If bridge call fails, report issue clearly and keep orchestration state.");
+  return lines.join("\n");
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./install.js";
+export * from "./run.js";
+export * from "./benchmark.js";
+export * from "./doctor.js";
+export * from "./bridge-test.js";
+export * from "./init-host.js";
+export * from "./bootstrap.js";
+export * from "./host-init-templates.js";
+export * from "./bridge-adapter-templates.js";
+export * from "./vendor-manifests.js";

package/src/init-host.ts

@@ -0,0 +1,285 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { c } from "./styles.js";
+import { HOST_TEMPLATES, HostTarget, buildBootstrapPrompt, listHostTargets, parseHostTarget } from "./host-init-templates.js";
+import { generateVendorManifest, vendorManifestFilename, type HostManifestModel } from "./vendor-manifests.js";
+import { bridgeAdapterFilename, renderBridgeAdapter } from "./bridge-adapter-templates.js";
+
+interface InitHostOptions {
+  cwd: string;
+  target?: string;
+  printOnly?: boolean;
+  all?: boolean;
+  task?: string;
+}
+
+function bridgeCommand(adapterFile: string): string {
+  return `node ${adapterFile}`;
+}
+
+function renderSetupScript(command: string): string {
+  return [
+    "#!/usr/bin/env bash",
+    "set -e",
+    `export RAX_HOST_BRIDGE_COMMAND=\"${command}\"`,
+    'echo "RAX_HOST_BRIDGE_COMMAND configured"',
+    "echo \"Run: npx rax-flow doctor\"",
+    "echo \"Run: npx rax-flow run --prompt 'Build feature X' --stream\""
+  ].join("\n");
+}
+
+function renderInstructions(params: {
+  title: string;
+  envHint: string;
+  chatHint: string;
+  command: string;
+  adapterFile: string;
+  quickCommands: string[];
+  sessionEntryExamples: string[];
+  autoInjectMode: "native" | "scripted" | "manual";
+  task?: string;
+}): string {
+  const taskSection = params.task?.trim()
+    ? ["", "## Task context", `- ${params.task.trim()}`, "- Embedded into BOOTSTRAP_PROMPT.txt"]
+    : [];
+
+  return [
+    `# ${params.title} - Non-UI Initialization`,
+    "",
+    "## 1) Configure bridge command",
+    `- ${params.envHint}`,
+    `- Command: \`${params.command}\``,
+    `- Bridge adapter scaffold: \`${params.adapterFile}\``,
+    "- Replace callHostModel() with your editor runtime model call implementation.",
+    "- Configure bridge runtime values in `bridge-runtime-config.json`.",
+    "- Use `bridge-smoke-test.json` to validate structured response mapping.",
+    "",
+    "## 2) Chat bootstrap",
+    `- ${params.chatHint}`,
+    "- Use BOOTSTRAP_PROMPT.txt content.",
+    ...taskSection,
+    "",
+    "## 3) Session launch patterns",
+    `- Auto inject mode: \`${params.autoInjectMode}\``,
+    ...params.sessionEntryExamples.map((line) => `- \`${line}\``),
+    "",
+    "## 4) Validate",
+    ...params.quickCommands.map((cmd) => `- \`${cmd}\``)
+  ].join("\n");
+}
+
+function renderSessionStartScript(target: HostTarget, sessionEntryExamples: string[]): string {
+  const lines = [
+    "#!/usr/bin/env bash",
+    "set -e",
+    `echo \"RAX-FLOW session starter (${target})\"`,
+    "echo \"Use one of these commands (adapt to your local CLI):\""
+  ];
+
+  for (const entry of sessionEntryExamples) {
+    lines.push(`echo \"- ${entry}\"`);
+  }
+
+  lines.push("echo \"If unsupported, copy/paste BOOTSTRAP_PROMPT.txt manually.\"");
+  return lines.join("\n");
+}
+
+function renderRuntimeConfig(target: HostTarget, task?: string): string {
+  const payload = {
+    version: 1,
+    vendor: target,
+    model: "host-managed",
+    endpoint: null,
+    authEnv: null,
+    structuredMode: "json",
+    timeoutMs: 20000,
+    taskContext: task?.trim() || null,
+    notes: [
+      "Fill endpoint/auth fields if your host runtime requires external transport.",
+      "If host runtime is in-process, keep endpoint null and call runtime SDK directly in bridge adapter."
+    ]
+  };
+  return JSON.stringify(payload, null, 2);
+}
+
+function renderBridgeSmokeTest(target: HostTarget): string {
+  const payload = {
+    version: 1,
+    action: "callStructured",
+    prompt: "Smoke test structured output",
+    schema: {
+      type: "object",
+      required: ["agent", "success", "confidence", "risks", "logs", "data"],
+      properties: {
+        agent: { type: "string" },
+        success: { type: "boolean" },
+        confidence: { type: "number" },
+        risks: { type: "array" },
+        logs: { type: "array" },
+        data: { type: "object" }
+      }
+    },
+    options: { model: "host-managed", temperature: 0, maxTokens: 256 },
+    meta: { target }
+  };
+  return JSON.stringify(payload, null, 2);
+}
+
+function renderManifest(params: {
+  target: HostTarget;
+  title: string;
+  autoInjectMode: "native" | "scripted" | "manual";
+  bridgeCommand: string;
+  quickCommands: string[];
+  sessionEntryExamples: string[];
+  bootstrapPromptFile: string;
+  instructionsFile: string;
+  adapterFile: string;
+  runtimeConfigFile: string;
+  smokeTestFile: string;
+  vendorFile: string;
+  task?: string;
+}): HostManifestModel {
+  return {
+    version: 2,
+    target: params.target,
+    title: params.title,
+    autoInjectMode: params.autoInjectMode,
+    bridgeCommand: params.bridgeCommand,
+    quickCommands: params.quickCommands,
+    sessionEntryExamples: params.sessionEntryExamples,
+    task: params.task ?? null,
+    files: {
+      bootstrapPrompt: params.bootstrapPromptFile,
+      instructions: params.instructionsFile,
+      bridgeAdapter: params.adapterFile,
+      bridgeRuntimeConfig: params.runtimeConfigFile,
+      bridgeSmokeTest: params.smokeTestFile,
+      vendorManifest: params.vendorFile
+    }
+  };
+}
+
+async function generateForTarget(cwd: string, target: HostTarget, task?: string): Promise<{ dir: string; bootstrapPrompt: string; quickCommands: string[] }> {
+  const template = HOST_TEMPLATES[target];
+  const baseDir = path.join(cwd, ".rax-flow", "host-init", target);
+  const adapterFile = path.join(baseDir, bridgeAdapterFilename(target));
+  const command = bridgeCommand(adapterFile);
+
+  await mkdir(baseDir, { recursive: true });
+
+  const setupSh = renderSetupScript(command);
+  const sessionStartSh = renderSessionStartScript(target, template.sessionEntryExamples);
+  const bootstrapPrompt = buildBootstrapPrompt(target, task);
+  const bridgeAdapter = renderBridgeAdapter(target);
+  const instructions = renderInstructions({
+    title: template.title,
+    envHint: template.envHint,
+    chatHint: template.chatHint,
+    command,
+    adapterFile,
+    quickCommands: template.quickCommands,
+    sessionEntryExamples: template.sessionEntryExamples,
+    autoInjectMode: template.autoInjectMode,
+    task
+  });
+
+  const bootstrapPromptFile = path.join(baseDir, "BOOTSTRAP_PROMPT.txt");
+  const instructionsFile = path.join(baseDir, "INSTRUCTIONS.md");
+  const runtimeConfigFile = path.join(baseDir, "bridge-runtime-config.json");
+  const smokeTestFile = path.join(baseDir, "bridge-smoke-test.json");
+  const vendorFile = vendorManifestFilename(target);
+  const manifestObj = renderManifest({
+    target,
+    title: template.title,
+    autoInjectMode: template.autoInjectMode,
+    bridgeCommand: command,
+    quickCommands: template.quickCommands,
+    sessionEntryExamples: template.sessionEntryExamples,
+    bootstrapPromptFile,
+    instructionsFile,
+    adapterFile,
+    runtimeConfigFile,
+    smokeTestFile,
+    vendorFile: path.join(baseDir, vendorFile),
+    task
+  });
+  const manifest = JSON.stringify(manifestObj, null, 2);
+  const vendorManifest = generateVendorManifest(target, baseDir, manifestObj);
+
+  await writeFile(path.join(baseDir, "setup-bridge.sh"), `${setupSh}\n`, "utf8");
+  await writeFile(path.join(baseDir, "start-session.sh"), `${sessionStartSh}\n`, "utf8");
+  await writeFile(adapterFile, `${bridgeAdapter}\n`, "utf8");
+  await writeFile(runtimeConfigFile, `${renderRuntimeConfig(target, task)}\n`, "utf8");
+  await writeFile(smokeTestFile, `${renderBridgeSmokeTest(target)}\n`, "utf8");
+  await writeFile(bootstrapPromptFile, `${bootstrapPrompt}\n`, "utf8");
+  await writeFile(instructionsFile, `${instructions}\n`, "utf8");
+  await writeFile(path.join(baseDir, "host-manifest.json"), `${manifest}\n`, "utf8");
+  await writeFile(path.join(baseDir, vendorFile), `${JSON.stringify(vendorManifest, null, 2)}\n`, "utf8");
+
+  return { dir: baseDir, bootstrapPrompt, quickCommands: template.quickCommands };
+}
+
+async function generateSummary(cwd: string, generated: Array<{ target: HostTarget; dir: string }>, task?: string): Promise<string> {
+  const summaryFile = path.join(cwd, ".rax-flow", "host-init", "INIT_SUMMARY.md");
+  const body = [
+    "# RAX-FLOW Host Init Summary",
+    "",
+    ...(task?.trim() ? ["Task context:", `- ${task.trim()}`, ""] : []),
+    "Generated targets:",
+    ...generated.map((item) => `- ${item.target}: \`${item.dir}\``),
+    "",
+    "Recommended sequence:",
+    "1. Review bridge-adapter-*.mjs and wire host runtime in callHostModel",
+    "2. Source setup-bridge.sh for your target",
+    "3. Run start-session.sh for launch hints",
+    "4. Paste BOOTSTRAP_PROMPT.txt into chat start",
+    "5. Run `npx rax-flow doctor`",
+    "6. Run `npx rax-flow run --prompt \"Build feature X\" --stream`"
+  ].join("\n");
+  await writeFile(summaryFile, `${body}\n`, "utf8");
+  return summaryFile;
+}
+
+export async function runInitHost(options: InitHostOptions): Promise<number> {
+  const targets = options.all ? listHostTargets() : [parseHostTarget(options.target)];
+
+  if (options.printOnly) {
+    for (const target of targets) {
+      const template = HOST_TEMPLATES[target];
+      const bootstrapPrompt = buildBootstrapPrompt(target, options.task);
+      console.log(c.blue(`RAX-FLOW Host Init (print) - ${target}`));
+      console.log(bootstrapPrompt);
+      console.log("quick commands:");
+      template.quickCommands.forEach((cmd) => console.log(`- ${cmd}`));
+      console.log("session launch patterns:");
+      template.sessionEntryExamples.forEach((line) => console.log(`- ${line}`));
+    }
+    return 0;
+  }
+
+  const generated: Array<{ target: HostTarget; dir: string }> = [];
+
+  for (const target of targets) {
+    const out = await generateForTarget(options.cwd, target, options.task);
+    generated.push({ target, dir: out.dir });
+    console.log(c.blue("RAX-FLOW Host Init"));
+    console.log(`target: ${target}`);
+    if (options.task?.trim()) {
+      console.log(`task context: ${options.task.trim()}`);
+    }
+    console.log(c.green(`Generated ${path.join(out.dir, "INSTRUCTIONS.md")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "BOOTSTRAP_PROMPT.txt")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "setup-bridge.sh")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "start-session.sh")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, bridgeAdapterFilename(target))}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "bridge-runtime-config.json")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "bridge-smoke-test.json")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, "host-manifest.json")}`));
+    console.log(c.green(`Generated ${path.join(out.dir, vendorManifestFilename(target))}`));
+  }
+
+  const summary = await generateSummary(options.cwd, generated, options.task);
+  console.log(c.green(`Generated ${summary}`));
+  return 0;
+}