@bahulam/code 2.6.0

package/src/agents/multi_workflow_loader.mjs

@@ -0,0 +1,330 @@
+/**
+ * Multi-Agent Workflow Loader — loads multi-agent workflow YAML files
+ * from .bahulam/workflows/ and produces API payloads for POST /api/workflows.
+ *
+ * Multi-agent workflow YAML schema:
+ *
+ * ```yaml
+ * metadata:
+ *   name: Code Review Pipeline
+ *   description: Sequential review by specialist agents
+ *
+ * orchestration:
+ *   pattern: sequential  # sequential | parallel
+ *   instruction: "Review the PR"
+ *
+ * agents:
+ *   - slug: code-explorer
+ *     label: Explore Codebase
+ *     config:
+ *       depth: full
+ *   - slug: security-reviewer
+ *     label: Security Audit
+ *     config: {}
+ *
+ * edges:
+ *   - source: trigger
+ *     target: code-explorer
+ *   - source: code-explorer
+ *     target: security-reviewer
+ *   - source: security-reviewer
+ *     target: output
+ *
+ * global_params:
+ *   repo_url: ""
+ *   pr_number: ""
+ * ```
+ *
+ * The loader converts this into a graph structure matching the canvas
+ * format: { nodes: [...], edges: [...] } with node types trigger/agent/output.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Load a multi-agent workflow YAML file and return an API-ready payload.
+ * @param {string} filePath - absolute path to .yaml file
+ * @returns {object} payload ready for POST /api/workflows
+ */
+export function loadMultiWorkflowFromFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!['.yaml', '.yml'].includes(ext)) {
+        throw new Error(`Unsupported workflow format: ${ext}. Use .yaml or .yml`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = parseWorkflowYaml(content);
+
+    if (!parsed) {
+        throw new Error('Empty or invalid YAML file');
+    }
+
+    return multiWorkflowToApiPayload(parsed, filePath);
+}
+
+/**
+ * Convert a parsed multi-agent workflow YAML into the API payload.
+ *
+ * @param {object} parsed - parsed YAML content
+ * @param {string} sourcePath - file path for slug derivation
+ * @returns {object} { name, description, graph, global_params, pattern }
+ */
+export function multiWorkflowToApiPayload(parsed, sourcePath) {
+    const metadata = parsed.metadata || {};
+    const orchestration = parsed.orchestration || {};
+    const agents = parsed.agents || [];
+    const edges = parsed.edges || [];
+    const globalParams = parsed.global_params || {};
+
+    // Validate
+    if (!metadata.name && !sourcePath) {
+        throw new Error('Workflow must have a name in metadata or a filename');
+    }
+    if (!Array.isArray(agents) || agents.length === 0) {
+        throw new Error('Workflow must define at least one agent in the agents list');
+    }
+    if (!Array.isArray(edges) || edges.length === 0) {
+        throw new Error('Workflow must define at least one edge connecting nodes');
+    }
+
+    const name = metadata.name || path.basename(sourcePath, path.extname(sourcePath));
+    const description = metadata.description || '';
+
+    // Build graph nodes
+    // 1. Trigger node
+    const nodes = [
+        {
+            id: 'trigger',
+            type: 'trigger',
+            position: { x: 0, y: 120 },
+            data: {
+                label: 'Manual Run',
+                icon: 'trigger',
+                status: 'idle',
+                nodeType: 'trigger',
+                triggerType: 'manual',
+            },
+        },
+    ];
+
+    // 2. Agent nodes from the agents list
+    for (const agent of agents) {
+        const slug = agent.slug || agent.name || 'agent';
+        const label = agent.label || slug;
+        // Position agents in a vertical column or horizontal row
+        const index = agents.indexOf(agent);
+        nodes.push({
+            id: slug,
+            type: 'agent',
+            position: { x: 250, y: 120 + index * 160 },
+            data: {
+                label,
+                subtitle: '',
+                icon: 'agent',
+                status: 'idle',
+                nodeType: 'agent',
+                agent_source: 'user',
+                agent_slug: slug,
+                user_agent_slug: slug,
+                model: agent.model || 'auto',
+                tools: agent.tools || [],
+                config: {
+                    ...(agent.config || {}),
+                    agent_slug: slug,
+                    user_agent_slug: slug,
+                },
+            },
+        });
+    }
+
+    // 3. Output node
+    nodes.push({
+        id: 'output',
+        type: 'output',
+        position: { x: 500, y: 120 + (agents.length - 1) * 80 },
+        data: {
+            label: 'Results',
+            icon: 'review',
+            status: 'idle',
+            nodeType: 'output',
+            outputType: 'display',
+        },
+    });
+
+    // Build graph edges
+    // Use explicit edges from YAML, or auto-wire: trigger → first agent → ... → last agent → output
+    let graphEdges;
+    if (edges.length > 0) {
+        graphEdges = edges.map((e, i) => ({
+            id: `e-${i}`,
+            source: e.source,
+            target: e.target,
+        }));
+    } else {
+        // Auto-wire sequential
+        graphEdges = [];
+        const agentIds = agents.map(a => a.slug || a.name || 'agent');
+        graphEdges.push({ id: 'e-trigger-first', source: 'trigger', target: agentIds[0] });
+        for (let i = 0; i < agentIds.length - 1; i++) {
+            graphEdges.push({ id: `e-${i}-${i + 1}`, source: agentIds[i], target: agentIds[i + 1] });
+        }
+        graphEdges.push({ id: 'e-last-output', source: agentIds[agentIds.length - 1], target: 'output' });
+    }
+
+    const graph = {
+        nodes,
+        edges: graphEdges,
+    };
+
+    const pattern = orchestration.pattern || 'sequential';
+
+    return {
+        name,
+        description,
+        graph,
+        global_params: globalParams,
+        orchestration_pattern: pattern,
+        pattern,
+    };
+}
+
+function stripComment(line) {
+    let quote = null;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if ((ch === '"' || ch === "'") && line[i - 1] !== '\\') {
+            quote = quote === ch ? null : quote || ch;
+        }
+        if (ch === '#' && !quote) return line.slice(0, i);
+    }
+    return line;
+}
+
+function parseScalar(value) {
+    const raw = stripComment(String(value || '')).trim();
+    if (raw === '{}') return {};
+    if (raw === '[]') return [];
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+        return raw.slice(1, -1);
+    }
+    if (raw.startsWith('[') && raw.endsWith(']')) {
+        return raw.slice(1, -1).split(',').map(s => parseScalar(s)).filter(v => v !== '');
+    }
+    if (raw === 'true') return true;
+    if (raw === 'false') return false;
+    if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+    return raw;
+}
+
+function assignNested(target, key, value) {
+    if (key.includes('.')) {
+        const parts = key.split('.');
+        let cursor = target;
+        for (const part of parts.slice(0, -1)) {
+            cursor[part] ||= {};
+            cursor = cursor[part];
+        }
+        cursor[parts[parts.length - 1]] = value;
+        return;
+    }
+    target[key] = value;
+}
+
+function parseWorkflowYaml(content) {
+    const root = {};
+    const lines = String(content || '').split(/\r?\n/);
+    let section = null;
+    let currentItem = null;
+    let currentNested = null;
+
+    for (const originalLine of lines) {
+        if (!originalLine.trim() || originalLine.trimStart().startsWith('#')) continue;
+        const line = stripComment(originalLine);
+        if (!line.trim()) continue;
+
+        const top = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+        if (top) {
+            const key = top[1];
+            const value = top[2].trim();
+            section = key;
+            currentItem = null;
+            currentNested = null;
+            if (value) root[key] = parseScalar(value);
+            else root[key] = key === 'agents' || key === 'edges' ? [] : {};
+            continue;
+        }
+
+        if (!section) continue;
+
+        const listItem = line.match(/^\s{2}-\s*([^:]+):\s*(.*)$/);
+        if (listItem && Array.isArray(root[section])) {
+            currentItem = {};
+            currentNested = null;
+            assignNested(currentItem, listItem[1].trim(), parseScalar(listItem[2]));
+            root[section].push(currentItem);
+            continue;
+        }
+
+        const listScalar = line.match(/^\s{2}-\s*(.+)$/);
+        if (listScalar && Array.isArray(root[section])) {
+            root[section].push(parseScalar(listScalar[1]));
+            continue;
+        }
+
+        const nestedField = line.match(/^\s{4}([^:]+):\s*(.*)$/);
+        if (nestedField && currentNested) {
+            assignNested(currentNested, nestedField[1].trim(), parseScalar(nestedField[2]));
+            continue;
+        }
+
+        const objectField = line.match(/^\s{2}([^:]+):\s*(.*)$/);
+        if (objectField) {
+            const key = objectField[1].trim();
+            const value = objectField[2].trim();
+            if (currentItem) {
+                if (!value) {
+                    currentItem[key] = {};
+                    currentNested = currentItem[key];
+                } else {
+                    assignNested(currentItem, key, parseScalar(value));
+                    currentNested = null;
+                }
+            } else if (typeof root[section] === 'object' && !Array.isArray(root[section])) {
+                assignNested(root[section], key, parseScalar(value));
+            }
+            continue;
+        }
+    }
+
+    return root;
+}
+
+/**
+ * Scan a directory for multi-agent workflow YAML files.
+ * @param {string} dir - directory path
+ * @returns {Array<{file: string, payload: object}>}
+ */
+export function loadMultiWorkflowsFromDir(dir) {
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile()) continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            if (ext !== '.yaml' && ext !== '.yml') continue;
+            const filePath = path.join(dir, entry.name);
+            try {
+                const payload = loadMultiWorkflowFromFile(filePath);
+                results.push({ file: filePath, payload });
+            } catch (err) {
+                if (process.env.DEBUG) {
+                    console.error(`[multi-workflow-loader] Failed to load ${filePath}: ${err.message}`);
+                }
+            }
+        }
+    } catch {
+        // Directory does not exist
+    }
+    return results;
+}

package/src/agents/parser.mjs

@@ -0,0 +1,205 @@
+/**
+ * Agent Parser — parses agent definitions from native YAML, JSON, and Markdown.
+ *
+ * JSON format:
+ * {
+ *   "name": "my-agent",
+ *   "description": "Does things",
+ *   "model": "claude-sonnet-4-6",
+ *   "tools": ["Bash", "Read", "Write"],
+ *   "hooks": { ... },
+ *   "prompt": "You are a specialized agent..."
+ * }
+ *
+ * Markdown format (YAML frontmatter):
+ * ---
+ * name: my-agent
+ * description: Does things
+ * model: claude-sonnet-4-6
+ * tools: [Bash, Read, Write]
+ * ---
+ * You are a specialized agent...
+ */
+
+/**
+ * Parse an agent definition from file content.
+ * @param {string} content - file content
+ * @param {string} ext - file extension (.yaml, .yml, .json, or .md)
+ * @returns {object} agent definition
+ */
+export function parseAgentDefinition(content, ext) {
+    if (ext === '.yaml' || ext === '.yml') {
+        return parseYamlAgent(content);
+    }
+    if (ext === '.json') {
+        return parseJsonAgent(content);
+    }
+    if (ext === '.md') {
+        return parseMarkdownAgent(content);
+    }
+    throw new Error(`Unsupported agent format: ${ext}`);
+}
+
+function parseJsonAgent(content) {
+    const data = JSON.parse(content);
+    return normalizeAgent(data);
+}
+
+function parseMarkdownAgent(content) {
+    const { frontmatter, body } = parseFrontmatter(content);
+    return normalizeAgent({ ...frontmatter, prompt: body });
+}
+
+function parseYamlAgent(content) {
+    const config = parseKeplerSubAgentYaml(content);
+    return normalizeAgent({
+        raw_config: config,
+        apiVersion: config.apiVersion,
+        kind: config.kind,
+        ...(config.metadata || {}),
+        ...(config.agent?.model ? { model: config.agent.model } : {}),
+        ...(config.agent?.models ? { models: config.agent.models } : {}),
+        max_iterations: config.agent?.max_iterations,
+        max_tokens: config.agent?.max_tokens,
+        prompt: config.agent?.system_prompt || '',
+        tools: config.tools || [],
+    });
+}
+
+function parseScalar(value) {
+    const raw = String(value || '').trim();
+    if (raw.startsWith('"') && raw.endsWith('"')) return raw.slice(1, -1);
+    if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+    if (raw.startsWith('[') && raw.endsWith(']')) {
+        return raw.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+    }
+    if (raw === 'true') return true;
+    if (raw === 'false') return false;
+    if (/^\d+$/.test(raw)) return Number.parseInt(raw, 10);
+    return raw;
+}
+
+function parseKeplerSubAgentYaml(content) {
+    const root = {};
+    const lines = String(content || '').split(/\r?\n/);
+    let section = root;
+    let sectionName = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim() || line.trimStart().startsWith('#')) continue;
+        if (!line.startsWith(' ')) {
+            const match = line.match(/^([^:]+):\s*(.*)$/);
+            if (!match) continue;
+            const key = match[1].trim();
+            const value = match[2].trim();
+            if (value === '') {
+                root[key] = key === 'tools' ? [] : {};
+                section = root[key];
+                sectionName = key;
+            } else {
+                root[key] = parseScalar(value);
+                section = root;
+                sectionName = null;
+            }
+            continue;
+        }
+
+        if (sectionName === 'tools') {
+            const item = line.trim().match(/^-\s*(.+)$/);
+            if (item) section.push(parseScalar(item[1]));
+            continue;
+        }
+
+        const nested = line.match(/^\s{2}([^:]+):\s*(.*)$/);
+        if (!nested || typeof section !== 'object' || Array.isArray(section)) continue;
+        const key = nested[1].trim();
+        const value = nested[2].trim();
+        if (value === '|') {
+            const block = [];
+            const baseIndent = (lines[i + 1]?.match(/^(\s*)/)?.[1]?.length ?? 4);
+            while (i + 1 < lines.length) {
+                const next = lines[i + 1];
+                if (!next.trim()) {
+                    block.push('');
+                    i++;
+                    continue;
+                }
+                const indent = next.match(/^(\s*)/)?.[1]?.length ?? 0;
+                if (indent < baseIndent) break;
+                block.push(next.slice(baseIndent));
+                i++;
+            }
+            section[key] = block.join('\n').trimEnd();
+        } else if (value === '') {
+            section[key] = {};
+        } else {
+            section[key] = parseScalar(value);
+        }
+    }
+    return root;
+}
+
+/**
+ * Parse YAML-like frontmatter from markdown.
+ * Simple key-value parser (no full YAML dependency).
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+
+    const yamlBlock = match[1];
+    const body = match[2].trim();
+    const frontmatter = {};
+
+    for (const line of yamlBlock.split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) continue;
+
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+
+        // Parse arrays: [a, b, c]
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+        }
+        // Parse booleans
+        else if (value === 'true') value = true;
+        else if (value === 'false') value = false;
+        // Parse numbers
+        else if (/^\d+$/.test(value)) value = parseInt(value, 10);
+
+        frontmatter[key] = value;
+    }
+
+    return { frontmatter, body };
+}
+
+function normalizeAgent(data) {
+    const config = data.raw_config || null;
+    const metadata = config?.metadata || {};
+    const agent = config?.agent || {};
+    return {
+        slug: data.slug || data.id || metadata.slug || metadata.name || data.name || 'unnamed',
+        id: data.id || data.slug || metadata.slug || metadata.name || data.name || 'unnamed',
+        name: data.name || metadata.name || 'unnamed',
+        description: data.description || metadata.description || '',
+        role: data.role || metadata.role || 'specialist',
+        model: data.model || agent.model || null,
+        models: data.models && typeof data.models === 'object' ? data.models : {},
+        tools: Array.isArray(data.tools) ? data.tools : Array.isArray(config?.tools) ? config.tools : [],
+        capabilities: Array.isArray(data.capabilities) ? data.capabilities : Array.isArray(metadata.capabilities) ? metadata.capabilities : [],
+        domains: Array.isArray(data.domains) ? data.domains : Array.isArray(metadata.domains) ? metadata.domains : [],
+        hooks: data.hooks || {},
+        prompt: data.prompt || agent.system_prompt || '',
+        maxTokens: data.max_tokens || agent.max_tokens || 4096,
+        maxTurns: data.maxTurns || data.max_turns || data.max_iterations || agent.max_iterations || 10,
+        max_iterations: data.max_iterations || data.maxTurns || data.max_turns || agent.max_iterations || 10,
+        can_delegate: data.can_delegate ?? false,
+        can_be_delegated_to: data.can_be_delegated_to ?? true,
+        temperature: data.temperature || undefined,
+        raw_config: config,
+        config,
+    };
+}