@ranker/raxflow 0.2.0

package/src/setup/utils/cli-detection.ts

@@ -0,0 +1,99 @@
+import { execSync } from "node:child_process";
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface DetectedCli {
+  id: string;
+  name: string;
+  detected: boolean;
+  configPath?: string;
+  version?: string;
+}
+
+const CLI_CONFIG_PATHS: Record<string, string[]> = {
+  "claude-code": [
+    path.join(os.homedir(), ".claude"),
+    path.join(os.homedir(), ".config", "claude-code"),
+  ],
+  codex: [
+    path.join(os.homedir(), ".codex"),
+    path.join(os.homedir(), ".config", "codex"),
+  ],
+  opencode: [
+    path.join(os.homedir(), ".opencode"),
+    path.join(os.homedir(), ".config", "opencode"),
+  ],
+  kilo: [
+    path.join(os.homedir(), ".kilo"),
+    path.join(os.homedir(), ".config", "kilo"),
+  ],
+};
+
+const CLI_BOOTSTRAP_FILES: Record<string, string> = {
+  "claude-code": "CLAUDE.md",
+  codex: "CODEX.md",
+  opencode: "OPENCODE.md",
+  kilo: "KILO.md",
+};
+
+export function getCliBootstrapFile(cliId: string): string {
+  return CLI_BOOTSTRAP_FILES[cliId] || "README.md";
+}
+
+export async function detectInstalledClis(): Promise<DetectedCli[]> {
+  const candidates = [
+    { id: "claude-code", name: "Claude Code", cmd: "claude-code --version" },
+    { id: "codex", name: "Codex", cmd: "codex --version" },
+    { id: "opencode", name: "OpenCode", cmd: "opencode --version" },
+    { id: "kilo", name: "Kilo", cmd: "kilo --version" },
+  ];
+
+  const results: DetectedCli[] = [];
+
+  for (const cli of candidates) {
+    let detected = false;
+    let version: string | undefined;
+    let configPath: string | undefined;
+
+    try {
+      const output = execSync(cli.cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      detected = true;
+      version = output.trim().split("\n")[0];
+    } catch {
+      // Not in PATH, check config directories
+    }
+
+    // Check for config directories even if not in PATH
+    const configPaths = CLI_CONFIG_PATHS[cli.id] || [];
+    for (const p of configPaths) {
+      try {
+        await access(p, constants.F_OK);
+        configPath = p;
+        if (!detected) detected = true;
+        break;
+      } catch {
+        // Directory doesn't exist
+      }
+    }
+
+    results.push({
+      id: cli.id,
+      name: cli.name,
+      detected,
+      configPath,
+      version,
+    });
+  }
+
+  return results;
+}
+
+export async function detectInstalledClisFast(): Promise<DetectedCli[]> {
+  return detectInstalledClis();
+}
+
+export function getCliConfigPath(cliId: string): string | undefined {
+  return (CLI_CONFIG_PATHS[cliId] || [])[0];
+}

package/src/setup/utils/config-writer.ts

@@ -0,0 +1,249 @@
+import { mkdir, writeFile, access } from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface ProviderConfig {
+  id: string;
+  name: string;
+  apiKey?: string;
+  model?: string;
+  apiKeyEnv?: string;
+}
+
+export interface SetupConfig {
+  mode: "hub" | "standalone" | "both";
+  providers: ProviderConfig[];
+  defaultProvider: string;
+  hubTargets: string[];
+  projectPath: string;
+}
+
+export interface RaxrcConfig {
+  version: number;
+  defaultProvider: string;
+  strongProvider?: string;
+  providers: Record<string, {
+    model?: string;
+    apiKeyEnv?: string;
+    apiKey?: string;
+    mode?: string;
+    bridgeCommand?: string;
+    bridgeCommandEnv?: string;
+  }>;
+  privacyMode: boolean;
+  verifyFixLoops: number;
+}
+
+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",
+};
+
+const MODEL_MAP: Record<string, string> = {
+  anthropic: "claude-3-5-sonnet-latest",
+  openai: "gpt-4o",
+  gemini: "gemini-2.0-flash",
+  mistral: "mistral-large-latest",
+  groq: "llama-3.3-70b-versatile",
+};
+
+export async function ensureDirectory(dir: string): Promise<void> {
+  try {
+    await access(dir, constants.F_OK);
+  } catch {
+    await mkdir(dir, { recursive: true });
+  }
+}
+
+export async function writeRaxrc(targetDir: string, config: SetupConfig): Promise<string> {
+  const raxrc: RaxrcConfig = {
+    version: 1,
+    defaultProvider: config.defaultProvider,
+    providers: {},
+    privacyMode: true,
+    verifyFixLoops: 3,
+  };
+
+  // Add host provider if hub mode
+  if (config.mode === "hub" || config.mode === "both") {
+    const primaryTarget = config.hubTargets[0] || "claude-code";
+    raxrc.providers.host = {
+      model: primaryTarget,
+      mode: "auto",
+      bridgeCommand: primaryTarget,
+      bridgeCommandEnv: "RAX_HOST_BRIDGE_COMMAND",
+    };
+  }
+
+  // Add configured providers
+  for (const provider of config.providers) {
+    if (provider.id === "host") continue;
+    
+    raxrc.providers[provider.id] = {
+      model: provider.model || MODEL_MAP[provider.id] || "unknown",
+      apiKeyEnv: ENV_VAR_MAP[provider.id] || `${provider.id.toUpperCase()}_API_KEY`,
+    };
+
+    if (provider.apiKey) {
+      raxrc.providers[provider.id].apiKey = provider.apiKey;
+    }
+  }
+
+  // Ensure at least one fallback
+  if (!raxrc.providers.openai) {
+    raxrc.providers.openai = {
+      model: "gpt-4o",
+      apiKeyEnv: "OPENAI_API_KEY",
+    };
+  }
+
+  if (!raxrc.providers.anthropic) {
+    raxrc.providers.anthropic = {
+      model: "claude-3-5-sonnet-latest",
+      apiKeyEnv: "ANTHROPIC_API_KEY",
+    };
+  }
+
+  const filePath = path.join(targetDir, ".raxrc");
+  await writeFile(filePath, JSON.stringify(raxrc, null, 2) + "\n", "utf-8");
+  return filePath;
+}
+
+export async function writeHubBootstrap(
+  targetCli: string,
+  configPath: string,
+  projectPath: string
+): Promise<string> {
+  const bootstrapFileName = getBootstrapFileName(targetCli);
+  const raxFlowDir = path.join(configPath, ".raxflow");
+  
+  await ensureDirectory(raxFlowDir);
+  await ensureDirectory(path.join(raxFlowDir, "workflows"));
+
+  const bootstrapContent = generateBootstrapContent(targetCli, projectPath);
+  const bootstrapPath = path.join(configPath, bootstrapFileName);
+  
+  await writeFile(bootstrapPath, bootstrapContent, "utf-8");
+  
+  // Create example workflow
+  const exampleWorkflow = {
+    id: "default-workflow",
+    nodes: [
+      { id: "analyze", agent: "IntentClassifierAgent", dependsOn: [] },
+      { id: "spec", agent: "SpecAgent", dependsOn: ["analyze"] },
+      { id: "implement", agent: "CodeGeneratorAgent", dependsOn: ["spec"] },
+      { id: "verify", agent: "ValidatorAgent", dependsOn: ["implement"] },
+    ],
+  };
+  
+  const workflowPath = path.join(raxFlowDir, "workflows", "default.json");
+  await writeFile(workflowPath, JSON.stringify(exampleWorkflow, null, 2) + "\n", "utf-8");
+
+  return bootstrapPath;
+}
+
+function getBootstrapFileName(cliId: string): string {
+  const map: Record<string, string> = {
+    "claude-code": "CLAUDE.md",
+    codex: "CODEX.md",
+    opencode: "OPENCODE.md",
+    kilo: "KILO.md",
+  };
+  return map[cliId] || "RAXFLOW.md";
+}
+
+function generateBootstrapContent(cliId: string, projectPath: string): string {
+  return `# RAXFLOW Bootstrap Configuration
+
+This project is configured to work with RAXFLOW orchestration.
+
+## Project Context
+- Path: ${projectPath}
+- CLI: ${cliId}
+
+## Available Commands
+- \`raxflow run --prompt "..." --stream\` - Execute orchestrated workflow
+- \`raxflow doctor\` - Check system health
+- \`raxflow status\` - View current state
+
+## Workflows
+Workflows are stored in \`.raxflow/workflows/\` directory.
+
+## Provider Configuration
+See \`.raxrc\` in the project root for provider settings.
+`;
+}
+
+export async function writeStandaloneConfig(projectPath: string): Promise<{
+  raxFlowDir: string;
+  workflowsDir: string;
+  globalDir: string;
+}> {
+  const raxFlowDir = path.join(projectPath, ".raxflow");
+  const workflowsDir = path.join(raxFlowDir, "workflows");
+  const globalDir = path.join(os.homedir(), ".raxflow");
+
+  await ensureDirectory(raxFlowDir);
+  await ensureDirectory(workflowsDir);
+  await ensureDirectory(globalDir);
+
+  // Create default workflow
+  const defaultWorkflow = {
+    id: "default",
+    name: "Default Workflow",
+    nodes: [
+      { id: "classify", agent: "IntentClassifierAgent", dependsOn: [] },
+      { id: "plan", agent: "TaskPlannerAgent", dependsOn: ["classify"] },
+      { id: "code", agent: "CodeGeneratorAgent", dependsOn: ["plan"] },
+      { id: "test", agent: "TestAgent", dependsOn: ["code"] },
+      { id: "fix", agent: "FixAgent", dependsOn: ["test"] },
+    ],
+  };
+
+  const workflowPath = path.join(workflowsDir, "default.json");
+  await writeFile(workflowPath, JSON.stringify(defaultWorkflow, null, 2) + "\n", "utf-8");
+
+  // Create global config
+  const globalConfigPath = path.join(globalDir, "config.json");
+  const globalConfig = {
+    version: 1,
+    createdAt: new Date().toISOString(),
+    lastUsed: new Date().toISOString(),
+  };
+  await writeFile(globalConfigPath, JSON.stringify(globalConfig, null, 2) + "\n", "utf-8");
+
+  return { raxFlowDir, workflowsDir, globalDir };
+}
+
+export async function validateSetup(projectPath: string): Promise<{
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}> {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Check .raxrc exists
+  try {
+    await access(path.join(projectPath, ".raxrc"), constants.F_OK);
+  } catch {
+    errors.push(".raxrc configuration file not found");
+  }
+
+  // Check .raxflow directory
+  try {
+    await access(path.join(projectPath, ".raxflow"), constants.F_OK);
+  } catch {
+    warnings.push(".raxflow directory not found (optional for hub mode)");
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}

package/src/styles.ts

@@ -0,0 +1,12 @@
+export const c = {
+  blue: (s: string) => `\u001b[34m${s}\u001b[0m`,
+  green: (s: string) => `\u001b[32m${s}\u001b[0m`,
+  yellow: (s: string) => `\u001b[33m${s}\u001b[0m`,
+  red: (s: string) => `\u001b[31m${s}\u001b[0m`,
+  magenta: (s: string) => `\u001b[35m${s}\u001b[0m`,
+  cyan: (s: string) => `\u001b[36m${s}\u001b[0m`,
+  white: (s: string) => `\u001b[37m${s}\u001b[0m`,
+  gray: (s: string) => `\u001b[90m${s}\u001b[0m`,
+  bold: (s: string) => `\u001b[1m${s}\u001b[22m`
+};
+

package/src/tui/App.tsx

@@ -0,0 +1,177 @@
+import React, { useState, useEffect, useRef, useMemo, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { Header } from "./components/Header.js";
+import { ChatPanel } from "./components/ChatPanel.js";
+import { StatusPanel } from "./components/StatusPanel.js";
+import { DAGPanel } from "./components/DAGPanel.js";
+import { LogsPanel } from "./components/LogsPanel.js";
+import { MetricsPanel } from "./components/MetricsPanel.js";
+import { MemoryPanel } from "./components/MemoryPanel.js";
+import { InputBar } from "./components/InputBar.js";
+import { HelpOverlay } from "./components/HelpOverlay.js";
+import { useAppState } from "./hooks/useAppState.js";
+
+type ActivePanel = "chat" | "dag" | "status" | "logs" | "metrics" | "memory";
+
+const PANEL_ORDER: ActivePanel[] = ["chat", "dag", "status", "logs", "metrics", "memory"];
+const TICK_INTERVAL = 200;
+
+export const App = React.memo(function App() {
+  const { exit } = useApp();
+  const { state, processCommand } = useAppState();
+  const [activePanel, setActivePanel] = useState<ActivePanel>("chat");
+  const [showHelp, setShowHelp] = useState(false);
+  const [tick, setTick] = useState(0);
+  const [viewMode, setViewMode] = useState<"full" | "compact">("full");
+  const intervalRef = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    intervalRef.current = setInterval(() => {
+      setTick((t) => t + 1);
+    }, TICK_INTERVAL);
+    return () => {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+    };
+  }, []);
+
+  const handleTab = useCallback(() => {
+    setActivePanel((current) => {
+      const currentIndex = PANEL_ORDER.indexOf(current);
+      return PANEL_ORDER[(currentIndex + 1) % PANEL_ORDER.length];
+    });
+  }, []);
+
+  useInput((input, key) => {
+    if (key.ctrl && (input === "c" || input === "d")) {
+      exit();
+      return;
+    }
+    if (key.escape) {
+      if (showHelp) {
+        setShowHelp(false);
+      }
+      return;
+    }
+    if (input === "?" && !showHelp) {
+      setShowHelp(true);
+      return;
+    }
+    if (showHelp) return;
+
+    if (key.tab) {
+      handleTab();
+      return;
+    }
+
+    if (key.leftArrow) {
+      setViewMode((v) => (v === "full" ? "compact" : "full"));
+    }
+  });
+
+  const handleSubmit = useCallback((input: string) => {
+    const trimmed = input.trim();
+    if (!trimmed) return;
+
+    if (trimmed === "exit" || trimmed === "quit") {
+      exit();
+      return;
+    }
+
+    if (trimmed === "?" || trimmed === "/help") {
+      setShowHelp((s) => !s);
+      return;
+    }
+
+    processCommand(trimmed);
+  }, [exit, processCommand]);
+
+  const handleDismissHelp = useCallback(() => setShowHelp(false), []);
+
+  const headerProps = useMemo(() => ({
+    projectName: state.projectName,
+    agentCount: state.agentCount,
+    provider: state.provider,
+    status: state.status,
+    tick,
+    activePanel,
+  }), [state.projectName, state.agentCount, state.provider, state.status, tick, activePanel]);
+
+  const chatPanelProps = useMemo(() => ({
+    messages: state.messages,
+    isProcessing: state.isProcessing,
+    isActive: activePanel === "chat",
+  }), [state.messages, state.isProcessing, activePanel]);
+
+  const dagPanelProps = useMemo(() => ({
+    workflowState: state.workflowState,
+    tick,
+    isActive: activePanel === "dag",
+  }), [state.workflowState, tick, activePanel]);
+
+  const logsPanelProps = useMemo(() => ({
+    logs: state.logs,
+    isActive: activePanel === "logs",
+  }), [state.logs, activePanel]);
+
+  const metricsPanelProps = useMemo(() => ({
+    metrics: state.metrics,
+    fitness: state.fitness,
+    isActive: activePanel === "metrics",
+    tick,
+  }), [state.metrics, state.fitness, activePanel, tick]);
+
+  const memoryPanelProps = useMemo(() => ({
+    nodes: [] as never[],
+    edges: [] as never[],
+    nodeCount: 247,
+    cacheHitRate: 94,
+    isActive: activePanel === "memory",
+    tick,
+  }), [activePanel, tick]);
+
+  const statusPanelProps = useMemo(() => ({
+    agents: state.agents,
+    providers: state.providers,
+    fitness: state.fitness,
+    currentWorkflow: state.currentWorkflow,
+    isActive: activePanel === "status",
+    tick,
+  }), [state.agents, state.providers, state.fitness, state.currentWorkflow, activePanel, tick]);
+
+  const inputBarProps = useMemo(() => ({
+    onSubmit: handleSubmit,
+    suggestions: state.suggestions,
+    isProcessing: state.isProcessing,
+    projectName: state.projectName,
+  }), [handleSubmit, state.suggestions, state.isProcessing, state.projectName]);
+
+  return (
+    <Box flexDirection="column" height="100%" width="100%">
+      <Header {...headerProps} />
+
+      {showHelp ? (
+        <HelpOverlay onDismiss={handleDismissHelp} />
+      ) : (
+        <>
+          <Box flexGrow={1} flexDirection="row" width="100%">
+            <ChatPanel {...chatPanelProps} />
+            <DAGPanel {...dagPanelProps} />
+            {viewMode === "full" && (
+              <>
+                <LogsPanel {...logsPanelProps} />
+                <Box flexDirection="column">
+                  <MetricsPanel {...metricsPanelProps} />
+                  <MemoryPanel {...memoryPanelProps} />
+                </Box>
+              </>
+            )}
+            {viewMode === "compact" && (
+              <StatusPanel {...statusPanelProps} />
+            )}
+          </Box>
+          <InputBar {...inputBarProps} />
+        </>
+      )}
+    </Box>
+  );
+});

package/src/tui/components/AgentStateIcon.tsx

@@ -0,0 +1,84 @@
+import React, { memo, useMemo } from "react";
+import { Text } from "ink";
+import { tuiColors } from "../styles/index.js";
+
+const THINKING_FRAMES = ["◠", "◡", "◠", "◡"];
+const PROCESSING_FRAMES = ["▶", "▷", "▶", "▷"];
+const RUNNING_FRAMES = ["●", "◉", "●", "○"];
+const WAITING_FRAMES = ["◐", "◓", "◐", "◓"];
+
+export type AgentState = 'idle' | 'thinking' | 'processing' | 'running' | 'success' | 'error' | 'waiting';
+
+interface AgentStateIconProps {
+  state: AgentState;
+  animated?: boolean;
+  tick?: number;
+}
+
+const STATE_CONFIG: Record<AgentState, { icon: string; color: string; animated: boolean; frames?: string[] }> = {
+  idle: { icon: "○", color: tuiColors.textTertiary, animated: false },
+  thinking: { icon: "◠", color: tuiColors.warning, animated: true, frames: THINKING_FRAMES },
+  processing: { icon: "▶", color: tuiColors.primary, animated: true, frames: PROCESSING_FRAMES },
+  running: { icon: "●", color: tuiColors.success, animated: true, frames: RUNNING_FRAMES },
+  success: { icon: "✓", color: tuiColors.success, animated: false },
+  error: { icon: "✗", color: tuiColors.error, animated: false },
+  waiting: { icon: "◐", color: tuiColors.warning, animated: true, frames: WAITING_FRAMES },
+};
+
+export const AgentStateIcon = memo(function AgentStateIcon({ state, animated = true, tick = 0 }: AgentStateIconProps) {
+  const config = STATE_CONFIG[state];
+  const showAnimation = animated && config.animated && config.frames;
+  
+  const icon = useMemo(() => {
+    if (showAnimation && config.frames) {
+      return config.frames[tick % config.frames.length];
+    }
+    return config.icon;
+  }, [showAnimation, config.frames, config.icon, tick]);
+
+  return <Text color={config.color}>{icon}</Text>;
+});
+
+export function useAgentStateFrame(state: AgentState, tick: number): string {
+  const config = STATE_CONFIG[state];
+  if (config.frames) {
+    return config.frames[tick % config.frames.length];
+  }
+  return config.icon;
+}
+
+const STATE_LABELS: Record<AgentState, string> = {
+  idle: "pending",
+  thinking: "thinking...",
+  processing: "processing",
+  running: "running",
+  success: "done",
+  error: "error",
+  waiting: "waiting",
+};
+
+interface AgentStateWithLabelProps {
+  state: AgentState;
+  label: string;
+  tick: number;
+}
+
+export const AgentStateWithLabel = memo(function AgentStateWithLabel({ state, label, tick }: AgentStateWithLabelProps) {
+  return (
+    <>
+      <AgentStateIcon state={state} tick={tick} />
+      <Text color={tuiColors.textSecondary}> {label}</Text>
+      <Text color={tuiColors.textTertiary}> {STATE_LABELS[state]}</Text>
+    </>
+  );
+});
+
+export const agentStateColors: Record<AgentState, string> = {
+  idle: tuiColors.textTertiary,
+  thinking: tuiColors.warning,
+  processing: tuiColors.primary,
+  running: tuiColors.success,
+  success: tuiColors.success,
+  error: tuiColors.error,
+  waiting: tuiColors.warning,
+};