bmad-studio 0.1.0 → 1.0.0

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

@@ -1,83 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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)
-  })
-})