@ranker/raxflow 0.2.2 → 0.2.4

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

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

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

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

@@ -1,183 +0,0 @@
-import React, { useState, useEffect, useRef, useMemo, useCallback } from "react";
-import { Box, Text, useApp, useInput, useStdout } 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 { stdout } = useStdout();
-  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);
-
-  const terminalHeight = stdout?.rows || 24;
-  const headerHeight = 5;
-  const inputBarHeight = 4;
-  const availableHeight = Math.max(8, terminalHeight - headerHeight - inputBarHeight);
-
-  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={terminalHeight} width="100%">
-      <Header {...headerProps} />
-
-      {showHelp ? (
-        <HelpOverlay onDismiss={handleDismissHelp} />
-      ) : (
-        <>
-          <Box flexDirection="row" width="100%" height={availableHeight}>
-            <ChatPanel {...chatPanelProps} maxHeight={availableHeight} />
-            <DAGPanel {...dagPanelProps} maxHeight={availableHeight} />
-            {viewMode === "full" && (
-              <>
-                <LogsPanel {...logsPanelProps} maxHeight={availableHeight} />
-                <Box flexDirection="column">
-                  <MetricsPanel {...metricsPanelProps} maxHeight={Math.floor(availableHeight / 2)} />
-                  <MemoryPanel {...memoryPanelProps} maxHeight={Math.floor(availableHeight / 2)} />
-                </Box>
-              </>
-            )}
-            {viewMode === "compact" && (
-              <StatusPanel {...statusPanelProps} maxHeight={availableHeight} />
-            )}
-          </Box>
-          <InputBar {...inputBarProps} />
-        </>
-      )}
-    </Box>
-  );
-});

package/src/tui/components/AgentStateIcon.tsx

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