bmad-studio 0.1.0

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

@@ -0,0 +1,270 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { FastifyInstance } from 'fastify'
+import type { WorkflowListItem } from '@bmad-studio/shared'
+
+import { NotFoundError, ValidationError } from '../core/errors.js'
+import { writeFile } from '../core/write-service.js'
+
+function toKebab(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+}
+
+export async function workflowsPlugin(app: FastifyInstance) {
+  // Create a new workflow
+  app.post('/api/workflows', async (request, reply) => {
+    if (!('fileStore' in app)) {
+      throw new ValidationError('No project detected')
+    }
+
+    const body = request.body as {
+      name?: string
+      description?: string
+      type?: string
+      phase?: string
+      module?: string
+      steps?: Array<{ title: string; agent?: string }>
+    }
+
+    const name = body.name?.trim()
+    const description = body.description?.trim() ?? ''
+    const type = body.type ?? 'step-based'
+    const phase = body.phase?.trim()
+    const moduleName = body.module?.trim()
+    const steps = body.steps ?? []
+
+    if (!name) throw new ValidationError('Workflow name is required')
+    if (!moduleName) throw new ValidationError('Module is required')
+
+    const bmadDir = path.join(app.fileStore.projectRoot, '_bmad')
+    const moduleDir = path.join(bmadDir, moduleName)
+
+    if (!fs.existsSync(moduleDir)) {
+      throw new NotFoundError(`Module "${moduleName}" not found`)
+    }
+
+    // Build workflow directory path
+    let workflowDir: string
+    if (phase) {
+      workflowDir = path.join(moduleDir, 'workflows', phase, name)
+    } else {
+      workflowDir = path.join(moduleDir, 'workflows', name)
+    }
+
+    if (fs.existsSync(workflowDir)) {
+      throw new ValidationError(`Workflow "${name}" already exists in module "${moduleName}"`)
+    }
+
+    // Create directory structure
+    fs.mkdirSync(workflowDir, { recursive: true })
+
+    // Create workflow.md
+    const workflowMd = [
+      '---',
+      `name: ${name}`,
+      `description: "${description}"`,
+      `type: ${type}`,
+      '---',
+      '',
+      `# ${name}`,
+      '',
+      description || '<!-- Add workflow description here -->',
+      '',
+    ].join('\n')
+
+    fs.writeFileSync(path.join(workflowDir, 'workflow.md'), workflowMd, 'utf-8')
+
+    // Create steps directory and step files (step-based only)
+    if (type === 'step-based' && steps.length > 0) {
+      const stepsDir = path.join(workflowDir, 'steps')
+      fs.mkdirSync(stepsDir, { recursive: true })
+
+      steps.forEach((step, i) => {
+        const num = String(i + 1).padStart(2, '0')
+        const slug = toKebab(step.title)
+        const stepContent = [
+          '---',
+          `title: "${step.title}"`,
+          step.agent ? `agent: ${step.agent}` : '',
+          '---',
+          '',
+          `# Step ${num}: ${step.title}`,
+          '',
+          '## Instructions',
+          '',
+          '<!-- Add step instructions here -->',
+          '',
+        ]
+          .filter(Boolean)
+          .join('\n')
+
+        fs.writeFileSync(path.join(stepsDir, `step-${num}-${slug}.md`), stepContent, 'utf-8')
+      })
+    }
+
+    app.fileStore.rebuild()
+
+    reply.code(201)
+    return { ok: true, name, path: workflowDir }
+  })
+
+  app.get('/api/workflows', async () => {
+    if (!('fileStore' in app)) return []
+    const index = app.fileStore.getIndex()
+    return index.workflows.map(
+      (w): WorkflowListItem => ({
+        id: w.id,
+        name: w.name,
+        description: w.description,
+        module: w.module,
+        stepCount: w.steps.length,
+        type: w.type,
+        phase: w.phase,
+      }),
+    )
+  })
+
+  app.get<{ Params: { id: string } }>('/api/workflows/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const workflow = index.workflows.find((w) => w.id === request.params.id)
+    if (!workflow) throw new NotFoundError(`Workflow "${request.params.id}" not found`)
+    return workflow
+  })
+
+  // Update workflow metadata
+  app.put<{ Params: { id: string } }>('/api/workflows/:id', async (request) => {
+    if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+    const index = app.fileStore.getIndex()
+    const workflow = index.workflows.find((w) => w.id === request.params.id)
+    if (!workflow) throw new NotFoundError(`Workflow "${request.params.id}" not found`)
+
+    const body = request.body as { description?: string }
+
+    if (!fs.existsSync(workflow.entryPoint)) {
+      throw new NotFoundError(`Workflow file not found: ${workflow.entryPoint}`)
+    }
+
+    let content = fs.readFileSync(workflow.entryPoint, 'utf-8')
+
+    if (body.description !== undefined) {
+      // Update description in frontmatter
+      const descPattern = /^(description:\s*)"?.*?"?\s*$/m
+      if (descPattern.test(content)) {
+        content = content.replace(descPattern, `$1"${body.description}"`)
+      }
+    }
+
+    app.fileStore.markPendingWrite(workflow.entryPoint)
+    const result = writeFile(workflow.entryPoint, content, app.fileStore.studioDir)
+    app.fileStore.clearPendingWrite(workflow.entryPoint)
+
+    if (!result.ok) {
+      throw new ValidationError(result.error)
+    }
+
+    return { ok: true, filePath: result.filePath }
+  })
+
+  // Get step content
+  app.get<{ Params: { id: string; stepIndex: string } }>(
+    '/api/workflows/:id/steps/:stepIndex',
+    async (request) => {
+      if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+
+      const index = app.fileStore.getIndex()
+      const workflow = index.workflows.find((w) => w.id === request.params.id)
+      if (!workflow) throw new NotFoundError(`Workflow "${request.params.id}" not found`)
+
+      const stepIndex = parseInt(request.params.stepIndex, 10)
+      if (isNaN(stepIndex) || stepIndex < 0 || stepIndex >= workflow.steps.length) {
+        throw new ValidationError(`Invalid step index: ${request.params.stepIndex}`)
+      }
+
+      const step = workflow.steps[stepIndex]
+      if (!step.filePath || !fs.existsSync(step.filePath)) {
+        throw new NotFoundError(`Step file not found: ${step.filePath}`)
+      }
+
+      const content = fs.readFileSync(step.filePath, 'utf-8')
+      return { content, filePath: step.filePath, title: step.title }
+    },
+  )
+
+  // Update a workflow step
+  app.put<{ Params: { id: string; stepIndex: string }; Body: { content: string } }>(
+    '/api/workflows/:id/steps/:stepIndex',
+    async (request) => {
+      if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+
+      const index = app.fileStore.getIndex()
+      const workflow = index.workflows.find((w) => w.id === request.params.id)
+      if (!workflow) throw new NotFoundError(`Workflow "${request.params.id}" not found`)
+
+      const stepIndex = parseInt(request.params.stepIndex, 10)
+      if (isNaN(stepIndex) || stepIndex < 0 || stepIndex >= workflow.steps.length) {
+        throw new ValidationError(`Invalid step index: ${request.params.stepIndex}`)
+      }
+
+      const step = workflow.steps[stepIndex]
+      if (!step.filePath) {
+        throw new ValidationError('Step has no associated file')
+      }
+
+      const { content } = request.body as { content: string }
+      if (typeof content !== 'string') {
+        throw new ValidationError('Content must be a string')
+      }
+
+      if (!fs.existsSync(step.filePath)) {
+        throw new NotFoundError(`Step file not found: ${step.filePath}`)
+      }
+
+      app.fileStore.markPendingWrite(step.filePath)
+      const result = writeFile(step.filePath, content, app.fileStore.studioDir)
+      app.fileStore.clearPendingWrite(step.filePath)
+
+      if (!result.ok) {
+        throw new ValidationError(result.error)
+      }
+
+      return { ok: true, filePath: result.filePath }
+    },
+  )
+
+  // List files within a workflow's supporting directories
+  app.get<{ Params: { id: string } }>(
+    '/api/workflows/:id/supporting-files',
+    async (request) => {
+      if (!('fileStore' in app)) throw new NotFoundError('File store not available')
+      const index = app.fileStore.getIndex()
+      const workflow = index.workflows.find((w) => w.id === request.params.id)
+      if (!workflow) throw new NotFoundError(`Workflow "${request.params.id}" not found`)
+
+      const groups: Array<{ name: string; files: Array<{ name: string; relativePath: string }> }> = []
+
+      for (const dirPath of workflow.supportingFiles ?? []) {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) continue
+        const dirName = path.basename(dirPath)
+        const files = fs.readdirSync(dirPath)
+          .filter((f) => !f.startsWith('.'))
+          .sort()
+          .map((f) => {
+            const fullPath = path.join(dirPath, f)
+            const bmadIndex = fullPath.indexOf('_bmad/')
+            const relativePath = bmadIndex >= 0 ? fullPath.slice(bmadIndex + 6) : f
+            return { name: f, relativePath }
+          })
+        if (files.length > 0) {
+          groups.push({ name: dirName, files })
+        }
+      }
+
+      return { groups }
+    },
+  )
+}

package/packages/server/src/static.ts

@@ -0,0 +1,29 @@
+import { fileURLToPath } from 'node:url'
+import fs from 'node:fs'
+import path from 'node:path'
+
+import fastifyStatic from '@fastify/static'
+
+import type { FastifyInstance } from 'fastify'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CLIENT_DIST = path.join(__dirname, '..', '..', 'client', 'dist')
+
+export async function registerStatic(app: FastifyInstance) {
+  if (!fs.existsSync(CLIENT_DIST)) {
+    app.log.warn(`Client dist not found at ${CLIENT_DIST} — static serving disabled`)
+    return
+  }
+
+  await app.register(fastifyStatic, {
+    root: CLIENT_DIST,
+    wildcard: false,
+  })
+
+  app.setNotFoundHandler((request, reply) => {
+    if (request.url.startsWith('/api/')) {
+      return reply.status(404).send({ error: 'Not Found' })
+    }
+    return reply.sendFile('index.html')
+  })
+}

package/packages/server/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/packages/shared/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@bmad-studio/shared",
+  "version": "0.1.0",
+  "description": "Shared types and constants for BMAD Studio",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "license": "MIT"
+}

package/packages/shared/src/agents.ts

@@ -0,0 +1,39 @@
+export type AgentMenuItem = {
+  trigger: string
+  input: string
+  route: string
+  action?: string
+}
+
+export type Agent = {
+  id: string
+  name: string
+  title: string
+  icon?: string
+  role: string
+  module?: string
+  discussion: boolean
+  webskip: boolean
+  hasSidecar: boolean
+  menu: AgentMenuItem[]
+  skills: string[]
+  conversationalKnowledge?: Record<string, unknown>[]
+  customizations?: Record<string, unknown>
+  filePath: string
+}
+
+export type AgentListItem = {
+  id: string
+  name: string
+  title: string
+  icon?: string
+  role: string
+  module?: string
+  skillCount: number
+  hasOverrides: boolean
+}
+
+export type AgentDetail = Agent & {
+  overrides?: Record<string, unknown>
+  resolvedSkills?: string[]
+}

package/packages/shared/src/config.ts

@@ -0,0 +1,33 @@
+export type ProjectType = 'web-app' | 'mobile-app' | 'api' | 'game' | 'library' | 'other'
+
+export type ProjectLevel = 0 | 1 | 2 | 3 | 4
+
+export type ModuleConfig = {
+  [key: string]: unknown
+}
+
+export type ProjectConfig = {
+  projectName: string
+  projectType: ProjectType
+  projectLevel: ProjectLevel
+  modules: Record<string, ModuleConfig>
+}
+
+export type StudioSettings = {
+  port: number
+  theme: 'dark' | 'light'
+  customSettings?: Record<string, unknown>
+}
+
+export type ProjectStatus = {
+  detected: boolean
+  bmadVersion?: string
+  projectRoot?: string
+  modules: string[]
+  ideDirectories: string[]
+}
+
+export type AppInfo = {
+  name: string
+  version: string
+}

package/packages/shared/src/connections.ts

@@ -0,0 +1,28 @@
+export type ConnectionStatus = 'connected' | 'configured' | 'not-configured'
+
+export type DataSource = {
+  id: string
+  name: string
+  type: string
+  status: ConnectionStatus
+  config: Record<string, unknown>
+  lastSync: string | null
+  toolAvailable?: boolean
+}
+
+export type DataSourceListItem = {
+  id: string
+  name: string
+  type: string
+  status: ConnectionStatus
+  lastSync: string | null
+}
+
+export type DataSourceTemplate = {
+  id: string
+  name: string
+  type: string
+  description: string
+  requiredTool: string
+  configSchema: Record<string, unknown>
+}

package/packages/shared/src/errors.ts

@@ -0,0 +1,17 @@
+export type Severity = 'error' | 'warning'
+
+export type ErrorCode =
+  | 'NOT_FOUND'
+  | 'VALIDATION_ERROR'
+  | 'CONFLICT'
+  | 'FILE_SYSTEM_ERROR'
+  | 'INTERNAL_ERROR'
+
+export type ApiError = {
+  error: {
+    code: ErrorCode
+    message: string
+    details?: unknown
+    severity: Severity
+  }
+}

package/packages/shared/src/events.ts

@@ -0,0 +1,35 @@
+import type { FileCategory } from './files.js'
+
+export type FileChangedEvent = {
+  type: 'file:changed'
+  path: string
+  category: FileCategory
+}
+
+export type FileCreatedEvent = {
+  type: 'file:created'
+  path: string
+  category: FileCategory
+}
+
+export type FileDeletedEvent = {
+  type: 'file:deleted'
+  path: string
+  category: FileCategory
+}
+
+export type ProjectReloadedEvent = {
+  type: 'project:reloaded'
+}
+
+export type CompileNeededEvent = {
+  type: 'compile:needed'
+  agents: string[]
+}
+
+export type WebSocketEvent =
+  | FileChangedEvent
+  | FileCreatedEvent
+  | FileDeletedEvent
+  | ProjectReloadedEvent
+  | CompileNeededEvent

package/packages/shared/src/files.ts

@@ -0,0 +1,11 @@
+export type FileCategory = 'agent' | 'skill' | 'workflow' | 'config' | 'connection' | 'other'
+
+export type FileNode = {
+  name: string
+  path: string
+  type: 'file' | 'directory'
+  children?: FileNode[]
+  size?: number
+  modifiedAt?: string
+  category?: FileCategory
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,40 @@
+export type { Agent, AgentMenuItem, AgentListItem, AgentDetail } from './agents.js'
+export type { Skill, SkillListItem } from './skills.js'
+export type { Team, TeamMember, TeamListItem } from './teams.js'
+export type {
+  WorkflowType,
+  WorkflowTemplate,
+  WorkflowSubWorkflow,
+  Workflow,
+  WorkflowStep,
+  WorkflowListItem,
+} from './workflows.js'
+export type {
+  ConnectionStatus,
+  DataSource,
+  DataSourceListItem,
+  DataSourceTemplate,
+} from './connections.js'
+export type { Workspace, WorkspaceSection } from './workspace.js'
+export type { Package, PackageManifest, PackageConflict, PackageImportPreview } from './packages.js'
+export type { Output, Template, TemplateListItem } from './outputs.js'
+export type {
+  ProjectType,
+  ProjectLevel,
+  ModuleConfig,
+  ProjectConfig,
+  StudioSettings,
+  ProjectStatus,
+  AppInfo,
+} from './config.js'
+export type { FileCategory, FileNode } from './files.js'
+export type { ValidationIssue, ValidationResult } from './validation.js'
+export type {
+  FileChangedEvent,
+  FileCreatedEvent,
+  FileDeletedEvent,
+  ProjectReloadedEvent,
+  CompileNeededEvent,
+  WebSocketEvent,
+} from './events.js'
+export type { Severity, ErrorCode, ApiError } from './errors.js'

package/packages/shared/src/outputs.ts

@@ -0,0 +1,25 @@
+export type Output = {
+  path: string
+  name: string
+  type: string
+  size: number
+  modifiedAt: string
+}
+
+export type Template = {
+  id: string
+  name: string
+  description: string
+  source: 'shared' | 'project'
+  forkedFrom?: string
+  version?: string
+  content: string
+  filePath: string
+}
+
+export type TemplateListItem = {
+  id: string
+  name: string
+  description: string
+  source: 'shared' | 'project'
+}

package/packages/shared/src/packages.ts

@@ -0,0 +1,30 @@
+export type PackageManifest = {
+  name: string
+  description: string
+  version: string
+  platform?: string
+  agents: string[]
+  skills: string[]
+  workflows: string[]
+  templates: string[]
+  connections?: string[]
+  contextTemplate?: string
+}
+
+export type Package = PackageManifest & {
+  id: string
+  filePath: string
+}
+
+export type PackageConflict = {
+  path: string
+  type: 'overwrite' | 'merge' | 'skip'
+  localContent?: string
+  incomingContent?: string
+}
+
+export type PackageImportPreview = {
+  package: PackageManifest
+  conflicts: PackageConflict[]
+  newFiles: string[]
+}

package/packages/shared/src/skills.ts

@@ -0,0 +1,17 @@
+export type Skill = {
+  id: string
+  name: string
+  description: string
+  bestFor?: string[]
+  content: string
+  filePath: string
+  module?: string
+}
+
+export type SkillListItem = {
+  id: string
+  name: string
+  description: string
+  module?: string
+  bestFor?: string[]
+}

package/packages/shared/src/teams.ts

@@ -0,0 +1,33 @@
+export type TeamMember = {
+  agentId: string
+  displayName: string
+  title: string
+  icon: string
+  role: string
+  communicationStyle: string
+  identity: string
+  principles: string
+  module: string
+}
+
+export type Team = {
+  id: string
+  name: string
+  icon: string
+  description: string
+  agentIds: string[]
+  members: TeamMember[]
+  partyFile: string
+  filePath: string
+  module?: string
+}
+
+export type TeamListItem = {
+  id: string
+  name: string
+  icon: string
+  description: string
+  memberCount: number
+  agentIds: string[]
+  module?: string
+}