create-byan-agent 2.8.1 → 2.9.0

package/src/webui/chat/claude-adapter.js

@@ -0,0 +1,174 @@
+/**
+ * Claude Code CLI bridge adapter.
+ * Uses --print --output-format stream-json --input-format stream-json
+ * for persistent streaming sessions.
+ */
+
+const { spawn } = require('child_process');
+const { Bridge } = require('./bridge');
+
+class ClaudeAdapter extends Bridge {
+  constructor(options) {
+    super(options);
+    this._buffer = '';
+    this._sessionId = null;
+  }
+
+  async start() {
+    const args = [
+      '--print',
+      '--output-format', 'stream-json',
+      '--input-format', 'stream-json',
+    ];
+
+    if (this.agent) {
+      const agentPath = this.resolveAgent(this.agent);
+      if (agentPath) {
+        args.push('--agent', agentPath);
+      }
+    }
+
+    if (this.model) {
+      args.push('--model', this.model);
+    }
+
+    if (this._sessionId) {
+      args.push('--session-id', this._sessionId);
+    }
+
+    this.process = spawn('claude', args, {
+      cwd: this.projectRoot,
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    this.active = true;
+
+    this.process.stdout.on('data', (data) => this._handleStdout(data));
+    this.process.stderr.on('data', (data) => this._handleStderr(data));
+
+    this.process.on('error', (err) => {
+      this.active = false;
+      this.onError(err);
+    });
+
+    this.process.on('exit', (code) => {
+      this.active = false;
+      this.onComplete({ code, sessionId: this._sessionId });
+    });
+  }
+
+  async send(message) {
+    if (!this.active || !this.process || !this.process.stdin.writable) {
+      if (!this.active) {
+        await this.start();
+      } else {
+        this.onError(new Error('Claude process stdin is not writable'));
+        return;
+      }
+    }
+
+    const payload = JSON.stringify({ type: 'user', content: message }) + '\n';
+
+    try {
+      this.process.stdin.write(payload);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+
+  async stop() {
+    this.active = false;
+    if (this.process) {
+      await this._killProcess(this.process);
+      this.process = null;
+    }
+  }
+
+  _handleStdout(data) {
+    this._buffer += data.toString();
+    const lines = this._buffer.split('\n');
+    this._buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      this._parseLine(trimmed);
+    }
+  }
+
+  _handleStderr(data) {
+    const text = data.toString().trim();
+    if (text) {
+      this.onError(new Error(`claude stderr: ${text}`));
+    }
+  }
+
+  _parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      this.onChunk(line);
+      return;
+    }
+
+    switch (event.type) {
+      case 'assistant': {
+        const contents = event.message?.content || event.content || [];
+        const items = Array.isArray(contents) ? contents : [contents];
+        for (const item of items) {
+          if (typeof item === 'string') {
+            this.onChunk(item);
+          } else if (item.type === 'text') {
+            this.onChunk(item.text || '');
+          } else if (item.type === 'tool_use') {
+            this.onToolUse({
+              id: item.id,
+              name: item.name,
+              input: item.input,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'content_block_delta': {
+        const delta = event.delta;
+        if (delta?.type === 'text_delta') {
+          this.onChunk(delta.text || '');
+        }
+        break;
+      }
+
+      case 'result': {
+        if (event.session_id) this._sessionId = event.session_id;
+        this.onComplete({
+          result: event.result,
+          cost: event.cost_usd,
+          sessionId: event.session_id,
+        });
+        break;
+      }
+
+      case 'tool_use': {
+        this.onToolUse({
+          id: event.id || event.tool_use_id,
+          name: event.name,
+          input: event.input,
+        });
+        break;
+      }
+
+      case 'error': {
+        this.onError(new Error(event.error || event.message || 'Unknown claude error'));
+        break;
+      }
+
+      default:
+        break;
+    }
+  }
+}
+
+module.exports = ClaudeAdapter;

package/src/webui/chat/cli-detector.js

@@ -0,0 +1,156 @@
+/**
+ * CLI auto-detection and BMAD agent scanner.
+ */
+
+const { execFile } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const CLI_DEFINITIONS = [
+  { name: 'claude', command: 'claude', versionArg: '--version' },
+  { name: 'copilot', command: 'copilot', versionArg: '--version' },
+  { name: 'codex', command: 'codex', versionArg: '--version' },
+];
+
+function execPromise(cmd, args, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    try {
+      const proc = execFile(cmd, args, { timeout: timeoutMs }, (err, stdout, stderr) => {
+        if (err) {
+          resolve({ ok: false, output: '' });
+          return;
+        }
+        resolve({ ok: true, output: (stdout || stderr || '').trim() });
+      });
+      proc.on('error', () => resolve({ ok: false, output: '' }));
+    } catch {
+      resolve({ ok: false, output: '' });
+    }
+  });
+}
+
+function parseVersion(output) {
+  const match = output.match(/(\d+\.\d+[\w.-]*)/);
+  return match ? match[1] : null;
+}
+
+function whichSync(cmd) {
+  try {
+    const { execFileSync } = require('child_process');
+    return execFileSync('which', [cmd], { encoding: 'utf8', timeout: 3000 }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function detectCLIs() {
+  const results = [];
+
+  for (const def of CLI_DEFINITIONS) {
+    const cmdPath = whichSync(def.command);
+    if (!cmdPath) {
+      results.push({
+        name: def.name,
+        path: null,
+        version: null,
+        available: false,
+        preferred: false,
+      });
+      continue;
+    }
+
+    const versionResult = await execPromise(def.command, [def.versionArg]);
+    const version = versionResult.ok ? parseVersion(versionResult.output) : null;
+
+    results.push({
+      name: def.name,
+      path: cmdPath,
+      version,
+      available: true,
+      preferred: false,
+    });
+  }
+
+  const firstAvailable = results.find((r) => r.available);
+  if (firstAvailable) firstAvailable.preferred = true;
+
+  return results;
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const fm = {};
+  for (const line of match[1].split('\n')) {
+    const sep = line.indexOf(':');
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim().replace(/^['"]|['"]$/g, '');
+    const val = line.slice(sep + 1).trim().replace(/^['"]|['"]$/g, '');
+    if (key && val) fm[key] = val;
+  }
+  return fm;
+}
+
+function scanDir(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) return [];
+    return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md'));
+  } catch {
+    return [];
+  }
+}
+
+async function detectAgents(projectRoot) {
+  const agents = [];
+  const seen = new Set();
+
+  const locations = [
+    { dir: path.join(projectRoot, '.github', 'agents'), source: 'copilot' },
+    { dir: path.join(projectRoot, '_byan', 'agents'), source: 'byan' },
+  ];
+
+  const bmadModules = ['core', 'bmm', 'bmb', 'tea', 'cis'];
+  for (const mod of bmadModules) {
+    locations.push({
+      dir: path.join(projectRoot, '_bmad', mod, 'agents'),
+      source: `bmad-${mod}`,
+    });
+  }
+
+  for (const loc of locations) {
+    const files = scanDir(loc.dir);
+    for (const file of files) {
+      const filePath = path.join(loc.dir, file);
+      const baseName = file.replace(/\.md$/, '');
+
+      const id = baseName
+        .replace(/^bmad-agent-/, '')
+        .replace(/\.backup\.\d+.*$/, '')
+        .replace(/\.optimized.*$/, '');
+
+      if (seen.has(id)) continue;
+      seen.add(id);
+
+      let fm = {};
+      try {
+        const content = fs.readFileSync(filePath, 'utf8').slice(0, 2000);
+        fm = parseFrontmatter(content);
+      } catch { /* skip unparseable */ }
+
+      agents.push({
+        id,
+        name: fm.name || id,
+        description: fm.description || '',
+        icon: fm.icon || null,
+        source: loc.source,
+        path: filePath,
+      });
+    }
+  }
+
+  agents.sort((a, b) => a.name.localeCompare(b.name));
+  return agents;
+}
+
+module.exports = { detectCLIs, detectAgents };

package/src/webui/chat/codex-adapter.js

@@ -0,0 +1,57 @@
+/**
+ * Codex CLI bridge adapter.
+ * Uses `codex exec` for non-interactive operation.
+ */
+
+const { spawn } = require('child_process');
+const { Bridge } = require('./bridge');
+
+class CodexAdapter extends Bridge {
+  async start() {
+    this.active = true;
+  }
+
+  async send(message) {
+    if (!this.active) return;
+
+    const args = ['exec', '--prompt', message, '--approval-mode', 'auto-edit'];
+
+    this.process = spawn('codex', args, {
+      cwd: this.projectRoot,
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let output = '';
+
+    this.process.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      output += chunk;
+      this.onChunk(chunk);
+    });
+
+    this.process.stderr.on('data', (data) => {
+      const text = data.toString().trim();
+      if (text) this.onError(new Error(`codex stderr: ${text}`));
+    });
+
+    this.process.on('error', (err) => {
+      this.onError(err);
+    });
+
+    this.process.on('exit', (code) => {
+      this.process = null;
+      this.onComplete({ code, output });
+    });
+  }
+
+  async stop() {
+    this.active = false;
+    if (this.process) {
+      await this._killProcess(this.process);
+      this.process = null;
+    }
+  }
+}
+
+module.exports = CodexAdapter;

package/src/webui/chat/copilot-adapter.js

@@ -0,0 +1,67 @@
+/**
+ * GitHub Copilot CLI bridge adapter.
+ * Copilot CLI is TUI-based; this uses one-shot spawns per message.
+ * Full multi-turn PTY support deferred to P2.
+ */
+
+const { spawn } = require('child_process');
+const { Bridge } = require('./bridge');
+
+class CopilotAdapter extends Bridge {
+  async start() {
+    this.active = true;
+  }
+
+  async send(message) {
+    if (!this.active) return;
+
+    const args = [];
+
+    if (this.agent) {
+      const agentPath = this.resolveAgent(this.agent);
+      if (agentPath) {
+        args.push(`--agent=${agentPath}`);
+      }
+    }
+
+    args.push('--prompt', message);
+
+    this.process = spawn('copilot', args, {
+      cwd: this.projectRoot,
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let output = '';
+
+    this.process.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      output += chunk;
+      this.onChunk(chunk);
+    });
+
+    this.process.stderr.on('data', (data) => {
+      const text = data.toString().trim();
+      if (text) this.onError(new Error(`copilot stderr: ${text}`));
+    });
+
+    this.process.on('error', (err) => {
+      this.onError(err);
+    });
+
+    this.process.on('exit', (code) => {
+      this.process = null;
+      this.onComplete({ code, output });
+    });
+  }
+
+  async stop() {
+    this.active = false;
+    if (this.process) {
+      await this._killProcess(this.process);
+      this.process = null;
+    }
+  }
+}
+
+module.exports = CopilotAdapter;

package/src/webui/chat/session-manager.js

@@ -0,0 +1,185 @@
+/**
+ * Chat session persistence -- save, load, list, export conversations.
+ * Stores under {projectRoot}/_byan/_memory/chat-sessions/
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+class SessionManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.sessionsDir = path.join(projectRoot, '_byan', '_memory', 'chat-sessions');
+    this.sessions = new Map();
+    this._ensureDir();
+  }
+
+  _ensureDir() {
+    try {
+      if (!fs.existsSync(this.sessionsDir)) {
+        fs.mkdirSync(this.sessionsDir, { recursive: true });
+      }
+    } catch { /* best effort */ }
+  }
+
+  _generateId() {
+    const ts = Date.now().toString(36);
+    const rand = crypto.randomBytes(4).toString('hex');
+    return `chat-${ts}-${rand}`;
+  }
+
+  create(cliName, agentName) {
+    const id = this._generateId();
+    const session = {
+      id,
+      cli: cliName || 'claude',
+      agent: agentName || null,
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      messages: [],
+    };
+
+    this.sessions.set(id, session);
+    this._saveToDisk(session);
+    return session;
+  }
+
+  addMessage(sessionId, role, content, metadata = {}) {
+    const session = this._getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+    session.messages.push({
+      role,
+      content,
+      timestamp: new Date().toISOString(),
+      ...metadata,
+    });
+
+    session.updated = new Date().toISOString();
+    this._saveToDisk(session);
+  }
+
+  save(sessionId) {
+    const session = this._getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    this._saveToDisk(session);
+  }
+
+  load(sessionId) {
+    if (this.sessions.has(sessionId)) {
+      return this.sessions.get(sessionId);
+    }
+
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      this.sessions.set(sessionId, data);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  list() {
+    this._loadAllFromDisk();
+
+    const summaries = [];
+    for (const session of this.sessions.values()) {
+      const lastMsg = session.messages[session.messages.length - 1];
+      summaries.push({
+        id: session.id,
+        cli: session.cli,
+        agent: session.agent,
+        created: session.created,
+        updated: session.updated,
+        messageCount: session.messages.length,
+        lastMessage: lastMsg
+          ? lastMsg.content.slice(0, 100)
+          : null,
+      });
+    }
+
+    summaries.sort((a, b) => b.updated.localeCompare(a.updated));
+    return summaries;
+  }
+
+  delete(sessionId) {
+    this.sessions.delete(sessionId);
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+    try {
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    } catch { /* best effort */ }
+  }
+
+  exportJSON(sessionId) {
+    const session = this._getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    return JSON.stringify(session, null, 2);
+  }
+
+  exportMarkdown(sessionId) {
+    const session = this._getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+    const lines = [
+      `# Chat Session: ${session.id}`,
+      '',
+      `- **CLI:** ${session.cli}`,
+      `- **Agent:** ${session.agent || 'none'}`,
+      `- **Created:** ${session.created}`,
+      '',
+      '---',
+      '',
+    ];
+
+    for (const msg of session.messages) {
+      const label = msg.role === 'user' ? 'User' : 'Assistant';
+      lines.push(`### ${label} (${msg.timestamp})`);
+      lines.push('');
+      lines.push(msg.content);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  getSession(sessionId) {
+    return this._getSession(sessionId);
+  }
+
+  _getSession(sessionId) {
+    if (this.sessions.has(sessionId)) {
+      return this.sessions.get(sessionId);
+    }
+    return this.load(sessionId);
+  }
+
+  _saveToDisk(session) {
+    try {
+      this._ensureDir();
+      const filePath = path.join(this.sessionsDir, `${session.id}.json`);
+      fs.writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf8');
+    } catch { /* best effort */ }
+  }
+
+  _loadAllFromDisk() {
+    try {
+      if (!fs.existsSync(this.sessionsDir)) return;
+      const files = fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith('.json'));
+      for (const file of files) {
+        const id = file.replace(/\.json$/, '');
+        if (!this.sessions.has(id)) {
+          try {
+            const data = JSON.parse(
+              fs.readFileSync(path.join(this.sessionsDir, file), 'utf8')
+            );
+            this.sessions.set(id, data);
+          } catch { /* skip corrupted */ }
+        }
+      }
+    } catch { /* best effort */ }
+  }
+}
+
+module.exports = SessionManager;