rax-flow-core 0.1.0

package/src/orchestrator/decomposition-engine.ts

@@ -0,0 +1,165 @@
+import { Intent } from "../types/contracts.js";
+
+export interface TaskChunk {
+  id: string;
+  description: string;
+  preferredAgent: string;
+  canRunInParallel: boolean;
+}
+
+export interface Subtask {
+  id: string;
+  title: string;
+  description: string;
+  estimatedDuration: number;
+  priority: number;
+  dependencies?: string[];
+  parallelizable: boolean;
+  complexity: "low" | "medium" | "high";
+}
+
+export class Decomposition {
+  async decompose(task: string, options?: { constraints?: { maxSubtasks?: number; maxDuration?: number } }): Promise<Subtask[]> {
+    const complexity = this.getComplexity(task);
+    const wordCount = task.split(" ").length;
+    const baseDuration = wordCount * 5;
+
+    const subtasks: Subtask[] = [
+      {
+        id: "analyze",
+        title: "Analyze Requirements",
+        description: `Analyze: ${task}`,
+        estimatedDuration: baseDuration * 0.2,
+        priority: 1,
+        parallelizable: false,
+        complexity
+      },
+      {
+        id: "design",
+        title: "Design Solution",
+        description: "Design technical solution",
+        estimatedDuration: baseDuration * 0.3,
+        priority: 2,
+        dependencies: ["analyze"],
+        parallelizable: false,
+        complexity
+      },
+      {
+        id: "implement",
+        title: "Implement",
+        description: "Implement the solution",
+        estimatedDuration: baseDuration * 0.3,
+        priority: 3,
+        dependencies: ["design"],
+        parallelizable: complexity === "low",
+        complexity
+      },
+      {
+        id: "test",
+        title: "Test & Validate",
+        description: "Test and validate",
+        estimatedDuration: baseDuration * 0.2,
+        priority: 4,
+        dependencies: ["implement"],
+        parallelizable: true,
+        complexity
+      }
+    ];
+
+    // Apply constraints
+    if (options?.constraints?.maxSubtasks) {
+      return subtasks.slice(0, Math.min(options.constraints.maxSubtasks, subtasks.length));
+    }
+
+    return subtasks;
+  }
+
+  private getComplexity(task: string): "low" | "medium" | "high" {
+    const complexKeywords = ["distributed", "replication", "concurrent", "async", "architecture"];
+    const hasComplex = complexKeywords.some(kw => task.toLowerCase().includes(kw));
+    const wordCount = task.split(" ").length;
+
+    if (hasComplex || wordCount > 15) return "high";
+    if (wordCount > 8) return "medium";
+    return "low";
+  }
+
+  async analyzeComplexity(task: string): Promise<{ complexity: "low" | "medium" | "high"; score: number }> {
+    const complexity = this.getComplexity(task);
+    const scoreMap = { low: 1, medium: 5, high: 9 };
+    return {
+      complexity,
+      score: scoreMap[complexity]
+    };
+  }
+
+  analyzeDependencies(subtasks: Subtask[]): Map<string, string[]> {
+    const deps = new Map<string, string[]>();
+    for (const task of subtasks) {
+      deps.set(task.id, task.dependencies || []);
+    }
+    return deps;
+  }
+
+  buildHierarchy(subtasks: Subtask[]) {
+    return {
+      id: "root",
+      title: "Main Task",
+      children: subtasks,
+      totalDuration: subtasks.reduce((sum, t) => sum + t.estimatedDuration, 0)
+    };
+  }
+
+  optimizeOrder(subtasks: Subtask[]): Subtask[] {
+    const sorted = [...subtasks].sort((a, b) => {
+      if (a.dependencies?.includes(b.id)) return 1;
+      if (b.dependencies?.includes(a.id)) return -1;
+      return a.priority - b.priority;
+    });
+    return sorted;
+  }
+
+  detectParallel(subtasks: Subtask[]): Subtask[][] {
+    const batches: Subtask[][] = [];
+    const processed = new Set<string>();
+
+    for (const task of subtasks) {
+      if (processed.has(task.id)) continue;
+
+      const batch: Subtask[] = [task];
+      processed.add(task.id);
+
+      if (task.parallelizable) {
+        for (const other of subtasks) {
+          if (!processed.has(other.id) && other.parallelizable) {
+            const canParallelize = !task.dependencies?.includes(other.id) && !other.dependencies?.includes(task.id);
+            if (canParallelize) {
+              batch.push(other);
+              processed.add(other.id);
+            }
+          }
+        }
+      }
+
+      batches.push(batch);
+    }
+
+    return batches;
+  }
+}
+
+export function decomposeTask(intent: Intent, prompt: string): TaskChunk[] {
+  const base = [
+    { id: "analyze", description: `Analyze: ${prompt}`, preferredAgent: "IntentClassifierAgent", canRunInParallel: false },
+    { id: "spec", description: "Draft technical specification", preferredAgent: "SpecAgent", canRunInParallel: false },
+    { id: "implement", description: "Produce implementation artifacts", preferredAgent: "CodeGeneratorAgent", canRunInParallel: intent !== "architecture" },
+    { id: "verify", description: "Run tests and validate schema", preferredAgent: "ValidatorAgent", canRunInParallel: true },
+    { id: "fix", description: "Fix detected issues", preferredAgent: "FixAgent", canRunInParallel: false }
+  ];
+
+  if (intent === "benchmark") {
+    base.push({ id: "benchmark", description: "Generate benchmark report", preferredAgent: "BenchmarkAgent", canRunInParallel: true });
+  }
+
+  return base;
+}

package/src/orchestrator/decomposition.ts

@@ -0,0 +1,25 @@
+import { Intent } from "../types/contracts.js";
+export { Decomposition, Subtask } from "./decomposition-engine.js";
+
+export interface TaskChunk {
+  id: string;
+  description: string;
+  preferredAgent: string;
+  canRunInParallel: boolean;
+}
+
+export function decomposeTask(intent: Intent, prompt: string): TaskChunk[] {
+  const base = [
+    { id: "analyze", description: `Analyze: ${prompt}`, preferredAgent: "IntentClassifierAgent", canRunInParallel: false },
+    { id: "spec", description: "Draft technical specification", preferredAgent: "SpecAgent", canRunInParallel: false },
+    { id: "implement", description: "Produce implementation artifacts", preferredAgent: "CodeGeneratorAgent", canRunInParallel: intent !== "architecture" },
+    { id: "verify", description: "Run tests and validate schema", preferredAgent: "ValidatorAgent", canRunInParallel: true },
+    { id: "fix", description: "Fix detected issues", preferredAgent: "FixAgent", canRunInParallel: false }
+  ];
+
+  if (intent === "benchmark") {
+    base.push({ id: "benchmark", description: "Generate benchmark report", preferredAgent: "BenchmarkAgent", canRunInParallel: true });
+  }
+
+  return base;
+}

package/src/orchestrator/default-workflow.ts

@@ -0,0 +1,269 @@
+import { WorkflowGraph } from "../types/contracts.js";
+import { TaskChunk } from "./decomposition.js";
+
+export interface WorkflowStep {
+  id: string;
+  action?: Function | string;
+  condition?: () => boolean;
+  retries?: number;
+  timeout?: number;
+}
+
+export interface WorkflowDefinition {
+  id?: string;
+  steps: WorkflowStep[];
+  metadata?: Record<string, any>;
+  status?: string;
+  state?: Record<string, any>;
+  context?: Record<string, any>;
+}
+
+export class DefaultWorkflow {
+  private defaultSteps: WorkflowStep[] = [
+    { id: "init", action: () => {} },
+    { id: "process", action: () => {} },
+    { id: "finalize", action: () => {} }
+  ];
+  private workflowState: Record<string, any> = {};
+  private workflowStatus: string = "created";
+  private workflowContext: Record<string, any> = {};
+  private eventLog: string[] = [];
+  private savedState: Record<string, any> = {};
+
+  create(): WorkflowDefinition {
+    return {
+      id: `workflow_${Date.now()}`,
+      steps: JSON.parse(JSON.stringify(this.defaultSteps)),
+      status: "created",
+      state: {},
+      context: {}
+    };
+  }
+
+  async init(workflow?: WorkflowDefinition): Promise<WorkflowDefinition> {
+    const flow = workflow || this.create();
+    this.workflowStatus = "initialized";
+    this.eventLog.push("init");
+    return { ...flow, status: "initialized" };
+  }
+
+  async execute(flow: WorkflowDefinition, options?: { continueOnError?: boolean }): Promise<any> {
+    const results: any[] = [];
+    let completedSteps = 0;
+    this.workflowStatus = "running";
+    this.eventLog.push("start");
+
+    for (const step of flow.steps) {
+      try {
+        if (step.condition && !step.condition()) {
+          results.push({ stepId: step.id, status: "skipped" });
+          continue;
+        }
+        if (step.action && typeof step.action === 'function') {
+          await step.action();
+        }
+        results.push({ stepId: step.id, status: "completed" });
+        completedSteps++;
+        this.eventLog.push(step.id);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        this.eventLog.push(errorMsg);
+        if (!options?.continueOnError) {
+          results.push({ stepId: step.id, status: "failed", error });
+          throw error;
+        }
+        results.push({ stepId: step.id, status: "failed", error });
+      }
+    }
+
+    this.workflowStatus = "completed";
+    this.eventLog.push("end");
+    return { results, completedSteps, status: "completed" };
+  }
+
+  async executeSteps(steps: WorkflowStep[], context?: Record<string, any>): Promise<any[]> {
+    const results: any[] = [];
+    for (const step of steps) {
+      try {
+        if (step.action && typeof step.action === 'function') {
+          const result = await step.action();
+          results.push(result);
+        } else {
+          results.push(undefined);
+        }
+      } catch (error) {
+        results.push({ error });
+      }
+    }
+    return results;
+  }
+
+  validate(flow?: WorkflowDefinition): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!flow) {
+      return { isValid: true, errors };
+    }
+
+    if (!flow.steps || !Array.isArray(flow.steps)) {
+      errors.push("Workflow must have steps array");
+    } else if (flow.steps.length === 0) {
+      errors.push("Workflow must have at least one step");
+    }
+
+    return { isValid: errors.length === 0, errors };
+  }
+
+  clone(flow: WorkflowDefinition): WorkflowDefinition {
+    return JSON.parse(JSON.stringify(flow));
+  }
+
+  merge(...workflows: WorkflowDefinition[]): WorkflowDefinition {
+    const merged: WorkflowStep[] = [];
+    for (const workflow of workflows) {
+      merged.push(...(workflow.steps || []));
+    }
+    return {
+      id: `merged_${Date.now()}`,
+      steps: merged
+    };
+  }
+
+  listSteps(): string[] {
+    return this.defaultSteps.map(s => s.id);
+  }
+
+  getStep(stepId: string): WorkflowStep | undefined {
+    return this.defaultSteps.find(s => s.id === stepId);
+  }
+
+  addStep(step: WorkflowStep): void {
+    this.defaultSteps.push(step);
+  }
+
+  removeStep(stepId: string): boolean {
+    const idx = this.defaultSteps.findIndex(s => s.id === stepId);
+    if (idx >= 0) {
+      this.defaultSteps.splice(idx, 1);
+      return true;
+    }
+    return false;
+  }
+
+  toGraph(id: string): WorkflowGraph {
+    return {
+      id,
+      nodes: this.defaultSteps.map((step, index) => ({
+        id: step.id,
+        agent: "default",
+        dependsOn: index === 0 ? [] : [this.defaultSteps[index - 1].id]
+      }))
+    };
+  }
+
+  getState(): Record<string, any> {
+    return { ...this.workflowState };
+  }
+
+  setState(state: Record<string, any>): void {
+    this.workflowState = { ...this.workflowState, ...state };
+  }
+
+  getStatus(): string {
+    return this.workflowStatus;
+  }
+
+  pause(): void {
+    this.workflowStatus = "paused";
+    this.eventLog.push("pause");
+  }
+
+  resume(): void {
+    if (this.workflowStatus === "paused") {
+      this.workflowStatus = "running";
+      this.eventLog.push("resume");
+    }
+  }
+
+  cancel(): void {
+    this.workflowStatus = "cancelled";
+    this.eventLog.push("cancel");
+  }
+
+  async saveState(id?: string): Promise<void> {
+    const workflowId = id || `workflow_${Date.now()}`;
+    this.savedState[workflowId] = {
+      state: { ...this.workflowState },
+      status: this.workflowStatus,
+      context: { ...this.workflowContext }
+    };
+  }
+
+  async loadState(id: string): Promise<void> {
+    const saved = this.savedState[id];
+    if (saved) {
+      this.workflowState = saved.state;
+      this.workflowStatus = saved.status;
+      this.workflowContext = saved.context;
+    }
+  }
+
+  exportDefinition(): string {
+    return JSON.stringify({
+      steps: this.defaultSteps,
+      state: this.workflowState,
+      context: this.workflowContext
+    });
+  }
+
+  importDefinition(data: string): WorkflowDefinition {
+    const parsed = JSON.parse(data);
+    this.defaultSteps = parsed.steps || [];
+    this.workflowState = parsed.state || {};
+    this.workflowContext = parsed.context || {};
+    return {
+      id: `imported_${Date.now()}`,
+      steps: this.defaultSteps,
+      state: this.workflowState,
+      context: this.workflowContext
+    };
+  }
+
+  getTemplates(): Record<string, WorkflowDefinition> {
+    return {
+      basic: { id: "basic", steps: [{ id: "step1" }] },
+      sequential: { id: "sequential", steps: [{ id: "step1" }, { id: "step2" }] }
+    };
+  }
+
+  fromTemplate(templateName: string): WorkflowDefinition | undefined {
+    const templates = this.getTemplates();
+    return templates[templateName] ? JSON.parse(JSON.stringify(templates[templateName])) : undefined;
+  }
+
+  getEventLog(): string[] {
+    return [...this.eventLog];
+  }
+
+  setContextValue(key: string, value: any): void {
+    if (!this.workflowContext) {
+      this.workflowContext = {};
+    }
+    this.workflowContext[key] = value;
+  }
+
+  getContextValue(key: string): any {
+    return this.workflowContext?.[key];
+  }
+}
+
+export function chunksToWorkflow(id: string, chunks: TaskChunk[]): WorkflowGraph {
+  return {
+    id,
+    nodes: chunks.map((chunk, index) => ({
+      id: chunk.id,
+      agent: chunk.preferredAgent,
+      dependsOn: index === 0 ? [] : [chunks[index - 1].id]
+    }))
+  };
+}