@ranker/raxflow 0.2.0

package/src/run.ts

@@ -0,0 +1,317 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import { CoreOrchestrator, WorkflowGraph } from "rax-flow-core";
+import { buildOfficialAgentsRuntime } from "rax-flow-agents";
+import { ClaudeAdapter, GenericRestAdapter, HostBridgeAdapter, OpenAIAdapter } from "rax-flow-providers";
+import { WebSocketRelay } from "./ws-relay.js";
+import { c } from "./styles.js";
+
+interface RunOptions {
+  cwd: string;
+  prompt: string;
+  workflowPath?: string;
+  asJson?: boolean;
+  stream?: boolean;
+  maxParallel?: number;
+  noCachePersist?: boolean;
+  providerOverride?: string;
+  bridgeCommandOverride?: string;
+  ui?: boolean;
+  yolo?: boolean;
+}
+
+
+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;
+}
+
+async function loadWorkflow(cwd: string, workflowPath?: string): Promise<WorkflowGraph | undefined> {
+  const file = workflowPath
+    ? path.resolve(cwd, workflowPath)
+    : path.join(cwd, ".raxflow", "workflows", "fullstack-feature.json");
+
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw) as WorkflowGraph;
+  } catch {
+    return undefined;
+  }
+}
+
+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 cachePath(cwd: string): string {
+  return path.join(cwd, ".raxflow", "cache", "semantic-cache.json");
+}
+
+async function saveHistory(cwd: string, taskId: string, data: any) {
+  const dir = path.join(cwd, ".raxflow", "history");
+  await mkdir(dir, { recursive: true });
+  const file = path.join(dir, `${taskId}.json`);
+  await writeFile(file, JSON.stringify(data, null, 2));
+}
+
+async function askApproval(nodeId: string, agent: string, data: any): Promise<{ approved: boolean; feedback?: string }> {
+  const rl = readline.createInterface({ input, output });
+  console.log(c.magenta("\n--- [HUMAN INTERVENTION REQUIRED] ---"));
+  console.log(c.cyan(`Step: ${nodeId} | Agent: ${agent}`));
+  console.log(c.white("Candidate Output Data:"));
+  console.log(JSON.stringify(data, null, 2));
+
+  const answer = await rl.question(c.yellow("\nApprove? [Y to accept, or type your feedback to reject/fix]: "));
+  rl.close();
+
+  if (answer.toLowerCase() === "y" || answer === "") {
+    return { approved: true };
+  } else {
+    return { approved: false, feedback: answer };
+  }
+}
+
+
+export async function runWorkflow(options: RunOptions): 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 selectedDefault = options.providerOverride ?? config.defaultProvider ?? "host";
+
+  // Pre-flight check: Ensure Zero-Error compliance for Bridge integration
+  if (selectedDefault === "host") {
+    const health = await providers.host.healthCheck();
+    if (!health) {
+      console.error(c.red(`[Error] Host Bridge connectivity failed.`));
+      console.error(c.yellow(`Check your .raxrc or set RAX_HOST_BRIDGE_COMMAND env var.`));
+      console.log("Tip: run `raxflow doctor` for detailed diagnostics.");
+      return 1;
+    }
+  }
+
+  const selectedStrong = config.strongProvider ?? "host";
+
+
+  const agents = buildOfficialAgentsRuntime({
+    providers,
+    defaultProvider: selectedDefault,
+    strongProvider: selectedStrong,
+    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 workflow = await loadWorkflow(options.cwd, options.workflowPath);
+  // Memory System: Quantum Semantic Graph Memory (QSGM)
+  const memoryDir = path.join(options.cwd, ".raxflow", "memory");
+  const { LocalVectorStore, GraphMemory, MemoryManager } = await import("rax-flow-core");
+
+  const vectorStore = new LocalVectorStore(path.join(memoryDir, "vector-index.json"));
+  await vectorStore.load();
+
+  const graphMemory = new GraphMemory(path.join(memoryDir, "graph-memory.json"));
+  await graphMemory.load();
+
+  const memoryManager = new MemoryManager(vectorStore, graphMemory);
+
+  const orchestrator = new CoreOrchestrator(providers, agents, { memory: memoryManager }, { maxParallel: options.maxParallel ?? 4, cacheTtlMs: 1000 * 60 * 60 * 24 });
+
+  // Governance System: Enterprise security & compliance
+  const { GovernancePlugin, PIIPolicy } = await import("rax-flow-core");
+  const governancePlugin = new GovernancePlugin(
+    [new PIIPolicy()],
+    path.join(options.cwd, ".raxflow", "audit"),
+    orchestrator.events
+  );
+  orchestrator.registerPlugin(governancePlugin);
+
+
+  // Register Memory Plugin if an embedding provider is available (OpenAI in this case)
+  if (providers.openai) {
+    const { LongTermMemoryPlugin } = await import("rax-flow-core");
+    orchestrator.registerPlugin(new LongTermMemoryPlugin(memoryManager, providers.openai as any));
+  }
+
+
+
+  let relay: WebSocketRelay | undefined;
+
+  if (options.ui) {
+    relay = new WebSocketRelay(3002);
+    relay.start(orchestrator.events);
+  }
+
+  const persistentCacheFile = cachePath(options.cwd);
+  if (!options.noCachePersist) {
+    await orchestrator.loadCache(persistentCacheFile);
+  }
+
+  const sessionEvents: any[] = [];
+  orchestrator.onEvent(e => sessionEvents.push(e));
+
+  // Connect WebSocket relay resolutions to orchestrator
+  orchestrator.onEvent((event: any) => {
+    if (event.type === "INTERNAL_RESOLVE_APPROVAL") {
+      orchestrator.resolveApproval(event.taskId, event.nodeId, event.approved, event.feedback);
+    }
+  });
+
+  if (options.stream) {
+    orchestrator.onEvent((event) => {
+      if (event.type === "graph_ready") {
+        console.log(c.magenta(c.bold(`\n--- [DAG FLOW] ---`)));
+        const edgeCount = event.workflow.nodes.reduce((acc: number, n: any) => acc + (n.dependsOn?.length || 0), 0);
+        console.log(c.gray(`Tasks: ${event.workflow.nodes.length} | Edges: ${edgeCount}`));
+      }
+
+      if (event.type === "node_start") {
+        const retryPrefix = event.retry > 0 ? c.yellow(` (Retry ${event.retry})`) : "";
+        console.log(`${c.blue("◆")} ${c.bold(event.nodeId)}${retryPrefix} ${c.gray(`[${event.agent}]`)}`);
+      }
+
+      if (event.type === "node_awaiting_approval") {
+        if (options.yolo) {
+          orchestrator.resolveApproval(event.taskId, event.nodeId, true);
+        } else {
+          (async () => {
+            const { approved, feedback } = await askApproval(event.nodeId, event.agent, event.data);
+            orchestrator.resolveApproval(event.taskId, event.nodeId, approved, feedback);
+          })();
+        }
+      }
+
+      if (event.type === "node_end") {
+        const confColor = event.confidence >= 0.8 ? c.green : (event.confidence >= 0.6 ? c.yellow : c.red);
+        const icon = event.success ? c.green("✔") : c.red("✘");
+        console.log(`  ${icon} ${confColor(`conf: ${(event.confidence * 100).toFixed(0)}%`)} ${c.gray(`cost: $${(event.costUsd || 0).toFixed(5)}`)}`);
+      }
+
+      if (event.type === "node_error") {
+        console.log(`  ${c.red("!")} ${c.red(event.message)}`);
+      }
+
+      if (event.type === "audit_record" && event.mutation) {
+        console.log(c.magenta(`\n🧬 [Genetic Mutation Generated]`));
+        console.log(c.magenta(`   Reason: ${event.mutation.reason ?? "Optimization"}`));
+      }
+    });
+  }
+
+  const taskId = `task_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+  const result = await orchestrator.run(
+    {
+      taskId,
+      userPrompt: options.prompt,
+      context: {
+        cli: true,
+        host: os.hostname()
+      }
+    },
+    workflow
+  );
+
+  if (relay) {
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    relay.stop();
+  }
+
+  if (!options.noCachePersist) {
+    await orchestrator.saveCache(persistentCacheFile);
+  }
+
+  // Save to history
+  await saveHistory(options.cwd, taskId, {
+    taskId,
+    timestamp: Date.now(),
+    prompt: options.prompt,
+    result: result.result,
+    metrics: result.metrics,
+    workflow: result.workflow,
+    events: sessionEvents
+  });
+
+  if (options.asJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  // Final Summary Table
+  console.log(c.bold(c.cyan(`\n\n--- [RUN SUMMARY] ---`)));
+  const tableData = [
+    ["Task ID", taskId],
+    ["Main Agent", result.result.agent],
+    ["Status", result.result.success ? c.green("SUCCESS") : c.red("FAILED")],
+    ["Confidence", `${(result.result.confidence * 100).toFixed(1)}%`],
+    ["Retries", result.metrics.retries.toString()],
+    ["Escalations", result.metrics.escalations.toString()],
+    ["Latency", `${(result.metrics.totalLatencyMs / 1000).toFixed(2)}s`],
+    ["Total Cost", c.yellow(`$${(result.metrics.totalCostUsd || 0).toFixed(5)}`)]
+  ];
+
+  for (const [key, value] of tableData) {
+    console.log(`${c.bold(key.padEnd(15))} : ${value}`);
+  }
+
+  if (result.result.logs.length > 0) {
+    console.log(c.bold(`\nTrace Logs:`));
+    for (const line of result.result.logs.slice(-5)) {
+      console.log(c.gray(`  • ${line}`));
+    }
+    if (result.result.logs.length > 5) {
+      console.log(c.gray(`  ... and ${result.result.logs.length - 5} more lines.`));
+    }
+  }
+
+  return 0;
+}

package/src/setup/components/ApiKeyInput.tsx

@@ -0,0 +1,158 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+
+interface ApiKeyInputProps {
+  providerId: string;
+  providerName: string;
+  currentKey?: string;
+  envVar?: string;
+  onSetKey: (key: string) => void;
+  onSkip: () => void;
+  onBack: () => void;
+}
+
+export function ApiKeyInput({
+  providerId,
+  providerName,
+  currentKey,
+  envVar,
+  onSetKey,
+  onSkip,
+  onBack,
+}: ApiKeyInputProps) {
+  const [inputValue, setInputValue] = useState(currentKey || "");
+  const [isEditing, setIsEditing] = useState(true);
+  const [showKey, setShowKey] = useState(false);
+  const PRIMARY = "#f97316";
+
+  const envValue = process.env[envVar || ""];
+
+  useInput((input, key) => {
+    if (!isEditing) {
+      if (key.return || input === "s") {
+        onSkip();
+      } else if (input === "b") {
+        onBack();
+      } else if (input === "e") {
+        setIsEditing(true);
+      }
+    }
+  });
+
+  const handleSubmit = (value: string) => {
+    if (value.trim()) {
+      onSetKey(value.trim());
+    } else {
+      setIsEditing(false);
+    }
+  };
+
+  const maskedValue = (key: string) => {
+    if (key.length <= 8) return "••••••••";
+    return key.slice(0, 4) + "•".repeat(8) + key.slice(-4);
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1}>
+        <Text color={PRIMARY} bold>
+          CONFIGURE {providerName.toUpperCase()}
+        </Text>
+      </Box>
+
+      {envValue && (
+        <Box marginBottom={1}>
+          <Text color="#22c55e">✓</Text>
+          <Text color="#a1a1aa">
+            {" Found key in "}
+          </Text>
+          <Text color="#f59e0b">{envVar}</Text>
+        </Box>
+      )}
+
+      <Box marginBottom={1}>
+        <Text color="#a1a1aa">Enter your API key (or leave empty to skip):</Text>
+      </Box>
+
+      {isEditing ? (
+        <Box>
+          <Text color="#27272a">{"> "}</Text>
+          <TextInput
+            value={inputValue}
+            onChange={setInputValue}
+            onSubmit={handleSubmit}
+            placeholder={envValue ? "Press Enter to use env variable" : "sk-..."}
+            showCursor={true}
+          />
+        </Box>
+      ) : (
+        <Box flexDirection="column">
+          {inputValue && (
+            <Box>
+              <Text color="#22c55e">✓ Key set: </Text>
+              <Text color="#a1a1aa">
+                {showKey ? inputValue : maskedValue(inputValue)}
+              </Text>
+            </Box>
+          )}
+        </Box>
+      )}
+
+      <Box marginTop={1}>
+        <Text color="#27272a">{"─".repeat(50)}</Text>
+      </Box>
+
+      <Box marginTop={1}>
+        <Text color="#71717a">[E] Edit</Text>
+        <Text color="#71717a">  [S] Skip</Text>
+        <Text color="#71717a">  [B] Back</Text>
+      </Box>
+    </Box>
+  );
+}
+
+interface ApiKeyCollectorProps {
+  providers: Array<{ id: string; name: string; requiresApiKey: boolean }>;
+  currentIndex: number;
+  keys: Record<string, string>;
+  onSetKey: (providerId: string, key: string) => void;
+  onSkip: () => void;
+  onBack: () => void;
+}
+
+const ENV_VAR_MAP: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  gemini: "GOOGLE_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  groq: "GROQ_API_KEY",
+};
+
+export function ApiKeyCollector({
+  providers,
+  currentIndex,
+  keys,
+  onSetKey,
+  onSkip,
+  onBack,
+}: ApiKeyCollectorProps) {
+  const providersNeedingKeys = providers.filter((p) => p.requiresApiKey);
+  const currentProvider = providersNeedingKeys[currentIndex];
+
+  if (!currentProvider) {
+    return null;
+  }
+
+  return (
+    <ApiKeyInput
+      providerId={currentProvider.id}
+      providerName={currentProvider.name}
+      currentKey={keys[currentProvider.id]}
+      envVar={ENV_VAR_MAP[currentProvider.id]}
+      onSetKey={(key) => onSetKey(currentProvider.id, key)}
+      onSkip={onSkip}
+      onBack={onBack}
+    />
+  );
+}

package/src/setup/components/AsciiBanner.tsx

@@ -0,0 +1,125 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+const PRIMARY = "#f97316";
+const SECONDARY = "#a1a1aa";
+
+const RAX_FLOW_ASCII = `
+╔══════════════════════════════════════════════════════════════════════════╗
+║  ██████╗  █████╗  ██████╗ ██╗  ██╗ █████╗ ███╗   ██╗ ██████╗███████╗    ║
+║  ██╔══██╗██╔══██╗██╔════╝██║ ██╔╝██╔══██╗████╗  ██║██╔════╝██╔════╝    ║
+║  ██████╔╝███████║██║     █████╔╝ ███████║██╔██╗ ██║██║     █████╗      ║
+║  ██╔══██╗██╔══██║██║     ██╔═██╗ ██╔══██║██║╚██╗██║██║     ██╔══╝      ║
+║  ██║  ██║██║  ██║╚██████╗██║  ██╗██║  ██║██║ ╚████║╚██████╗███████╗    ║
+║  ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝╚══════╝    ║
+╠══════════════════════════════════════════════════════════════════════════╣
+║  [■■■■■■■■■■] ORCHESTRATOR THAT EVOLVES WITH YOUR HOST TOOLS [■■■■■■]    ║
+╚══════════════════════════════════════════════════════════════════════════╝`;
+
+const RAX_FLOW_ASCII_COMPACT = `
+╔═══════════════════════════════════════════════════════╗
+║  ██████╗ █████╗ ██████╗ ██╗ ██╗███████╗              ║
+║  ██╔══██╗██╔══██╗██╔════╝ ██║ ██║██╔════╝              ║
+║  ██████╔╝███████║██║      █████║█████╗                ║
+║  ██╔══██╗██╔══██║██║      ██╔═██║██╔══╝               ║
+║  ██║  ██║██║  ██║╚██████╗ ██║  ██║███████╗            ║
+║  ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝            ║
+╠═══════════════════════════════════════════════════════╣
+║  [■■■■■] ORCHESTRATOR [■■■■■]                          ║
+╚═══════════════════════════════════════════════════════╝`;
+
+const GEAR_PATTERN = " ⚙ ";
+const CIRCUIT_PATTERN = " │├┤│ ";
+
+interface AsciiBannerProps {
+  compact?: boolean;
+  showTagline?: boolean;
+}
+
+export function AsciiBanner({ compact = false, showTagline = true }: AsciiBannerProps) {
+  const ascii = compact ? RAX_FLOW_ASCII_COMPACT : RAX_FLOW_ASCII;
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Box>
+        <Text color={PRIMARY} bold>
+          {ascii}
+        </Text>
+      </Box>
+      {showTagline && (
+        <Box marginTop={1} justifyContent="center">
+          <Text color={SECONDARY} dimColor>
+            {compact ? "Setup Wizard v1.0" : "Multi-Agent Orchestration Framework • Setup Wizard v1.0"}
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+export function IndustrialDivider({ width = 60 }: { width?: number }) {
+  const segment = "─".repeat(Math.floor(width / 3));
+  const full = `╟${segment}╂${segment}╂${segment}╢`;
+  
+  return (
+    <Box>
+      <Text color="#27272a">{full}</Text>
+    </Box>
+  );
+}
+
+export function IndustrialBox({ 
+  children, 
+  title, 
+  width = 60,
+  active = false,
+}: { 
+  children: React.ReactNode;
+  title?: string;
+  width?: number;
+  active?: boolean;
+}) {
+  const borderColor = active ? PRIMARY : "#27272a";
+  const innerWidth = width - 4;
+  
+  return (
+    <Box flexDirection="column">
+      <Text color={borderColor}>
+        {`┌${title ? `─ ${title} ` : ""}${"─".repeat(innerWidth - (title?.length || 0) - 2)}┐`}
+      </Text>
+      <Box flexDirection="column" borderStyle="single" borderColor={borderColor}>
+        {children}
+      </Box>
+      <Text color={borderColor}>{`└${"─".repeat(innerWidth)}┘`}</Text>
+    </Box>
+  );
+}
+
+export function StatusIndicator({ 
+  status, 
+  label, 
+  active = false 
+}: { 
+  status: "online" | "offline" | "running" | "pending" | "done" | "error";
+  label: string;
+  active?: boolean;
+}) {
+  const indicators: Record<string, { char: string; color: string }> = {
+    online: { char: "●", color: "#22c55e" },
+    offline: { char: "○", color: "#71717a" },
+    running: { char: "▶", color: "#f59e0b" },
+    pending: { char: "◐", color: "#a1a1aa" },
+    done: { char: "✓", color: "#22c55e" },
+    error: { char: "✗", color: "#ef4444" },
+  };
+
+  const { char, color } = indicators[status];
+
+  return (
+    <Box>
+      <Text color={active ? PRIMARY : color}>{char}</Text>
+      <Text> </Text>
+      <Text color={active ? PRIMARY : "#ffffff"}>{label}</Text>
+    </Box>
+  );
+}