@bahulam/code 0.1.1

package/src/agents/scaffold.mjs

@@ -0,0 +1,223 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { AgentLoader } from './loader.mjs';
+
+export const AGENT_SYNC_ENDPOINT = '/api/user/agents/sync';
+
+export function slugifyAgentName(value) {
+  return String(value || 'agent')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    || 'agent';
+}
+
+export function agentContentHash(agent) {
+  const body = JSON.stringify(agentToSpec(agent));
+  return crypto.createHash('sha256').update(body).digest('hex');
+}
+
+export function agentToSpec(agent) {
+  const slug = slugifyAgentName(agent.slug || agent.id || agent.name);
+  const config = agent.raw_config || {
+    apiVersion: 'agent.framework/v1',
+    kind: 'SubAgent',
+    metadata: {
+      name: agent.name || slug,
+      role: agent.role || 'specialist',
+      description: agent.description || '',
+      capabilities: Array.isArray(agent.capabilities) ? agent.capabilities : [],
+      domains: Array.isArray(agent.domains) ? agent.domains : [],
+    },
+    agent: {
+      ...(agent.model ? { model: agent.model } : {}),
+      ...(agent.maxTokens ? { max_tokens: agent.maxTokens } : { max_tokens: 4096 }),
+      max_iterations: agent.max_iterations || agent.maxTurns || 10,
+      system_prompt: agent.prompt || agent.system_prompt || '',
+    },
+    tools: Array.isArray(agent.tools) ? agent.tools : [],
+  };
+  const spec = {
+    id: slug,
+    slug,
+    name: agent.name || slug,
+    description: agent.description || '',
+    role: agent.role || 'specialist',
+    model: agent.model || undefined,
+    models: agent.models && Object.keys(agent.models).length ? agent.models : undefined,
+    tools: Array.isArray(agent.tools) ? agent.tools : [],
+    capabilities: Array.isArray(agent.capabilities) ? agent.capabilities : [],
+    domains: Array.isArray(agent.domains) ? agent.domains : [],
+    system_prompt: agent.prompt || agent.system_prompt || '',
+    config,
+    max_iterations: agent.max_iterations || agent.maxTurns || 10,
+    can_delegate: agent.can_delegate ?? false,
+    can_be_delegated_to: agent.can_be_delegated_to ?? true,
+    source: 'cli',
+  };
+  return Object.fromEntries(Object.entries(spec).filter(([, value]) => value !== undefined));
+}
+
+export function listLocalAgents(cwd = process.cwd()) {
+  return new AgentLoader().load(cwd).list().map(agent => {
+    const spec = agentToSpec(agent);
+    return {
+      ...agent,
+      slug: spec.slug,
+      spec,
+      content_hash: agentContentHash(agent),
+      source_scope: String(agent.source || '').includes(`${path.sep}.bahulam${path.sep}agents${path.sep}`)
+        ? (String(agent.source).startsWith(path.join(cwd, '.bahulam')) ? 'project' : 'global')
+        : 'unknown',
+    };
+  });
+}
+
+function splitCommand(value) {
+  return String(value || '')
+    .match(/"[^"]+"|'[^']+'|\S+/g)
+    ?.map(part => part.replace(/^["']|["']$/g, '')) || [];
+}
+
+function commandExists(command, env = process.env) {
+  if (!command) return false;
+  if (command.includes(path.sep)) return fs.existsSync(command);
+
+  const pathValue = env.PATH || '';
+  const extensions = process.platform === 'win32'
+    ? ['', '.cmd', '.exe', '.bat']
+    : [''];
+  return pathValue.split(path.delimiter).some(dir => (
+    extensions.some(ext => fs.existsSync(path.join(dir, `${command}${ext}`)))
+  ));
+}
+
+export function isVsCodeTerminal(env = process.env) {
+  return env.TERM_PROGRAM === 'vscode' || Boolean(env.VSCODE_PID);
+}
+
+export function resolveAgentEditor({
+  env = process.env,
+  allowConfiguredEditor = true,
+} = {}) {
+  if (isVsCodeTerminal(env) && commandExists('code', env)) {
+    return { command: 'code', args: ['-r'], label: 'VS Code' };
+  }
+
+  if (!allowConfiguredEditor) return null;
+  const configured = env.VISUAL || env.EDITOR || '';
+  const [command, ...args] = splitCommand(configured);
+  if (command && commandExists(command, env)) {
+    return { command, args, label: command };
+  }
+  return null;
+}
+
+export function openAgentFile(filePath, {
+  env = process.env,
+  allowConfiguredEditor = true,
+} = {}) {
+  const editor = resolveAgentEditor({ env, allowConfiguredEditor });
+  if (!editor) {
+    return {
+      opened: false,
+      reason: isVsCodeTerminal(env)
+        ? 'VS Code terminal detected, but the code command is unavailable.'
+        : 'No editor command found. Set VISUAL or EDITOR, or open the file manually.',
+    };
+  }
+
+  const child = spawn(editor.command, [...editor.args, filePath], {
+    detached: true,
+    stdio: 'ignore',
+    env,
+  });
+  child.on('error', () => {});
+  child.unref();
+  return { opened: true, editor: editor.label };
+}
+
+export function createAgentFile({
+  cwd = process.cwd(),
+  name,
+  description = '',
+  role = 'specialist',
+  model = '',
+  tools = [],
+  prompt = '',
+  force = false,
+} = {}) {
+  const slug = slugifyAgentName(name);
+  const dir = path.join(cwd, '.bahulam', 'agents');
+  const filePath = path.join(dir, `${slug}.yaml`);
+  if (fs.existsSync(filePath) && !force) {
+    throw new Error(`Agent already exists: ${filePath}`);
+  }
+  fs.mkdirSync(dir, { recursive: true });
+  const toolList = Array.isArray(tools) ? tools : String(tools || '').split(',').map(s => s.trim()).filter(Boolean);
+  const body = prompt || `You are ${name}, a project-local Bahulam Code sub-agent.\n\nFocus on the assigned task and return a concise handoff with evidence.`;
+  const indentedPrompt = body.trim().split('\n').map(line => `    ${line}`).join('\n');
+  const lines = [
+    'apiVersion: agent.framework/v1',
+    'kind: SubAgent',
+    'metadata:',
+    `  name: ${name}`,
+    `  role: ${role}`,
+    `  description: ${description || `${name} project agent`}`,
+    'agent:',
+    '  max_tokens: 4096',
+    '  max_iterations: 10',
+    ...(model ? [`  model: ${model}`] : []),
+    '  system_prompt: |',
+    indentedPrompt,
+    'tools:',
+    ...toolList.map(tool => `  - ${tool}`),
+    '',
+  ];
+  fs.writeFileSync(filePath, lines.join('\n'), { mode: 0o600 });
+  return { slug, filePath };
+}
+
+export async function syncAgentsToBackend({
+  backendUrl,
+  token,
+  agents,
+  timeoutMs = 15_000,
+} = {}) {
+  if (!backendUrl) throw new Error('Missing backend URL');
+  if (!token) throw new Error('Not logged in. Run /login first.');
+  const payload = {
+    agents: agents.map(agent => ({
+      slug: agent.slug,
+      name: agent.name,
+      description: agent.description || '',
+      source: agent.source_scope || 'cli',
+      spec: agent.spec || agentToSpec(agent),
+      content_hash: agent.content_hash || agentContentHash(agent),
+    })),
+  };
+  const resp = await fetch(`${backendUrl}${AGENT_SYNC_ENDPOINT}`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      'X-Product': 'bahulam',
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!resp.ok) {
+    let detail = '';
+    try {
+      const data = await resp.json();
+      detail = data.detail || data.error || JSON.stringify(data);
+    } catch {
+      detail = await resp.text().catch(() => '');
+    }
+    throw new Error(`Agent sync failed (${resp.status})${detail ? `: ${detail}` : ''}`);
+  }
+  return await resp.json();
+}

package/src/agents/teams.mjs

@@ -0,0 +1,123 @@
+/**
+ * Agent Teams — multi-agent coordination.
+ *
+ * Allows registering named agents that can communicate via messages.
+ * Each teammate is an agent loop that can be invoked with a prompt.
+ */
+
+export class AgentTeams {
+    constructor() {
+        /** @type {Map<string, { loop: object, role?: string, status: string }>} */
+        this.teammates = new Map();
+        this.messageLog = [];
+    }
+
+    /**
+     * Register a named agent.
+     * @param {string} name - unique agent name
+     * @param {object} agentLoop - agent loop with .run() async generator
+     * @param {object} [options]
+     * @param {string} [options.role] - agent role description
+     */
+    register(name, agentLoop, options = {}) {
+        if (this.teammates.has(name)) {
+            throw new Error(`Agent "${name}" is already registered`);
+        }
+        this.teammates.set(name, {
+            loop: agentLoop,
+            role: options.role || 'general',
+            status: 'idle',
+        });
+    }
+
+    /**
+     * Unregister an agent.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    unregister(name) {
+        return this.teammates.delete(name);
+    }
+
+    /**
+     * Send a message to a teammate and collect all events.
+     * @param {string} to - target agent name
+     * @param {string} message - prompt to send
+     * @returns {Promise<Array<object>>} collected events
+     */
+    async sendMessage(to, message) {
+        const agent = this.teammates.get(to);
+        if (!agent) throw new Error(`Unknown teammate: ${to}`);
+
+        agent.status = 'running';
+        const results = [];
+
+        try {
+            for await (const event of agent.loop.run(message)) {
+                results.push(event);
+            }
+        } finally {
+            agent.status = 'idle';
+        }
+
+        this.messageLog.push({
+            to,
+            message: message.substring(0, 100),
+            resultCount: results.length,
+            timestamp: new Date().toISOString(),
+        });
+
+        return results;
+    }
+
+    /**
+     * Broadcast a message to all teammates.
+     * @param {string} message
+     * @returns {Promise<Map<string, Array<object>>>} results per agent
+     */
+    async broadcast(message) {
+        const results = new Map();
+        const promises = [];
+
+        for (const [name] of this.teammates) {
+            promises.push(
+                this.sendMessage(name, message)
+                    .then(events => results.set(name, events))
+                    .catch(err => results.set(name, [{ type: 'error', message: err.message }]))
+            );
+        }
+
+        await Promise.all(promises);
+        return results;
+    }
+
+    /**
+     * List all registered teammates.
+     * @returns {Array<{ name: string, role: string, status: string }>}
+     */
+    list() {
+        return [...this.teammates.entries()].map(([name, info]) => ({
+            name,
+            role: info.role,
+            status: info.status,
+        }));
+    }
+
+    /**
+     * Get the message log.
+     * @param {number} [limit] - max entries to return
+     * @returns {Array<object>}
+     */
+    getMessageLog(limit) {
+        if (limit) return this.messageLog.slice(-limit);
+        return [...this.messageLog];
+    }
+
+    /**
+     * Get count of registered teammates.
+     * @returns {number}
+     */
+    size() {
+        return this.teammates.size;
+    }
+}

package/src/agents/workflow_loader.mjs

@@ -0,0 +1,122 @@
+/**
+ * Workflow Loader — loads single-agent workflow YAML files from .bahulam/workflows/
+ *
+ * Workflow YAML files follow the same structure as Kepler SubAgent YAML:
+ *   metadata: { id, name, description, icon, tags }
+ *   agent: { system_prompt, model, max_iterations }
+ *   tools: { include: [...], exclude: [...] }
+ *   params: { ... }
+ *   channel: "server"
+ *
+ * These are submitted to POST /api/templates (backend object = template).
+ * The user-facing term is "workflow" everywhere.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parseAgentDefinition } from './parser.mjs';
+
+/**
+ * Load a single workflow YAML file and return an API-ready payload.
+ * @param {string} filePath - absolute path to .yaml file
+ * @returns {object} payload ready for POST /api/templates
+ */
+export function loadWorkflowFromFile(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 = parseAgentDefinition(content, ext);
+
+    return workflowToTemplatePayload(parsed, filePath);
+}
+
+/**
+ * Scan a directory for .yaml/.yml files and load each one.
+ * @param {string} dir - directory path
+ * @returns {Array<{file: string, payload: object}>}
+ */
+export function loadWorkflowsFromDir(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 = loadWorkflowFromFile(filePath);
+                results.push({ file: filePath, payload });
+            } catch (err) {
+                if (process.env.DEBUG) {
+                    console.error(`[workflow-loader] Failed to load ${filePath}: ${err.message}`);
+                }
+            }
+        }
+    } catch {
+        // Directory does not exist
+    }
+    return results;
+}
+
+/**
+ * Convert a parsed agent definition into the API payload expected by POST /api/templates.
+ *
+ * The parsed agent from parseAgentDefinition() has this shape:
+ *   { name, description, raw_config: { metadata, agent, tools, params, channel }, ... }
+ *
+ * The API expects:
+ *   { slug, name, description, category, tags, icon, system_prompt, model,
+ *     max_iterations, tools_include, tools_exclude, params, channel }
+ *
+ * @param {object} agent - parsed agent definition
+ * @param {string} [sourcePath] - optional file path for slug derivation
+ * @returns {object} API payload
+ */
+export function workflowToTemplatePayload(agent, sourcePath) {
+    const raw = agent.raw_config || {};
+    const metadata = raw.metadata || {};
+    const agentConfig = raw.agent || {};
+
+    // Derive slug: metadata.id > filename stem > agent name
+    let slug = metadata.id || '';
+    if (!slug && sourcePath) {
+        slug = path.basename(sourcePath, path.extname(sourcePath));
+    }
+    if (!slug) {
+        slug = (agent.name || 'unnamed').toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    }
+
+    // Tools: include/exclude
+    const tools = raw.tools || {};
+    let toolsInclude = [];
+    let toolsExclude = [];
+    if (Array.isArray(tools)) {
+        toolsInclude = tools;
+    } else {
+        toolsInclude = tools.include || [];
+        toolsExclude = tools.exclude || [];
+    }
+
+    // Params
+    const params = raw.params || {};
+
+    return {
+        slug,
+        name: metadata.name || agent.name || slug,
+        description: metadata.description || agent.description || '',
+        category: metadata.category || 'custom',
+        tags: metadata.tags || [],
+        icon: metadata.icon || 'code',
+        system_prompt: agentConfig.system_prompt || agent.prompt || '',
+        model: agentConfig.model || agent.model || null,
+        max_iterations: agentConfig.max_iterations || agent.max_iterations || 20,
+        tools_include: toolsInclude,
+        tools_exclude: toolsExclude,
+        params,
+        channel: raw.channel || 'server',
+    };
+}