@ranker/raxflow 0.2.0

package/src/hub/commands/providers.ts

@@ -0,0 +1,39 @@
+import { HubContext } from "../types.js";
+import { drawBox } from "../styles/borders.js";
+import { colorize, formatStatus } from "../styles/colors.js";
+import { padRight } from "../styles/typography.js";
+
+interface ProviderInfo {
+  name: string;
+  key: string;
+  status: string;
+  latency: string;
+  lastCall: string;
+}
+
+export async function listProviders(_args: string[], _flags: Record<string, string | boolean>, _context: HubContext): Promise<void> {
+  const width = 65;
+  
+  const providers: ProviderInfo[] = [
+    { name: "Host-Native", key: "[H]", status: "online", latency: "12ms", lastCall: "2s ago" },
+    { name: "Claude Code", key: "[C]", status: "online", latency: "8ms", lastCall: "5s ago" },
+    { name: "OpenCode", key: "[O]", status: "idle", latency: "--", lastCall: "1h ago" },
+    { name: "Anthropic API", key: "[A]", status: "online", latency: "45ms", lastCall: "1m ago" },
+    { name: "Gemini", key: "[G]", status: "idle", latency: "--", lastCall: "2h ago" },
+    { name: "Mistral", key: "[M]", status: "idle", latency: "--", lastCall: "3h ago" },
+    { name: "Groq", key: "[Q]", status: "idle", latency: "--", lastCall: "5h ago" },
+    { name: "OpenAI", key: "[O]", status: "idle", latency: "--", lastCall: "1d ago" },
+  ];
+
+  const lines: string[] = [];
+  lines.push(`  ${colorize("PROVIDER", "bright")}          ${colorize("STATUS", "bright")}    ${colorize("LATENCY", "bright")}  ${colorize("LAST CALL", "bright")}`);
+  lines.push("  " + "─".repeat(61));
+
+  for (const provider of providers) {
+    const indicator = formatStatus(provider.status);
+    const statusColor = provider.status === "online" ? "green" : "gray";
+    lines.push(`  ${provider.key} ${padRight(provider.name, 14)} ${indicator} ${colorize(provider.status.toUpperCase().padEnd(8), statusColor)} ${padRight(provider.latency, 8)} ${colorize(provider.lastCall, "gray")}`);
+  }
+
+  console.log(drawBox(lines, width, "PROVIDERS"));
+}

package/src/hub/commands/run.ts

@@ -0,0 +1,37 @@
+import { HubContext } from "../types.js";
+import { runWorkflow as runWorkflowOriginal } from "../../run.js";
+
+export async function runWorkflow(args: string[], flags: Record<string, string | boolean>, context: HubContext): Promise<void> {
+  const prompt = args.join(" ");
+  
+  if (!prompt) {
+    console.error("❌ Usage: run <prompt>");
+    console.log("\nExemples:");
+    console.log('  run "Crée une API REST"');
+    console.log('  run "Génère des tests unitaires" --workflow custom.json');
+    return;
+  }
+
+  console.log(`▶ Lancement du workflow...`);
+  console.log(`  Prompt: ${prompt}`);
+  console.log(`  Mode: ${flags["workflow"] || "default"}`);
+  console.log("");
+
+  // Call the original run function
+  const code = await runWorkflowOriginal({
+    cwd: context.config.project || process.cwd(),
+    prompt,
+    workflowPath: typeof flags["workflow"] === "string" ? flags["workflow"] : undefined,
+    asJson: flags["json"] === true,
+    stream: flags["stream"] === true,
+    maxParallel: typeof flags["max-parallel"] === "string" ? Number(flags["max-parallel"]) : undefined,
+    noCachePersist: flags["no-cache-persist"] === true,
+    ui: flags["ui"] === true,
+  });
+
+  if (code !== 0) {
+    throw new Error(`Workflow failed with code ${code}`);
+  }
+
+  console.log("\n✅ Workflow terminé avec succès");
+}

package/src/hub/commands/status.ts

@@ -0,0 +1,69 @@
+import { HubContext } from "../types.js";
+import { drawBox } from "../styles/borders.js";
+import { colorize, formatStatus, statusIndicators } from "../styles/colors.js";
+import { padRight } from "../styles/typography.js";
+
+export async function showStatus(_args: string[], _flags: Record<string, string | boolean>, context: HubContext): Promise<void> {
+  const width = 61;
+  
+  // Simulated status data (will be replaced with real data from orchestrator)
+  const status = {
+    orchestrator: "ACTIVE",
+    mode: "HOST-NATIVE",
+    activeAgents: "3/12",
+    currentRun: "L2: CodeGen [H] 67%",
+    fitness: "0.87",
+    fitnessTrend: "improving",
+    cacheHit: "94%",
+    memoryNodes: "247",
+    latency: "12ms",
+    providers: [
+      { name: "Host-Native", status: "online", latency: "12ms" },
+      { name: "Claude", status: "online", latency: "8ms" },
+      { name: "OpenAI", status: "idle", latency: "--" },
+    ],
+    activeWorkflows: [
+      { agent: "CodeGenerator", provider: "[H]", status: "running", progress: 67 },
+      { agent: "TestAgent", provider: "[H]", status: "queued", progress: 0 },
+    ],
+  };
+
+  const lines: string[] = [];
+
+  // Orchestrator status
+  lines.push(`  Orchestrator:   ${formatStatus("online")} ${colorize(status.orchestrator, "green")}`);
+  lines.push(`  Mode:           ${colorize(status.mode, "cyan")}`);
+  lines.push(`  Active Agents:  ${colorize(status.activeAgents, "yellow")}`);
+  lines.push("");
+
+  // Current run
+  if (status.currentRun) {
+    lines.push(`  Current Run:    ${statusIndicators.running} ${colorize(status.currentRun, "yellow")}`);
+    lines.push(`  Fitness:        ${colorize(status.fitness, "green")} (${colorize(status.fitnessTrend, "cyan")})`);
+    lines.push(`  Cache Hit:      ${colorize(status.cacheHit, "green")}`);
+    lines.push(`  Memory Nodes:   ${colorize(status.memoryNodes, "cyan")}`);
+    lines.push(`  Latency:        ${colorize(status.latency, "green")}`);
+    lines.push("");
+  }
+
+  // Active workflows
+  if (status.activeWorkflows.length > 0) {
+    lines.push(colorize("  Active Workflows:", "bright"));
+    for (const wf of status.activeWorkflows) {
+      const indicator = statusIndicators[wf.status as keyof typeof statusIndicators] || "○";
+      const color = wf.status === "running" ? "yellow" : wf.status === "queued" ? "gray" : "white";
+      lines.push(`    ${indicator} ${padRight(wf.agent, 20)} ${wf.provider} ${colorize(wf.status.toUpperCase(), color)}`);
+    }
+    lines.push("");
+  }
+
+  // Providers
+  lines.push(colorize("  Providers:", "bright"));
+  for (const provider of status.providers) {
+    const indicator = formatStatus(provider.status);
+    const latencyStr = provider.latency !== "--" ? `${provider.latency}` : "--";
+    lines.push(`    ${indicator} ${padRight(provider.name, 18)} ${colorize(latencyStr, "gray")}`);
+  }
+
+  console.log(drawBox(lines, width, "SYSTEM STATUS"));
+}

package/src/hub/commands/workflows.ts

@@ -0,0 +1,64 @@
+import { HubContext } from "../types.js";
+import { drawBox } from "../styles/borders.js";
+import { colorize } from "../styles/colors.js";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+interface WorkflowInfo {
+  name: string;
+  description: string;
+  fitness?: number;
+  recommended?: boolean;
+}
+
+export async function listWorkflows(_args: string[], _flags: Record<string, string | boolean>, context: HubContext): Promise<void> {
+  const width = 70;
+  const lines: string[] = [];
+  
+  // Try to find workflow files
+  const workflowDir = path.join(context.config.project || process.cwd(), ".rax", "workflows");
+  const workflows: WorkflowInfo[] = [];
+  
+  try {
+    const files = await fs.readdir(workflowDir);
+    for (const file of files.filter(f => f.endsWith('.json'))) {
+      const filePath = path.join(workflowDir, file);
+      const content = await fs.readFile(filePath, 'utf-8');
+      const workflow = JSON.parse(content);
+      workflows.push({
+        name: file.replace('.json', ''),
+        description: workflow.description || 'No description',
+        fitness: workflow.fitness,
+        recommended: workflow.recommended,
+      });
+    }
+  } catch {
+    // Directory doesn't exist or is empty, use defaults
+  }
+
+  // Add default workflows
+  if (workflows.length === 0) {
+    workflows.push(
+      { name: "default-routing", description: "Standard workflow with intent classification", fitness: 0.87 },
+      { name: "secure-api-blueprint", description: "Security-focused API generation", fitness: 0.92 },
+      { name: "test-heavy-workflow", description: "Prioritizes test generation", fitness: 0.89 },
+      { name: "mutation-evolved-v3", description: "Optimized with mutations", fitness: 0.96, recommended: true }
+    );
+  }
+
+  lines.push(`  ${colorize("WORKFLOW", "bright")}                 ${colorize("DESCRIPTION", "bright")}              ${colorize("FITNESS", "bright")}`);
+  lines.push("  " + "─".repeat(66));
+
+  for (const wf of workflows) {
+    const name = wf.name.slice(0, 22).padEnd(24);
+    const desc = wf.description.slice(0, 25).padEnd(27);
+    const fitness = wf.fitness ? colorize(wf.fitness.toFixed(2), wf.fitness >= 0.9 ? "green" : "yellow") : "--";
+    const marker = wf.recommended ? colorize(" ★", "yellow") : "";
+    lines.push(`  • ${name} ${desc} ${fitness}${marker}`);
+  }
+
+  lines.push("");
+  lines.push(`  ${colorize("Usage:", "bright")} run -w <workflow-name> "<prompt>"`);
+
+  console.log(drawBox(lines, width, "WORKFLOWS"));
+}

package/src/hub/config-loader.ts

@@ -0,0 +1,37 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { HubConfig } from "./types.js";
+
+interface RaxRcConfig {
+  project?: string;
+  providers?: string[];
+  theme?: 'industrial' | 'minimal' | 'high-contrast';
+  [key: string]: unknown;
+}
+
+export async function loadConfig(cwd: string): Promise<HubConfig> {
+  const configPath = path.join(cwd, ".raxrc");
+  
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config: RaxRcConfig = JSON.parse(content);
+    
+    return {
+      project: config.project,
+      providers: config.providers,
+      theme: config.theme || 'industrial',
+    };
+  } catch {
+    // Return default config if .raxrc doesn't exist or is invalid
+    return {
+      project: path.basename(cwd),
+      providers: [],
+      theme: 'industrial',
+    };
+  }
+}
+
+export async function saveConfig(cwd: string, config: HubConfig): Promise<void> {
+  const configPath = path.join(cwd, ".raxrc");
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/src/hub/event-listener.ts

@@ -0,0 +1,17 @@
+import { RuntimeEventBus, RuntimeEvent } from "rax-flow-core";
+
+const globalEventBus = new RuntimeEventBus();
+
+export type { RuntimeEvent };
+
+export function getEventBus(): RuntimeEventBus {
+  return globalEventBus;
+}
+
+export function subscribeToEvents(callback: (event: RuntimeEvent) => void): () => void {
+  return globalEventBus.onEvent(callback);
+}
+
+export function emitEvent(event: RuntimeEvent): void {
+  globalEventBus.emit(event);
+}

package/src/hub/history.ts

@@ -0,0 +1,66 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+export class CommandHistory {
+  private history: string[] = [];
+  private position = -1;
+  private readonly historyPath: string;
+
+  constructor(cwd: string) {
+    this.historyPath = path.join(cwd, ".rax", "history.json");
+  }
+
+  add(command: string): void {
+    // Avoid duplicates at the end
+    if (this.history.length === 0 || this.history[this.history.length - 1] !== command) {
+      this.history.push(command);
+    }
+    this.position = this.history.length;
+  }
+
+  up(): string | undefined {
+    if (this.position > 0) {
+      this.position--;
+      return this.history[this.position];
+    }
+    return undefined;
+  }
+
+  down(): string | undefined {
+    if (this.position < this.history.length - 1) {
+      this.position++;
+      return this.history[this.position];
+    }
+    this.position = this.history.length;
+    return undefined;
+  }
+
+  async save(): Promise<void> {
+    try {
+      const dir = path.dirname(this.historyPath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(
+        this.historyPath,
+        JSON.stringify(this.history.slice(-1000), null, 2) // Keep last 1000 commands
+      );
+    } catch {
+      // Silently fail if we can't save history
+    }
+  }
+
+  async load(): Promise<void> {
+    try {
+      const data = await fs.readFile(this.historyPath, "utf-8");
+      this.history = JSON.parse(data);
+      this.position = this.history.length;
+    } catch {
+      // No history file yet, start fresh
+      this.history = [];
+      this.position = 0;
+    }
+  }
+
+  getAll(): string[] {
+    return [...this.history];
+  }
+}

package/src/hub/index.ts

@@ -0,0 +1,132 @@
+import * as readline from "readline";
+import { HubOptions, HubContext, Command } from "./types.js";
+import { parseCommand, getCompletions } from "./parser.js";
+import { CommandHistory } from "./history.js";
+import { subscribeToEvents, RuntimeEvent } from "./event-listener.js";
+import { getCommandRegistry } from "./commands/index.js";
+import { loadConfig } from "./config-loader.js";
+
+const WELCOME_MESSAGE = `
+┌─────────────────────────────────────────────────────────────┐
+│  ■ RAXFLOW HUB                      [HOST-NATIVE]  ● READY  │
+│      Project: %PROJECT%          Agents: 12/12 Online         │
+├─────────────────────────────────────────────────────────────┤
+│  // BIENVENUE — Tapez 'help' ou '?' pour commencer          │
+└─────────────────────────────────────────────────────────────┘
+`;
+
+export async function startHub(options: HubOptions): Promise<void> {
+  const config = options.config || (await loadConfig(options.cwd));
+  const context: HubContext = {
+    config,
+  };
+
+  const history = new CommandHistory(options.cwd);
+  await history.load();
+
+  const commands = getCommandRegistry();
+
+  console.log(WELCOME_MESSAGE.replace("%PROJECT%", config.project || "default"));
+
+  let isClosing = false;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "raxflow > ",
+    completer: (line: string) => {
+      const completions = getCompletions(line, context);
+      const hits = completions.filter((c) => c.startsWith(line));
+      return [hits.length ? hits : completions, line];
+    },
+  });
+
+  const unsubscribe = subscribeToEvents((event: RuntimeEvent) => {
+    const timeStr = new Date().toLocaleTimeString("fr-FR", { hour: "2-digit", minute: "2-digit" });
+    switch (event.type) {
+      case "run_start":
+        console.log(`[${timeStr}] ▶ Task started: ${event.taskId}`);
+        break;
+      case "run_end":
+        console.log(`[${timeStr}] ✓ Task completed: ${event.taskId} (confidence: ${event.metrics.confidence.toFixed(2)})`);
+        break;
+      case "node_error":
+        console.log(`[${timeStr}] ⚠ Node error: ${event.agent} - ${event.message}`);
+        break;
+    }
+  });
+
+  rl.on("line", async (input: string) => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+
+    history.add(trimmed);
+
+    const command = parseCommand(trimmed);
+
+    if (command.name === "exit" || command.name === "quit") {
+      isClosing = true;
+      console.log("👋 À bientôt !");
+      unsubscribe();
+      rl.close();
+      return;
+    }
+
+    const cmdDef = commands.get(command.name) || commands.get("help");
+    if (cmdDef) {
+      try {
+        await cmdDef.handler(command.args, command.flags, context);
+      } catch (error) {
+        console.error(`❌ Erreur: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } else {
+      console.log(`Commande inconnue: ${command.name}. Tapez 'help' pour voir les commandes disponibles.`);
+    }
+
+    if (!isClosing) {
+      rl.prompt();
+    }
+  });
+
+  rl.on("close", async () => {
+    if (!isClosing) {
+      await history.save();
+      console.log("\n👋 À bientôt !");
+      unsubscribe();
+    }
+    process.exit(0);
+  });
+
+  process.on("SIGINT", () => {
+    console.log("\n");
+    rl.prompt();
+  });
+
+  rl.prompt();
+}
+
+export async function startHubOneShot(command: string, args: string[]): Promise<void> {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  const context: HubContext = { config };
+  const commands = getCommandRegistry();
+
+  const parsed = parseCommand([command, ...args].join(" "));
+  const cmdDef = commands.get(parsed.name);
+
+  if (!cmdDef) {
+    console.error(`Commande inconnue: ${parsed.name}`);
+    process.exit(1);
+  }
+
+  try {
+    await cmdDef.handler(parsed.args, parsed.flags, context);
+    process.exit(0);
+  } catch (error) {
+    console.error(`❌ Erreur: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}

package/src/hub/parser.ts

@@ -0,0 +1,107 @@
+import { Command } from "./types.js";
+
+const BOOLEAN_FLAGS = new Set([
+  "stream",
+  "json",
+  "f",
+  "force",
+  "verbose",
+  "quiet",
+  "dry-run",
+  "yes",
+  "help",
+]);
+
+export function parseCommand(input: string): Command {
+  const tokens = input.trim().split(/\s+/);
+  const name = tokens[0] || "";
+  const args: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("--")) {
+      const flagName = token.slice(2);
+      const nextToken = tokens[i + 1];
+      if (nextToken && !nextToken.startsWith("-") && !BOOLEAN_FLAGS.has(flagName)) {
+        flags[flagName] = nextToken;
+        i++;
+      } else {
+        flags[flagName] = true;
+      }
+    } else if (token.startsWith("-")) {
+      const flagName = token.slice(1);
+      const nextToken = tokens[i + 1];
+      if (nextToken && !nextToken.startsWith("-") && !BOOLEAN_FLAGS.has(flagName)) {
+        flags[flagName] = nextToken;
+        i++;
+      } else {
+        flags[flagName] = true;
+      }
+    } else {
+      args.push(token);
+    }
+  }
+
+  return { name, args, flags };
+}
+
+export function getCompletions(partial: string, _context?: unknown): string[] {
+  const commands = [
+    "run",
+    "status",
+    "agents",
+    "providers",
+    "workflows",
+    "logs",
+    "metrics",
+    "memory",
+    "install",
+    "config",
+    "doctor",
+    "bridge-test",
+    "benchmark",
+    "evolve",
+    "dashboard",
+    "ui",
+    "chat",
+    "help",
+    "exit",
+    "quit",
+  ];
+
+  if (!partial) {
+    return commands;
+  }
+
+  const trimmed = partial.trim();
+  const endsWithSpace = partial.endsWith(" ");
+  const tokens = trimmed.split(/\s+/);
+  const currentWord = endsWithSpace ? "" : tokens[tokens.length - 1];
+
+  if (tokens.length === 1 && !endsWithSpace) {
+    return commands.filter((c) => c.startsWith(currentWord));
+  }
+
+  const command = tokens[0];
+  const isKnownCommand = commands.includes(command);
+  
+  if (!isKnownCommand) {
+    return [];
+  }
+
+  switch (command) {
+    case "run":
+      return ["--workflow", "--max-parallel", "--stream", "--json"].filter((c) =>
+        c.startsWith(currentWord)
+      );
+    case "logs":
+      return ["-f", "--agent", "--level"].filter((c) => c.startsWith(currentWord));
+    case "agents":
+    case "providers":
+    case "workflows":
+      return [];
+    default:
+      return [];
+  }
+}

package/src/hub/styles/borders.ts

@@ -0,0 +1,74 @@
+// RAXFLOW Design System - Borders and Boxes
+// Brutalist style: no border-radius, sharp corners
+
+export const borders = {
+  // Border characters for ASCII boxes
+  horizontal: "─",
+  vertical: "│",
+  topLeft: "┌",
+  topRight: "┐",
+  bottomLeft: "└",
+  bottomRight: "┘",
+  leftT: "├",
+  rightT: "┤",
+  topT: "┬",
+  bottomT: "┴",
+  cross: "┼",
+  
+  // Double line (for emphasis)
+  doubleHorizontal: "═",
+  doubleVertical: "║",
+  doubleTopLeft: "╔",
+  doubleTopRight: "╗",
+  doubleBottomLeft: "╚",
+  doubleBottomRight: "╝",
+};
+
+// Box drawing utilities
+export function drawBox(content: string[], width: number, title?: string): string {
+  const { topLeft, topRight, bottomLeft, bottomRight, horizontal, vertical } = borders;
+  
+  const lines: string[] = [];
+  
+  // Top border
+  if (title) {
+    const titleStr = ` ${title} `;
+    const sideWidth = Math.floor((width - titleStr.length - 2) / 2);
+    const leftSide = horizontal.repeat(sideWidth);
+    const rightSide = horizontal.repeat(width - titleStr.length - 2 - sideWidth);
+    lines.push(`${topLeft}${leftSide}${titleStr}${rightSide}${topRight}`);
+  } else {
+    lines.push(`${topLeft}${horizontal.repeat(width - 2)}${topRight}`);
+  }
+  
+  // Content
+  for (const line of content) {
+    const padded = line.padEnd(width - 2, " ").slice(0, width - 2);
+    lines.push(`${vertical}${padded}${vertical}`);
+  }
+  
+  // Bottom border
+  lines.push(`${bottomLeft}${horizontal.repeat(width - 2)}${bottomRight}`);
+  
+  return lines.join("\n");
+}
+
+export function drawSeparator(width: number, title?: string): string {
+  const { leftT, rightT, horizontal } = borders;
+  
+  if (title) {
+    const titleStr = ` ${title} `;
+    const sideWidth = Math.floor((width - titleStr.length - 2) / 2);
+    const leftSide = horizontal.repeat(sideWidth);
+    const rightSide = horizontal.repeat(width - titleStr.length - 2 - sideWidth);
+    return `${leftT}${leftSide}${titleStr}${rightSide}${rightT}`;
+  }
+  
+  return `${leftT}${horizontal.repeat(width - 2)}${rightT}`;
+}
+
+export function drawProgressBar(percent: number, width: number = 20): string {
+  const filled = Math.floor((percent / 100) * width);
+  const empty = width - filled;
+  return "█".repeat(filled) + "░".repeat(empty);
+}