mstro-app 0.4.2 → 0.4.4

package/server/services/plan/parser.ts

@@ -2,464 +2,190 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * PPS Parser — Parses .pm/ (or legacy .plan/) directory files into structured TypeScript objects.
+ * PPS Parser — Public API for reading .pm/ (or legacy .plan/) directories.
  *
- * Handles YAML front matter extraction and markdown body parsing.
+ * Entity parsing lives in parser-core.ts; migration in parser-migration.ts.
  */
 
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { parseBoard, parseIssue, parseMilestone, parseProjectConfig, parseProjectState, parseSprint, parseWorkspace } from './parser-core.js';
+import { isLegacyFormat, migrateToBoards } from './parser-migration.js';
 import type {
-  AcceptanceCriterion,
+  Board,
+  BoardArtifacts,
+  BoardFullState,
   Issue,
-  IssueSummary,
   Milestone,
-  MilestoneEpicSummary,
   PlanFullState,
   ProjectConfig,
   ProjectState,
+  ReviewResult,
   Sprint,
-  SprintIssueSummary,
-  Team,
-  WorkflowStatus,
+  SprintArtifacts,
+  Workspace,
 } from './types.js';
 
 // ============================================================================
-// Front Matter Extraction
+// Directory Resolution
 // ============================================================================
 
-interface ParsedFile {
-  frontMatter: Record<string, unknown>;
-  body: string;
+export function isBoardCentricFormat(pmDir: string): boolean {
+  return existsSync(join(pmDir, 'boards'));
 }
 
-function stripQuotes(v: string): string {
-  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
-    return v.slice(1, -1);
-  }
-  return v;
-}
-
-function parseYamlValue(v: string): unknown {
-  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
-    return v.slice(1, -1);
-  }
-  if (v.startsWith('[') && v.endsWith(']')) {
-    return v.slice(1, -1).split(',').map(s => stripQuotes(s.trim())).filter(Boolean);
-  }
-  if (v === 'true') return true;
-  if (v === 'false') return false;
-  if (v === 'null' || v === '~' || v === '') return null;
-  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
-  return v;
+export function resolvePmDir(workingDir: string): string | null {
+  const mstroPmDir = join(workingDir, '.mstro', 'pm');
+  if (existsSync(mstroPmDir)) return mstroPmDir;
+  const legacyPmDir = join(workingDir, '.pm');
+  if (existsSync(legacyPmDir)) return legacyPmDir;
+  const legacyPlanDir = join(workingDir, '.plan');
+  if (existsSync(legacyPlanDir)) return legacyPlanDir;
+  return null;
 }
 
-/** Consume indented YAML list items starting after the current index. Returns [items, newIndex]. */
-function consumeIndentedList(lines: string[], startIdx: number): [string[], number] {
-  const items: string[] = [];
-  let i = startIdx;
-  while (i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1])) {
-    i++;
-    const item = lines[i].trim().replace(/^-\s+/, '');
-    items.push(stripQuotes(item));
-  }
-  return [items, i];
+export function defaultPmDir(workingDir: string): string {
+  return join(workingDir, '.mstro', 'pm');
 }
 
-function parseFrontMatter(content: string): ParsedFile {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) {
-    return { frontMatter: {}, body: content };
-  }
-  const frontMatter: Record<string, unknown> = {};
-  const lines = match[1].split('\n');
-
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const colonIdx = trimmed.indexOf(':');
-    if (colonIdx === -1) continue;
-
-    const key = trimmed.slice(0, colonIdx).trim();
-    const rawValue = trimmed.slice(colonIdx + 1).trim();
-
-    if (!rawValue) {
-      const [items, newIdx] = consumeIndentedList(lines, i);
-      i = newIdx;
-      frontMatter[key] = items.length > 0 ? items : null;
-    } else {
-      frontMatter[key] = parseYamlValue(rawValue);
-    }
-  }
-
-  return { frontMatter, body: match[2] };
+export function planDirExists(workingDir: string): boolean {
+  return resolvePmDir(workingDir) !== null;
 }
 
 // ============================================================================
-// Section Extraction
+// File Utilities
 // ============================================================================
 
-function extractSections(body: string): Map<string, string> {
-  const sections = new Map<string, string>();
-  const lines = body.split('\n');
-  let currentSection = '';
-  let currentContent: string[] = [];
-
-  for (const line of lines) {
-    if (line.startsWith('## ')) {
-      if (currentSection) {
-        sections.set(currentSection, currentContent.join('\n').trim());
-      }
-      currentSection = line.slice(3).trim();
-      currentContent = [];
-    } else {
-      currentContent.push(line);
-    }
-  }
-  if (currentSection) {
-    sections.set(currentSection, currentContent.join('\n').trim());
-  }
-
-  return sections;
-}
-
-function parseCheckboxes(content: string): AcceptanceCriterion[] {
-  const items: AcceptanceCriterion[] = [];
-  for (const line of content.split('\n')) {
-    const match = line.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
-    if (match) {
-      items.push({ text: match[2].trim(), checked: match[1] !== ' ' });
-    }
-  }
-  return items;
+function readFileIfExists(path: string): string | null {
+  try {
+    if (existsSync(path)) return readFileSync(path, 'utf-8');
+  } catch { /* skip */ }
+  return null;
 }
 
-function parseListItems(content: string): string[] {
-  const items: string[] = [];
-  for (const line of content.split('\n')) {
-    const match = line.match(/^[-*]\s+(.+)$/);
-    if (match) items.push(match[1].trim());
-  }
-  return items;
+function readMdFilesInDir(dirPath: string): Array<{ name: string; content: string }> {
+  if (!existsSync(dirPath)) return [];
+  try {
+    return readdirSync(dirPath)
+      .filter(f => f.endsWith('.md'))
+      .map(name => ({ name, content: readFileSync(join(dirPath, name), 'utf-8') }));
+  } catch { return []; }
 }
 
-function parseIssueSummaries(content: string): IssueSummary[] {
-  const summaries: IssueSummary[] = [];
-  for (const line of content.split('\n')) {
-    // Match: 1. [IS-003](backlog/IS-003.md) — Title (P1)
-    const match = line.match(/\d+\.\s+\[([^\]]+)\]\(([^)]+)\)\s*[—–-]\s*(.+?)(?:\s*\((\w+)\))?\s*$/);
-    if (match) {
-      summaries.push({
-        id: match[1],
-        path: match[2],
-        title: match[3].trim(),
-        priority: match[4] || '',
-      });
-      continue;
-    }
-    // Match: - [IS-001](backlog/IS-001.md) — Title
-    const match2 = line.match(/^[-*]\s+\[([^\]]+)\]\(([^)]+)\)\s*[—–-]\s*(.+?)(?:\s*[→→]\s*blocked by\s+\[([^\]]+)\])?\s*$/i);
-    if (match2) {
-      summaries.push({
-        id: match2[1],
-        path: match2[2],
-        title: match2[3].trim(),
-        priority: '',
-        blockedBy: match2[4] || undefined,
-      });
-    }
-  }
-  return summaries;
+function listDirFiles(dirPath: string, ext: string): string[] {
+  if (!existsSync(dirPath)) return [];
+  try {
+    return readdirSync(dirPath).filter(f => f.endsWith(ext));
+  } catch { return []; }
 }
 
-function parseCompletedSummaries(content: string): IssueSummary[] {
-  const summaries: IssueSummary[] = [];
-  for (const line of content.split('\n')) {
-    const match = line.match(/^[-*]\s+\[([^\]]+)\]\(([^)]+)\)\s*[—–-]\s*(.+?)(?:\s*✓)?\s*$/);
-    if (match) {
-      summaries.push({
-        id: match[1],
-        path: match[2],
-        title: match[3].trim(),
-        priority: '',
-      });
-    }
+function readReviewResults(reviewsDir: string): ReviewResult[] {
+  const results: ReviewResult[] = [];
+  for (const f of listDirFiles(reviewsDir, '.json')) {
+    const content = readFileIfExists(join(reviewsDir, f));
+    if (content) results.push(JSON.parse(content) as ReviewResult);
   }
-  return summaries;
+  return results;
 }
 
 // ============================================================================
-// Entity Parsers
+// Defaults
 // ============================================================================
 
-function parseWorkflows(section: string | undefined): WorkflowStatus[] {
-  if (!section) return [];
-  const workflows: WorkflowStatus[] = [];
-  for (const line of section.split('\n')) {
-    const match = line.match(/\|\s*(\w+)\s*\|\s*(\w+)\s*\|\s*(.+?)\s*\|/);
-    if (match && match[1] !== 'Status') {
-      workflows.push({
-        status: match[1],
-        category: match[2] as WorkflowStatus['category'],
-        description: match[3].trim(),
-      });
-    }
-  }
-  return workflows;
-}
-
-function parseTeams(section: string | undefined): Team[] {
-  if (!section) return [];
-  const teams: Team[] = [];
-  for (const line of section.split('\n')) {
-    const match = line.match(/^[-*]\s+(\w+)(?:\s*[—–-]\s*(.+))?$/);
-    if (match) teams.push({ name: match[1], description: match[2]?.trim() });
-  }
-  return teams;
-}
+const defaultProject: ProjectConfig = {
+  name: '', id: '', created: '', status: 'active', estimation: 'none',
+  idPrefixes: {}, workflows: [], labels: [], teams: [],
+};
 
-function parseProjectConfig(content: string): ProjectConfig {
-  const { frontMatter, body } = parseFrontMatter(content);
-  const sections = extractSections(body);
+const defaultState: ProjectState = {
+  project: '', currentSprint: null, activeMilestone: null, paused: false,
+  lastSession: null, readyToWork: [], inProgress: [], blocked: [],
+  recentlyCompleted: [], warnings: [],
+};
 
-  const idPrefixes: Record<string, string> = {};
-  const rawPrefixes = frontMatter.id_prefixes;
-  if (rawPrefixes && typeof rawPrefixes === 'object') {
-    Object.assign(idPrefixes, rawPrefixes);
-  }
+// ============================================================================
+// Board & Plan Directory Parsing
+// ============================================================================
 
-  return {
-    name: String(frontMatter.name || ''),
-    id: String(frontMatter.id || ''),
-    created: String(frontMatter.created || ''),
-    status: (frontMatter.status as ProjectConfig['status']) || 'active',
-    estimation: (frontMatter.estimation as ProjectConfig['estimation']) || 'none',
-    idPrefixes,
-    workflows: parseWorkflows(sections.get('Workflows')),
-    labels: (Array.isArray(frontMatter.labels) ? frontMatter.labels : []) as string[],
-    teams: parseTeams(sections.get('Teams')),
-  };
-}
+export function parseBoardDirectory(pmDir: string, boardId: string): BoardFullState | null {
+  const boardDir = join(pmDir, 'boards', boardId);
+  if (!existsSync(boardDir)) return null;
 
-function parseProjectState(content: string): ProjectState {
-  const { frontMatter, body } = parseFrontMatter(content);
-  const sections = extractSections(body);
+  const boardContent = readFileIfExists(join(boardDir, 'board.md'));
+  if (!boardContent) return null;
+  const board = parseBoard(boardContent, `boards/${boardId}/board.md`);
 
-  return {
-    project: String(frontMatter.project || ''),
-    currentSprint: (frontMatter.current_sprint as string) || null,
-    activeMilestone: (frontMatter.active_milestone as string) || null,
-    paused: frontMatter.paused === true,
-    lastSession: (frontMatter.last_session as string) || null,
-    readyToWork: parseIssueSummaries(sections.get('Ready to Work') || ''),
-    inProgress: parseIssueSummaries(sections.get('In Progress') || ''),
-    blocked: parseIssueSummaries(sections.get('Blocked') || ''),
-    recentlyCompleted: parseCompletedSummaries(sections.get('Recently Completed') || ''),
-    warnings: parseListItems(sections.get('Warnings') || ''),
-  };
-}
+  const stateContent = readFileIfExists(join(boardDir, 'STATE.md'));
+  const state = stateContent ? parseProjectState(stateContent) : { ...defaultState };
 
-function toStringArray(val: unknown): string[] {
-  return Array.isArray(val) ? val.map(String) : [];
-}
+  const issueFiles = readMdFilesInDir(join(boardDir, 'backlog'));
+  const boardPrefix = `boards/${boardId}/`;
+  const issues = issueFiles.map(f => {
+    const issue = parseIssue(f.content, `${boardPrefix}backlog/${f.name}`);
+    issue.blockedBy = issue.blockedBy.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
+    issue.blocks = issue.blocks.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
+    if (issue.epic && !issue.epic.startsWith('boards/')) issue.epic = `${boardPrefix}${issue.epic}`;
+    return issue;
+  });
 
-function optionalString(val: unknown): string | null {
-  if (val == null) return null;
-  const s = String(val);
-  return s === '' ? null : s;
+  return { board, state, issues };
 }
 
-function parseIssue(content: string, filePath: string): Issue {
-  const { frontMatter: fm, body } = parseFrontMatter(content);
-  const sections = extractSections(body);
-
-  return {
-    id: String(fm.id || ''),
-    title: String(fm.title || ''),
-    type: (fm.type as Issue['type']) || 'issue',
-    status: String(fm.status || 'backlog'),
-    priority: String(fm.priority || 'P2'),
-    estimate: fm.estimate != null ? fm.estimate as number | string : null,
-    labels: toStringArray(fm.labels),
-    epic: optionalString(fm.epic),
-    sprint: optionalString(fm.sprint),
-    milestone: optionalString(fm.milestone),
-    assigned: optionalString(fm.assigned),
-    created: String(fm.created || ''),
-    updated: optionalString(fm.updated),
-    due: optionalString(fm.due),
-    blockedBy: toStringArray(fm.blocked_by),
-    blocks: toStringArray(fm.blocks),
-    relatesTo: toStringArray(fm.relates_to),
-    children: toStringArray(fm.children),
-    progress: optionalString(fm.progress),
-    description: sections.get('Description') || '',
-    acceptanceCriteria: parseCheckboxes(sections.get('Acceptance Criteria') || ''),
-    technicalNotes: sections.get('Technical Notes') || null,
-    filesToModify: parseListItems(sections.get('Files to Modify') || ''),
-    activity: parseListItems(sections.get('Activity') || ''),
-    outputFile: optionalString(fm.output_file),
-    body,
-    path: filePath,
-  };
-}
-
-function parseSprintIssues(section: string | undefined): SprintIssueSummary[] {
-  if (!section) return [];
-  const issues: SprintIssueSummary[] = [];
-  for (const line of section.split('\n')) {
-    const match = line.match(/\|\s*\[([^\]]+)\]\(([^)]+)\)\s*\|\s*(.+?)\s*\|\s*(\S+)\s*\|\s*(\S+)\s*\|/);
-    if (match) {
-      issues.push({
-        id: match[1],
-        path: match[2],
-        title: match[3].trim(),
-        points: /^\d+$/.test(match[4]) ? Number(match[4]) : match[4],
-        status: match[5],
-      });
+function parseBoardCentricState(planDir: string): { boards: Board[]; workspace: Workspace; activeBoard: BoardFullState | null } {
+  const workspaceContent = readFileIfExists(join(planDir, 'workspace.json'));
+  const workspace = workspaceContent ? parseWorkspace(workspaceContent) : { activeBoardId: null, boardOrder: [] };
+
+  const boards: Board[] = [];
+  const boardsDir = join(planDir, 'boards');
+  if (existsSync(boardsDir)) {
+    for (const entry of readdirSync(boardsDir)) {
+      const boardMdPath = join(boardsDir, entry, 'board.md');
+      if (!existsSync(boardMdPath)) continue;
+      boards.push(parseBoard(readFileSync(boardMdPath, 'utf-8'), `boards/${entry}/board.md`));
     }
   }
-  return issues;
-}
 
-function optionalNumber(val: unknown): number | null {
-  return val != null ? Number(val) : null;
-}
+  const orderMap = new Map(workspace.boardOrder.map((id, i) => [id, i]));
+  boards.sort((a, b) => (orderMap.get(a.id) ?? 999) - (orderMap.get(b.id) ?? 999));
 
-function parseSprint(content: string, filePath: string): Sprint {
-  const { frontMatter: fm, body } = parseFrontMatter(content);
-  const sections = extractSections(body);
+  const activeBoard = workspace.activeBoardId ? parseBoardDirectory(planDir, workspace.activeBoardId) : null;
+  return { boards, workspace, activeBoard };
+}
 
-  // Table-based parsing (markdown links in table rows)
-  let issues = parseSprintIssues(sections.get('Issues'));
+export function parsePlanDirectory(workingDir: string): PlanFullState | null {
+  const planDir = resolvePmDir(workingDir);
+  if (!planDir) return null;
 
-  // Fallback: front matter issues array (e.g., ["backlog/IS-001.md", ...])
-  if (issues.length === 0 && Array.isArray(fm.issues)) {
-    issues = (fm.issues as string[]).map(path => {
-      const id = path.replace(/^backlog\//, '').replace(/\.md$/, '');
-      return { id, path, title: '', points: null, status: '' };
-    });
-  }
+  if (isLegacyFormat(planDir)) migrateToBoards(planDir);
 
-  return {
-    id: String(fm.id || ''),
-    title: String(fm.title || ''),
-    status: (fm.status as Sprint['status']) || 'planned',
-    start: String(fm.start || fm.start_date || ''),
-    end: String(fm.end || fm.end_date || ''),
-    goal: String(fm.goal || sections.get('Goal') || sections.get('Sprint Goal') || ''),
-    capacity: optionalNumber(fm.capacity),
-    committed: optionalNumber(fm.committed),
-    completed: optionalNumber(fm.completed),
-    issues,
-    path: filePath,
-  };
-}
+  const projectContent = readFileIfExists(join(planDir, 'project.md'));
+  const project = projectContent ? parseProjectConfig(projectContent) : { ...defaultProject };
+  const milestoneFiles = readMdFilesInDir(join(planDir, 'milestones'));
+  const milestones = milestoneFiles.map(f => parseMilestone(f.content, `milestones/${f.name}`));
 
-function parseMilestone(content: string, filePath: string): Milestone {
-  const { frontMatter, body } = parseFrontMatter(content);
-  const sections = extractSections(body);
-
-  const epics: MilestoneEpicSummary[] = [];
-  const epicSection = sections.get('Epics');
-  if (epicSection) {
-    for (const line of epicSection.split('\n')) {
-      const match = line.match(/\|\s*\[([^\]]+)\]\(([^)]+)\)\s*\|\s*(.+?)\s*\|\s*(\S+)\s*\|/);
-      if (match) {
-        epics.push({
-          id: match[1],
-          path: match[2],
-          title: match[3].trim(),
-          progress: match[4],
-        });
-      }
-    }
+  if (!isBoardCentricFormat(planDir)) {
+    return {
+      project, state: { ...defaultState }, boards: [], workspace: { activeBoardId: null, boardOrder: [] },
+      activeBoard: null, issues: [], sprints: [], milestones,
+    };
   }
 
+  const { boards, workspace, activeBoard } = parseBoardCentricState(planDir);
   return {
-    id: String(frontMatter.id || ''),
-    title: String(frontMatter.title || ''),
-    status: (frontMatter.status as Milestone['status']) || 'planned',
-    targetDate: (frontMatter.target_date as string) || null,
-    progress: (frontMatter.progress as string) || null,
-    definition: sections.get('Definition of Done') || '',
-    epics,
-    path: filePath,
+    project, state: activeBoard?.state ?? { ...defaultState },
+    boards, workspace, activeBoard, issues: activeBoard?.issues ?? [],
+    sprints: [], milestones,
   };
 }
 
 // ============================================================================
-// Directory Parser
+// Single Entity Parsers
 // ============================================================================
 
-/** Resolve the PM directory — prefers .pm/, falls back to legacy .plan/ */
-export function resolvePmDir(workingDir: string): string | null {
-  const pmDir = join(workingDir, '.pm');
-  if (existsSync(pmDir)) return pmDir;
-  const legacyDir = join(workingDir, '.plan');
-  if (existsSync(legacyDir)) return legacyDir;
-  return null;
-}
-
-export function planDirExists(workingDir: string): boolean {
-  return resolvePmDir(workingDir) !== null;
-}
-
-function readFileIfExists(path: string): string | null {
-  try {
-    if (existsSync(path)) return readFileSync(path, 'utf-8');
-  } catch { /* skip */ }
-  return null;
-}
-
-function readMdFilesInDir(dirPath: string): Array<{ name: string; content: string }> {
-  if (!existsSync(dirPath)) return [];
-  try {
-    return readdirSync(dirPath)
-      .filter(f => f.endsWith('.md'))
-      .map(name => {
-        const content = readFileSync(join(dirPath, name), 'utf-8');
-        return { name, content };
-      });
-  } catch { return []; }
-}
-
-export function parsePlanDirectory(workingDir: string): PlanFullState | null {
-  const planDir = resolvePmDir(workingDir);
-  if (!planDir) return null;
-
-  // Parse project.md
-  const projectContent = readFileIfExists(join(planDir, 'project.md'));
-  const project = projectContent
-    ? parseProjectConfig(projectContent)
-    : { name: '', id: '', created: '', status: 'active' as const, estimation: 'none' as const, idPrefixes: {}, workflows: [], labels: [], teams: [] };
-
-  // Parse STATE.md
-  const stateContent = readFileIfExists(join(planDir, 'STATE.md'));
-  const state = stateContent
-    ? parseProjectState(stateContent)
-    : { project: '', currentSprint: null, activeMilestone: null, paused: false, lastSession: null, readyToWork: [], inProgress: [], blocked: [], recentlyCompleted: [], warnings: [] };
-
-  // Parse backlog issues
-  const issueFiles = readMdFilesInDir(join(planDir, 'backlog'));
-  const issues = issueFiles.map(f => parseIssue(f.content, `backlog/${f.name}`));
-
-  // Parse sprints
-  const sprintFiles = readMdFilesInDir(join(planDir, 'sprints'));
-  const sprints = sprintFiles.map(f => parseSprint(f.content, `sprints/${f.name}`));
-
-  // Parse milestones
-  const milestoneFiles = readMdFilesInDir(join(planDir, 'milestones'));
-  const milestones = milestoneFiles.map(f => parseMilestone(f.content, `milestones/${f.name}`));
-
-  return { project, state, issues, sprints, milestones };
-}
-
 export function parseSingleIssue(workingDir: string, issuePath: string): Issue | null {
   const pmDir = resolvePmDir(workingDir);
   if (!pmDir) return null;
-  const fullPath = join(pmDir, issuePath);
-  const content = readFileIfExists(fullPath);
+  const content = readFileIfExists(join(pmDir, issuePath));
   if (!content) return null;
   return parseIssue(content, issuePath);
 }
@@ -467,8 +193,7 @@ export function parseSingleIssue(workingDir: string, issuePath: string): Issue |
 export function parseSingleSprint(workingDir: string, sprintPath: string): Sprint | null {
   const pmDir = resolvePmDir(workingDir);
   if (!pmDir) return null;
-  const fullPath = join(pmDir, sprintPath);
-  const content = readFileIfExists(fullPath);
+  const content = readFileIfExists(join(pmDir, sprintPath));
   if (!content) return null;
   return parseSprint(content, sprintPath);
 }
@@ -476,13 +201,15 @@ export function parseSingleSprint(workingDir: string, sprintPath: string): Sprin
 export function parseSingleMilestone(workingDir: string, milestonePath: string): Milestone | null {
   const pmDir = resolvePmDir(workingDir);
   if (!pmDir) return null;
-  const fullPath = join(pmDir, milestonePath);
-  const content = readFileIfExists(fullPath);
+  const content = readFileIfExists(join(pmDir, milestonePath));
   if (!content) return null;
   return parseMilestone(content, milestonePath);
 }
 
-/** Compute the next available ID for a given prefix (e.g., "IS" → "IS-004") */
+// ============================================================================
+// ID Generation
+// ============================================================================
+
 export function getNextId(issues: Issue[], prefix: string): string {
   const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const pattern = new RegExp(`^${escaped}-(\\d+)$`);
@@ -496,3 +223,70 @@ export function getNextId(issues: Issue[], prefix: string): string {
   }
   return `${prefix}-${String(max + 1).padStart(3, '0')}`;
 }
+
+export function getNextBoardId(boards: Board[]): string {
+  let max = 0;
+  for (const board of boards) {
+    const match = board.id.match(/^BOARD-(\d+)$/);
+    if (match) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return `BOARD-${String(max + 1).padStart(3, '0')}`;
+}
+
+export function getNextBoardNumber(boards: Board[]): number {
+  let max = 0;
+  for (const board of boards) {
+    const match = board.title.match(/^Board (\d+)$/);
+    if (match) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return max + 1;
+}
+
+export function parseBoardArtifacts(workingDir: string, boardId: string): BoardArtifacts | null {
+  const pmDir = resolvePmDir(workingDir);
+  if (!pmDir) return null;
+
+  const boardDir = join(pmDir, 'boards', boardId);
+  if (!existsSync(boardDir)) return null;
+
+  const progressLog = readFileIfExists(join(boardDir, 'progress.md')) ?? '';
+  const outputFiles = listDirFiles(join(boardDir, 'out'), '.md');
+  const reviewResults = readReviewResults(join(boardDir, 'reviews'));
+  const executionLogs = listDirFiles(join(boardDir, 'logs'), '.log').sort();
+
+  return { boardId, progressLog, outputFiles, reviewResults, executionLogs };
+}
+
+/** @deprecated Use getNextBoardId — kept for migration compatibility */
+export function getNextSprintId(sprints: Sprint[]): string {
+  let max = 0;
+  for (const sprint of sprints) {
+    const match = sprint.id.match(/^SPRINT-(\d+)$/);
+    if (match) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return `SPRINT-${String(max + 1).padStart(3, '0')}`;
+}
+
+/** @deprecated Use parseBoardArtifacts — kept for migration compatibility */
+export function parseSprintArtifacts(workingDir: string, sprintId: string): SprintArtifacts | null {
+  const pmDir = resolvePmDir(workingDir);
+  if (!pmDir) return null;
+
+  const sandboxDir = join(pmDir, 'sprints', sprintId);
+  if (!existsSync(sandboxDir)) return null;
+
+  const progressLog = readFileIfExists(join(sandboxDir, 'progress.md')) ?? '';
+  const outputFiles = listDirFiles(join(sandboxDir, 'out'), '.md');
+  const reviewResults = readReviewResults(join(sandboxDir, 'reviews'));
+
+  return { sprintId, progressLog, outputFiles, reviewResults };
+}