@ranker/raxflow 0.2.2 → 0.2.4

package/src/bin.ts

@@ -1,156 +0,0 @@
-#!/usr/bin/env node
-import { runInstall } from "./install.js";
-import { runBenchmark } from "./benchmark.js";
-import { runBootstrap } from "./bootstrap.js";
-import { runBridgeTest } from "./bridge-test.js";
-import { runDoctor } from "./doctor.js";
-import { runInitHost } from "./init-host.js";
-import { runWorkflow } from "./run.js";
-import { runDashboard } from "./dashboard.js";
-import { startHubOneShot } from "./hub/index.js";
-import { runSetup } from "./setup/index.js";
-
-function getFlag(args: string[], flag: string): string | undefined {
-  const index = args.indexOf(flag);
-  if (index === -1) return undefined;
-  return args[index + 1];
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  // Mode hub interactif (défaut) - sans arguments ou avec 'hub'
-  if (!command || command === "hub") {
-    const { startTUI } = await import("./tui/index.js");
-    startTUI();
-    return;
-  }
-
-  // Mode one-shot
-  if (command === "--run") {
-    const prompt = getFlag(args, "--run");
-    if (!prompt) {
-      console.error("Missing --run <prompt>");
-      process.exit(1);
-    }
-    await startHubOneShot("run", [prompt, ...args.slice(1)]);
-    return;
-  }
-
-  // Help pour le hub
-  if (command === "--help" || command === "-h") {
-    console.log("Usage: raxflow [command]");
-    console.log("");
-    console.log("Modes:");
-    console.log("  (no args)          Launch interactive hub (default)");
-    console.log("  hub                Launch interactive hub");
-    console.log("  --run <prompt>     One-shot mode (execute and exit)");
-    console.log("");
-    console.log("Setup:");
-    console.log("  setup              Interactive setup wizard (TUI)");
-    console.log("  install [--ui]     Legacy setup (alias for setup)");
-    console.log("");
-    console.log("Commands:");
-    console.log("  run --prompt <text> [--workflow path] [--json] [--stream] [--max-parallel N] [--no-cache-persist]");
-    console.log("                     Execute workflow");
-    console.log("                     Optional: [--provider host|openai|claude|rest] [--bridge-command \"node bridge.mjs\"]");
-    console.log("  benchmark --prompt <text> [--output path]   Compare baseline vs orchestrated");
-    console.log("                     Optional: [--provider host|openai|claude|rest] [--bridge-command \"node bridge.mjs\"]");
-    console.log("  doctor   Validate host-native bridge setup");
-    console.log("  bridge-test [--target claude-code|codex|opencode|kilo|generic]   Run bridge smoke payload");
-    console.log("  bootstrap [--target claude-code|codex|opencode|kilo|generic] [--task \"...\"] [--json]");
-    console.log("                     Print chat bootstrap prompt");
-    console.log("  dashboard [--port N]   Start the visual insights dashboard");
-    process.exit(0);
-  }
-
-  if (command === "install" || command === "setup") {
-    const code = await runSetup();
-    process.exit(code);
-  }
-
-  if (command === "run") {
-    const prompt = getFlag(args, "--prompt");
-    if (!prompt) {
-      console.error("Missing --prompt");
-      process.exit(1);
-    }
-    const workflowPath = getFlag(args, "--workflow");
-    const provider = getFlag(args, "--provider");
-    const bridgeCommand = getFlag(args, "--bridge-command");
-    const maxParallelRaw = getFlag(args, "--max-parallel");
-    const maxParallel = maxParallelRaw ? Number(maxParallelRaw) : undefined;
-    const code = await runWorkflow({
-      cwd: process.cwd(),
-      prompt,
-      workflowPath,
-      asJson: args.includes("--json"),
-      stream: args.includes("--stream"),
-      maxParallel: Number.isFinite(maxParallel) ? maxParallel : undefined,
-      noCachePersist: args.includes("--no-cache-persist"),
-      providerOverride: provider,
-      bridgeCommandOverride: bridgeCommand,
-      ui: args.includes("--ui")
-    });
-    process.exit(code);
-  }
-
-  if (command === "benchmark") {
-    const prompt = getFlag(args, "--prompt");
-    if (!prompt) {
-      console.error("Missing --prompt");
-      process.exit(1);
-    }
-    const output = getFlag(args, "--output");
-    const provider = getFlag(args, "--provider");
-    const bridgeCommand = getFlag(args, "--bridge-command");
-    const code = await runBenchmark({ cwd: process.cwd(), prompt, output, providerOverride: provider, bridgeCommandOverride: bridgeCommand });
-    process.exit(code);
-  }
-
-  if (command === "doctor") {
-    const code = await runDoctor({ cwd: process.cwd() });
-    process.exit(code);
-  }
-
-  if (command === "bridge-test") {
-    const target = getFlag(args, "--target");
-    const code = await runBridgeTest({ cwd: process.cwd(), target });
-    process.exit(code);
-  }
-
-  if (command === "init-host") {
-    const target = getFlag(args, "--target");
-    const task = getFlag(args, "--task");
-    const code = await runInitHost({ cwd: process.cwd(), target, printOnly: args.includes("--print"), all: args.includes("--all"), task });
-    process.exit(code);
-  }
-
-  if (command === "bootstrap") {
-    const target = getFlag(args, "--target");
-    const task = getFlag(args, "--task");
-    const code = await runBootstrap({ target, task, asJson: args.includes("--json") });
-    process.exit(code);
-  }
-
-  if (command === "dashboard") {
-    const port = getFlag(args, "--port");
-    const code = await runDashboard({ port: port ? Number(port) : 3003 });
-    process.exit(code);
-  }
-
-  if (command === "evolve") {
-    const { showEvolution } = await import("./evolve.js");
-    const code = await showEvolution({ cwd: process.cwd(), history: args.includes("--history") });
-    process.exit(code);
-  }
-
-  console.error(`Unknown command: ${command}`);
-  process.exit(1);
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});

package/src/bootstrap.ts

@@ -1,36 +0,0 @@
-import { c } from "./styles.js";
-import { HOST_TEMPLATES, buildBootstrapPrompt, parseHostTarget } from "./host-init-templates.js";
-
-interface BootstrapOptions {
-  target?: string;
-  asJson?: boolean;
-  task?: string;
-}
-
-export async function runBootstrap(options: BootstrapOptions): Promise<number> {
-  const target = parseHostTarget(options.target);
-  const template = HOST_TEMPLATES[target];
-  const prompt = buildBootstrapPrompt(target, options.task);
-
-  if (options.asJson) {
-    console.log(
-      JSON.stringify(
-        {
-          target,
-          title: template.title,
-          autoInjectMode: template.autoInjectMode,
-          prompt,
-          quickCommands: template.quickCommands,
-          sessionEntryExamples: template.sessionEntryExamples
-        },
-        null,
-        2
-      )
-    );
-    return 0;
-  }
-
-  console.log(c.blue(`RAX-FLOW Bootstrap Prompt (${target})`));
-  console.log(prompt);
-  return 0;
-}

package/src/bridge-adapter-templates.ts

@@ -1,181 +0,0 @@
-import { HostTarget } from "./host-init-templates.js";
-
-function vendorCallFunction(target: HostTarget): string {
-  if (target === "claude-code") return "callClaudeCodeRuntime";
-  if (target === "codex") return "callCodexRuntime";
-  if (target === "opencode") return "callOpenCodeRuntime";
-  if (target === "kilo") return "callKiloRuntime";
-  return "callGenericHostRuntime";
-}
-
-function vendorNotes(target: HostTarget): string {
-  if (target === "claude-code") {
-    return [
-      "// Claude Code integration notes:",
-      "// - Map `payload.action` to Claude Code message/runtime API.",
-      "// - Ensure structured mode returns strict JSON object, not markdown.",
-      ""
-    ].join("\n");
-  }
-  if (target === "codex") {
-    return [
-      "// Codex integration notes:",
-      "// - Map payload.options.model to your Codex runtime model selector.",
-      "// - For callStructured, return parsed JSON object only.",
-      ""
-    ].join("\n");
-  }
-  if (target === "opencode") {
-    return [
-      "// OpenCode integration notes:",
-      "// - Connect to OpenCode model invocation API/SDK.",
-      "// - Preserve latency and model name in response when possible.",
-      ""
-    ].join("\n");
-  }
-  if (target === "kilo") {
-    return [
-      "// Kilo integration notes:",
-      "// - Route both actions through Kilo's model runtime.",
-      "// - Handle model fallback inside runtime wrapper if supported.",
-      ""
-    ].join("\n");
-  }
-  return [
-    "// Generic host integration notes:",
-    "// - Replace runtime call with your environment-specific function.",
-    "// - Keep response aligned with HostBridgeResponse schema.",
-    ""
-  ].join("\n");
-}
-
-export function renderBridgeAdapter(target: HostTarget): string {
-  const runtimeFn = vendorCallFunction(target);
-  return [
-    "#!/usr/bin/env node",
-    "",
-    "/**",
-    ` * RAX-FLOW bridge adapter scaffold for ${target}.`,
-    " *",
-    " * Input : HostBridgeRequest JSON on stdin",
-    " * Output: HostBridgeResponse JSON on stdout",
-    " */",
-    "",
-    "import { readFileSync } from \"node:fs\";",
-    "import path from \"node:path\";",
-    "",
-    "function readStdin() {",
-    "  return new Promise((resolve) => {",
-    "    let data = \"\";",
-    "    process.stdin.setEncoding(\"utf8\");",
-    "    process.stdin.on(\"data\", (chunk) => { data += chunk; });",
-    "    process.stdin.on(\"end\", () => resolve(data));",
-    "  });",
-    "}",
-    "",
-    "function safeJsonParse(text) {",
-    "  try { return JSON.parse(text); } catch { return null; }",
-    "}",
-    "",
-    "function normalizeError(error) {",
-    "  if (!error) return \"unknown_error\";",
-    "  if (typeof error === \"string\") return error;",
-    "  return error.message || String(error);",
-    "}",
-    "",
-    "function isStructuredPayload(obj) {",
-    "  return obj && typeof obj === \"object\" &&",
-    "    typeof obj.agent === \"string\" &&",
-    "    typeof obj.success === \"boolean\" &&",
-    "    typeof obj.confidence === \"number\" &&",
-    "    Array.isArray(obj.risks) &&",
-    "    Array.isArray(obj.logs) &&",
-    "    obj.data && typeof obj.data === \"object\";",
-    "}",
-    "",
-    "function loadRuntimeConfig() {",
-    "  const file = path.join(process.cwd(), '.rax-flow', 'host-init', '" + target + "', 'bridge-runtime-config.json');",
-    "  try {",
-    "    return JSON.parse(readFileSync(file, 'utf8'));",
-    "  } catch {",
-    "    return {",
-    "      vendor: '" + target + "',",
-    "      model: 'host-managed',",
-    "      endpoint: null,",
-    "      authEnv: null,",
-    "      structuredMode: 'json',",
-    "      responseStrict: true,",
-    "      timeoutMs: 20000",
-    "    };",
-    "  }",
-    "}",
-    "",
-    vendorNotes(target),
-    "// callHostModel is the bridge interface for runtime calls",
-    `async function ${runtimeFn}(payload, runtimeConfig) {`,
-    "  // TODO: implement real runtime call for this vendor.",
-    "  // payload.action = callModel | callStructured",
-    "  // runtimeConfig can provide endpoint/auth/model/runtime settings.",
-    "  if (payload.action === 'callStructured') {",
-    "    return {",
-    "      ok: true,",
-    "      model: runtimeConfig.model || payload.options?.model || 'host-managed',",
-    "      latencyMs: 8,",
-    "      output: {",
-    "        agent: 'VendorBridgeTemplate',",
-    "        success: true,",
-    "        confidence: 0.73,",
-    "        risks: [],",
-    "        logs: ['replace with real vendor runtime response'],",
-    "        data: { summary: 'template structured output', nextAction: 'continue' }",
-    "      }",
-    "    };",
-    "  }",
-    "  return {",
-    "    ok: true,",
-    "    model: runtimeConfig.model || payload.options?.model || 'host-managed',",
-    "    latencyMs: 8,",
-    "    output: `template-text:${String(payload.prompt || '').slice(0, 220)}`",
-    "  };",
-    "}",
-    "",
-    "async function main() {",
-    "  const input = await readStdin();",
-    "  const payload = safeJsonParse(input);",
-    "  if (!payload || payload.version !== 1 || !payload.action) {",
-    "    process.stdout.write(JSON.stringify({ ok: false, error: 'invalid_payload' }));",
-    "    return;",
-    "  }",
-    "",
-    "  const runtimeConfig = loadRuntimeConfig();",
-    "",
-    "  try {",
-    `    const response = await ${runtimeFn}(payload, runtimeConfig);`,
-    "    if (payload.action === 'callStructured' && runtimeConfig.responseStrict) {",
-    "      if (!response || !isStructuredPayload(response.output)) {",
-    "        process.stdout.write(JSON.stringify({",
-    "          ok: false,",
-    "          error: 'structured_output_invalid',",
-    "          details: 'Ensure output contains agent/success/confidence/risks/logs/data',",
-    "        }));",
-    "        return;",
-    "      }",
-    "    }",
-    "    process.stdout.write(JSON.stringify(response));",
-    "  } catch (error) {",
-    "    process.stdout.write(JSON.stringify({ ok: false, error: `bridge_exception:${normalizeError(error)}` }));",
-    "  }",
-    "}",
-    "",
-    "main();",
-    ""
-  ].join("\n");
-}
-
-export function bridgeAdapterFilename(target: HostTarget): string {
-  if (target === "claude-code") return "bridge-adapter-claude-code.mjs";
-  if (target === "codex") return "bridge-adapter-codex.mjs";
-  if (target === "opencode") return "bridge-adapter-opencode.mjs";
-  if (target === "kilo") return "bridge-adapter-kilo.mjs";
-  return "bridge-adapter-generic.mjs";
-}

package/src/bridge-test.ts

@@ -1,107 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { c } from "./styles.js";
-import { parseHostTarget } from "./host-init-templates.js";
-
-interface BridgeTestOptions {
-  cwd: string;
-  target?: string;
-}
-
-function parseShellCommand(input: string): { command: string; args: string[] } {
-  const parts = input.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [];
-  if (parts.length === 0) {
-    throw new Error("invalid_bridge_command");
-  }
-  const [command, ...rawArgs] = parts;
-  const args = rawArgs.map((arg) => arg.replace(/^"|"$/g, ""));
-  return { command: command!, args };
-}
-
-async function runCommand(commandSpec: string, payload: unknown): Promise<{ code: number; stdout: string; stderr: string }> {
-  const { command, args } = parseShellCommand(commandSpec);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-
-    child.on("error", (error) => reject(error));
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
-
-    child.stdin.write(JSON.stringify(payload));
-    child.stdin.end();
-  });
-}
-
-export async function runBridgeTest(options: BridgeTestOptions): Promise<number> {
-  const target = parseHostTarget(options.target);
-  const baseDir = path.join(options.cwd, ".rax-flow", "host-init", target);
-  const manifestFile = path.join(baseDir, "host-manifest.json");
-  const smokeFile = path.join(baseDir, "bridge-smoke-test.json");
-
-  let manifest: { bridgeCommand?: string };
-  let smokePayload: unknown;
-
-  try {
-    manifest = JSON.parse(await readFile(manifestFile, "utf8")) as { bridgeCommand?: string };
-  } catch {
-    console.error(c.red(`Missing host manifest: ${manifestFile}`));
-    return 1;
-  }
-
-  try {
-    smokePayload = JSON.parse(await readFile(smokeFile, "utf8"));
-  } catch {
-    console.error(c.red(`Missing bridge smoke test payload: ${smokeFile}`));
-    return 1;
-  }
-
-  if (!manifest.bridgeCommand) {
-    console.error(c.red("host-manifest.json missing bridgeCommand"));
-    return 1;
-  }
-
-  const result = await runCommand(manifest.bridgeCommand, smokePayload);
-  console.log(c.blue(`RAX-FLOW Bridge Test (${target})`));
-  console.log(`command: ${manifest.bridgeCommand}`);
-  console.log(`exitCode: ${result.code}`);
-
-  if (result.stdout.trim()) {
-    console.log("stdout:");
-    console.log(result.stdout.trim());
-  }
-
-  if (result.stderr.trim()) {
-    console.log("stderr:");
-    console.log(result.stderr.trim());
-  }
-
-  if (result.code !== 0) {
-    console.log(c.red("Bridge smoke test failed."));
-    return 1;
-  }
-
-  try {
-    const parsed = JSON.parse(result.stdout);
-    const ok = Boolean(parsed?.ok);
-    if (!ok) {
-      console.log(c.red(`Bridge responded with ok=false: ${parsed?.error ?? "unknown"}`));
-      return 1;
-    }
-  } catch {
-    console.log(c.red("Bridge output is not valid JSON."));
-    return 1;
-  }
-
-  console.log(c.green("Bridge smoke test passed."));
-  return 0;
-}

package/src/doctor.ts

@@ -1,92 +0,0 @@
-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("RAXFLOW Doctor"));
-
-  const config = await loadConfig(options.cwd);
-  if (!config) {
-    printLine(false, "Missing .raxrc", "run `raxflow 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;
-}