bmad-studio 0.1.0

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

@@ -0,0 +1,34 @@
+import yaml from 'js-yaml'
+
+import type { Package } from '@bmad-studio/shared'
+
+import type { ParseResult } from './config-parser.js'
+
+export function parsePackage(filePath: string, content: string): ParseResult<Package> {
+  try {
+    const raw = yaml.load(content) as Record<string, unknown> | null
+    if (!raw || typeof raw !== 'object') {
+      return { ok: false, error: 'Package file is empty or not an object', filePath }
+    }
+
+    const pkg: Package = {
+      id: (raw.name as string) || '',
+      name: (raw.name as string) || '',
+      description: (raw.description as string) || '',
+      version: (raw.version as string) || '0.0.0',
+      platform: raw.platform as string | undefined,
+      agents: (raw.agents as string[]) || [],
+      skills: (raw.skills as string[]) || [],
+      workflows: (raw.workflows as string[]) || [],
+      templates: (raw.templates as string[]) || [],
+      connections: raw.connections as string[] | undefined,
+      contextTemplate: raw.context_template as string | undefined,
+      filePath,
+    }
+
+    return { ok: true, data: pkg }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `Package parse error: ${message}`, filePath }
+  }
+}

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

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest'
+
+import { parseSkill } from './skill-parser.js'
+
+describe('skill-parser', () => {
+  it('extracts frontmatter and body', () => {
+    const content = `---
+name: bmad-create-prd
+description: 'Create a PRD from scratch.'
+---
+
+Follow the instructions in ./workflow.md.
+`
+    const result = parseSkill('SKILL.md', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.id).toBe('bmad-create-prd')
+      expect(result.data.name).toBe('bmad-create-prd')
+      expect(result.data.description).toBe('Create a PRD from scratch.')
+      expect(result.data.content).toBe('Follow the instructions in ./workflow.md.')
+      expect(result.data.filePath).toBe('SKILL.md')
+    }
+  })
+
+  it('handles best_for array', () => {
+    const content = `---
+name: test-skill
+description: A test skill
+best_for:
+  - pm
+  - analyst
+---
+
+Content here.
+`
+    const result = parseSkill('test.md', content)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.bestFor).toEqual(['pm', 'analyst'])
+    }
+  })
+
+  it('handles missing frontmatter gracefully', () => {
+    const result = parseSkill('plain.md', 'Just plain markdown without frontmatter.')
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.id).toBe('')
+      expect(result.data.content).toBe('Just plain markdown without frontmatter.')
+    }
+  })
+})

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

@@ -0,0 +1,26 @@
+import matter from 'gray-matter'
+
+import type { Skill } from '@bmad-studio/shared'
+
+import type { ParseResult } from './config-parser.js'
+
+export function parseSkill(filePath: string, content: string): ParseResult<Skill> {
+  try {
+    const { data: frontmatter, content: body } = matter(content)
+
+    const skill: Skill = {
+      id: (frontmatter.name as string) || '',
+      name: (frontmatter.name as string) || '',
+      description: (frontmatter.description as string) || '',
+      bestFor: frontmatter.best_for as string[] | undefined,
+      content: body.trim(),
+      filePath,
+      module: undefined,
+    }
+
+    return { ok: true, data: skill }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `Skill parse error: ${message}`, filePath }
+  }
+}

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

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { parseTeam } from './team-parser.js'
+
+describe('team-parser', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'team-parser-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('parses team YAML with bundle metadata and agents list', () => {
+    const teamFile = path.join(tmpDir, 'team-fullstack.yaml')
+    fs.writeFileSync(
+      teamFile,
+      `bundle:
+  name: Team Fullstack
+  icon: "🚀"
+  description: Full stack development team
+agents:
+  - analyst
+  - architect
+  - dev
+party: "./default-party.csv"
+`,
+    )
+
+    // Create party CSV
+    fs.writeFileSync(
+      path.join(tmpDir, 'default-party.csv'),
+      `name,displayName,title,icon,role,communicationStyle,identity,principles,module,path
+"analyst","Mary","Business Analyst","📊","BA","Analytical","Senior analyst","Evidence-based","bmm","agents/analyst.md"
+"architect","Winston","Architect","🏗️","Arch","Pragmatic","Senior architect","Simple solutions","bmm","agents/architect.md"
+"dev","Amelia","Developer","💻","Dev","Succinct","Senior dev","Tests first","bmm","agents/dev.md"
+`,
+    )
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.id).toBe('team-fullstack')
+      expect(result.data.name).toBe('Team Fullstack')
+      expect(result.data.icon).toBe('🚀')
+      expect(result.data.description).toBe('Full stack development team')
+      expect(result.data.agentIds).toEqual(['analyst', 'architect', 'dev'])
+      expect(result.data.members).toHaveLength(3)
+      expect(result.data.members[0].agentId).toBe('analyst')
+      expect(result.data.members[0].displayName).toBe('Mary')
+      expect(result.data.members[0].title).toBe('Business Analyst')
+      expect(result.data.members[0].icon).toBe('📊')
+      expect(result.data.members[0].module).toBe('bmm')
+      expect(result.data.partyFile).toBe('./default-party.csv')
+    }
+  })
+
+  it('handles unresolved agents (in agentIds but not in party CSV)', () => {
+    const teamFile = path.join(tmpDir, 'team-mixed.yaml')
+    fs.writeFileSync(
+      teamFile,
+      `bundle:
+  name: Mixed Team
+  icon: "🔧"
+  description: Team with some missing party entries
+agents:
+  - analyst
+  - missing-agent
+  - dev
+party: "./party.csv"
+`,
+    )
+
+    fs.writeFileSync(
+      path.join(tmpDir, 'party.csv'),
+      `name,displayName,title,icon,role,communicationStyle,identity,principles,module,path
+"analyst","Mary","BA","📊","BA","Analytical","Senior","Evidence","bmm",""
+"dev","Amelia","Dev","💻","Dev","Succinct","Senior","Tests","bmm",""
+`,
+    )
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.agentIds).toHaveLength(3)
+      expect(result.data.agentIds).toContain('missing-agent')
+      // Only 2 members resolved (missing-agent not in CSV)
+      expect(result.data.members).toHaveLength(2)
+      expect(result.data.members.map((m) => m.agentId)).not.toContain('missing-agent')
+    }
+  })
+
+  it('handles malformed YAML gracefully', () => {
+    const teamFile = path.join(tmpDir, 'bad-team.yaml')
+    fs.writeFileSync(teamFile, '{{invalid yaml content!!')
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain('Team parse error')
+    }
+  })
+
+  it('handles missing bundle section', () => {
+    const teamFile = path.join(tmpDir, 'no-bundle.yaml')
+    fs.writeFileSync(teamFile, 'agents:\n  - analyst\n')
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain('missing bundle')
+    }
+  })
+
+  it('handles missing party CSV file', () => {
+    const teamFile = path.join(tmpDir, 'team-no-party.yaml')
+    fs.writeFileSync(
+      teamFile,
+      `bundle:
+  name: No Party Team
+  icon: "❌"
+  description: Team without party CSV
+agents:
+  - analyst
+party: "./nonexistent.csv"
+`,
+    )
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.agentIds).toEqual(['analyst'])
+      expect(result.data.members).toHaveLength(0)
+    }
+  })
+
+  it('derives team ID from filename', () => {
+    const teamFile = path.join(tmpDir, 'my-custom-team.yaml')
+    fs.writeFileSync(
+      teamFile,
+      `bundle:
+  name: Custom Team
+agents: []
+`,
+    )
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.id).toBe('my-custom-team')
+    }
+  })
+
+  it('handles party CSV with quoted fields containing commas', () => {
+    const teamFile = path.join(tmpDir, 'team-quotes.yaml')
+    fs.writeFileSync(
+      teamFile,
+      `bundle:
+  name: Quoted Team
+agents:
+  - analyst
+party: "./quoted.csv"
+`,
+    )
+
+    fs.writeFileSync(
+      path.join(tmpDir, 'quoted.csv'),
+      `name,displayName,title,icon,role,communicationStyle,identity,principles,module,path
+"analyst","Mary","Business Analyst","📊","Strategic Business Analyst + Requirements Expert","Treats analysis like a treasure hunt, excited by every clue","Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation.","Every business challenge has root causes. Ground findings in verifiable evidence.","bmm","agents/analyst.md"
+`,
+    )
+
+    const result = parseTeam(teamFile)
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.members).toHaveLength(1)
+      expect(result.data.members[0].communicationStyle).toContain('treasure hunt')
+      expect(result.data.members[0].identity).toContain('market research')
+    }
+  })
+})

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

@@ -0,0 +1,128 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import yaml from 'js-yaml'
+
+import type { Team, TeamMember } from '@bmad-studio/shared'
+
+import type { ParseResult } from './config-parser.js'
+
+type TeamYaml = {
+  bundle?: {
+    name?: string
+    icon?: string
+    description?: string
+  }
+  agents?: string[]
+  party?: string
+}
+
+function parseCsvLine(line: string): string[] {
+  const cells: string[] = []
+  let current = ''
+  let inQuotes = false
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"'
+        i++
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (ch === ',' && !inQuotes) {
+      cells.push(current.trim())
+      current = ''
+    } else {
+      current += ch
+    }
+  }
+  cells.push(current.trim())
+  return cells
+}
+
+function parsePartyCsv(csvPath: string, agentIds: string[]): TeamMember[] {
+  if (!fs.existsSync(csvPath)) return []
+
+  try {
+    const content = fs.readFileSync(csvPath, 'utf-8')
+    const lines = content.split('\n').filter((l) => l.trim())
+    if (lines.length < 2) return []
+
+    const headers = parseCsvLine(lines[0])
+    const nameIdx = headers.indexOf('name')
+    if (nameIdx === -1) return []
+
+    const getField = (row: string[], field: string): string => {
+      const idx = headers.indexOf(field)
+      return idx >= 0 ? (row[idx] ?? '') : ''
+    }
+
+    const agentIdSet = new Set(agentIds)
+    const members: TeamMember[] = []
+
+    for (let i = 1; i < lines.length; i++) {
+      const row = parseCsvLine(lines[i])
+      const name = row[nameIdx] ?? ''
+      if (!name || !agentIdSet.has(name)) continue
+
+      members.push({
+        agentId: name,
+        displayName: getField(row, 'displayName'),
+        title: getField(row, 'title'),
+        icon: getField(row, 'icon'),
+        role: getField(row, 'role'),
+        communicationStyle: getField(row, 'communicationStyle'),
+        identity: getField(row, 'identity'),
+        principles: getField(row, 'principles'),
+        module: getField(row, 'module'),
+      })
+    }
+
+    return members
+  } catch {
+    return []
+  }
+}
+
+export function parseTeam(filePath: string): ParseResult<Team> {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const data = yaml.load(content) as TeamYaml
+
+    if (!data || !data.bundle) {
+      return { ok: false, error: 'Team YAML missing bundle section', filePath }
+    }
+
+    const id = path.basename(filePath, '.yaml')
+    const name = data.bundle.name ?? id
+    const icon = data.bundle.icon ?? ''
+    const description = data.bundle.description ?? ''
+    const agentIds = data.agents ?? []
+    const partyRef = data.party ?? ''
+
+    // Resolve party CSV path relative to team YAML directory
+    let members: TeamMember[] = []
+    let partyFile = ''
+    if (partyRef) {
+      partyFile = path.resolve(path.dirname(filePath), partyRef)
+      members = parsePartyCsv(partyFile, agentIds)
+    }
+
+    const team: Team = {
+      id,
+      name,
+      icon,
+      description,
+      agentIds,
+      members,
+      partyFile: partyRef,
+      filePath,
+    }
+
+    return { ok: true, data: team }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: `Team parse error: ${message}`, filePath }
+  }
+}