@marktoflow/gui 2.0.0-alpha.1

package/src/server/routes/workflows.ts

@@ -0,0 +1,106 @@
+import { Router, type Router as RouterType } from 'express';
+import { WorkflowService } from '../services/WorkflowService.js';
+
+const router: RouterType = Router();
+const workflowService = new WorkflowService();
+
+// List all workflows
+router.get('/', async (_req, res) => {
+  try {
+    const workflows = await workflowService.listWorkflows();
+    res.json({ workflows });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to list workflows',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+// Get a specific workflow
+router.get('/:path(*)', async (req, res) => {
+  try {
+    const workflowPath = decodeURIComponent((req.params as Record<string, string>)['path(*)']);
+    const workflow = await workflowService.getWorkflow(workflowPath);
+
+    if (!workflow) {
+      return res.status(404).json({ error: 'Workflow not found' });
+    }
+
+    res.json({ workflow });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to get workflow',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+// Create a new workflow
+router.post('/', async (req, res) => {
+  try {
+    const { name, template } = req.body;
+
+    if (!name) {
+      return res.status(400).json({ error: 'Name is required' });
+    }
+
+    const workflow = await workflowService.createWorkflow(name, template);
+    res.status(201).json({ workflow });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to create workflow',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+// Update a workflow
+router.put('/:path(*)', async (req, res) => {
+  try {
+    const workflowPath = decodeURIComponent((req.params as Record<string, string>)['path(*)']);
+    const { workflow } = req.body;
+
+    if (!workflow) {
+      return res.status(400).json({ error: 'Workflow data is required' });
+    }
+
+    const updated = await workflowService.updateWorkflow(workflowPath, workflow);
+    res.json({ workflow: updated });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to update workflow',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+// Delete a workflow
+router.delete('/:path(*)', async (req, res) => {
+  try {
+    const workflowPath = decodeURIComponent((req.params as Record<string, string>)['path(*)']);
+    await workflowService.deleteWorkflow(workflowPath);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to delete workflow',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+// Get workflow execution history
+router.get('/:path(*)/runs', async (req, res) => {
+  try {
+    const workflowPath = decodeURIComponent((req.params as Record<string, string>)['path(*)']);
+    const runs = await workflowService.getExecutionHistory(workflowPath);
+    res.json({ runs });
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to get execution history',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+export { router as workflowRoutes };

package/src/server/services/AIService.ts

@@ -0,0 +1,105 @@
+/**
+ * AI Service - Backwards-compatible wrapper around the Agent Registry
+ *
+ * This service provides the same interface as before but now supports
+ * multiple AI backends through the agent provider system.
+ */
+
+import { getAgentRegistry, type AgentRegistry, type PromptHistoryItem } from './agents/index.js';
+
+interface Workflow {
+  metadata: any;
+  steps: any[];
+  tools?: Record<string, any>;
+  inputs?: Record<string, any>;
+}
+
+interface PromptResult {
+  explanation: string;
+  workflow?: Workflow;
+  diff?: string;
+}
+
+export class AIService {
+  private registry: AgentRegistry;
+  private initialized: boolean = false;
+
+  constructor() {
+    this.registry = getAgentRegistry();
+  }
+
+  /**
+   * Initialize the service with auto-detection of available providers
+   */
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      await this.registry.autoDetectProvider();
+      this.initialized = true;
+    }
+  }
+
+  /**
+   * Process a prompt to modify a workflow
+   */
+  async processPrompt(prompt: string, workflow: Workflow): Promise<PromptResult> {
+    await this.initialize();
+    return this.registry.processPrompt(prompt, workflow);
+  }
+
+  /**
+   * Stream a prompt response (if supported by the active provider)
+   */
+  async streamPrompt(
+    prompt: string,
+    workflow: Workflow,
+    onChunk: (chunk: string) => void
+  ): Promise<PromptResult> {
+    await this.initialize();
+    return this.registry.streamPrompt(prompt, workflow, onChunk);
+  }
+
+  /**
+   * Get prompt history
+   */
+  async getHistory(): Promise<PromptHistoryItem[]> {
+    return this.registry.getHistory(20);
+  }
+
+  /**
+   * Get suggestions for the current workflow
+   */
+  async getSuggestions(
+    workflow: Workflow,
+    selectedStepId?: string
+  ): Promise<string[]> {
+    await this.initialize();
+    return this.registry.getSuggestions(workflow, selectedStepId);
+  }
+
+  /**
+   * Get the current provider status
+   */
+  getStatus(): {
+    activeProvider: string;
+    providers: Array<{ id: string; name: string; ready: boolean; model?: string; error?: string }>;
+  } {
+    return this.registry.getStatus();
+  }
+
+  /**
+   * Switch to a different provider
+   */
+  async setProvider(
+    providerId: string,
+    config?: { apiKey?: string; baseUrl?: string; model?: string }
+  ): Promise<boolean> {
+    return this.registry.setActiveProvider(providerId, config);
+  }
+
+  /**
+   * Get the registry for direct access to providers
+   */
+  getRegistry(): AgentRegistry {
+    return this.registry;
+  }
+}

package/src/server/services/FileWatcher.ts

@@ -0,0 +1,69 @@
+import { watch, type FSWatcher } from 'chokidar';
+import type { Server as SocketIOServer } from 'socket.io';
+
+export class FileWatcher {
+  private watcher: FSWatcher;
+  private io: SocketIOServer;
+
+  constructor(baseDir: string, io: SocketIOServer) {
+    this.io = io;
+
+    // Watch for workflow files
+    this.watcher = watch(['**/*.md', '**/*.yaml', '**/*.yml'], {
+      cwd: baseDir,
+      ignored: [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/.git/**',
+        '**/.*',
+      ],
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100,
+      },
+    });
+
+    this.setupListeners();
+    console.log(`File watcher started for: ${baseDir}`);
+  }
+
+  private setupListeners() {
+    this.watcher.on('change', (path) => {
+      console.log(`File changed: ${path}`);
+      this.io.emit('workflow:updated', {
+        path,
+        event: 'change',
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    this.watcher.on('add', (path) => {
+      console.log(`File added: ${path}`);
+      this.io.emit('workflow:updated', {
+        path,
+        event: 'add',
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    this.watcher.on('unlink', (path) => {
+      console.log(`File removed: ${path}`);
+      this.io.emit('workflow:updated', {
+        path,
+        event: 'remove',
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    this.watcher.on('error', (error) => {
+      console.error('File watcher error:', error);
+    });
+  }
+
+  stop() {
+    this.watcher.close();
+    console.log('File watcher stopped');
+  }
+}