@ranker/raxflow 0.2.1 → 0.2.3

package/src/run.ts

@@ -1,317 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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>
-  );
-}