@minionry/minion 0.7.36

package/dist/server/services/plan/parser-core.js

@@ -0,0 +1,435 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+function stripQuotes(v) {
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+        return v.slice(1, -1);
+    }
+    return v;
+}
+function parseYamlValue(v) {
+    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;
+}
+function consumeIndentedList(lines, startIdx) {
+    const items = [];
+    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];
+}
+function consumeIndentedMap(lines, startIdx) {
+    const map = {};
+    let i = startIdx;
+    while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1]) && !/^\s+-\s/.test(lines[i + 1])) {
+        const t = lines[i + 1].trim();
+        const colon = t.indexOf(':');
+        if (colon === -1)
+            break;
+        i++;
+        const k = t.slice(0, colon).trim();
+        const v = t.slice(colon + 1).trim();
+        map[k] = parseYamlValue(v);
+    }
+    return [map, i];
+}
+function consumeEmptyValueBlock(lines, i) {
+    const next = lines[i + 1];
+    if (next && /^\s+-\s/.test(next)) {
+        const [items, newIdx] = consumeIndentedList(lines, i);
+        return [items.length > 0 ? items : null, newIdx];
+    }
+    if (next && /^\s+\S/.test(next) && next.includes(':')) {
+        const [map, newIdx] = consumeIndentedMap(lines, i);
+        return [Object.keys(map).length > 0 ? map : null, newIdx];
+    }
+    return [null, i];
+}
+export function parseFrontMatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) {
+        return { frontMatter: {}, body: content };
+    }
+    const frontMatter = {};
+    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 [value, newIdx] = consumeEmptyValueBlock(lines, i);
+            frontMatter[key] = value;
+            i = newIdx;
+        }
+        else {
+            frontMatter[key] = parseYamlValue(rawValue);
+        }
+    }
+    return { frontMatter, body: match[2] };
+}
+export function extractSections(body) {
+    const sections = new Map();
+    const lines = body.split('\n');
+    let currentSection = '';
+    let currentContent = [];
+    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;
+}
+export function parseCheckboxes(content) {
+    const items = [];
+    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;
+}
+const OUTPUT_HISTORY_LINE = /^-\s+(\S+)\s+—\s+\[([^\]]*)\]\(minionry:\/\/output\/([^)]+)\)\s+—\s+(done|failed)\s*$/;
+export function parseOutputHistory(content) {
+    const entries = [];
+    for (const line of content.split('\n')) {
+        const m = line.match(OUTPUT_HISTORY_LINE);
+        if (!m)
+            continue;
+        const [, timestamp, linkText, sessionId, status] = m;
+        const title = linkText !== sessionId ? linkText : undefined;
+        entries.push({ sessionId, title, timestamp, status: status });
+    }
+    return entries;
+}
+export function parseListItems(content) {
+    const items = [];
+    for (const line of content.split('\n')) {
+        const match = line.match(/^[-*]\s+(.+)$/);
+        if (match)
+            items.push(match[1].trim());
+    }
+    return items;
+}
+function parseIssueSummaries(content) {
+    const summaries = [];
+    for (const line of content.split('\n')) {
+        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;
+        }
+        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 parseCompletedSummaries(content) {
+    const summaries = [];
+    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: '' });
+        }
+    }
+    return summaries;
+}
+function parseWorkflows(section) {
+    if (!section)
+        return [];
+    const workflows = [];
+    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], description: match[3].trim() });
+        }
+    }
+    return workflows;
+}
+function parseTeams(section) {
+    if (!section)
+        return [];
+    const teams = [];
+    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;
+}
+function toStringArray(val) {
+    return Array.isArray(val) ? val.map(String) : [];
+}
+function optionalString(val) {
+    if (val == null)
+        return null;
+    const s = String(val);
+    return s === '' ? null : s;
+}
+function optionalNumber(val) {
+    return val != null ? Number(val) : null;
+}
+function optionalBool(val) {
+    if (val === true)
+        return true;
+    if (val === false)
+        return false;
+    return null;
+}
+function clampParallelAgents(val) {
+    if (val == null)
+        return 3;
+    const n = Number(val);
+    if (!Number.isFinite(n) || n < 1)
+        return 3;
+    return Math.min(Math.round(n), 10);
+}
+export const QUALITY_GATE_MODES = ['off', 'advise', 'block'];
+export const DEFAULT_QUALITY_GATE = 'advise';
+export function parseQualityGate(val) {
+    return QUALITY_GATE_MODES.includes(val) ? val : DEFAULT_QUALITY_GATE;
+}
+export function parseProjectConfig(content) {
+    const { frontMatter, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    const idPrefixes = {};
+    const rawPrefixes = frontMatter.id_prefixes;
+    if (rawPrefixes && typeof rawPrefixes === 'object') {
+        Object.assign(idPrefixes, rawPrefixes);
+    }
+    return {
+        name: String(frontMatter.name || ''),
+        id: String(frontMatter.id || ''),
+        created: String(frontMatter.created || ''),
+        status: frontMatter.status || 'active',
+        estimation: frontMatter.estimation || 'none',
+        idPrefixes,
+        workflows: parseWorkflows(sections.get('Workflows')),
+        labels: (Array.isArray(frontMatter.labels) ? frontMatter.labels : []),
+        teams: parseTeams(sections.get('Teams')),
+    };
+}
+export function parseProjectState(content) {
+    const { frontMatter, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    return {
+        project: String(frontMatter.project || ''),
+        currentSprint: frontMatter.current_sprint || null,
+        activeMilestone: frontMatter.active_milestone || null,
+        paused: frontMatter.paused === true,
+        lastSession: frontMatter.last_session || 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') || ''),
+    };
+}
+export function parseIssue(content, filePath) {
+    const { frontMatter: fm, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    return {
+        id: String(fm.id || ''),
+        title: String(fm.title || ''),
+        type: fm.type || 'issue',
+        status: String(fm.status || 'todo'),
+        priority: String(fm.priority || 'P2'),
+        estimate: fm.estimate != null ? fm.estimate : 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') || ''),
+        outputHistory: parseOutputHistory(sections.get('Output History') || ''),
+        reviewGate: (['none', 'auto', 'required'].includes(String(fm.review_gate)) ? String(fm.review_gate) : 'auto'),
+        outputType: (['code', 'document', 'auto'].includes(String(fm.output_type)) ? String(fm.output_type) : 'auto'),
+        outputFile: optionalString(fm.output_file),
+        agents: toStringArray(fm.agents),
+        engine: optionalString(fm.engine),
+        model: optionalString(fm.model),
+        effortLevel: optionalString(fm.effort_level),
+        fastMode: optionalBool(fm.fast_mode),
+        reviewModel: optionalString(fm.review_model),
+        body,
+        path: filePath,
+    };
+}
+function parseSprintIssues(section) {
+    if (!section)
+        return [];
+    const issues = [];
+    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] });
+        }
+    }
+    return issues;
+}
+export function parseSprint(content, filePath) {
+    const { frontMatter: fm, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    let issues = parseSprintIssues(sections.get('Issues'));
+    if (issues.length === 0 && Array.isArray(fm.issues)) {
+        issues = fm.issues.map(path => {
+            const id = path.replace(/^backlog\//, '').replace(/\.md$/, '');
+            return { id, path, title: '', points: null, status: '' };
+        });
+    }
+    let executionSummary = null;
+    if (fm.execution_summary && typeof fm.execution_summary === 'object') {
+        const es = fm.execution_summary;
+        executionSummary = {
+            totalIssues: Number(es.total_issues ?? 0),
+            completedIssues: Number(es.completed_issues ?? 0),
+            failedIssues: Number(es.failed_issues ?? 0),
+            totalDuration: Number(es.total_duration ?? 0),
+            waves: Number(es.waves ?? 0),
+        };
+    }
+    return {
+        id: String(fm.id || ''),
+        title: String(fm.title || ''),
+        status: fm.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,
+        completedAt: optionalString(fm.completed_at),
+        executionSummary,
+    };
+}
+export function parseMilestone(content, filePath) {
+    const { frontMatter, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    const epics = [];
+    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] });
+            }
+        }
+    }
+    return {
+        id: String(frontMatter.id || ''),
+        title: String(frontMatter.title || ''),
+        status: frontMatter.status || 'planned',
+        targetDate: frontMatter.target_date || null,
+        progress: frontMatter.progress || null,
+        definition: sections.get('Definition of Done') || '',
+        epics,
+        path: filePath,
+    };
+}
+export function parseBoard(content, filePath) {
+    const { frontMatter: fm, body } = parseFrontMatter(content);
+    const sections = extractSections(body);
+    let executionSummary = null;
+    if (fm.execution_summary && typeof fm.execution_summary === 'object') {
+        const es = fm.execution_summary;
+        executionSummary = {
+            totalIssues: Number(es.total_issues ?? 0),
+            completedIssues: Number(es.completed_issues ?? 0),
+            failedIssues: Number(es.failed_issues ?? 0),
+            totalDuration: Number(es.total_duration ?? 0),
+            waves: Number(es.waves ?? 0),
+        };
+    }
+    return {
+        id: String(fm.id || ''),
+        title: String(fm.title || ''),
+        status: fm.status || 'draft',
+        created: String(fm.created || ''),
+        completedAt: optionalString(fm.completed_at),
+        goal: String(fm.goal || sections.get('Goal') || ''),
+        executionSummary,
+        maxParallelAgents: clampParallelAgents(fm.max_parallel_agents),
+        qualityGate: parseQualityGate(fm.quality_gate),
+        autoImplement: fm.auto_implement === true,
+        path: filePath,
+    };
+}
+function parseWorktreeEntry(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const e = v;
+    const entry = {};
+    if (typeof e.path === 'string' && typeof e.branch === 'string') {
+        entry.path = e.path;
+        entry.branch = e.branch;
+    }
+    if (typeof e.repoPath === 'string')
+        entry.repoPath = e.repoPath;
+    return entry.path || entry.repoPath ? entry : null;
+}
+export function parseWorkspace(content) {
+    try {
+        const parsed = JSON.parse(content);
+        const boardWorktrees = {};
+        if (parsed.boardWorktrees && typeof parsed.boardWorktrees === 'object') {
+            for (const [k, v] of Object.entries(parsed.boardWorktrees)) {
+                const entry = parseWorktreeEntry(v);
+                if (entry)
+                    boardWorktrees[k] = entry;
+            }
+        }
+        return {
+            activeBoardId: typeof parsed.activeBoardId === 'string' ? parsed.activeBoardId : null,
+            boardOrder: Array.isArray(parsed.boardOrder) ? parsed.boardOrder.map(String) : [],
+            ...(Object.keys(boardWorktrees).length > 0 ? { boardWorktrees } : {}),
+        };
+    }
+    catch {
+        return { activeBoardId: null, boardOrder: [] };
+    }
+}

package/dist/server/services/plan/parser-migration.js

@@ -0,0 +1,108 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseFrontMatter } from './parser-core.js';
+export function isLegacyFormat(pmDir) {
+    return existsSync(join(pmDir, 'backlog')) && !existsSync(join(pmDir, 'boards'));
+}
+function readFileIfExists(path) {
+    try {
+        if (existsSync(path))
+            return readFileSync(path, 'utf-8');
+    }
+    catch {   }
+    return null;
+}
+function moveLegacyDir(srcDir, destDir) {
+    if (!existsSync(srcDir))
+        return;
+    for (const file of readdirSync(srcDir)) {
+        renameSync(join(srcDir, file), join(destDir, file));
+    }
+    rmSync(srcDir, { recursive: true });
+}
+function moveLegacyFile(src, dest) {
+    if (existsSync(src))
+        renameSync(src, dest);
+}
+function copySprintReviews(sprintsDir, boardReviewsDir) {
+    for (const entry of readdirSync(sprintsDir)) {
+        if (entry.endsWith('.md'))
+            continue;
+        const reviewsDir = join(sprintsDir, entry, 'reviews');
+        if (!existsSync(reviewsDir))
+            continue;
+        for (const reviewFile of readdirSync(reviewsDir)) {
+            cpSync(join(reviewsDir, reviewFile), join(boardReviewsDir, reviewFile));
+        }
+    }
+}
+function extractActiveSprintGoal(sprintsDir) {
+    for (const entry of readdirSync(sprintsDir).filter(e => e.endsWith('.md'))) {
+        const content = readFileIfExists(join(sprintsDir, entry));
+        if (!content)
+            continue;
+        const fm = parseFrontMatter(content).frontMatter;
+        if (fm.status === 'active')
+            return String(fm.goal || '');
+    }
+    return '';
+}
+function migrateLegacySprints(sprintsDir, boardReviewsDir) {
+    if (!existsSync(sprintsDir))
+        return '';
+    const goal = extractActiveSprintGoal(sprintsDir);
+    copySprintReviews(sprintsDir, boardReviewsDir);
+    return goal;
+}
+function cleanupMigratedIssues(boardBacklogDir) {
+    let hasActive = false;
+    for (const f of readdirSync(boardBacklogDir).filter(f => f.endsWith('.md'))) {
+        const content = readFileIfExists(join(boardBacklogDir, f));
+        if (!content)
+            continue;
+        const fm = parseFrontMatter(content).frontMatter;
+        const status = String(fm.status || 'todo');
+        if (status === 'done' || status === 'closed' || status === 'cancelled') {
+            rmSync(join(boardBacklogDir, f));
+        }
+        else if (status !== 'todo') {
+            hasActive = true;
+        }
+    }
+    return hasActive;
+}
+function writeBoardMetadata(pmDir, boardDir, boardId, sprintGoal, hasActive) {
+    const today = new Date().toISOString().split('T')[0];
+    const goal = sprintGoal || 'Migrated board';
+    writeFileSync(join(boardDir, 'board.md'), [
+        '---', `id: ${boardId}`, `title: Board 1`, `status: ${hasActive ? 'active' : 'draft'}`,
+        `created: ${today}`, `goal: ${goal}`, '---', '', `# Board 1`, '', `## Goal`, '', goal, '',
+    ].join('\n'));
+    const legacyState = readFileIfExists(join(pmDir, 'STATE.md'));
+    if (legacyState) {
+        writeFileSync(join(boardDir, 'STATE.md'), legacyState);
+    }
+    writeFileSync(join(pmDir, 'workspace.json'), JSON.stringify({
+        activeBoardId: boardId, boardOrder: [boardId],
+    }, null, 2));
+}
+export function migrateToBoards(pmDir) {
+    const boardId = 'BOARD-001';
+    const boardDir = join(pmDir, 'boards', boardId);
+    mkdirSync(join(boardDir, 'backlog'), { recursive: true });
+    mkdirSync(join(boardDir, 'reviews'), { recursive: true });
+    mkdirSync(join(boardDir, 'out'), { recursive: true });
+    moveLegacyDir(join(pmDir, 'backlog'), join(boardDir, 'backlog'));
+    moveLegacyFile(join(pmDir, 'progress.md'), join(boardDir, 'progress.md'));
+    const boardReviewsDir = join(boardDir, 'reviews');
+    const sprintGoal = migrateLegacySprints(join(pmDir, 'sprints'), boardReviewsDir);
+    const hasActive = cleanupMigratedIssues(join(boardDir, 'backlog'));
+    writeBoardMetadata(pmDir, boardDir, boardId, sprintGoal, hasActive);
+    for (const f of ['STATE.md']) {
+        const p = join(pmDir, f);
+        if (existsSync(p))
+            rmSync(p);
+    }
+}