bmad-studio 0.1.0

package/packages/server/src/parsers/agent-parser.ts

@@ -0,0 +1,83 @@
+import matter from 'gray-matter'
+
+import type { Agent, AgentMenuItem } from '@bmad-studio/shared'
+
+import type { ParseResult } from './config-parser.js'
+
+function extractAgentAttributes(content: string): Partial<Agent> {
+  const agentMatch = content.match(/<agent\s+([^>]+)>/)
+  if (!agentMatch) return {}
+
+  const attrs = agentMatch[1]
+  const getId = (name: string) => {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`, 'i'))
+    return match ? match[1] : undefined
+  }
+
+  return {
+    id: getId('id')?.replace('.agent.yaml', '') ?? '',
+    name: getId('name') ?? '',
+    title: getId('title') ?? '',
+    icon: getId('icon'),
+    role: getId('capabilities') ?? '',
+  }
+}
+
+function extractMenuItems(content: string): AgentMenuItem[] {
+  const items: AgentMenuItem[] = []
+  const itemRegex = /<item\s+([^>]*)>([^<]*)<\/item>/g
+  let match
+
+  while ((match = itemRegex.exec(content)) !== null) {
+    const attrs = match[1]
+    const label = match[2].trim()
+
+    const cmdMatch = attrs.match(/cmd="([^"]*)"/)
+    const execMatch = attrs.match(/exec="([^"]*)"/)
+
+    const trigger = cmdMatch
+      ? cmdMatch[1]
+          .split(/\s+or\s+/i)[0]
+          .trim()
+          .toLowerCase()
+      : ''
+
+    items.push({
+      trigger,
+      input: label.replace(/^\[.*?\]\s*/, ''),
+      route: execMatch ? execMatch[1] : '',
+      action: undefined,
+    })
+  }
+
+  return items
+}
+
+export function parseAgent(filePath: string, content: string): ParseResult<Agent> {
+  try {
+    const { data: frontmatter, content: body } = matter(content)
+
+    const xmlAttrs = extractAgentAttributes(body)
+    const menuItems = extractMenuItems(body)
+
+    const agent: Agent = {
+      id: xmlAttrs.id || (frontmatter.name as string) || '',
+      name: xmlAttrs.name || (frontmatter.name as string) || '',
+      title: xmlAttrs.title || (frontmatter.description as string) || '',
+      icon: xmlAttrs.icon,
+      role: xmlAttrs.role || (frontmatter.description as string) || '',
+      module: undefined,
+      discussion: false,
+      webskip: false,
+      hasSidecar: false,
+      menu: menuItems,
+      skills: [],
+      filePath,
+    }
+
+    return { ok: true, data: agent }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `Agent parse error: ${message}`, filePath }
+  }
+}

package/packages/server/src/parsers/config-parser.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest'
+
+import { parseConfig, interpolateVariables } from './config-parser.js'
+
+describe('config-parser', () => {
+  it('parses valid YAML config', () => {
+    const content = `
+project_name: test
+output_folder: "{project-root}/_bmad-output"
+user_name: Jonathan
+`
+    const result = parseConfig('config.yaml', content, '/home/user/project')
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.project_name).toBe('test')
+      expect(result.data.user_name).toBe('Jonathan')
+    }
+  })
+
+  it('resolves {project-root} variables', () => {
+    const content = `
+planning_artifacts: "{project-root}/_bmad-output/planning"
+output_folder: "{project-root}/_bmad-output"
+`
+    const result = parseConfig('config.yaml', content, '/app')
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.planning_artifacts).toBe('/app/_bmad-output/planning')
+      expect(result.data.output_folder).toBe('/app/_bmad-output')
+    }
+  })
+
+  it('returns error for malformed YAML', () => {
+    const content = `
+bad: yaml: [invalid
+: : :
+`
+    const result = parseConfig('bad.yaml', content, '/app')
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain('YAML parse error')
+      expect(result.filePath).toBe('bad.yaml')
+    }
+  })
+
+  it('returns error for empty file', () => {
+    const result = parseConfig('empty.yaml', '', '/app')
+    expect(result.ok).toBe(false)
+  })
+
+  it('interpolates variables in nested objects', () => {
+    const result = interpolateVariables(
+      { nested: { path: '{project-root}/sub' } },
+      { 'project-root': '/root' },
+    )
+    expect(result).toEqual({ nested: { path: '/root/sub' } })
+  })
+
+  it('interpolates variables in arrays', () => {
+    const result = interpolateVariables(['{project-root}/a', '{project-root}/b'], {
+      'project-root': '/root',
+    })
+    expect(result).toEqual(['/root/a', '/root/b'])
+  })
+})

package/packages/server/src/parsers/config-parser.ts

@@ -0,0 +1,51 @@
+import yaml from 'js-yaml'
+
+export type ParsedConfig = {
+  [key: string]: unknown
+}
+
+export type ParseResult<T> = { ok: true; data: T } | { ok: false; error: string; filePath: string }
+
+export function interpolateVariables(value: unknown, variables: Record<string, string>): unknown {
+  if (typeof value === 'string') {
+    let result = value
+    for (const [key, replacement] of Object.entries(variables)) {
+      result = result.replaceAll(`{${key}}`, replacement)
+    }
+    return result
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateVariables(item, variables))
+  }
+  if (value !== null && typeof value === 'object') {
+    const result: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      result[k] = interpolateVariables(v, variables)
+    }
+    return result
+  }
+  return value
+}
+
+export function parseConfig(
+  filePath: string,
+  content: string,
+  projectRoot: string,
+): ParseResult<ParsedConfig> {
+  try {
+    const raw = yaml.load(content)
+    if (raw === null || typeof raw !== 'object') {
+      return { ok: false, error: 'Config file is empty or not an object', filePath }
+    }
+
+    const variables: Record<string, string> = {
+      'project-root': projectRoot,
+    }
+
+    const data = interpolateVariables(raw, variables) as ParsedConfig
+    return { ok: true, data }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `YAML parse error: ${message}`, filePath }
+  }
+}

package/packages/server/src/parsers/csv-parser.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest'
+
+import { parseCsv } from './csv-parser.js'
+
+describe('csv-parser', () => {
+  it('parses simple CSV with headers', () => {
+    const content = `name,role,module
+analyst,Business Analyst,bmm
+architect,System Architect,bmm`
+
+    const result = parseCsv('test.csv', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data).toHaveLength(2)
+      expect(result.data[0].name).toBe('analyst')
+      expect(result.data[0].role).toBe('Business Analyst')
+      expect(result.data[1].name).toBe('architect')
+    }
+  })
+
+  it('handles quoted fields with commas', () => {
+    const content = `name,capabilities
+"analyst","market research, competitive analysis, requirements"
+"architect","distributed systems, cloud, API design"`
+
+    const result = parseCsv('test.csv', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data[0].capabilities).toBe(
+        'market research, competitive analysis, requirements',
+      )
+    }
+  })
+
+  it('handles empty file', () => {
+    const result = parseCsv('empty.csv', '')
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data).toHaveLength(0)
+    }
+  })
+
+  it('handles escaped quotes', () => {
+    const content = `name,desc
+"test","a ""quoted"" value"`
+
+    const result = parseCsv('test.csv', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data[0].desc).toBe('a "quoted" value')
+    }
+  })
+})

package/packages/server/src/parsers/csv-parser.ts

@@ -0,0 +1,55 @@
+import type { ParseResult } from './config-parser.js'
+
+export type CsvRow = Record<string, string>
+
+function parseCsvLine(line: string): string[] {
+  const fields: string[] = []
+  let current = ''
+  let inQuotes = false
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]
+    if (char === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"'
+        i++
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (char === ',' && !inQuotes) {
+      fields.push(current.trim())
+      current = ''
+    } else {
+      current += char
+    }
+  }
+  fields.push(current.trim())
+
+  return fields
+}
+
+export function parseCsv(filePath: string, content: string): ParseResult<CsvRow[]> {
+  try {
+    const lines = content.split('\n').filter((line) => line.trim() !== '')
+    if (lines.length === 0) {
+      return { ok: true, data: [] }
+    }
+
+    const headers = parseCsvLine(lines[0])
+    const rows: CsvRow[] = []
+
+    for (let i = 1; i < lines.length; i++) {
+      const values = parseCsvLine(lines[i])
+      const row: CsvRow = {}
+      for (let j = 0; j < headers.length; j++) {
+        row[headers[j]] = values[j] || ''
+      }
+      rows.push(row)
+    }
+
+    return { ok: true, data: rows }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `CSV parse error: ${message}`, filePath }
+  }
+}

package/packages/server/src/parsers/ide-config-parser.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest'
+
+import { parseIdeConfig } from './ide-config-parser.js'
+
+describe('ide-config-parser', () => {
+  it('parses valid IDE config', () => {
+    const content = `
+ide: claude-code
+configured_date: 2026-03-17T01:03:21.264Z
+last_updated: 2026-03-17T01:03:21.264Z
+configuration:
+  _noConfigNeeded: true
+`
+    const result = parseIdeConfig('claude-code.yaml', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.ide).toBe('claude-code')
+      expect(result.data.configuredDate).toBe('2026-03-17T01:03:21.264Z')
+      expect(result.data.configuration._noConfigNeeded).toBe(true)
+    }
+  })
+
+  it('returns error for empty file', () => {
+    const result = parseIdeConfig('empty.yaml', '')
+    expect(result.ok).toBe(false)
+  })
+
+  it('handles malformed YAML', () => {
+    const result = parseIdeConfig('bad.yaml', 'bad: yaml: [invalid')
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain('IDE config parse error')
+    }
+  })
+})

package/packages/server/src/parsers/ide-config-parser.ts

@@ -0,0 +1,37 @@
+import yaml from 'js-yaml'
+
+import type { ParseResult } from './config-parser.js'
+
+export type IdeConfig = {
+  ide: string
+  configuredDate: string | null
+  lastUpdated: string | null
+  configuration: Record<string, unknown>
+}
+
+function toDateString(value: unknown): string | null {
+  if (value instanceof Date) return value.toISOString()
+  if (typeof value === 'string') return value
+  return null
+}
+
+export function parseIdeConfig(filePath: string, content: string): ParseResult<IdeConfig> {
+  try {
+    const raw = yaml.load(content) as Record<string, unknown> | null
+    if (!raw || typeof raw !== 'object') {
+      return { ok: false, error: 'IDE config file is empty or not an object', filePath }
+    }
+
+    const config: IdeConfig = {
+      ide: (raw.ide as string) || '',
+      configuredDate: toDateString(raw.configured_date),
+      lastUpdated: toDateString(raw.last_updated),
+      configuration: (raw.configuration as Record<string, unknown>) || {},
+    }
+
+    return { ok: true, data: config }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `IDE config parse error: ${message}`, filePath }
+  }
+}

package/packages/server/src/parsers/index-builder.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { buildIndex } from './index-builder.js'
+
+describe('index-builder', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'index-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns empty index when _bmad/ does not exist', () => {
+    const index = buildIndex(tmpDir)
+    expect(index.agents).toHaveLength(0)
+    expect(index.skills).toHaveLength(0)
+    expect(index.workflows).toHaveLength(0)
+    expect(index.configs).toHaveLength(0)
+    expect(index.errors).toHaveLength(0)
+  })
+
+  it('parses config files from modules', () => {
+    const moduleDir = path.join(tmpDir, '_bmad', 'bmm')
+    fs.mkdirSync(moduleDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(moduleDir, 'config.yaml'),
+      `project_name: test\noutput_folder: "{project-root}/output"\n`,
+    )
+
+    const index = buildIndex(tmpDir)
+    expect(index.configs).toHaveLength(1)
+    expect(index.configs[0].project_name).toBe('test')
+    expect(index.configs[0].output_folder).toBe(`${tmpDir}/output`)
+  })
+
+  it('parses skill files', () => {
+    const skillDir = path.join(tmpDir, '_bmad', 'core', 'skills', 'test-skill')
+    fs.mkdirSync(skillDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(skillDir, 'SKILL.md'),
+      `---\nname: test-skill\ndescription: A test\n---\nContent here.\n`,
+    )
+
+    const index = buildIndex(tmpDir)
+    expect(index.skills).toHaveLength(1)
+    expect(index.skills[0].name).toBe('test-skill')
+    expect(index.skills[0].module).toBe('core')
+  })
+
+  it('parses IDE configs', () => {
+    const ideDir = path.join(tmpDir, '_bmad', '_config', 'ides')
+    fs.mkdirSync(ideDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(ideDir, 'claude-code.yaml'),
+      `ide: claude-code\nconfigured_date: 2026-01-01\n`,
+    )
+
+    const index = buildIndex(tmpDir)
+    expect(index.ideConfigs).toHaveLength(1)
+    expect(index.ideConfigs[0].ide).toBe('claude-code')
+  })
+
+  it('collects parse errors without crashing', () => {
+    const moduleDir = path.join(tmpDir, '_bmad', 'broken')
+    fs.mkdirSync(moduleDir, { recursive: true })
+    fs.writeFileSync(path.join(moduleDir, 'config.yaml'), 'bad: yaml: [invalid')
+
+    const index = buildIndex(tmpDir)
+    expect(index.errors.length).toBeGreaterThan(0)
+    expect(index.errors[0].error).toContain('YAML parse error')
+  })
+})

package/packages/server/src/parsers/index-builder.ts

@@ -0,0 +1,195 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { Agent, Skill, Workflow, Package, Team } from '@bmad-studio/shared'
+
+import type { ParseResult, ParsedConfig } from './config-parser.js'
+import { parseConfig } from './config-parser.js'
+import { parseAgent } from './agent-parser.js'
+import { parseSkill } from './skill-parser.js'
+import { parseWorkflow } from './workflow-parser.js'
+import { parsePackage } from './package-parser.js'
+import { parseIdeConfig } from './ide-config-parser.js'
+import { parseTeam } from './team-parser.js'
+import { parseCsv } from './csv-parser.js'
+import type { IdeConfig } from './ide-config-parser.js'
+import type { CsvRow } from './csv-parser.js'
+
+export type EntityIndex = {
+  agents: Agent[]
+  skills: Skill[]
+  workflows: Workflow[]
+  teams: Team[]
+  configs: ParsedConfig[]
+  packages: Package[]
+  ideConfigs: IdeConfig[]
+  manifests: CsvRow[][]
+  errors: Array<{ error: string; filePath: string }>
+}
+
+function readFilesSafe(dir: string, ext: string): Array<{ path: string; content: string }> {
+  const results: Array<{ path: string; content: string }> = []
+  if (!fs.existsSync(dir)) return results
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isFile() && entry.name.endsWith(ext)) {
+      results.push({ path: fullPath, content: fs.readFileSync(fullPath, 'utf-8') })
+    }
+  }
+  return results
+}
+
+function scanRecursive(
+  dir: string,
+  predicate: (name: string, isDir: boolean) => boolean,
+): string[] {
+  const results: string[] = []
+  if (!fs.existsSync(dir)) return results
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (predicate(entry.name, entry.isDirectory())) {
+      results.push(fullPath)
+    }
+    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+      results.push(...scanRecursive(fullPath, predicate))
+    }
+  }
+  return results
+}
+
+function collectResult<T>(result: ParseResult<T>, successes: T[], errors: EntityIndex['errors']) {
+  if (result.ok) {
+    successes.push(result.data)
+  } else {
+    errors.push({ error: result.error, filePath: result.filePath })
+  }
+}
+
+export function buildIndex(projectRoot: string): EntityIndex {
+  const bmadDir = path.join(projectRoot, '_bmad')
+  const index: EntityIndex = {
+    agents: [],
+    skills: [],
+    workflows: [],
+    teams: [],
+    configs: [],
+    packages: [],
+    ideConfigs: [],
+    manifests: [],
+    errors: [],
+  }
+
+  if (!fs.existsSync(bmadDir)) {
+    return index
+  }
+
+  // Parse configs from each module
+  const configFiles = scanRecursive(bmadDir, (name) => name === 'config.yaml')
+  for (const configPath of configFiles) {
+    const content = fs.readFileSync(configPath, 'utf-8')
+    collectResult(parseConfig(configPath, content, projectRoot), index.configs, index.errors)
+  }
+
+  // Parse agent files (*.md in agents/ directories)
+  const agentFiles = scanRecursive(bmadDir, (name, isDir) => !isDir && name.endsWith('.md')).filter(
+    (f) => f.includes('/agents/') && !f.includes('bmad-skill-manifest'),
+  )
+  for (const agentPath of agentFiles) {
+    const content = fs.readFileSync(agentPath, 'utf-8')
+    const result = parseAgent(agentPath, content)
+    if (result.ok) {
+      // Derive module from path
+      const relPath = path.relative(bmadDir, agentPath)
+      const moduleName = relPath.split(path.sep)[0]
+      if (moduleName !== '_config') {
+        result.data.module = moduleName
+      }
+    }
+    collectResult(result, index.agents, index.errors)
+  }
+
+  // Parse skill files (SKILL.md)
+  const skillFiles = scanRecursive(bmadDir, (name) => name === 'SKILL.md')
+  for (const skillPath of skillFiles) {
+    const content = fs.readFileSync(skillPath, 'utf-8')
+    const result = parseSkill(skillPath, content)
+    if (result.ok) {
+      const relPath = path.relative(bmadDir, skillPath)
+      const moduleName = relPath.split(path.sep)[0]
+      if (moduleName !== '_config') {
+        result.data.module = moduleName
+      }
+    }
+    collectResult(result, index.skills, index.errors)
+  }
+
+  // Parse workflows (directories containing workflow.md or bmad-manifest.json)
+  const workflowEntryFiles = scanRecursive(
+    bmadDir,
+    (name) => name === 'workflow.md' || name === 'bmad-manifest.json',
+  )
+  // Deduplicate by directory (a dir may have both workflow.md and bmad-manifest.json)
+  const workflowDirs = new Set<string>()
+  for (const entryPath of workflowEntryFiles) {
+    workflowDirs.add(path.dirname(entryPath))
+  }
+  for (const wfDir of workflowDirs) {
+    const result = parseWorkflow(wfDir)
+    if (result.ok) {
+      const relPath = path.relative(bmadDir, wfDir)
+      const moduleName = relPath.split(path.sep)[0]
+      if (moduleName !== '_config') {
+        result.data.module = moduleName
+      }
+    }
+    collectResult(result, index.workflows, index.errors)
+  }
+
+  // Parse team files (*.yaml in teams/ directories)
+  const teamFiles = scanRecursive(
+    bmadDir,
+    (name, isDir) => !isDir && name.endsWith('.yaml'),
+  ).filter((f) => f.includes('/teams/') && !f.includes('manifest'))
+  for (const teamPath of teamFiles) {
+    const result = parseTeam(teamPath)
+    if (result.ok) {
+      const relPath = path.relative(bmadDir, teamPath)
+      const moduleName = relPath.split(path.sep)[0]
+      if (moduleName !== '_config') {
+        result.data.module = moduleName
+      }
+    }
+    collectResult(result, index.teams, index.errors)
+  }
+
+  // Parse package files
+  const packageFiles = scanRecursive(bmadDir, (name) => name === 'package.yaml')
+  for (const pkgPath of packageFiles) {
+    const content = fs.readFileSync(pkgPath, 'utf-8')
+    collectResult(parsePackage(pkgPath, content), index.packages, index.errors)
+  }
+
+  // Parse IDE configs
+  const ideDir = path.join(bmadDir, '_config', 'ides')
+  const ideFiles = readFilesSafe(ideDir, '.yaml')
+  for (const file of ideFiles) {
+    collectResult(parseIdeConfig(file.path, file.content), index.ideConfigs, index.errors)
+  }
+
+  // Parse CSV manifests
+  const csvFiles = readFilesSafe(path.join(bmadDir, '_config'), '.csv')
+  for (const file of csvFiles) {
+    const result = parseCsv(file.path, file.content)
+    if (result.ok) {
+      index.manifests.push(result.data)
+    } else {
+      index.errors.push({ error: result.error, filePath: result.filePath })
+    }
+  }
+
+  return index
+}

package/packages/server/src/parsers/package-parser.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest'
+
+import { parsePackage } from './package-parser.js'
+
+describe('package-parser', () => {
+  it('parses valid package YAML', () => {
+    const content = `
+name: test-package
+description: A test package
+version: 1.0.0
+agents:
+  - agents/analyst.md
+skills:
+  - skills/research.md
+workflows:
+  - workflows/create-prd/
+templates:
+  - templates/prd-template.md
+`
+    const result = parsePackage('package.yaml', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.name).toBe('test-package')
+      expect(result.data.version).toBe('1.0.0')
+      expect(result.data.agents).toEqual(['agents/analyst.md'])
+      expect(result.data.skills).toEqual(['skills/research.md'])
+      expect(result.data.workflows).toEqual(['workflows/create-prd/'])
+      expect(result.data.templates).toEqual(['templates/prd-template.md'])
+    }
+  })
+
+  it('returns error for empty file', () => {
+    const result = parsePackage('empty.yaml', '')
+    expect(result.ok).toBe(false)
+  })
+})