rax-flow 0.1.7 → 0.1.8

package/src/tui/hooks/useAppState.ts

@@ -21,6 +21,25 @@ interface Provider {
   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 AppState {
   projectName: string;
   agentCount: number;
@@ -33,6 +52,7 @@ interface AppState {
   currentWorkflow: string | null;
   suggestions: string[];
   isProcessing: boolean;
+  workflowState: WorkflowState;
 }
 
 const COMMAND_SUGGESTIONS = [
@@ -58,6 +78,38 @@ const DEFAULT_PROVIDERS: Provider[] = [
   { 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);
 }
@@ -82,6 +134,7 @@ export function useAppState() {
     currentWorkflow: null,
     suggestions: COMMAND_SUGGESTIONS,
     isProcessing: false,
+    workflowState: DEFAULT_WORKFLOW_STATE,
   });
 
   const addMessage = useCallback((type: Message["type"], content: string, agent?: string) => {
@@ -94,6 +147,37 @@ export function useAppState() {
     }));
   }, []);
 
+  const updateWorkflowProgress = useCallback((level: number, nodeIndex: number, status: DAGNode["status"]) => {
+    setState((prev: AppState) => {
+      const newLevels = prev.workflowState.levels.map((l, i) => {
+        if (i !== level) return l;
+        const newNodes = l.nodes.map((n, j) => 
+          j === nodeIndex ? { ...n, status } : n
+        );
+        const doneCount = newNodes.filter((n) => n.status === "done").length;
+        return {
+          ...l,
+          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: level,
+          totalProgress: Math.round((totalDone / totalNodes) * 100),
+        },
+      };
+    });
+  }, []);
+
   const processCommand = useCallback((input: string) => {
     if (input.startsWith("/")) {
       const cmd = input.slice(1).toLowerCase();
@@ -120,45 +204,57 @@ export function useAppState() {
         default:
           if (cmd.startsWith("run ")) {
             const prompt = cmd.slice(4);
-            setState((prev: AppState) => ({ ...prev, status: "running", isProcessing: true }));
-            addMessage("user", prompt);
-            addMessage("agent", "Analyse de l'intent...", "IntentClassifier");
-            setTimeout(() => {
-              addMessage("agent", `Intent détecté: code_generation`, "IntentClassifier");
-              addMessage("agent", "Décomposition en tâches...", "TaskPlanner");
-              setState((prev: AppState) => ({
-                ...prev,
-                status: "ready",
-                isProcessing: false,
-                fitness: Math.min(prev.fitness + 0.02, 0.99),
-                currentWorkflow: prompt,
-                agents: prev.agents.map((a: Agent, i: number) => ({
-                  ...a,
-                  status: i === 0 ? "done" as const : i === 1 ? "running" as const : "idle" as const,
-                })),
-              }));
-            }, 1500);
+            runWorkflow(prompt);
           } else {
             addMessage("error", `Commande inconnue: /${cmd}. Tapez /help pour l'aide.`);
           }
       }
     } else {
-      setState((prev: AppState) => ({ ...prev, status: "running", isProcessing: true }));
-      addMessage("user", input);
-      addMessage("agent", "Analyse de l'intent...", "IntentClassifier");
-      setTimeout(() => {
-        addMessage("agent", `Intent détecté: code_generation`, "IntentClassifier");
-        addMessage("agent", "Exécution du workflow...", "Orchestrator");
+      runWorkflow(input);
+    }
+  }, [state, addMessage]);
+
+  const runWorkflow = useCallback((prompt: string) => {
+    setState((prev: AppState) => ({ ...prev, status: "running", isProcessing: true }));
+    addMessage("user", prompt);
+    
+    let step = 0;
+    const steps = [
+      { level: 0, node: 0, msg: "Analyse de l'intent...", agent: "IntentClassifier" },
+      { level: 0, node: 1, msg: "Génération des specs...", agent: "SpecAgent" },
+      { level: 0, node: 2, msg: "Design de l'architecture...", agent: "ArchitectureAgent" },
+      { level: 1, node: 0, msg: "Planification des tâches...", agent: "TaskPlanner" },
+      { level: 1, node: 1, msg: "Génération du code...", agent: "CodeGenerator" },
+      { level: 2, node: 0, msg: "Exécution des tests...", agent: "TestAgent" },
+      { level: 2, node: 1, msg: "Application des fixes...", agent: "FixAgent" },
+    ];
+
+    function executeStep() {
+      if (step >= steps.length) {
         setState((prev: AppState) => ({
           ...prev,
           status: "ready",
           isProcessing: false,
-          fitness: Math.min(prev.fitness + 0.01, 0.99),
-          currentWorkflow: input,
+          fitness: Math.min(prev.fitness + 0.05, 0.99),
+          currentWorkflow: prompt,
         }));
-      }, 2000);
+        addMessage("success", `✓ Workflow terminé! Fitness: ${(state.fitness + 0.05).toFixed(2)}`);
+        return;
+      }
+
+      const s = steps[step];
+      updateWorkflowProgress(s.level, s.node, "running");
+      addMessage("agent", s.msg, s.agent);
+
+      setTimeout(() => {
+        updateWorkflowProgress(s.level, s.node, "done");
+        step++;
+        executeStep();
+      }, 500 + Math.random() * 500);
     }
-  }, [state, addMessage]);
+
+    executeStep();
+  }, [addMessage, updateWorkflowProgress, state.fitness]);
 
   return {
     state,