bmad-studio 0.1.0 → 0.2.0

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

@@ -1,386 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import type { FastifyInstance } from 'fastify'
-import yaml from 'js-yaml'
-
-import { ValidationError, ConflictError, NotFoundError } from '../core/errors.js'
-
-type ManifestModule = {
-  name: string
-  version: string
-  installDate: string
-  lastUpdated: string
-  source: string
-  npmPackage: string | null
-  repoUrl: string | null
-}
-
-type ManifestFile = {
-  installation: { version: string; installDate: string; lastUpdated: string }
-  modules: ManifestModule[]
-  ides?: string[]
-}
-
-function readManifest(manifestPath: string): ManifestFile {
-  const content = fs.readFileSync(manifestPath, 'utf-8')
-  return yaml.load(content) as ManifestFile
-}
-
-function writeManifest(manifestPath: string, manifest: ManifestFile) {
-  fs.writeFileSync(manifestPath, yaml.dump(manifest, { lineWidth: -1 }), 'utf-8')
-}
-
-const MODULE_NAME_RE = /^[a-z][a-z0-9-]*$/
-
-export async function modulesPlugin(app: FastifyInstance) {
-  app.post('/api/modules', async (request, reply) => {
-    if (!('fileStore' in app)) {
-      throw new ValidationError('No project detected')
-    }
-
-    const body = request.body as { name?: string; description?: string; version?: string }
-    const name = body.name?.trim()
-
-    if (!name) {
-      throw new ValidationError('Module name is required')
-    }
-    if (!MODULE_NAME_RE.test(name)) {
-      throw new ValidationError(
-        'Module name must be lowercase alphanumeric with hyphens (e.g., my-module)',
-      )
-    }
-
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const moduleDir = path.join(bmadDir, name)
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml')
-
-    if (fs.existsSync(moduleDir)) {
-      throw new ConflictError(`Module "${name}" already exists`)
-    }
-
-    // Create module directory structure
-    const subdirs = ['agents', 'skills', 'workflows']
-    for (const sub of subdirs) {
-      fs.mkdirSync(path.join(moduleDir, sub), { recursive: true })
-    }
-
-    // Create module config.yaml
-    const version = body.version?.trim() || '1.0.0'
-    const configContent = [
-      `# ${name} Module Configuration`,
-      `# Created by BMAD Studio`,
-      `# Date: ${new Date().toISOString()}`,
-      '',
-      `project_name: ${name}`,
-    ].join('\n')
-    fs.writeFileSync(path.join(moduleDir, 'config.yaml'), configContent, 'utf-8')
-
-    // Update manifest
-    if (fs.existsSync(manifestPath)) {
-      const manifest = readManifest(manifestPath)
-      const now = new Date().toISOString()
-      manifest.modules.push({
-        name,
-        version,
-        installDate: now,
-        lastUpdated: now,
-        source: 'custom',
-        npmPackage: null,
-        repoUrl: null,
-      })
-      writeManifest(manifestPath, manifest)
-    }
-
-    // Rebuild index
-    app.fileStore.rebuild()
-
-    reply.status(201)
-    return { ok: true, name, path: moduleDir }
-  })
-
-  app.delete('/api/modules/:name', async (request) => {
-    if (!('fileStore' in app)) {
-      throw new ValidationError('No project detected')
-    }
-
-    const { name } = request.params as { name: string }
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const moduleDir = path.join(bmadDir, name)
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml')
-
-    // Check manifest for source
-    if (fs.existsSync(manifestPath)) {
-      const manifest = readManifest(manifestPath)
-      const entry = manifest.modules.find((m) => m.name === name)
-
-      if (!entry) {
-        throw new NotFoundError(`Module "${name}" not found in manifest`)
-      }
-
-      if (entry.source === 'built-in') {
-        throw new ValidationError(`Cannot remove built-in module "${name}"`)
-      }
-
-      // Remove from manifest
-      manifest.modules = manifest.modules.filter((m) => m.name !== name)
-      writeManifest(manifestPath, manifest)
-    }
-
-    // Delete module directory
-    if (fs.existsSync(moduleDir)) {
-      fs.rmSync(moduleDir, { recursive: true, force: true })
-    }
-
-    // Rebuild index
-    app.fileStore.rebuild()
-
-    return { ok: true, name }
-  })
-
-  // Story 12.1 + 12.2: Add/upload entities to a module
-  app.post('/api/modules/:name/entities', async (request, reply) => {
-    if (!('fileStore' in app)) {
-      throw new ValidationError('No project detected')
-    }
-
-    const { name } = request.params as { name: string }
-    const body = request.body as {
-      type?: string
-      name?: string
-      content?: string
-    }
-
-    const entityType = body.type
-    const entityName = body.name?.trim()
-    const entityContent = body.content
-
-    if (!entityType || !['agent', 'skill', 'workflow'].includes(entityType)) {
-      throw new ValidationError('Entity type must be one of: agent, skill, workflow')
-    }
-    if (!entityName) {
-      throw new ValidationError('Entity name is required')
-    }
-
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const moduleDir = path.join(bmadDir, name)
-
-    if (!fs.existsSync(moduleDir)) {
-      throw new NotFoundError(`Module "${name}" not found`)
-    }
-
-    let filePath: string
-
-    if (entityType === 'skill') {
-      // Skills get their own directory with a SKILL.md file (matches index-builder convention)
-      const sanitized = entityName.replace(/\.md$/i, '')
-      const skillDir = path.join(moduleDir, 'skills', sanitized)
-      fs.mkdirSync(skillDir, { recursive: true })
-      filePath = path.join(skillDir, 'SKILL.md')
-
-      if (fs.existsSync(filePath)) {
-        throw new ConflictError(`Skill "${sanitized}" already exists in module "${name}"`)
-      }
-
-      const content = entityContent ?? [
-        '---',
-        `name: ${sanitized}`,
-        'category: custom',
-        'description: ""',
-        '---',
-        '',
-        `# ${sanitized}`,
-        '',
-        '<!-- Add skill instructions here -->',
-        '',
-      ].join('\n')
-
-      fs.writeFileSync(filePath, content, 'utf-8')
-    } else if (entityType === 'workflow') {
-      // Workflows get their own directory with a workflow.md file
-      const sanitized = entityName.replace(/\.md$/i, '')
-      const wfDir = path.join(moduleDir, 'workflows', sanitized)
-      fs.mkdirSync(wfDir, { recursive: true })
-      filePath = path.join(wfDir, 'workflow.md')
-
-      if (fs.existsSync(filePath)) {
-        throw new ConflictError(`Workflow "${sanitized}" already exists in module "${name}"`)
-      }
-
-      const content = entityContent ?? [
-        '---',
-        `name: ${sanitized}`,
-        'description: ""',
-        '---',
-        '',
-        `# ${sanitized} Workflow`,
-        '',
-        '## Step 1: Start',
-        '',
-        '<!-- Add workflow steps here -->',
-        '',
-      ].join('\n')
-
-      fs.writeFileSync(filePath, content, 'utf-8')
-    } else {
-      // Agent: .md file in agents/ directory
-      const sanitized = entityName.replace(/\.md$/i, '')
-      const agentDir = path.join(moduleDir, 'agents')
-      fs.mkdirSync(agentDir, { recursive: true })
-      filePath = path.join(agentDir, `${sanitized}.md`)
-
-      if (fs.existsSync(filePath)) {
-        throw new ConflictError(`Agent "${sanitized}" already exists in module "${name}"`)
-      }
-
-      const content = entityContent ?? [
-        '---',
-        `name: ${sanitized}`,
-        'title: ""',
-        'description: ""',
-        '---',
-        '',
-        `# ${sanitized}`,
-        '',
-        '<!-- Add agent definition here -->',
-        '',
-      ].join('\n')
-
-      fs.writeFileSync(filePath, content, 'utf-8')
-    }
-
-    // Rebuild index
-    app.fileStore.rebuild()
-
-    reply.status(201)
-    return { ok: true, type: entityType, name: entityName, path: filePath }
-  })
-
-  // Story 12.3: Export module manifest
-  app.post('/api/modules/:name/export', async (request) => {
-    if (!('fileStore' in app)) {
-      throw new ValidationError('No project detected')
-    }
-
-    const { name } = request.params as { name: string }
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml')
-
-    if (!fs.existsSync(manifestPath)) {
-      throw new NotFoundError('No manifest found')
-    }
-
-    const manifest = readManifest(manifestPath)
-    const entry = manifest.modules.find((m) => m.name === name)
-    if (!entry) {
-      throw new NotFoundError(`Module "${name}" not found in manifest`)
-    }
-
-    const moduleDir = path.join(bmadDir, name)
-    if (!fs.existsSync(moduleDir)) {
-      throw new NotFoundError(`Module directory "${name}" not found`)
-    }
-
-    const index = app.fileStore.getIndex()
-    const agentCount = index.agents.filter((a) => a.module === name).length
-    const skillCount = index.skills.filter((s) => s.module === name).length
-    const workflowCount = index.workflows.filter((w) => w.module === name).length
-
-    // List entity names
-    const agentNames = index.agents.filter((a) => a.module === name).map((a) => a.name)
-    const skillNames = index.skills.filter((s) => s.module === name).map((s) => s.name)
-    const workflowNames = index.workflows.filter((w) => w.module === name).map((w) => w.name)
-
-    const exportManifest = {
-      module: name,
-      version: entry.version,
-      source: entry.source,
-      exportDate: new Date().toISOString(),
-      entities: {
-        agents: { count: agentCount, names: agentNames },
-        skills: { count: skillCount, names: skillNames },
-        workflows: { count: workflowCount, names: workflowNames },
-      },
-      totalEntities: agentCount + skillCount + workflowCount,
-      note: 'This is a module manifest preview. Full file bundling/archiving is a future enhancement.',
-    }
-
-    return exportManifest
-  })
-
-  // Update module metadata (version, description)
-  app.put<{ Params: { name: string } }>('/api/modules/:name', async (request) => {
-    if (!('fileStore' in app)) {
-      throw new ValidationError('No project detected')
-    }
-
-    const { name } = request.params as { name: string }
-    const body = request.body as { version?: string; description?: string }
-
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const moduleDir = path.join(bmadDir, name)
-    const configPath = path.join(moduleDir, 'config.yaml')
-
-    if (!fs.existsSync(configPath)) {
-      throw new NotFoundError(`Module "${name}" config not found`)
-    }
-
-    const configContent = fs.readFileSync(configPath, 'utf-8')
-    const config = yaml.load(configContent) as Record<string, unknown>
-
-    if (body.version !== undefined) config.version = body.version
-    if (body.description !== undefined) config.description = body.description
-
-    const updated = yaml.dump(config, { lineWidth: -1 })
-    fs.writeFileSync(configPath, updated, 'utf-8')
-
-    // Also update manifest.yaml
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml')
-    if (fs.existsSync(manifestPath)) {
-      const manifest = readManifest(manifestPath)
-      const mod = manifest.modules.find((m) => m.name === name)
-      if (mod) {
-        if (body.version !== undefined) mod.version = body.version
-        mod.lastUpdated = new Date().toISOString().split('T')[0]
-        writeManifest(manifestPath, manifest)
-      }
-    }
-
-    app.fileStore.rebuild()
-    return { ok: true, name }
-  })
-
-  app.get('/api/modules', async () => {
-    if (!('fileStore' in app)) {
-      return []
-    }
-
-    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml')
-
-    if (!fs.existsSync(manifestPath)) {
-      return []
-    }
-
-    const manifest = readManifest(manifestPath)
-    const index = app.fileStore.getIndex()
-
-    return manifest.modules.map((m) => {
-      const moduleAgents = index.agents.filter((a) => a.module === m.name)
-      const moduleSkills = index.skills.filter((s) => s.module === m.name)
-      const moduleWorkflows = index.workflows.filter((w) => w.module === m.name)
-      const moduleTeams = index.teams.filter((t) => t.module === m.name)
-      return {
-        ...m,
-        agentCount: moduleAgents.length,
-        skillCount: moduleSkills.length,
-        workflowCount: moduleWorkflows.length,
-        teamCount: moduleTeams.length,
-        agents: moduleAgents.map((a) => ({ id: a.id, name: a.name, title: a.title })),
-        skills: moduleSkills.map((s) => ({ id: s.id, name: s.name })),
-        workflows: moduleWorkflows.map((w) => ({ id: w.id, name: w.name })),
-        teams: moduleTeams.map((t) => ({ id: t.id, name: t.name })),
-      }
-    })
-  })
-}

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

@@ -1,89 +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 { 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('outputs-plugin', () => {
-  let tmpDir: string
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'outputs-plugin-test-'))
-    fs.mkdirSync(path.join(tmpDir, '_bmad', 'bmm'), { recursive: true })
-    fs.writeFileSync(path.join(tmpDir, '_bmad', 'bmm', 'config.yaml'), 'project_name: test\n')
-    const outputDir = path.join(tmpDir, '_bmad-output')
-    fs.mkdirSync(outputDir, { recursive: true })
-    fs.writeFileSync(path.join(outputDir, 'report.md'), '# Report\nSome output\n')
-    fs.mkdirSync(path.join(tmpDir, '.bmad-studio'), { recursive: true })
-  })
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('GET /api/outputs returns output list', async () => {
-    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
-    const resp = await app.inject({ method: 'GET', url: '/api/outputs' })
-    expect(resp.statusCode).toBe(200)
-    const outputs = JSON.parse(resp.body)
-    expect(outputs).toHaveLength(1)
-    expect(outputs[0].name).toBe('report.md')
-    await app.close()
-  })
-
-  it('GET /api/outputs/* returns file content', async () => {
-    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
-    const resp = await app.inject({ method: 'GET', url: '/api/outputs/report.md' })
-    expect(resp.statusCode).toBe(200)
-    const data = JSON.parse(resp.body)
-    expect(data.content).toContain('# Report')
-    await app.close()
-  })
-
-  it('GET /api/outputs/* returns 404 for missing file', async () => {
-    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
-    const resp = await app.inject({ method: 'GET', url: '/api/outputs/missing.md' })
-    expect(resp.statusCode).toBe(404)
-    await app.close()
-  })
-
-  it('PUT /api/outputs/* writes file', async () => {
-    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
-    const resp = await app.inject({
-      method: 'PUT',
-      url: '/api/outputs/report.md',
-      payload: { content: '# Updated Report\n' },
-    })
-    expect(resp.statusCode).toBe(200)
-    expect(JSON.parse(resp.body).ok).toBe(true)
-
-    const written = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'report.md'), 'utf-8')
-    expect(written).toBe('# Updated Report\n')
-    await app.close()
-  })
-
-  it('PUT /api/outputs/* rejects path traversal', async () => {
-    const app = await createApp({ logger: false, serveStatic: false, project: makeProject(tmpDir) })
-    // Fastify normalizes ../ in URL before routing, so the route doesn't match (404).
-    // The server-side check is a secondary guard.
-    const resp = await app.inject({
-      method: 'PUT',
-      url: '/api/outputs/../../../etc/passwd',
-      payload: { content: 'evil' },
-    })
-    expect(resp.statusCode).toBeLessThanOrEqual(422)
-    expect(resp.statusCode).toBeGreaterThanOrEqual(404)
-    await app.close()
-  })
-})

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

@@ -1,93 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import type { FastifyInstance } from 'fastify'
-import type { Output } from '@bmad-studio/shared'
-
-import { NotFoundError, ValidationError } from '../core/errors.js'
-import { writeFile } from '../core/write-service.js'
-
-function scanOutputs(outputDir: string): Output[] {
-  if (!fs.existsSync(outputDir)) return []
-
-  const outputs: Output[] = []
-  const entries = fs.readdirSync(outputDir, { withFileTypes: true, recursive: true })
-
-  for (const entry of entries) {
-    if (entry.isFile() && !entry.name.startsWith('.')) {
-      const fullPath = path.join(entry.parentPath ?? outputDir, entry.name)
-      const stats = fs.statSync(fullPath)
-      const relPath = path.relative(outputDir, fullPath)
-      outputs.push({
-        path: relPath,
-        name: entry.name,
-        type: path.extname(entry.name).slice(1),
-        size: stats.size,
-        modifiedAt: stats.mtime.toISOString(),
-      })
-    }
-  }
-
-  return outputs
-}
-
-export async function outputsPlugin(app: FastifyInstance) {
-  app.get('/api/outputs', async () => {
-    if (!('fileStore' in app)) return []
-    const projectRoot = app.fileStore.projectRoot
-    const outputDir = path.join(projectRoot, '_bmad-output')
-    return scanOutputs(outputDir)
-  })
-
-  app.get<{ Params: { '*': string } }>('/api/outputs/*', async (request) => {
-    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
-    const projectRoot = app.fileStore.projectRoot
-    const filePath = path.join(projectRoot, '_bmad-output', request.params['*'])
-
-    // Path traversal protection
-    const outputRoot = path.join(projectRoot, '_bmad-output')
-    const resolved = path.resolve(filePath)
-    if (!resolved.startsWith(path.resolve(outputRoot))) {
-      throw new ValidationError('Path traversal not allowed')
-    }
-
-    if (!fs.existsSync(filePath)) {
-      throw new NotFoundError(`Output file not found: ${request.params['*']}`)
-    }
-
-    return { content: fs.readFileSync(filePath, 'utf-8'), path: request.params['*'] }
-  })
-
-  // Write output file
-  app.put<{ Params: { '*': string }; Body: { content: string } }>(
-    '/api/outputs/*',
-    async (request) => {
-      if (!('fileStore' in app)) throw new NotFoundError('File store not available')
-
-      const projectRoot = app.fileStore.projectRoot
-      const filePath = path.join(projectRoot, '_bmad-output', request.params['*'])
-
-      // Path traversal protection
-      const outputRoot = path.join(projectRoot, '_bmad-output')
-      const resolved = path.resolve(filePath)
-      if (!resolved.startsWith(path.resolve(outputRoot))) {
-        throw new ValidationError('Path traversal not allowed')
-      }
-
-      const { content } = request.body as { content: string }
-      if (typeof content !== 'string') {
-        throw new ValidationError('Content must be a string')
-      }
-
-      app.fileStore.markPendingWrite(resolved)
-      const result = writeFile(resolved, content, app.fileStore.studioDir)
-      app.fileStore.clearPendingWrite(resolved)
-
-      if (!result.ok) {
-        throw new ValidationError(result.error)
-      }
-
-      return { ok: true, filePath: result.filePath }
-    },
-  )
-}

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

@@ -1,73 +0,0 @@
-import type { FastifyInstance } from 'fastify'
-
-export async function overviewPlugin(app: FastifyInstance) {
-  app.get('/api/overview', async () => {
-    const hasStore = 'fileStore' in app
-
-    if (!hasStore) {
-      return { detected: false, sections: {} }
-    }
-
-    const index = app.fileStore.getIndex()
-
-    return {
-      detected: true,
-      sections: {
-        teams: {
-          teams: index.teams.map((t) => ({
-            id: t.id,
-            name: t.name,
-            icon: t.icon,
-            description: t.description,
-            memberCount: t.members.length,
-            module: t.module,
-          })),
-          count: index.teams.length,
-        },
-        team: {
-          agents: index.agents.filter((a) => a.name || a.title).map((a) => ({
-            id: a.id,
-            name: a.name,
-            title: a.title,
-            icon: a.icon,
-            role: a.role,
-            skillCount: a.skills.length,
-            module: a.module,
-          })),
-          count: index.agents.filter((a) => a.name || a.title).length,
-        },
-        process: {
-          workflows: index.workflows.map((w) => ({
-            id: w.id,
-            name: w.name,
-            stepCount: w.steps.length,
-            module: w.module,
-            type: w.type,
-          })),
-          count: index.workflows.length,
-        },
-        toolkit: {
-          skills: index.skills.map((s) => ({
-            id: s.id,
-            name: s.name,
-            module: s.module,
-          })),
-          count: index.skills.length,
-        },
-        packages: {
-          packages: index.packages.map((p) => ({
-            name: p.name,
-            version: p.version,
-            agentCount: p.agents.length,
-            skillCount: p.skills.length,
-          })),
-          count: index.packages.length,
-        },
-        ideConfigs: {
-          ides: index.ideConfigs.map((c) => c.ide),
-          count: index.ideConfigs.length,
-        },
-      },
-    }
-  })
-}

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

@@ -1,63 +0,0 @@
-import type { FastifyInstance } from 'fastify'
-
-type SearchResult = {
-  type: 'agent' | 'skill' | 'workflow'
-  id: string
-  name: string
-  description: string
-  module?: string
-}
-
-export async function searchPlugin(app: FastifyInstance) {
-  app.get<{ Querystring: { q: string } }>('/api/search', async (request) => {
-    const query = (request.query.q || '').toLowerCase().trim()
-    if (!query || !('fileStore' in app)) return []
-
-    const index = app.fileStore.getIndex()
-    const results: SearchResult[] = []
-
-    for (const agent of index.agents) {
-      if (agent.name.toLowerCase().includes(query) || agent.role.toLowerCase().includes(query)) {
-        results.push({
-          type: 'agent',
-          id: agent.id,
-          name: agent.name,
-          description: agent.role,
-          module: agent.module,
-        })
-      }
-    }
-
-    for (const skill of index.skills) {
-      if (
-        skill.name.toLowerCase().includes(query) ||
-        skill.description.toLowerCase().includes(query)
-      ) {
-        results.push({
-          type: 'skill',
-          id: skill.id,
-          name: skill.name,
-          description: skill.description,
-          module: skill.module,
-        })
-      }
-    }
-
-    for (const workflow of index.workflows) {
-      if (
-        workflow.name.toLowerCase().includes(query) ||
-        workflow.description.toLowerCase().includes(query)
-      ) {
-        results.push({
-          type: 'workflow',
-          id: workflow.id,
-          name: workflow.name,
-          description: workflow.description,
-          module: workflow.module,
-        })
-      }
-    }
-
-    return results
-  })
-}