gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/migrate/parsers.js

@@ -0,0 +1,477 @@
+// Old .planning format per-file parsers
+// Pure functions that take file content (string) and return typed data.
+// Zero Pi dependencies — uses only exported helpers from files.ts.
+import { splitFrontmatter, parseFrontmatterMap, extractBoldField } from '../files.js';
+import { normalizeStringArray } from '../../shared/mod.js';
+// Re-export PlanningProjectMeta — not in types.ts yet, use string for project field
+// Actually PlanningProjectMeta isn't in types.ts — project is stored as string | null.
+// We'll keep parseOldProject returning a simple shape.
+// ─── XML-in-Markdown Extraction ────────────────────────────────────────────
+/**
+ * Extract content between XML-like tags in markdown.
+ * NOT a real XML parser — handles `<tag>content</tag>` with markdown inside.
+ */
+function extractXmlTag(content, tagName) {
+    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, 'i');
+    const match = regex.exec(content);
+    return match ? match[1].trim() : '';
+}
+/**
+ * Extract all nested `<task>` entries from within a `<tasks>` block.
+ */
+function extractTasks(content) {
+    const tasksBlock = extractXmlTag(content, 'tasks');
+    if (!tasksBlock)
+        return [];
+    const tasks = [];
+    const regex = /<task>([\s\S]*?)<\/task>/gi;
+    let match;
+    while ((match = regex.exec(tasksBlock)) !== null) {
+        const trimmed = match[1].trim();
+        if (trimmed)
+            tasks.push(trimmed);
+    }
+    return tasks;
+}
+// ─── Roadmap Parser ────────────────────────────────────────────────────────
+/** Parse a checkbox phase entry line: `- [x] 29 — Auth System` */
+function parsePhaseEntry(line) {
+    // Strip bold markers (**) for uniform matching — old roadmaps often bold phase entries
+    const stripped = line.replace(/\*\*/g, '');
+    // Format 1: - [x] Phase 25: Title (N/N plans) -- completed ...
+    // Also handles: - [x] Phase 25: Title - Description (completed ...)
+    const fmtPhaseColon = stripped.match(/^-\s+\[([ xX])\]\s+(?:Phase\s+)?(\d+(?:\.\d+)?)\s*:\s*(.+)$/);
+    if (fmtPhaseColon) {
+        let title = fmtPhaseColon[3].trim();
+        // Strip trailing parentheticals, plan counts, and completion notes
+        title = title.replace(/\s*\(\d+\/\d+\s+plans?\)/, '')
+            .replace(/\s*--\s+.*$/, '')
+            .replace(/\s*-\s+.*$/, '') // strip "- description" suffix
+            .replace(/\s*\(completed.*\)$/i, '')
+            .replace(/\s*\(shipped.*\)$/i, '')
+            .trim();
+        return {
+            number: parseFloat(fmtPhaseColon[2]),
+            title,
+            done: fmtPhaseColon[1].toLowerCase() === 'x',
+            raw: line,
+        };
+    }
+    // Format 2: - [x] 25 — Title (em-dash/en-dash only — NOT plain hyphen to avoid plan file refs)
+    const fmtDash = stripped.match(/^-\s+\[([ xX])\]\s+(?:Phase\s+)?(\d+(?:\.\d+)?)\s*[—–]\s*(.+)$/);
+    if (fmtDash) {
+        let title = fmtDash[3].trim();
+        title = title.replace(/\s*\(\d+\/\d+\s+plans?\)/, '')
+            .replace(/\s*--\s+.*$/, '')
+            .trim();
+        return {
+            number: parseFloat(fmtDash[2]),
+            title,
+            done: fmtDash[1].toLowerCase() === 'x',
+            raw: line,
+        };
+    }
+    return null;
+}
+/**
+ * Parse old-format ROADMAP.md.
+ * Handles two formats:
+ * 1. Flat phase lists — checkbox lines under a single Phases heading
+ * 2. Milestone-sectioned — `## v2.0 — Title` headings with optional `<details>` blocks
+ * 3. Details-sectioned — `<details><summary>v1.0 Title (Phases N-M)</summary>` blocks with phase checkboxes inside
+ */
+export function parseOldRoadmap(content) {
+    const result = {
+        raw: content,
+        milestones: [],
+        phases: [],
+    };
+    const lines = content.split('\n');
+    // ─── Strategy 1: Detect <details><summary>vN.N Title</summary> blocks ───
+    // This handles the format where milestones are <details> blocks containing phase checkboxes
+    const detailsMilestones = parseDetailsBlockMilestones(lines);
+    if (detailsMilestones.length > 0) {
+        result.milestones = detailsMilestones;
+        // Also check for non-collapsed milestone sections (### v3.0 Title)
+        // that follow the <details> blocks
+        for (let i = 0; i < lines.length; i++) {
+            const heading = lines[i].match(/^###\s+(v[\d.]+)\s+(.+?)(?:\s*\(.*\))?\s*$/);
+            if (heading) {
+                // Already captured as a details block?
+                const id = heading[1];
+                if (result.milestones.some(m => m.id === id))
+                    continue;
+                // Collect phase entries until next ## or ### heading
+                const phases = [];
+                for (let j = i + 1; j < lines.length; j++) {
+                    if (/^##?\s/.test(lines[j]) || /^###\s/.test(lines[j]))
+                        break;
+                    const entry = parsePhaseEntry(lines[j].trim());
+                    if (entry)
+                        phases.push(entry);
+                }
+                result.milestones.push({
+                    id,
+                    title: heading[2].trim(),
+                    collapsed: false,
+                    phases,
+                });
+            }
+        }
+        return result;
+    }
+    // ─── Strategy 2: Detect ## heading-sectioned milestones ───
+    const milestoneHeadingRegex = /^##\s+(.+)$/;
+    const milestoneHeadings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(milestoneHeadingRegex);
+        if (match) {
+            const heading = match[1].trim();
+            // Skip generic headings like "## Phases", "## Milestones", "## Phase Details", "## Progress"
+            if (/^(phases?|milestones?|phase\s+details?|progress)$/i.test(heading))
+                continue;
+            // Extract milestone ID (e.g. "v2.0" from "v2.0 — Foundation")
+            const idMatch = heading.match(/^(v[\d.]+|[\w.-]+)\s*[—–-]\s*(.+)$/);
+            if (idMatch) {
+                milestoneHeadings.push({ index: i, id: idMatch[1], title: idMatch[2].trim() });
+            }
+        }
+    }
+    if (milestoneHeadings.length > 0) {
+        // Milestone-sectioned format
+        for (let m = 0; m < milestoneHeadings.length; m++) {
+            const startIdx = milestoneHeadings[m].index + 1;
+            const endIdx = m + 1 < milestoneHeadings.length ? milestoneHeadings[m + 1].index : lines.length;
+            const sectionLines = lines.slice(startIdx, endIdx);
+            const milestone = {
+                id: milestoneHeadings[m].id,
+                title: milestoneHeadings[m].title,
+                collapsed: false,
+                phases: [],
+            };
+            // Check for <details> block
+            const sectionText = sectionLines.join('\n');
+            if (sectionText.includes('<details>')) {
+                milestone.collapsed = true;
+            }
+            // Extract phase entries from the section (including inside <details>)
+            for (const line of sectionLines) {
+                const entry = parsePhaseEntry(line.trim());
+                if (entry) {
+                    milestone.phases.push(entry);
+                }
+            }
+            result.milestones.push(milestone);
+        }
+    }
+    else {
+        // ─── Strategy 3: Flat format — just extract all phase checkbox lines ───
+        for (const line of lines) {
+            const entry = parsePhaseEntry(line.trim());
+            if (entry) {
+                result.phases.push(entry);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Parse <details><summary>vN.N Title (Phases N-M)</summary>...</details> blocks.
+ * Each block becomes a milestone with the phase entries inside it.
+ */
+function parseDetailsBlockMilestones(lines) {
+    const milestones = [];
+    let inDetails = false;
+    let currentMilestone = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '<details>') {
+            inDetails = true;
+            continue;
+        }
+        if (inDetails && !currentMilestone) {
+            // Look for <summary>vN.N Title (Phases N-M) -- STATUS</summary>
+            const summaryMatch = trimmed.match(/<summary>\s*(v[\d.]+)\s+(.+?)\s*(?:\(.*\))?\s*(?:--\s*.*)?\s*<\/summary>/);
+            if (summaryMatch) {
+                currentMilestone = {
+                    id: summaryMatch[1],
+                    title: summaryMatch[2].trim(),
+                    collapsed: true,
+                    phases: [],
+                };
+            }
+            continue;
+        }
+        if (trimmed === '</details>') {
+            if (currentMilestone) {
+                milestones.push(currentMilestone);
+                currentMilestone = null;
+            }
+            inDetails = false;
+            continue;
+        }
+        if (currentMilestone) {
+            const entry = parsePhaseEntry(trimmed);
+            if (entry) {
+                currentMilestone.phases.push(entry);
+            }
+        }
+    }
+    return milestones;
+}
+// ─── Plan Parser (XML-in-Markdown) ─────────────────────────────────────────
+/** Strip surrounding quotes from YAML string values */
+function unquote(val) {
+    const s = String(val ?? '');
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+/**
+ * Parse the must_haves nested structure from frontmatter lines directly.
+ * parseFrontmatterMap doesn't handle 3-level nesting well, so we re-parse.
+ */
+function parseMustHavesFromLines(fmLines) {
+    const start = fmLines.findIndex(l => /^must_haves\s*:/.test(l));
+    if (start === -1)
+        return null;
+    const truths = [];
+    const artifacts = [];
+    const keyLinks = [];
+    let currentList = null;
+    for (let i = start + 1; i < fmLines.length; i++) {
+        const line = fmLines[i];
+        // New top-level key — stop
+        if (/^\w/.test(line))
+            break;
+        // Sub-key at 2-space indent
+        const subKey = line.match(/^  (\w[\w_]*):/);
+        if (subKey) {
+            const key = subKey[1];
+            if (key === 'truths')
+                currentList = truths;
+            else if (key === 'artifacts')
+                currentList = artifacts;
+            else if (key === 'key_links')
+                currentList = keyLinks;
+            else
+                currentList = null;
+            // Check for inline empty array
+            if (/:\s*\[\]/.test(line))
+                currentList = null;
+            continue;
+        }
+        // Array item at 4-space indent
+        const item = line.match(/^    - (.+)$/);
+        if (item && currentList) {
+            currentList.push(item[1].trim());
+        }
+    }
+    if (truths.length === 0 && artifacts.length === 0 && keyLinks.length === 0)
+        return null;
+    return { truths, artifacts, key_links: keyLinks };
+}
+function parsePlanFrontmatter(fm, fmLines) {
+    const mustHaves = fmLines ? parseMustHavesFromLines(fmLines) : null;
+    return {
+        phase: unquote(fm.phase),
+        plan: unquote(fm.plan),
+        type: unquote(fm.type),
+        wave: fm.wave !== undefined ? Number(fm.wave) : null,
+        depends_on: Array.isArray(fm.depends_on) ? fm.depends_on.map(s => unquote(s)) : [],
+        files_modified: Array.isArray(fm.files_modified) ? fm.files_modified.map(s => unquote(s)) : [],
+        autonomous: fm.autonomous === 'true' || fm.autonomous === true,
+        must_haves: mustHaves,
+    };
+}
+/**
+ * Parse old-format plan file with YAML frontmatter and XML-in-markdown sections.
+ * Falls back to plain markdown for quick-task plans that lack XML tags.
+ */
+export function parseOldPlan(content, fileName = '', planNumber = '') {
+    const [fmLines, body] = splitFrontmatter(content);
+    const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
+    const frontmatter = parsePlanFrontmatter(fm, fmLines);
+    // Extract XML-in-markdown sections
+    const objective = extractXmlTag(content, 'objective');
+    const tasks = extractTasks(content);
+    const context = extractXmlTag(content, 'context');
+    const verification = extractXmlTag(content, 'verification');
+    const successCriteria = extractXmlTag(content, 'success_criteria');
+    return {
+        fileName,
+        planNumber: planNumber || String(fm.plan ?? ''),
+        frontmatter,
+        objective,
+        tasks,
+        context,
+        verification,
+        successCriteria,
+        raw: content,
+    };
+}
+// ─── Summary Parser (YAML Frontmatter) ─────────────────────────────────────
+function parseRequiresArray(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map(item => {
+        if (typeof item === 'object' && item !== null) {
+            const obj = item;
+            return { phase: obj.phase ?? '', provides: obj.provides ?? '' };
+        }
+        return { phase: '', provides: String(item) };
+    });
+}
+// parseFrontmatterMap from shared now supports hyphenated keys natively
+function parseSummaryFrontmatter(fm) {
+    return {
+        phase: unquote(fm.phase),
+        plan: unquote(fm.plan),
+        subsystem: unquote(fm.subsystem),
+        tags: normalizeStringArray(fm.tags),
+        requires: parseRequiresArray(fm.requires),
+        provides: normalizeStringArray(fm.provides),
+        affects: normalizeStringArray(fm.affects),
+        'tech-stack': normalizeStringArray(fm['tech-stack']),
+        'key-files': normalizeStringArray(fm['key-files']),
+        'key-decisions': normalizeStringArray(fm['key-decisions']),
+        'patterns-established': normalizeStringArray(fm['patterns-established']),
+        duration: unquote(fm.duration),
+        completed: unquote(fm.completed),
+    };
+}
+/**
+ * Parse old-format summary file with YAML frontmatter.
+ */
+export function parseOldSummary(content, fileName = '', planNumber = '') {
+    const [fmLines, body] = splitFrontmatter(content);
+    const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
+    return {
+        fileName,
+        planNumber: planNumber || String(fm.plan ?? ''),
+        frontmatter: parseSummaryFrontmatter(fm),
+        body,
+        raw: content,
+    };
+}
+// ─── Requirements Parser ───────────────────────────────────────────────────
+/**
+ * Parse old-format REQUIREMENTS.md.
+ * Extracts requirement entries from markdown with status sections and requirement headings.
+ */
+export function parseOldRequirements(content) {
+    const requirements = [];
+    const lines = content.split('\n');
+    let currentStatus = '';
+    let currentReq = null;
+    let currentRaw = [];
+    function flushReq() {
+        if (currentReq?.id && currentReq?.title) {
+            requirements.push({
+                id: currentReq.id,
+                title: currentReq.title,
+                status: currentReq.status || currentStatus || 'unknown',
+                description: currentReq.description || '',
+                raw: currentRaw.join('\n').trim(),
+            });
+        }
+        currentReq = null;
+        currentRaw = [];
+    }
+    for (const line of lines) {
+        // Status section heading (## Active, ## Validated, ## Deferred)
+        const statusMatch = line.match(/^##\s+(\w[\w\s&]*\w)\s*$/);
+        if (statusMatch) {
+            flushReq();
+            currentStatus = statusMatch[1].toLowerCase();
+            continue;
+        }
+        // Section heading (### Category Name) — use as context for bullet requirements
+        const sectionMatch = line.match(/^###\s+(.+)$/);
+        if (sectionMatch) {
+            // Check if this is a requirement heading (### R001 — Title)
+            const reqHeading = sectionMatch[1].match(/^(R\d+)\s*[—–-]\s*(.+)$/);
+            if (reqHeading) {
+                flushReq();
+                currentReq = { id: reqHeading[1], title: reqHeading[2].trim(), status: currentStatus, description: '' };
+                currentRaw.push(line);
+                continue;
+            }
+            // Otherwise just note the section — don't flush, could be a category for bullet reqs
+            flushReq();
+            continue;
+        }
+        // Bullet-format requirement: - [x] **ID**: Description
+        const bulletReqMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([^*]+)\*\*\s*:\s*(.+)$/);
+        if (bulletReqMatch) {
+            flushReq();
+            const done = bulletReqMatch[1].toLowerCase() === 'x';
+            const id = bulletReqMatch[2].trim();
+            const desc = bulletReqMatch[3].trim();
+            requirements.push({
+                id,
+                title: desc,
+                status: done ? 'complete' : (currentStatus || 'active'),
+                description: desc,
+                raw: line,
+            });
+            continue;
+        }
+        // Description or metadata within a requirement
+        if (currentReq) {
+            currentRaw.push(line);
+            const descMatch = line.match(/^-\s+Description:\s*(.+)$/);
+            if (descMatch) {
+                currentReq.description = descMatch[1].trim();
+                continue;
+            }
+            const statMatch = line.match(/^-\s+Status:\s*(.+)$/);
+            if (statMatch) {
+                currentReq.status = statMatch[1].trim();
+            }
+        }
+    }
+    flushReq();
+    return requirements;
+}
+// ─── Project Parser ────────────────────────────────────────────────────────
+// PlanningProjectMeta isn't in types.ts — project field on PlanningProject is `string | null`.
+// This parser returns the raw content as a string. The top-level parser stores it directly.
+/**
+ * Parse old-format PROJECT.md.
+ * Returns the raw content as a string (stored as project field on PlanningProject).
+ */
+export function parseOldProject(content) {
+    return content;
+}
+// ─── State Parser ──────────────────────────────────────────────────────────
+/**
+ * Parse old-format STATE.md.
+ * Extracts current phase and status from bold-field patterns.
+ */
+export function parseOldState(content) {
+    const currentPhase = extractBoldField(content, 'Current Phase');
+    const status = extractBoldField(content, 'Status');
+    return {
+        raw: content,
+        currentPhase,
+        status,
+    };
+}
+// ─── Config Parser ─────────────────────────────────────────────────────────
+/**
+ * Parse old-format config.json.
+ * Returns null on invalid JSON (graceful error handling).
+ */
+export function parseOldConfig(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/migrate/preview.js

@@ -0,0 +1,47 @@
+// GSD Migration Preview — Pre-write statistics
+// Pure function, no I/O. Computes counts from a GSDProject.
+/**
+ * Compute pre-write statistics from a GSDProject without performing I/O.
+ * Used to show the user what a migration will produce before writing anything.
+ */
+export function generatePreview(project) {
+    let totalSlices = 0;
+    let totalTasks = 0;
+    let doneSlices = 0;
+    let doneTasks = 0;
+    for (const milestone of project.milestones) {
+        for (const slice of milestone.slices) {
+            totalSlices++;
+            if (slice.done)
+                doneSlices++;
+            for (const task of slice.tasks) {
+                totalTasks++;
+                if (task.done)
+                    doneTasks++;
+            }
+        }
+    }
+    const reqCounts = { active: 0, validated: 0, deferred: 0, outOfScope: 0, total: 0 };
+    for (const req of project.requirements) {
+        const status = req.status.toLowerCase();
+        if (status === 'active')
+            reqCounts.active++;
+        else if (status === 'validated')
+            reqCounts.validated++;
+        else if (status === 'deferred')
+            reqCounts.deferred++;
+        else if (status === 'out-of-scope')
+            reqCounts.outOfScope++;
+        reqCounts.total++;
+    }
+    return {
+        milestoneCount: project.milestones.length,
+        totalSlices,
+        totalTasks,
+        doneSlices,
+        doneTasks,
+        sliceCompletionPct: totalSlices > 0 ? Math.round((doneSlices / totalSlices) * 100) : 0,
+        taskCompletionPct: totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0,
+        requirements: reqCounts,
+    };
+}