rax-flow 0.1.5 → 0.1.7

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,13 @@
+export interface RuntimeEvent {
+  type: string;
+  timestamp: number;
+  payload: unknown;
+}
+
+export function subscribeToEvents(_callback: (event: RuntimeEvent) => void): () => void {
+  // TODO: Integrate with RuntimeEventBus from core
+  // For now, return a no-op unsubscribe
+  return () => {
+    // Cleanup
+  };
+}

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,120 @@
+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 } from "./event-listener.js";
+import { getCommandRegistry } from "./commands/index.js";
+import { loadConfig } from "./config-loader.js";
+
+const WELCOME_MESSAGE = `
+┌─────────────────────────────────────────────────────────────┐
+│  ■ RAX-FLOW 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: "rax-flow > ",
+    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) => {
+  });
+
+  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 @@
+// RAX-FLOW 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);
+}

package/src/hub/styles/colors.ts

@@ -0,0 +1,129 @@
+// RAX-FLOW Design System - Colors
+// Based on cli-design.md specifications
+
+export const colors = {
+  // Backgrounds
+  background: "#050505",
+  surface: "#0a0a0a",
+  surfaceElev: "#0d0d0d",
+
+  // Primary
+  primary: "#f97316", // Orange vif
+  primaryGlow: "rgba(249, 115, 22, 0.3)",
+  primaryGlowHover: "rgba(249, 115, 22, 0.5)",
+
+  // Text
+  textPrimary: "#ffffff",
+  textSecondary: "#a1a1aa",
+  textTertiary: "#71717a",
+  textQuaternary: "#3f3f46",
+
+  // Status
+  success: "#22c55e",
+  warning: "#f59e0b",
+  error: "#ef4444",
+
+  // Borders
+  border: "#27272a",
+
+  // Mutations
+  mutation: "#f59e0b",
+  mutationGlow: "rgba(245, 158, 11, 0.4)",
+};
+
+// ANSI color codes for terminal
+export const ansiColors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  
+  // Foreground colors
+  black: "\x1b[30m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+  
+  // Bright colors
+  brightRed: "\x1b[91m",
+  brightGreen: "\x1b[92m",
+  brightYellow: "\x1b[93m",
+  brightBlue: "\x1b[94m",
+  brightMagenta: "\x1b[95m",
+  brightCyan: "\x1b[96m",
+  brightWhite: "\x1b[97m",
+  
+  // Background colors
+  bgBlack: "\x1b[40m",
+  bgRed: "\x1b[41m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgBlue: "\x1b[44m",
+  bgMagenta: "\x1b[45m",
+  bgCyan: "\x1b[46m",
+  bgWhite: "\x1b[47m",
+  bgGray: "\x1b[100m",
+};
+
+// Status indicators
+export const statusIndicators = {
+  online: "●",
+  offline: "○",
+  running: "▶",
+  loading: "◐",
+  mutation: "◆",
+  checkpoint: "■",
+  pending: "○",
+  done: "✓",
+};
+
+// Provider indicators
+export const providerIndicators: Record<string, string> = {
+  host: "[H]",
+  claude: "[C]",
+  opencode: "[O]",
+  kilo: "[K]",
+  anthropic: "[A]",
+  gemini: "[G]",
+  mistral: "[M]",
+  groq: "[Q]",
+  openai: "[O]",
+};
+
+// Utility functions
+export function colorize(text: string, color: keyof typeof ansiColors): string {
+  return `${ansiColors[color]}${text}${ansiColors.reset}`;
+}
+
+export function statusColor(status: string): string {
+  switch (status.toLowerCase()) {
+    case "online":
+    case "ready":
+    case "active":
+    case "done":
+    case "success":
+      return ansiColors.green;
+    case "running":
+    case "busy":
+      return ansiColors.yellow;
+    case "error":
+    case "failed":
+      return ansiColors.red;
+    case "queued":
+    case "pending":
+    case "idle":
+      return ansiColors.gray;
+    default:
+      return ansiColors.reset;
+  }
+}
+
+export function formatStatus(status: string): string {
+  const indicator = statusIndicators[status.toLowerCase() as keyof typeof statusIndicators] || "○";
+  const color = statusColor(status);
+  return `${color}${indicator}${ansiColors.reset}`;
+}