bmad-studio 0.1.0

package/packages/server/src/plugins/validation-plugin.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { createApp } from '../app.js'
+
+describe('validation-plugin', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'validation-plugin-test-'))
+    fs.mkdirSync(path.join(tmpDir, '_bmad', 'bmm'), { recursive: true })
+    fs.writeFileSync(path.join(tmpDir, '_bmad', 'bmm', 'config.yaml'), 'project_name: test\n')
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  function createTestApp() {
+    return createApp({
+      logger: false,
+      serveStatic: false,
+      project: {
+        projectRoot: tmpDir,
+        bmadVersion: '6.2.0',
+        versionSupported: true,
+        modules: [{ name: 'bmm', version: '6.2.0', source: 'built-in' }],
+        ideDirectories: [],
+      },
+    })
+  }
+
+  function createWorkflowWithSteps(wfName: string, stepFiles: string[], stepDir = 'steps') {
+    const wfDir = path.join(tmpDir, '_bmad', 'bmm', 'workflows', wfName)
+    fs.mkdirSync(wfDir, { recursive: true })
+    fs.writeFileSync(path.join(wfDir, 'workflow.md'), `# ${wfName}\n\n**Goal:** Test workflow.\n`)
+    const stepsDir = path.join(wfDir, stepDir)
+    fs.mkdirSync(stepsDir, { recursive: true })
+    for (const file of stepFiles) {
+      fs.writeFileSync(path.join(stepsDir, file), `# ${file}\n`)
+    }
+  }
+
+  it('detects duplicate step numbers in steps/', async () => {
+    createWorkflowWithSteps('dup-test', [
+      'step-01-init.md',
+      'step-01-setup.md',
+      'step-02-execute.md',
+    ])
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const dupIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'DUPLICATE_STEP_NUMBER',
+    )
+    expect(dupIssues).toHaveLength(1)
+    expect(dupIssues[0].severity).toBe('warning')
+    expect(dupIssues[0].message).toContain('duplicate step number 01')
+    expect(dupIssues[0].message).toContain('step-01-init.md')
+    expect(dupIssues[0].message).toContain('step-01-setup.md')
+
+    await app.close()
+  })
+
+  it('does not flag variant steps as duplicates', async () => {
+    createWorkflowWithSteps('variant-test', [
+      'step-01-init.md',
+      'step-01b-continue.md',
+      'step-02-execute.md',
+    ])
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const dupIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'DUPLICATE_STEP_NUMBER',
+    )
+    expect(dupIssues).toHaveLength(0)
+
+    await app.close()
+  })
+
+  it('detects duplicates in variant step directories', async () => {
+    createWorkflowWithSteps(
+      'variant-dir-dup',
+      ['step-01-create.md', 'step-01-validate.md'],
+      'steps-c',
+    )
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const dupIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'DUPLICATE_STEP_NUMBER',
+    )
+    expect(dupIssues).toHaveLength(1)
+    expect(dupIssues[0].message).toContain('steps-c')
+
+    await app.close()
+  })
+
+  it('skips step validation for agent-based workflows', async () => {
+    const wfDir = path.join(tmpDir, '_bmad', 'bmm', 'workflows', 'agent-wf')
+    fs.mkdirSync(wfDir, { recursive: true })
+    fs.mkdirSync(path.join(wfDir, 'agents'))
+    fs.mkdirSync(path.join(wfDir, 'prompts'))
+    fs.writeFileSync(
+      path.join(wfDir, 'bmad-manifest.json'),
+      JSON.stringify({ name: 'Agent Workflow' }),
+    )
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const dupIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'DUPLICATE_STEP_NUMBER',
+    )
+    expect(dupIssues).toHaveLength(0)
+
+    await app.close()
+  })
+
+  it('no false positives for normal step sequences', async () => {
+    createWorkflowWithSteps('normal-test', [
+      'step-01-init.md',
+      'step-02-plan.md',
+      'step-03-execute.md',
+    ])
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const dupIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'DUPLICATE_STEP_NUMBER',
+    )
+    expect(dupIssues).toHaveLength(0)
+
+    await app.close()
+  })
+
+  // --- Team Validation ---
+
+  function createTeamWithAgents(teamName: string, agents: string[]) {
+    const teamsDir = path.join(tmpDir, '_bmad', 'bmm', 'teams')
+    fs.mkdirSync(teamsDir, { recursive: true })
+
+    const yaml = [
+      'bundle:',
+      `  name: ${teamName}`,
+      '  icon: ""',
+      '  description: Test team',
+      'agents:',
+      ...agents.map((a) => `  - ${a}`),
+      'party: ""',
+    ].join('\n')
+
+    const slug = teamName.toLowerCase().replace(/\s+/g, '-')
+    fs.writeFileSync(path.join(teamsDir, `team-${slug}.yaml`), yaml)
+  }
+
+  function createAgentFile(agentId: string) {
+    const agentsDir = path.join(tmpDir, '_bmad', 'bmm', 'agents')
+    fs.mkdirSync(agentsDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(agentsDir, `${agentId}.md`),
+      `---\nname: "${agentId}"\n---\n\n<agent id="${agentId}" name="${agentId}" title="Test Agent" capabilities="testing">\n</agent>\n`,
+    )
+  }
+
+  it('detects missing team agent references', async () => {
+    createTeamWithAgents('Alpha Team', ['existing-agent', 'missing-agent'])
+    createAgentFile('existing-agent')
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const teamIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'MISSING_TEAM_AGENT_REF',
+    )
+    expect(teamIssues).toHaveLength(1)
+    expect(teamIssues[0].severity).toBe('warning')
+    expect(teamIssues[0].message).toContain('missing-agent')
+    expect(teamIssues[0].entityType).toBe('team')
+
+    await app.close()
+  })
+
+  it('no false positives for valid team agent references', async () => {
+    createTeamWithAgents('Good Team', ['agent-a', 'agent-b'])
+    createAgentFile('agent-a')
+    createAgentFile('agent-b')
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const teamIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'MISSING_TEAM_AGENT_REF',
+    )
+    expect(teamIssues).toHaveLength(0)
+
+    await app.close()
+  })
+
+  it('reports multiple missing agents in a single team', async () => {
+    createTeamWithAgents('Broken Team', ['ghost-a', 'ghost-b', 'ghost-c'])
+
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/validation' })
+    const result = JSON.parse(response.body)
+
+    const teamIssues = result.issues.filter(
+      (i: { code: string }) => i.code === 'MISSING_TEAM_AGENT_REF',
+    )
+    expect(teamIssues).toHaveLength(3)
+    expect(teamIssues.every((i: { entityType: string }) => i.entityType === 'team')).toBe(true)
+
+    await app.close()
+  })
+})

package/packages/server/src/plugins/validation-plugin.ts

@@ -0,0 +1,116 @@
+import path from 'node:path'
+
+import type { FastifyInstance } from 'fastify'
+import type { ValidationResult, ValidationIssue } from '@bmad-studio/shared'
+import type { Workflow, WorkflowStep } from '@bmad-studio/shared'
+
+const STEP_NUM_RE = /^step-(\d+)([a-z])?-/
+
+function checkDuplicateStepNumbers(workflow: Workflow, issues: ValidationIssue[]) {
+  // Skip agent-based workflows (no steps)
+  if (workflow.type === 'agent-based' || workflow.steps.length === 0) return
+
+  // Group steps by variantSet (each directory checked independently)
+  const groups = new Map<string, WorkflowStep[]>()
+  for (const step of workflow.steps) {
+    const key = step.variantSet ?? 'steps'
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key)!.push(step)
+  }
+
+  for (const [dir, steps] of groups) {
+    // Track base numbers for steps WITHOUT letter suffix only
+    const seen = new Map<string, string>() // number → filename
+
+    for (const step of steps) {
+      const filename = path.basename(step.filePath)
+      const match = STEP_NUM_RE.exec(filename)
+      if (!match) continue
+
+      const baseNum = match[1]
+      const hasSuffix = match[2] !== undefined
+
+      // Only flag duplicates for steps without a letter suffix
+      if (hasSuffix) continue
+
+      if (seen.has(baseNum)) {
+        issues.push({
+          severity: 'warning',
+          code: 'DUPLICATE_STEP_NUMBER',
+          message: `Workflow "${workflow.name}" has duplicate step number ${baseNum} in ${dir}: ${seen.get(baseNum)}, ${filename}`,
+          entityType: 'workflow',
+          entityId: workflow.id,
+        })
+      } else {
+        seen.set(baseNum, filename)
+      }
+    }
+  }
+}
+
+function validateEntities(app: FastifyInstance): ValidationResult {
+  if (!('fileStore' in app)) {
+    return { valid: true, issues: [] }
+  }
+
+  const index = app.fileStore.getIndex()
+  const issues: ValidationIssue[] = []
+
+  // Check workflow agent references
+  for (const workflow of index.workflows) {
+    for (const step of workflow.steps) {
+      if (step.agent) {
+        const agentExists = index.agents.some((a) => a.id === step.agent || a.name === step.agent)
+        if (!agentExists) {
+          issues.push({
+            severity: 'warning',
+            code: 'MISSING_AGENT_REF',
+            message: `Workflow "${workflow.name}" step references agent "${step.agent}" which was not found`,
+            entityType: 'workflow',
+            entityId: workflow.id,
+          })
+        }
+      }
+    }
+
+    // Check duplicate step numbers
+    checkDuplicateStepNumbers(workflow, issues)
+  }
+
+  // Check team agent references
+  for (const team of index.teams) {
+    for (const agentId of team.agentIds) {
+      const agentExists = index.agents.some((a) => a.id === agentId || a.name === agentId)
+      if (!agentExists) {
+        issues.push({
+          severity: 'warning',
+          code: 'MISSING_TEAM_AGENT_REF',
+          message: `Team "${team.name}" references agent "${agentId}" which was not found`,
+          entityType: 'team',
+          entityId: team.id,
+        })
+      }
+    }
+  }
+
+  // Report parse errors as validation issues
+  for (const error of index.errors) {
+    issues.push({
+      severity: 'error',
+      code: 'PARSE_ERROR',
+      message: error.error,
+      field: error.filePath,
+    })
+  }
+
+  return {
+    valid: issues.filter((i) => i.severity === 'error').length === 0,
+    issues,
+  }
+}
+
+export async function validationPlugin(app: FastifyInstance) {
+  app.get('/api/validation', async () => {
+    return validateEntities(app)
+  })
+}

package/packages/server/src/plugins/workflows-plugin.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { createApp } from '../app.js'
+
+describe('workflows-plugin', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflows-plugin-test-'))
+    const wfDir = path.join(tmpDir, '_bmad', 'bmm', 'workflows', '2-plan', 'test-workflow')
+    fs.mkdirSync(wfDir, { recursive: true })
+    fs.mkdirSync(path.join(tmpDir, '_bmad', 'bmm'), { recursive: true })
+    fs.writeFileSync(path.join(tmpDir, '_bmad', 'bmm', 'config.yaml'), 'project_name: test\n')
+
+    fs.writeFileSync(
+      path.join(wfDir, 'workflow.md'),
+      `---
+main_config: test
+---
+
+# Test Workflow
+
+**Goal:** A test workflow for plugin testing.
+`,
+    )
+
+    const stepsDir = path.join(wfDir, 'steps')
+    fs.mkdirSync(stepsDir)
+    fs.writeFileSync(
+      path.join(stepsDir, 'step-01-init.md'),
+      `---
+name: step-01-init
+description: 'Initialize the test'
+---
+
+# Step 1: Init
+
+## STEP GOAL:
+
+Set up the testing environment and validate prerequisites.
+
+## Instructions
+`,
+    )
+    fs.writeFileSync(path.join(stepsDir, 'step-02-execute.md'), '# Step 2: Execute\n\nRun the tests.\n')
+
+    // Add a template
+    fs.writeFileSync(path.join(wfDir, 'output.template.md'), '# Output Template\n')
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  function createTestApp() {
+    return createApp({
+      logger: false,
+      serveStatic: false,
+      project: {
+        projectRoot: tmpDir,
+        bmadVersion: '6.2.0',
+        versionSupported: true,
+        modules: [{ name: 'bmm', version: '6.2.0', source: 'built-in' }],
+        ideDirectories: [],
+      },
+    })
+  }
+
+  it('GET /api/workflows returns list with type and phase', async () => {
+    const app = await createTestApp()
+
+    const response = await app.inject({ method: 'GET', url: '/api/workflows' })
+    expect(response.statusCode).toBe(200)
+    const workflows = JSON.parse(response.body)
+    expect(workflows.length).toBeGreaterThanOrEqual(1)
+
+    const testWf = workflows.find((w: { id: string }) => w.id === 'test-workflow')
+    expect(testWf).toBeDefined()
+    expect(testWf.type).toBe('step-based')
+    expect(testWf.phase).toBe('2-plan')
+    expect(testWf.stepCount).toBe(2)
+
+    await app.close()
+  })
+
+  it('GET /api/workflows/:id returns enriched detail with templates and step descriptions', async () => {
+    const app = await createTestApp()
+
+    const response = await app.inject({ method: 'GET', url: '/api/workflows/test-workflow' })
+    expect(response.statusCode).toBe(200)
+    const wf = JSON.parse(response.body)
+
+    expect(wf.type).toBe('step-based')
+    expect(wf.phase).toBe('2-plan')
+    expect(wf.steps).toHaveLength(2)
+    expect(wf.steps[0].description).toContain('Set up the testing environment')
+    expect(wf.templates).toHaveLength(1)
+    expect(wf.templates[0].name).toBe('output')
+    expect(wf.supportingFiles).toBeDefined()
+    expect(wf.subWorkflows).toBeDefined()
+
+    await app.close()
+  })
+
+  it('GET /api/workflows/:id/steps/:stepIndex returns step file content', async () => {
+    const app = await createTestApp()
+
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/workflows/test-workflow/steps/0',
+    })
+    expect(response.statusCode).toBe(200)
+    const data = JSON.parse(response.body)
+    expect(data.content).toContain('## STEP GOAL:')
+    expect(data.content).toContain('Set up the testing environment')
+    expect(data.title).toBe('init')
+    expect(data.filePath).toContain('step-01-init.md')
+
+    await app.close()
+  })
+
+  it('GET /api/workflows/:id/steps/:stepIndex returns 422 for invalid index', async () => {
+    const app = await createTestApp()
+
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/workflows/test-workflow/steps/99',
+    })
+    expect(response.statusCode).toBe(422)
+
+    await app.close()
+  })
+
+  it('GET /api/workflows/:id returns 404 for missing workflow', async () => {
+    const app = await createTestApp()
+
+    const response = await app.inject({ method: 'GET', url: '/api/workflows/nonexistent' })
+    expect(response.statusCode).toBe(404)
+
+    await app.close()
+  })
+})