bmad-studio 0.1.0

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

@@ -0,0 +1,82 @@
+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'
+
+function makeProject(tmpDir: string) {
+  return {
+    projectRoot: tmpDir,
+    bmadVersion: '6.2.0',
+    versionSupported: true as const,
+    modules: [{ name: 'bmm', version: '6.2.0', source: 'built-in' as const }],
+    ideDirectories: [],
+  }
+}
+
+describe('settings-plugin', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'settings-plugin-test-'))
+    fs.mkdirSync(path.join(tmpDir, '_bmad', 'bmm'), { recursive: true })
+    fs.writeFileSync(path.join(tmpDir, '_bmad', 'bmm', 'config.yaml'), 'project_name: test\n')
+    fs.mkdirSync(path.join(tmpDir, '.bmad-studio'), { recursive: true })
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('GET /api/settings returns defaults when no settings file exists', async () => {
+    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
+    const resp = await app.inject({ method: 'GET', url: '/api/settings' })
+    expect(resp.statusCode).toBe(200)
+    const settings = JSON.parse(resp.body)
+    expect(settings.port).toBe(4040)
+    expect(settings.theme).toBe('dark')
+    await app.close()
+  })
+
+  it('PUT /api/settings saves settings', async () => {
+    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
+    const resp = await app.inject({
+      method: 'PUT',
+      url: '/api/settings',
+      payload: { port: 5050, theme: 'light' },
+    })
+    expect(resp.statusCode).toBe(200)
+    expect(JSON.parse(resp.body).ok).toBe(true)
+
+    // Verify the saved file
+    const settingsPath = path.join(tmpDir, '.bmad-studio', 'settings.json')
+    expect(fs.existsSync(settingsPath)).toBe(true)
+    const saved = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
+    expect(saved.port).toBe(5050)
+    expect(saved.theme).toBe('light')
+    await app.close()
+  })
+
+  it('GET /api/settings returns saved settings', async () => {
+    const settingsPath = path.join(tmpDir, '.bmad-studio', 'settings.json')
+    fs.writeFileSync(settingsPath, JSON.stringify({ port: 8080, theme: 'light' }))
+
+    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
+    const resp = await app.inject({ method: 'GET', url: '/api/settings' })
+    expect(resp.statusCode).toBe(200)
+    const settings = JSON.parse(resp.body)
+    expect(settings.port).toBe(8080)
+    expect(settings.theme).toBe('light')
+    await app.close()
+  })
+
+  it('GET /api/settings returns defaults without file store', async () => {
+    const app = await createApp({ logger: false, serveStatic: false, project: null })
+    const resp = await app.inject({ method: 'GET', url: '/api/settings' })
+    expect(resp.statusCode).toBe(200)
+    const settings = JSON.parse(resp.body)
+    expect(settings.port).toBe(4040)
+    await app.close()
+  })
+})

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

@@ -0,0 +1,46 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { FastifyInstance } from 'fastify'
+
+import { writeFile } from '../core/write-service.js'
+
+export async function settingsPlugin(app: FastifyInstance) {
+  app.get('/api/settings', async () => {
+    if (!('fileStore' in app)) {
+      return { port: 4040, theme: 'dark' }
+    }
+
+    const settingsPath = path.join(app.fileStore.studioDir, 'settings.json')
+    if (fs.existsSync(settingsPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
+      } catch {
+        return { port: 4040, theme: 'dark' }
+      }
+    }
+
+    return { port: 4040, theme: 'dark' }
+  })
+
+  app.put('/api/settings', async (request) => {
+    if (!('fileStore' in app)) {
+      return { ok: true }
+    }
+
+    const studioDir = app.fileStore.studioDir
+    if (!fs.existsSync(studioDir)) {
+      fs.mkdirSync(studioDir, { recursive: true })
+    }
+
+    const settingsPath = path.join(studioDir, 'settings.json')
+    const content = JSON.stringify(request.body, null, 2)
+    const result = writeFile(settingsPath, content, studioDir)
+
+    if (!result.ok) {
+      return { ok: false, error: result.error }
+    }
+
+    return { ok: true }
+  })
+}

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

@@ -0,0 +1,87 @@
+import fs from 'node:fs'
+
+import type { FastifyInstance } from 'fastify'
+import type { Skill, SkillListItem } from '@bmad-studio/shared'
+
+import { NotFoundError, ValidationError } from '../core/errors.js'
+import { writeFile } from '../core/write-service.js'
+
+function skillToListItem(skill: Skill): SkillListItem {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    module: skill.module,
+    bestFor: skill.bestFor,
+  }
+}
+
+export async function skillsPlugin(app: FastifyInstance) {
+  app.get('/api/skills', async () => {
+    if (!('fileStore' in app)) return []
+    const index = app.fileStore.getIndex()
+    return index.skills.map(skillToListItem)
+  })
+
+  app.get<{ Params: { id: string } }>('/api/skills/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const skill = index.skills.find((s) => s.id === request.params.id)
+    if (!skill) throw new NotFoundError(`Skill "${request.params.id}" not found`)
+    return skill
+  })
+
+  // Update skill content
+  app.put<{ Params: { id: string }; Body: { content: string } }>(
+    '/api/skills/:id',
+    async (request) => {
+      if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+
+      const index = app.fileStore.getIndex()
+      const skill = index.skills.find((s) => s.id === request.params.id)
+      if (!skill) throw new NotFoundError(`Skill "${request.params.id}" not found`)
+
+      const { content } = request.body as { content: string }
+      if (typeof content !== 'string') {
+        throw new ValidationError('Content must be a string')
+      }
+
+      if (!fs.existsSync(skill.filePath)) {
+        throw new NotFoundError(`Skill file not found: ${skill.filePath}`)
+      }
+
+      app.fileStore.markPendingWrite(skill.filePath)
+      const result = writeFile(skill.filePath, content, app.fileStore.studioDir)
+      app.fileStore.clearPendingWrite(skill.filePath)
+
+      if (!result.ok) {
+        throw new ValidationError(result.error)
+      }
+
+      return { ok: true, filePath: result.filePath }
+    },
+  )
+
+  // Delete skill
+  app.delete<{ Params: { id: string } }>('/api/skills/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+
+    const index = app.fileStore.getIndex()
+    const skill = index.skills.find((s) => s.id === request.params.id)
+    if (!skill) throw new NotFoundError(`Skill "${request.params.id}" not found`)
+
+    if (!fs.existsSync(skill.filePath)) {
+      throw new NotFoundError(`Skill file not found: ${skill.filePath}`)
+    }
+
+    // Snapshot before delete
+    const content = fs.readFileSync(skill.filePath, 'utf-8')
+    writeFile(skill.filePath, content, app.fileStore.studioDir) // creates snapshot
+
+    app.fileStore.markPendingWrite(skill.filePath)
+    fs.unlinkSync(skill.filePath)
+    app.fileStore.clearPendingWrite(skill.filePath)
+
+    return { ok: true, deleted: skill.id }
+  })
+}

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

@@ -0,0 +1,157 @@
+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('teams-plugin', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'teams-plugin-test-'))
+    const teamsDir = path.join(tmpDir, '_bmad', 'bmm', 'teams')
+    fs.mkdirSync(teamsDir, { 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(teamsDir, 'team-fullstack.yaml'),
+      `bundle:
+  name: Team Fullstack
+  icon: "🚀"
+  description: Full stack dev team
+agents:
+  - analyst
+  - dev
+party: "./default-party.csv"
+`,
+    )
+
+    fs.writeFileSync(
+      path.join(teamsDir, 'default-party.csv'),
+      `name,displayName,title,icon,role,communicationStyle,identity,principles,module,path
+"analyst","Mary","BA","📊","BA","Analytical","Senior analyst","Evidence-based","bmm","agents/analyst.md"
+"dev","Amelia","Dev","💻","Dev","Succinct","Senior dev","Tests first","bmm","agents/dev.md"
+`,
+    )
+  })
+
+  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/teams returns TeamListItem array', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/teams' })
+    expect(response.statusCode).toBe(200)
+    const teams = JSON.parse(response.body)
+    expect(teams).toHaveLength(1)
+    expect(teams[0].id).toBe('team-fullstack')
+    expect(teams[0].name).toBe('Team Fullstack')
+    expect(teams[0].icon).toBe('🚀')
+    expect(teams[0].memberCount).toBe(2)
+    expect(teams[0].module).toBe('bmm')
+
+    await app.close()
+  })
+
+  it('GET /api/teams/:id returns full Team with resolved members', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/teams/team-fullstack' })
+    expect(response.statusCode).toBe(200)
+    const team = JSON.parse(response.body)
+    expect(team.id).toBe('team-fullstack')
+    expect(team.agentIds).toEqual(['analyst', 'dev'])
+    expect(team.members).toHaveLength(2)
+    expect(team.members[0].displayName).toBe('Mary')
+    expect(team.members[1].displayName).toBe('Amelia')
+
+    await app.close()
+  })
+
+  it('GET /api/teams/:id returns 404 for missing team', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/teams/nonexistent' })
+    expect(response.statusCode).toBe(404)
+
+    await app.close()
+  })
+
+  it('GET /api/teams/:id/party returns raw CSV content', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'GET', url: '/api/teams/team-fullstack/party' })
+    expect(response.statusCode).toBe(200)
+    const data = JSON.parse(response.body)
+    expect(data.content).toContain('name,displayName,title')
+    expect(data.content).toContain('analyst')
+    expect(data.content).toContain('Mary')
+
+    await app.close()
+  })
+
+  it('POST /api/teams creates a new team YAML file', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({
+      method: 'POST',
+      url: '/api/teams',
+      payload: {
+        name: 'New Team',
+        icon: '⭐',
+        description: 'A new team',
+        agentIds: ['analyst'],
+        module: 'bmm',
+      },
+    })
+    expect(response.statusCode).toBe(201)
+    const data = JSON.parse(response.body)
+    expect(data.ok).toBe(true)
+    expect(data.id).toBe('team-new-team')
+
+    // Verify file was created
+    const teamFile = path.join(tmpDir, '_bmad', 'bmm', 'teams', 'team-new-team.yaml')
+    expect(fs.existsSync(teamFile)).toBe(true)
+
+    // Verify it appears in the index
+    const listResponse = await app.inject({ method: 'GET', url: '/api/teams' })
+    const teams = JSON.parse(listResponse.body)
+    expect(teams).toHaveLength(2)
+
+    await app.close()
+  })
+
+  it('DELETE /api/teams/:id removes YAML but preserves party CSV', async () => {
+    const app = await createTestApp()
+    const response = await app.inject({ method: 'DELETE', url: '/api/teams/team-fullstack' })
+    expect(response.statusCode).toBe(200)
+
+    // YAML removed
+    const teamFile = path.join(tmpDir, '_bmad', 'bmm', 'teams', 'team-fullstack.yaml')
+    expect(fs.existsSync(teamFile)).toBe(false)
+
+    // Party CSV preserved
+    const partyFile = path.join(tmpDir, '_bmad', 'bmm', 'teams', 'default-party.csv')
+    expect(fs.existsSync(partyFile)).toBe(true)
+
+    // No longer in index
+    const listResponse = await app.inject({ method: 'GET', url: '/api/teams' })
+    const teams = JSON.parse(listResponse.body)
+    expect(teams).toHaveLength(0)
+
+    await app.close()
+  })
+})

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

@@ -0,0 +1,198 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { FastifyInstance } from 'fastify'
+import yaml from 'js-yaml'
+
+import type { TeamListItem } from '@bmad-studio/shared'
+
+import { NotFoundError, ValidationError } from '../core/errors.js'
+import { writeFile } from '../core/write-service.js'
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-\s]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+export async function teamsPlugin(app: FastifyInstance) {
+  // List all teams
+  app.get('/api/teams', async () => {
+    if (!('fileStore' in app)) return []
+    const index = app.fileStore.getIndex()
+    return index.teams.map(
+      (t): TeamListItem => ({
+        id: t.id,
+        name: t.name,
+        icon: t.icon,
+        description: t.description,
+        memberCount: t.members.length,
+        agentIds: t.agentIds,
+        module: t.module,
+      }),
+    )
+  })
+
+  // Get team detail
+  app.get<{ Params: { id: string } }>('/api/teams/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const team = index.teams.find((t) => t.id === request.params.id)
+    if (!team) throw new NotFoundError(`Team "${request.params.id}" not found`)
+    return team
+  })
+
+  // Get party CSV content
+  app.get<{ Params: { id: string } }>('/api/teams/:id/party', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const team = index.teams.find((t) => t.id === request.params.id)
+    if (!team) throw new NotFoundError(`Team "${request.params.id}" not found`)
+
+    if (!team.partyFile) {
+      throw new NotFoundError('Team has no party CSV file')
+    }
+
+    const absPath = path.resolve(path.dirname(team.filePath), team.partyFile)
+    if (!fs.existsSync(absPath)) {
+      throw new NotFoundError(`Party CSV file not found: ${team.partyFile}`)
+    }
+
+    const content = fs.readFileSync(absPath, 'utf-8')
+    return { content, path: absPath }
+  })
+
+  // Create team
+  app.post('/api/teams', async (request, reply) => {
+    if (!('fileStore' in app)) throw new ValidationError('No project detected')
+
+    const body = request.body as {
+      name?: string
+      icon?: string
+      description?: string
+      agentIds?: string[]
+      module?: string
+    }
+
+    const name = body.name?.trim()
+    if (!name) throw new ValidationError('Team name is required')
+
+    const moduleName = body.module?.trim()
+    if (!moduleName) throw new ValidationError('Module is required')
+
+    const slug = slugify(name)
+    if (!slug) throw new ValidationError('Team name must contain alphanumeric characters')
+
+    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
+    const teamsDir = path.join(bmadDir, moduleName, 'teams')
+    const teamFile = path.join(teamsDir, `team-${slug}.yaml`)
+
+    if (fs.existsSync(teamFile)) {
+      throw new ValidationError(`Team file already exists: team-${slug}.yaml`)
+    }
+
+    // Ensure teams directory exists
+    if (!fs.existsSync(teamsDir)) {
+      fs.mkdirSync(teamsDir, { recursive: true })
+    }
+
+    const teamYaml = {
+      bundle: {
+        name,
+        icon: body.icon ?? '',
+        description: body.description ?? '',
+      },
+      agents: body.agentIds ?? [],
+      party: './default-party.csv',
+    }
+
+    const content = yaml.dump(teamYaml, { lineWidth: -1 })
+    fs.writeFileSync(teamFile, content, 'utf-8')
+
+    app.fileStore.rebuild()
+
+    reply.status(201)
+    return { ok: true, id: `team-${slug}`, path: teamFile }
+  })
+
+  // Update team
+  app.put<{ Params: { id: string } }>('/api/teams/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const team = index.teams.find((t) => t.id === request.params.id)
+    if (!team) throw new NotFoundError(`Team "${request.params.id}" not found`)
+
+    const body = request.body as {
+      name?: string
+      icon?: string
+      description?: string
+      agentIds?: string[]
+    }
+
+    // Read existing YAML, merge updates
+    const existing = yaml.load(fs.readFileSync(team.filePath, 'utf-8')) as {
+      bundle?: { name?: string; icon?: string; description?: string }
+      agents?: string[]
+      party?: string
+    }
+
+    if (body.name !== undefined) existing.bundle = { ...existing.bundle, name: body.name }
+    if (body.icon !== undefined) existing.bundle = { ...existing.bundle, icon: body.icon }
+    if (body.description !== undefined)
+      existing.bundle = { ...existing.bundle, description: body.description }
+    if (body.agentIds !== undefined) existing.agents = body.agentIds
+
+    const content = yaml.dump(existing, { lineWidth: -1 })
+
+    app.fileStore.markPendingWrite(team.filePath)
+    const result = writeFile(team.filePath, content, app.fileStore.studioDir)
+    app.fileStore.clearPendingWrite(team.filePath)
+
+    if (!result.ok) throw new ValidationError(result.error)
+
+    app.fileStore.rebuild()
+    return { ok: true }
+  })
+
+  // Delete team (YAML only, preserve party CSV)
+  app.delete<{ Params: { id: string } }>('/api/teams/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const team = index.teams.find((t) => t.id === request.params.id)
+    if (!team) throw new NotFoundError(`Team "${request.params.id}" not found`)
+
+    if (fs.existsSync(team.filePath)) {
+      fs.unlinkSync(team.filePath)
+    }
+
+    app.fileStore.rebuild()
+    return { ok: true, id: request.params.id }
+  })
+
+  // Update party CSV content
+  app.put<{ Params: { id: string } }>('/api/teams/:id/party', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const team = index.teams.find((t) => t.id === request.params.id)
+    if (!team) throw new NotFoundError(`Team "${request.params.id}" not found`)
+
+    if (!team.partyFile) throw new ValidationError('Team has no party CSV file configured')
+
+    const body = request.body as { content?: string }
+    if (typeof body.content !== 'string') throw new ValidationError('Content must be a string')
+
+    const absPath = path.resolve(path.dirname(team.filePath), team.partyFile)
+
+    app.fileStore.markPendingWrite(absPath)
+    const result = writeFile(absPath, body.content, app.fileStore.studioDir)
+    app.fileStore.clearPendingWrite(absPath)
+
+    if (!result.ok) throw new ValidationError(result.error)
+
+    app.fileStore.rebuild()
+    return { ok: true, path: absPath }
+  })
+}