@ranker/raxflow 0.2.1 → 0.2.3

package/src/benchmark.ts

@@ -1,156 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { performance } from "node:perf_hooks";
-import { CoreOrchestrator } from "rax-flow-core";
-import { buildOfficialAgentsRuntime } from "rax-flow-agents";
-import { ClaudeAdapter, GenericRestAdapter, HostBridgeAdapter, OpenAIAdapter } from "rax-flow-providers";
-import { c } from "./styles.js";
-import { readFile } from "node:fs/promises";
-
-interface BenchOptions {
-  cwd: string;
-  prompt: string;
-  output?: string;
-  providerOverride?: string;
-  bridgeCommandOverride?: string;
-}
-
-interface RaxConfig {
-  defaultProvider?: string;
-  strongProvider?: string;
-  providers?: {
-    host?: { model?: string; mode?: "auto" | "bridge-only" | "mock"; bridgeCommandEnv?: string; timeoutMs?: number };
-    openai?: { model?: string; apiKeyEnv?: string; baseUrl?: string };
-    claude?: { model?: string; apiKeyEnv?: string; baseUrl?: string };
-    rest?: { endpoint?: string; tokenEnv?: string; model?: string };
-  };
-}
-
-async function loadConfig(cwd: string): Promise<RaxConfig> {
-  const file = path.join(cwd, ".raxrc");
-  const raw = await readFile(file, "utf8");
-  return JSON.parse(raw) as RaxConfig;
-}
-
-function createProviders(config: RaxConfig, bridgeCommandOverride?: string) {
-  const providers: Record<string, OpenAIAdapter | ClaudeAdapter | GenericRestAdapter | HostBridgeAdapter> = {};
-
-  const hostCfg = config.providers?.host;
-  const bridgeCommand = bridgeCommandOverride ?? process.env[hostCfg?.bridgeCommandEnv ?? "RAX_HOST_BRIDGE_COMMAND"];
-  providers.host = new HostBridgeAdapter({
-    model: hostCfg?.model ?? "host-managed",
-    mode: hostCfg?.mode ?? "auto",
-    command: bridgeCommand,
-    timeoutMs: hostCfg?.timeoutMs ?? 20000
-  });
-
-  const openaiKey = process.env[config.providers?.openai?.apiKeyEnv ?? "OPENAI_API_KEY"];
-  if (openaiKey) {
-    providers.openai = new OpenAIAdapter(openaiKey, config.providers?.openai?.baseUrl);
-  }
-
-  const claudeKey = process.env[config.providers?.claude?.apiKeyEnv ?? "ANTHROPIC_API_KEY"];
-  if (claudeKey) {
-    providers.claude = new ClaudeAdapter(claudeKey, config.providers?.claude?.baseUrl);
-  }
-
-  const restEndpoint = config.providers?.rest?.endpoint;
-  if (restEndpoint) {
-    const restToken = process.env[config.providers?.rest?.tokenEnv ?? "RAX_REST_TOKEN"];
-    providers.rest = new GenericRestAdapter(restEndpoint, restToken);
-  }
-
-  return providers;
-}
-
-function pseudoScore(text: string): number {
-  const clean = text.trim();
-  if (!clean) return 0;
-  const lengthScore = Math.min(clean.length / 1200, 1);
-  const structureScore = ["{", "}", "-", "1.", "2."].reduce((acc, token) => acc + (clean.includes(token) ? 0.08 : 0), 0);
-  return Math.min(1, 0.45 + lengthScore * 0.35 + structureScore);
-}
-
-export async function runBenchmark(options: BenchOptions): Promise<number> {
-  let config: RaxConfig;
-  try {
-    config = await loadConfig(options.cwd);
-  } catch {
-    console.error(c.red("Missing .raxrc. Run `raxflow install` first."));
-    return 1;
-  }
-
-  const providers = createProviders(config, options.bridgeCommandOverride);
-  const selectedProvider = options.providerOverride ?? config.defaultProvider ?? "host";
-  const provider = providers[selectedProvider] ?? Object.values(providers)[0];
-  if (!provider) {
-    console.error(c.red("No provider configured for benchmark."));
-    return 1;
-  }
-
-  const baselineStart = performance.now();
-  const baselineRaw = await provider.callModel(options.prompt, { temperature: 0.2, maxTokens: 1200 });
-  const baselineLatency = performance.now() - baselineStart;
-
-  const agents = buildOfficialAgentsRuntime({
-    providers,
-    defaultProvider: selectedProvider,
-    strongProvider: config.strongProvider ?? "host",
-    providerModels: {
-      host: config.providers?.host?.model ?? "host-managed",
-      openai: config.providers?.openai?.model ?? "gpt-4.1-mini",
-      claude: config.providers?.claude?.model ?? "claude-3-5-sonnet-latest",
-      rest: config.providers?.rest?.model ?? "generic-llm"
-    }
-  });
-
-  const orchestrator = new CoreOrchestrator(providers, agents, {}, { maxParallel: 4, cacheTtlMs: 0 });
-  const raxStart = performance.now();
-  const rax = await orchestrator.run({
-    taskId: `bench_${Date.now()}`,
-    userPrompt: options.prompt,
-    context: { benchmark: true }
-  });
-  const raxLatency = performance.now() - raxStart;
-
-  const baselineCorrectness = pseudoScore(baselineRaw.output);
-  const report = {
-    generatedAt: new Date().toISOString(),
-    prompt: options.prompt,
-    baseline: {
-      correctness: baselineCorrectness,
-      cost: 0,
-      latencyMs: Math.round(baselineLatency),
-      stability: baselineCorrectness * 0.9,
-      humanIntervention: baselineCorrectness < 0.7 ? 0.6 : 0.3
-    },
-    orchestrated: {
-      correctness: rax.result.confidence,
-      cost: rax.metrics.totalCostUsd,
-      latencyMs: Math.round(raxLatency),
-      stability: rax.result.success ? 0.9 : 0.5,
-      humanIntervention: rax.metrics.humanInterventionRequired ? 0.6 : 0.1
-    }
-  };
-
-  const delta = {
-    correctness: +(report.orchestrated.correctness - report.baseline.correctness).toFixed(3),
-    cost: +(report.orchestrated.cost - report.baseline.cost).toFixed(3),
-    latencyMs: report.orchestrated.latencyMs - report.baseline.latencyMs,
-    stability: +(report.orchestrated.stability - report.baseline.stability).toFixed(3),
-    humanIntervention: +(report.orchestrated.humanIntervention - report.baseline.humanIntervention).toFixed(3)
-  };
-
-  const full = { ...report, delta };
-  const outputFile = path.resolve(options.cwd, options.output ?? "benchmarks/reports/latest.json");
-  await mkdir(path.dirname(outputFile), { recursive: true });
-  await writeFile(outputFile, `${JSON.stringify(full, null, 2)}\n`, "utf8");
-
-  console.log(c.blue("RAXFLOW Benchmark"));
-  console.log(`report: ${outputFile}`);
-  console.log(`delta correctness: ${delta.correctness}`);
-  console.log(`delta latency(ms): ${delta.latencyMs}`);
-  console.log(`delta stability: ${delta.stability}`);
-  console.log(`delta humanIntervention: ${delta.humanIntervention}`);
-  return 0;
-}

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/dashboard.ts

@@ -1,51 +0,0 @@
-import http from "node:http";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export async function runDashboard({ port = 3003 }: { port?: number } = {}): Promise<number> {
-    const server = http.createServer(async (req, res) => {
-        // Simple static server for the dashboard
-        if (req.url === "/" || req.url === "/index.html") {
-            try {
-                // Try to find the dashboard file
-                // In the monorepo, it's in packages/cli/dashboard/index.html
-                // When installed as a package, it will be relative to this file
-                let htmlPath = path.join(process.cwd(), "packages/cli/dashboard/index.html");
-
-                // Fallback for when running from dist or installed package
-                try {
-                    await readFile(htmlPath);
-                } catch {
-                    htmlPath = path.join(__dirname, "..", "dashboard", "index.html");
-                }
-
-                const content = await readFile(htmlPath, "utf8");
-                res.writeHead(200, { "Content-Type": "text/html" });
-                res.end(content);
-            } catch (err) {
-                console.error("[UI] Error loading dashboard:", err);
-                res.writeHead(500);
-                res.end("Error loading dashboard. Please ensure you are running from the project root.");
-            }
-        } else {
-            res.writeHead(404);
-            res.end("Not Found");
-        }
-    });
-
-    return new Promise((resolve) => {
-        server.listen(port, () => {
-            console.log(`\n[UI] 🚀 RAX Dashboard started on http://localhost:${port}`);
-            console.log(`[UI] Monitoring kernel evolution and workflow health.`);
-            console.log(`[UI] Press Ctrl+C to stop.`);
-        });
-
-        process.on("SIGINT", () => {
-            server.close();
-            resolve(0);
-        });
-    });
-}