@ranker/raxflow 0.2.1 → 0.2.3

package/src/tui/hooks/useAppState.ts

@@ -1,403 +0,0 @@
-import { useState, useCallback, useEffect, useRef } from "react";
-import { createOrchestrator, RuntimeEvent } from "../services/orchestrator.js";
-
-interface Message {
-  id: string;
-  type: "user" | "system" | "agent" | "error" | "success";
-  content: string;
-  timestamp: Date;
-  agent?: string;
-}
-
-interface Agent {
-  name: string;
-  role: string;
-  status: "idle" | "running" | "queued" | "done";
-  provider: string;
-}
-
-interface Provider {
-  name: string;
-  status: "active" | "idle";
-  latency: number;
-}
-
-interface DAGNode {
-  id: string;
-  name: string;
-  status: "pending" | "running" | "done" | "error";
-  agent?: string;
-}
-
-interface DAGLevel {
-  name: string;
-  progress: number;
-  nodes: DAGNode[];
-}
-
-interface WorkflowState {
-  levels: DAGLevel[];
-  currentLevel: number;
-  totalProgress: number;
-}
-
-interface MetricsState {
-  sessions: number;
-  avgDuration: number;
-  successRate: number;
-  totalCost: number;
-  totalRetries: number;
-  totalEscalations: number;
-}
-
-interface AppState {
-  projectName: string;
-  agentCount: number;
-  provider: string;
-  status: "ready" | "running" | "error";
-  messages: Message[];
-  agents: Agent[];
-  providers: Provider[];
-  fitness: number;
-  currentWorkflow: string | null;
-  suggestions: string[];
-  isProcessing: boolean;
-  workflowState: WorkflowState;
-  logs: string[];
-  metrics: MetricsState;
-}
-
-const COMMAND_SUGGESTIONS = [
-  "/run", "/status", "/agents", "/providers", "/workflows",
-  "/logs", "/metrics", "/memory", "/help", "/exit",
-  "/doctor", "/bridge-test", "/evolve", "/config",
-];
-
-const DEFAULT_AGENTS: Agent[] = [
-  { name: "IntentClassifier", role: "Classify intent", status: "idle", provider: "H" },
-  { name: "TaskPlanner", role: "Decompose tasks", status: "idle", provider: "H" },
-  { name: "SpecAgent", role: "Write specs", status: "idle", provider: "H" },
-  { name: "CodeGenerator", role: "Generate code", status: "idle", provider: "H" },
-  { name: "TestAgent", role: "Run tests", status: "idle", provider: "H" },
-  { name: "FixAgent", role: "Fix issues", status: "idle", provider: "H" },
-  { name: "MutationAgent", role: "Evolve workflow", status: "idle", provider: "H" },
-  { name: "ValidatorAgent", role: "Validate outputs", status: "idle", provider: "H" },
-];
-
-const DEFAULT_PROVIDERS: Provider[] = [
-  { name: "Host-Native", status: "active", latency: 12 },
-  { name: "Claude Code", status: "active", latency: 8 },
-  { name: "OpenCode", status: "idle", latency: 0 },
-  { name: "Anthropic", status: "idle", latency: 0 },
-];
-
-const DEFAULT_WORKFLOW_STATE: WorkflowState = {
-  levels: [
-    {
-      name: "L1: SPEC",
-      progress: 0,
-      nodes: [
-        { id: "intent", name: "IntentClassifier", status: "pending", agent: "H" },
-        { id: "spec", name: "SpecAgent", status: "pending", agent: "H" },
-        { id: "arch", name: "ArchitectureAgent", status: "pending", agent: "H" },
-      ],
-    },
-    {
-      name: "L2: CODE",
-      progress: 0,
-      nodes: [
-        { id: "task", name: "TaskPlanner", status: "pending", agent: "H" },
-        { id: "codegen", name: "CodeGenerator", status: "pending", agent: "H" },
-      ],
-    },
-    {
-      name: "L3: TEST",
-      progress: 0,
-      nodes: [
-        { id: "test", name: "TestAgent", status: "pending", agent: "H" },
-        { id: "fix", name: "FixAgent", status: "pending", agent: "H" },
-      ],
-    },
-  ],
-  currentLevel: 0,
-  totalProgress: 0,
-};
-
-function generateId(): string {
-  return Math.random().toString(36).slice(2, 9);
-}
-
-export function useAppState() {
-  const orchestratorRef = useRef(createOrchestrator());
-  
-  const [state, setState] = useState<AppState>({
-    projectName: process.cwd().split("/").pop() || "project",
-    agentCount: 12,
-    provider: "HOST-NATIVE",
-    status: "ready",
-    messages: [
-      {
-        id: generateId(),
-        type: "system",
-        content: "■ RAXFLOW HUB prêt. Tapez votre prompt ou /help pour les commandes.",
-        timestamp: new Date(),
-      },
-    ],
-    agents: DEFAULT_AGENTS,
-    providers: DEFAULT_PROVIDERS,
-    fitness: 0.87,
-    currentWorkflow: null,
-    suggestions: COMMAND_SUGGESTIONS,
-    isProcessing: false,
-    workflowState: DEFAULT_WORKFLOW_STATE,
-    logs: [],
-    metrics: {
-      sessions: 0,
-      avgDuration: 0,
-      successRate: 100,
-      totalCost: 0,
-      totalRetries: 0,
-      totalEscalations: 0,
-    },
-  });
-
-  useEffect(() => {
-    const unsubscribe = orchestratorRef.current.onEvent((event: RuntimeEvent) => {
-      handleOrchestratorEvent(event);
-    });
-    return unsubscribe;
-  }, []);
-
-  const handleOrchestratorEvent = useCallback((event: RuntimeEvent) => {
-    const timestamp = new Date();
-    const timeStr = timestamp.toLocaleTimeString("fr-FR", {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-    });
-
-    switch (event.type) {
-      case "run_start":
-        addLog(`[${timeStr}] [START] Task ${event.taskId}`);
-        setState((prev) => ({ ...prev, status: "running", isProcessing: true }));
-        break;
-
-      case "graph_ready":
-        addLog(`[${timeStr}] [GRAPH] Workflow ready with ${event.workflow.nodes.length} nodes`);
-        break;
-
-      case "node_start":
-        addLog(`[${timeStr}] [RUN] ${event.agent} starting... (retry: ${event.retry})`);
-        updateAgentStatus(event.agent, "running");
-        updateDAGNode(event.nodeId, "running");
-        break;
-
-      case "node_end":
-        if (event.success) {
-          addLog(`[${timeStr}] [OK] ${event.agent} done (confidence: ${event.confidence.toFixed(2)})`);
-          updateAgentStatus(event.agent, "done");
-          updateDAGNode(event.nodeId, "done");
-        } else {
-          addLog(`[${timeStr}] [FAIL] ${event.agent} failed`);
-          updateAgentStatus(event.agent, "idle");
-          updateDAGNode(event.nodeId, "error");
-        }
-        break;
-
-      case "node_error":
-        addLog(`[${timeStr}] [ERR] ${event.agent}: ${event.message}`);
-        updateDAGNode(event.nodeId, "error");
-        break;
-
-      case "run_end":
-        addLog(`[${timeStr}] [DONE] Task completed (confidence: ${event.metrics.confidence.toFixed(2)})`);
-        setState((prev) => {
-          const newSessions = prev.metrics.sessions + 1;
-          const newAvgDuration = prev.metrics.avgDuration === 0 
-            ? event.metrics.totalLatencyMs 
-            : Math.round((prev.metrics.avgDuration * prev.metrics.sessions + event.metrics.totalLatencyMs) / newSessions);
-          const newSuccessRate = event.metrics.confidence >= 0.7 
-            ? Math.round((prev.metrics.successRate * prev.metrics.sessions + 100) / newSessions)
-            : Math.round((prev.metrics.successRate * prev.metrics.sessions) / newSessions);
-          
-          return {
-            ...prev,
-            status: "ready",
-            isProcessing: false,
-            fitness: Math.min(prev.fitness + 0.02, 0.99),
-            metrics: {
-              sessions: newSessions,
-              avgDuration: newAvgDuration,
-              successRate: newSuccessRate,
-              totalCost: prev.metrics.totalCost + (event.metrics.totalCostUsd || 0),
-              totalRetries: prev.metrics.totalRetries + (event.metrics.retries || 0),
-              totalEscalations: prev.metrics.totalEscalations + (event.metrics.escalations || 0),
-            },
-          };
-        });
-        break;
-    }
-  }, []);
-
-  const addLog = useCallback((log: string) => {
-    setState((prev: AppState) => ({
-      ...prev,
-      logs: [...prev.logs.slice(-100), log],
-    }));
-  }, []);
-
-  const addMessage = useCallback((type: Message["type"], content: string, agent?: string) => {
-    setState((prev: AppState) => ({
-      ...prev,
-      messages: [
-        ...prev.messages,
-        { id: generateId(), type, content, timestamp: new Date(), agent },
-      ],
-    }));
-  }, []);
-
-  const updateAgentStatus = useCallback((agentName: string, status: Agent["status"]) => {
-    setState((prev: AppState) => ({
-      ...prev,
-      agents: prev.agents.map((a) =>
-        a.name === agentName ? { ...a, status } : a
-      ),
-    }));
-  }, []);
-
-  const updateDAGNode = useCallback((nodeId: string, status: DAGNode["status"]) => {
-    setState((prev: AppState) => {
-      const newLevels = prev.workflowState.levels.map((level) => {
-        const newNodes = level.nodes.map((node) =>
-          node.id === nodeId ? { ...node, status } : node
-        );
-        const doneCount = newNodes.filter((n) => n.status === "done").length;
-        return {
-          ...level,
-          nodes: newNodes,
-          progress: Math.round((doneCount / newNodes.length) * 100),
-        };
-      });
-
-      const totalDone = newLevels.reduce(
-        (acc, l) => acc + l.nodes.filter((n) => n.status === "done").length,
-        0
-      );
-      const totalNodes = newLevels.reduce((acc, l) => acc + l.nodes.length, 0);
-
-      return {
-        ...prev,
-        workflowState: {
-          levels: newLevels,
-          currentLevel: newLevels.findIndex((l) =>
-            l.nodes.some((n) => n.status === "running")
-          ),
-          totalProgress: Math.round((totalDone / totalNodes) * 100),
-        },
-      };
-    });
-  }, []);
-
-  const resetWorkflow = useCallback(() => {
-    setState((prev: AppState) => ({
-      ...prev,
-      workflowState: DEFAULT_WORKFLOW_STATE,
-      agents: DEFAULT_AGENTS.map((a) => ({ ...a, status: "idle" })),
-    }));
-  }, []);
-
-  const processCommand = useCallback((input: string) => {
-    const normalizedInput = input.startsWith("/") ? input : `/${input}`;
-    const cmd = normalizedInput.slice(1).toLowerCase();
-    const parts = cmd.split(" ");
-    const command = parts[0];
-    const args = parts.slice(1).join(" ");
-
-    switch (command) {
-      case "help":
-        addMessage("system", `Commandes: /run /status /agents /providers /workflows /logs /metrics /memory /doctor /bridge-test /evolve /config /exit\n(Note: commands work with or without '/' prefix)`);
-        break;
-
-        case "status":
-          const status = orchestratorRef.current.getStatus();
-          addMessage("system", `Orchestrator: ● ${status.isRunning ? "RUNNING" : "ACTIVE"} | Fitness: ${state.fitness.toFixed(2)} | Sessions: ${state.metrics.sessions}`);
-          break;
-
-        case "agents":
-          const agentList = state.agents.map((a) => `${a.status === "running" ? "▶" : a.status === "done" ? "●" : "○"} ${a.name} [${a.provider}]`).join("\n");
-          addMessage("system", agentList);
-          break;
-
-        case "providers":
-          const providerList = state.providers.map((p) => `${p.status === "active" ? "●" : "○"} ${p.name} ${p.latency > 0 ? `(${p.latency}ms)` : ""}`).join("\n");
-          addMessage("system", providerList);
-          break;
-
-        case "logs":
-          const recentLogs = state.logs.slice(-10).join("\n");
-          addMessage("system", recentLogs || "Aucun log");
-          break;
-
-        case "metrics":
-          addMessage("system", `Sessions: ${state.metrics.sessions}\nAvg Duration: ${state.metrics.avgDuration}ms\nSuccess Rate: ${state.metrics.successRate}%\nTotal Cost: $${state.metrics.totalCost.toFixed(4)}`);
-          break;
-
-        case "doctor":
-          addMessage("system", "✓ Host-Native Bridge: OK\n✓ Providers: 2/4 disponibles\n✓ Cache: Opérationnel\n✓ Memory Graph: Initialisé\n✓ Agents: 8/8 en ligne");
-          break;
-
-        case "bridge-test":
-          addMessage("system", "Test de connexion...\n✓ Bridge opérationnel (latency: 12ms)");
-          break;
-
-        case "evolve":
-          addMessage("system", `WORKFLOW EVOLUTION\nSession ${state.metrics.sessions}: fitness: ${state.fitness.toFixed(2)}\nMutations this session: +${Math.floor(Math.random() * 3)}\nTendance: ↗ +${(state.fitness * 10).toFixed(0)}% depuis le début`);
-          break;
-
-        case "config":
-          addMessage("system", `Config (.raxrc):\n- provider: host-native\n- maxParallel: 4\n- cacheEnabled: true\n- fitness: ${state.fitness.toFixed(2)}`);
-          break;
-
-        case "run":
-          if (args) {
-            runWorkflow(args);
-          } else {
-            addMessage("error", "Usage: /run <prompt>");
-          }
-          break;
-
-        case "exit":
-        case "quit":
-          addMessage("system", "À bientôt !");
-          break;
-
-        default:
-          if (args || command) {
-            addMessage("error", `Commande inconnue: /${command}. Tapez /help pour l'aide.`);
-          } else {
-            runWorkflow(input);
-          }
-      }
-  }, [state, addMessage]);
-
-  const runWorkflow = useCallback(async (prompt: string) => {
-    resetWorkflow();
-    addMessage("user", prompt);
-    addMessage("agent", "▶ Lancement du workflow...", "Orchestrator");
-    setState((prev) => ({ ...prev, currentWorkflow: prompt }));
-
-    try {
-      await orchestratorRef.current.run(prompt);
-      addMessage("success", `✓ Workflow terminé! Fitness: ${(state.fitness + 0.02).toFixed(2)}`);
-    } catch (error) {
-      addMessage("error", `Erreur: ${error instanceof Error ? error.message : String(error)}`);
-      setState((prev) => ({ ...prev, status: "error", isProcessing: false }));
-    }
-  }, [resetWorkflow, addMessage, state.fitness]);
-
-  return {
-    state,
-    dispatch: setState,
-    processCommand,
-  };
-}

package/src/tui/index.ts

@@ -1,9 +0,0 @@
-import { render } from "ink";
-import React from "react";
-import { App } from "./App.js";
-
-export function startTUI() {
-  return render(React.createElement(App));
-}
-
-export { App } from "./App.js";

package/src/tui/services/orchestrator.ts

@@ -1,195 +0,0 @@
-import {
-  CoreOrchestrator,
-  RuntimeEvent,
-  AgentDefinition,
-  IModelProvider,
-  WorkflowGraph,
-  AgentInput,
-  AgentOutput,
-  ModelResponse,
-  ProviderCallOptions,
-} from "rax-flow-core";
-import {
-  OpenAIAdapter,
-  ClaudeAdapter,
-  GeminiAdapter,
-  GroqAdapter,
-  HostBridgeAdapter,
-} from "rax-flow-providers";
-
-export interface OrchestratorService {
-  run(prompt: string): Promise<void>;
-  onEvent(handler: (event: RuntimeEvent) => void): () => void;
-  getStatus(): OrchestratorStatus;
-  stop(): void;
-}
-
-export interface OrchestratorStatus {
-  isRunning: boolean;
-  currentTaskId: string | null;
-  workflow: WorkflowGraph | null;
-  fitness: number;
-}
-
-function createProviderFromEnv(name: string): IModelProvider | null {
-  switch (name) {
-    case "openai":
-      if (process.env.OPENAI_API_KEY) {
-        return new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY });
-      }
-      return null;
-    case "claude":
-    case "anthropic":
-      if (process.env.ANTHROPIC_API_KEY) {
-        return new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY });
-      }
-      return null;
-    case "gemini":
-      if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
-        return new GeminiAdapter({ apiKey: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY! });
-      }
-      return null;
-    case "groq":
-      if (process.env.GROQ_API_KEY) {
-        return new GroqAdapter({ apiKey: process.env.GROQ_API_KEY });
-      }
-      return null;
-    case "host":
-      return new HostBridgeAdapter({ mode: "auto" });
-    default:
-      return null;
-  }
-}
-
-function createMockProvider(): IModelProvider {
-  return {
-    async callModel(prompt: string, options?: ProviderCallOptions): Promise<ModelResponse<string>> {
-      await new Promise((r) => setTimeout(r, 300 + Math.random() * 500));
-      return {
-        provider: "mock",
-        model: "mock-model",
-        latencyMs: 300 + Math.floor(Math.random() * 200),
-        output: `Processed: ${prompt.slice(0, 50)}...`,
-        usage: { promptTokens: 100, completionTokens: 50, totalTokens: 150 },
-      };
-    },
-    async callStructured<T>(prompt: string, schema: object, options?: ProviderCallOptions): Promise<ModelResponse<T>> {
-      const response = await this.callModel(prompt, options);
-      return {
-        ...response,
-        output: {} as T,
-      };
-    },
-    async healthCheck(): Promise<boolean> {
-      return true;
-    },
-  };
-}
-
-function buildProviders(): Record<string, IModelProvider> {
-  const providers: Record<string, IModelProvider> = {};
-  
-  const hostProvider = createProviderFromEnv("host");
-  if (hostProvider) providers["host"] = hostProvider;
-  
-  for (const name of ["openai", "claude", "gemini", "groq"]) {
-    const provider = createProviderFromEnv(name);
-    if (provider) providers[name] = provider;
-  }
-  
-  if (Object.keys(providers).length === 0) {
-    console.log("[Orchestrator] No API keys found, using mock provider");
-    providers["mock"] = createMockProvider();
-  }
-  
-  return providers;
-}
-
-function createAgent(name: string, role: string): AgentDefinition {
-  return {
-    name,
-    role,
-    activationWhen: `intent == "${name.toLowerCase()}"`,
-    inputSchema: { type: "object" },
-    outputSchema: { type: "object" },
-    async run(input: AgentInput): Promise<AgentOutput> {
-      await new Promise((r) => setTimeout(r, 200 + Math.random() * 300));
-      return {
-        agent: name,
-        success: true,
-        confidence: 0.85 + Math.random() * 0.1,
-        risks: [],
-        logs: [`Executed ${name}`],
-        data: { result: `Processed: ${input.userPrompt.slice(0, 50)}...` },
-        usage: { promptTokens: 100, completionTokens: 50, totalTokens: 150 },
-      };
-    },
-  };
-}
-
-const DEFAULT_AGENTS = [
-  createAgent("IntentClassifier", "Classifies user intent"),
-  createAgent("TaskPlanner", "Decomposes tasks"),
-  createAgent("SpecAgent", "Writes specifications"),
-  createAgent("ArchitectureAgent", "Designs architecture"),
-  createAgent("CodeGenerator", "Generates code"),
-  createAgent("TestAgent", "Runs tests"),
-  createAgent("FixAgent", "Fixes issues"),
-  createAgent("ValidatorAgent", "Validates outputs"),
-];
-
-export function createOrchestrator(): OrchestratorService {
-  const providers = buildProviders();
-  const agents: Record<string, AgentDefinition> = {};
-  for (const agent of DEFAULT_AGENTS) {
-    agents[agent.name] = agent;
-  }
-
-  const orchestrator = new CoreOrchestrator(providers, agents);
-  let isRunning = false;
-  let currentTaskId: string | null = null;
-  let fitness = 0.87;
-
-  orchestrator.initialize().catch(() => {});
-
-  return {
-    async run(prompt: string): Promise<void> {
-      if (isRunning) return;
-      isRunning = true;
-      currentTaskId = `task-${Date.now()}`;
-
-      try {
-        await orchestrator.run({
-          taskId: currentTaskId,
-          userPrompt: prompt,
-        });
-        fitness = Math.min(fitness + 0.02, 0.99);
-      } catch (error) {
-        console.error("Orchestrator error:", error);
-      } finally {
-        currentTaskId = null;
-        isRunning = false;
-      }
-    },
-
-    onEvent(handler: (event: RuntimeEvent) => void) {
-      return orchestrator.onEvent(handler);
-    },
-
-    getStatus() {
-      return {
-        isRunning,
-        currentTaskId,
-        workflow: null,
-        fitness,
-      };
-    },
-
-    stop() {
-      isRunning = false;
-      currentTaskId = null;
-    },
-  };
-}
-
-export type { RuntimeEvent, WorkflowGraph };

package/src/tui/styles/borders.ts

@@ -1,51 +0,0 @@
-export const borders = {
-  horizontal: "─",
-  vertical: "│",
-  topLeft: "┌",
-  topRight: "┐",
-  bottomLeft: "└",
-  bottomRight: "┘",
-  leftT: "├",
-  rightT: "┤",
-  topT: "┬",
-  bottomT: "┴",
-  cross: "┼",
-};
-
-export const doubleBorders = {
-  horizontal: "═",
-  vertical: "║",
-  topLeft: "╔",
-  topRight: "╗",
-  bottomLeft: "╚",
-  bottomRight: "╝",
-};
-
-export const treeChars = {
-  branch: "├─",
-  lastBranch: "└─",
-  vertical: "│",
-  indent: "  ",
-};
-
-export function drawTopBorder(width: number, title?: string): string {
-  const { topLeft, topRight, horizontal } = borders;
-  if (title) {
-    const titleStr = ` ${title} `;
-    const titleLen = titleStr.length;
-    const remaining = width - 2 - titleLen;
-    const rightDashes = Math.max(0, remaining);
-    return `${topLeft}${titleStr}${horizontal.repeat(rightDashes)}${topRight}`;
-  }
-  return `${topLeft}${horizontal.repeat(width - 2)}${topRight}`;
-}
-
-export function drawBottomBorder(width: number): string {
-  const { bottomLeft, bottomRight, horizontal } = borders;
-  return `${bottomLeft}${horizontal.repeat(width - 2)}${bottomRight}`;
-}
-
-export function drawSeparator(width: number): string {
-  const { leftT, rightT, horizontal } = borders;
-  return `${leftT}${horizontal.repeat(width - 2)}${rightT}`;
-}

package/src/tui/styles/colors.ts

@@ -1,19 +0,0 @@
-import { colors } from "../../hub/styles/colors.js";
-
-export { colors };
-
-export const tuiColors = {
-  background: "#050505",
-  surface: "#0a0a0a",
-  primary: "#f97316",
-  textPrimary: "#ffffff",
-  textSecondary: "#a1a1aa",
-  textTertiary: "#71717a",
-  textQuaternary: "#3f3f46",
-  success: "#22c55e",
-  warning: "#f59e0b",
-  error: "#ef4444",
-  border: "#27272a",
-  mutation: "#f59e0b",
-  checkpoint: "#f97316",
-};

package/src/tui/styles/index.ts

@@ -1,20 +0,0 @@
-export { colors, tuiColors } from "./colors.js";
-export { borders, doubleBorders, treeChars, drawTopBorder, drawBottomBorder, drawSeparator } from "./borders.js";
-export { 
-  statusIndicators, 
-  getStatusIndicator, 
-  spinnerFrames, 
-  getSpinnerFrame,
-  dotsSpinnerFrames,
-  circleSpinnerFrames,
-  pulseFrames,
-  breathFrames,
-  progressMarkerFrames,
-  progressGlowFrames,
-  getPulseFrame,
-  getBreathFrame,
-  getProgressMarker,
-  getProgressGlow
-} from "./indicators.js";
-export { providerTags, getProviderTag, logStatusTags } from "./providers.js";
-export { layout, formatTimestamp, formatTimestampMs, padRight, truncate } from "./layout.js";