@minionry/minion 0.7.36

package/dist/server/services/plan/review-verdict-stream.js

@@ -0,0 +1,161 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const OBJECT_OPEN = /\{\s*"/;
+const VERDICT_FIELD = /"(?:passed|checks)"\s*:/;
+const FENCE_BEFORE = /```[a-zA-Z]*\s*$/;
+const TRAILING_ARTIFACT = /^\s*(?:```[a-zA-Z]*[ \t]*\r?\n?)?\s*/;
+const FENCE_LOOKAHEAD = 16;
+const MAX_SPLIT_MARKER = 48;
+const MAX_HELD_CHARS = 64_000;
+export function balancedObjectEnd(text, start) {
+    let depth = 0;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"') {
+            i = skipJsonString(text, i + 1);
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}')
+            depth--;
+        if (depth === 0)
+            return i + 1;
+    }
+    return -1;
+}
+export function parseVerdictObject(candidate) {
+    try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const obj = parsed;
+            if (typeof obj.passed === 'boolean' || typeof obj.passed === 'number')
+                return obj;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+export function skipJsonString(text, from) {
+    for (let i = from; i < text.length; i++) {
+        if (text[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (text[i] === '"')
+            return i;
+    }
+    return text.length;
+}
+class VerdictSuppressingStream {
+    sink;
+    pending = '';
+    held = '';
+    heldOpen = 0;
+    holding = false;
+    constructor(sink) {
+        this.sink = sink;
+    }
+    write(text) {
+        if (!text)
+            return;
+        if (this.holding)
+            this.held += text;
+        else
+            this.pending += text;
+        this.drain(false);
+    }
+    flush() {
+        this.drain(true);
+    }
+    drain(final) {
+        for (;;) {
+            if (this.holding && !this.releaseHold(final))
+                return;
+            const open = OBJECT_OPEN.exec(this.pending);
+            if (open) {
+                this.beginHold(open.index);
+                continue;
+            }
+            if (final) {
+                this.emit(this.pending);
+                this.pending = '';
+            }
+            else {
+                this.emitSafePrefix();
+            }
+            return;
+        }
+    }
+    emitSafePrefix() {
+        const safe = safeBoundary(this.pending);
+        this.emit(this.pending.slice(0, safe));
+        this.pending = this.pending.slice(safe);
+    }
+    beginHold(openIndex) {
+        const cut = fenceCutBefore(this.pending, openIndex);
+        this.emit(this.pending.slice(0, cut));
+        this.held = this.pending.slice(cut);
+        this.heldOpen = openIndex - cut;
+        this.pending = '';
+        this.holding = true;
+    }
+    releaseHold(final) {
+        const end = balancedObjectEnd(this.held, this.heldOpen);
+        if (end === -1)
+            return this.releaseUnbalanced(final);
+        if (!parseVerdictObject(this.held.slice(this.heldOpen, end)))
+            return this.releaseVerbatim(end);
+        if (!final && this.held.length - end < FENCE_LOOKAHEAD)
+            return false;
+        const rest = this.held.slice(end).replace(TRAILING_ARTIFACT, '');
+        this.endHold();
+        this.pending = rest;
+        return true;
+    }
+    releaseVerbatim(end) {
+        const text = this.held;
+        this.endHold();
+        this.emit(text.slice(0, end));
+        this.pending = text.slice(end);
+        return true;
+    }
+    releaseUnbalanced(final) {
+        if (!final && this.held.length <= MAX_HELD_CHARS)
+            return false;
+        const text = this.held;
+        const open = this.heldOpen;
+        this.endHold();
+        if (final && VERDICT_FIELD.test(text.slice(open))) {
+            this.pending = text.slice(0, open);
+            return true;
+        }
+        this.emit(text);
+        return true;
+    }
+    endHold() {
+        this.held = '';
+        this.heldOpen = 0;
+        this.holding = false;
+    }
+    emit(text) {
+        if (text)
+            this.sink?.(text);
+    }
+}
+export function createVerdictStream(sink) {
+    return new VerdictSuppressingStream(sink);
+}
+function safeBoundary(text) {
+    const window = Math.max(0, text.length - MAX_SPLIT_MARKER);
+    for (let i = window; i < text.length; i++) {
+        if (text[i] === '{' || text[i] === '`')
+            return i;
+    }
+    return text.length;
+}
+function fenceCutBefore(text, openIndex) {
+    const fence = FENCE_BEFORE.exec(text.slice(0, openIndex));
+    return fence ? fence.index : openIndex;
+}

package/dist/server/services/plan/state-reconciler.js

@@ -0,0 +1,238 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveReadyToWork } from './dependency-resolver.js';
+import { replaceFrontMatterField, replaceYamlField } from './front-matter.js';
+import { isBoardCentricFormat, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from './parser.js';
+function categorizeIssues(issues, issueByPath) {
+    const inProgress = [];
+    const blocked = [];
+    const recentlyCompleted = [];
+    const readyToWork = resolveReadyToWork(issues);
+    for (const issue of issues) {
+        if (issue.type === 'epic')
+            continue;
+        if (issue.status === 'in_progress' || issue.status === 'in_review') {
+            inProgress.push(issue);
+        }
+        else if (issue.blockedBy.length > 0 && issue.status !== 'done' && issue.status !== 'cancelled') {
+            const allBlockersDone = issue.blockedBy.every(bp => {
+                const blocker = issueByPath.get(bp);
+                return blocker && (blocker.status === 'done' || blocker.status === 'cancelled');
+            });
+            if (!allBlockersDone) {
+                blocked.push(issue);
+            }
+        }
+        if (issue.status === 'done') {
+            recentlyCompleted.push(issue);
+        }
+    }
+    return { inProgress, blocked, recentlyCompleted, readyToWork };
+}
+function computeWarnings(issues) {
+    const warnings = [];
+    const today = new Date().toISOString().split('T')[0];
+    for (const issue of issues) {
+        if (issue.due && issue.due <= today && issue.status !== 'done' && issue.status !== 'cancelled') {
+            const daysOverdue = Math.ceil((Date.now() - new Date(issue.due).getTime()) / (1000 * 60 * 60 * 24));
+            warnings.push(`${issue.id} due date was ${issue.due} (${daysOverdue} day${daysOverdue !== 1 ? 's' : ''} overdue)`);
+        }
+    }
+    return warnings;
+}
+function buildStateMarkdown(frontMatter, categories, warnings, issueByPath, header = '# Project State') {
+    const formatSummary = (issue, index) => {
+        return `${index + 1}. [${issue.id}](${issue.path}) — ${issue.title} (${issue.priority})`;
+    };
+    const formatBlocked = (issue) => {
+        const blockerIds = issue.blockedBy.map(bp => {
+            const blocker = issueByPath.get(bp);
+            return blocker ? `[${blocker.id}](${blocker.path})` : bp;
+        }).join(', ');
+        return `- [${issue.id}](${issue.path}) — ${issue.title} → blocked by ${blockerIds}`;
+    };
+    const sections = [
+        header,
+        '',
+        '## Current Focus',
+        '',
+        '## Ready to Work',
+        ...categories.readyToWork.map(formatSummary),
+        '',
+        '## In Progress',
+        ...categories.inProgress.map(issue => `- [${issue.id}](${issue.path}) — ${issue.title}`),
+        '',
+        '## Blocked',
+        ...categories.blocked.map(formatBlocked),
+        '',
+        '## Recently Completed',
+        ...categories.recentlyCompleted.slice(0, 10).map(issue => `- [${issue.id}](${issue.path}) — ${issue.title} ✓`),
+        '',
+        '## Warnings',
+        ...warnings.map(w => `- ${w}`),
+        '',
+    ];
+    return `---\n${frontMatter}\n---\n\n${sections.join('\n')}`;
+}
+function deriveEpicStatus(epic, issueByPath) {
+    if (epic.children.length === 0)
+        return null;
+    if (epic.status === 'done' || epic.status === 'cancelled')
+        return null;
+    const childStatuses = epic.children.map(cp => issueByPath.get(cp)?.status).filter(Boolean);
+    if (childStatuses.length === 0)
+        return null;
+    const allFinished = childStatuses.every(s => s === 'done' || s === 'cancelled');
+    if (allFinished)
+        return 'done';
+    const anyStarted = childStatuses.some(s => s === 'in_progress' || s === 'in_review');
+    if (anyStarted && epic.status !== 'in_progress')
+        return 'in_progress';
+    return null;
+}
+function reconcileEpicStatuses(pmDir, issues, issueByPath) {
+    const epics = issues.filter(i => i.type === 'epic');
+    for (const epic of epics) {
+        const derived = deriveEpicStatus(epic, issueByPath);
+        if (!derived)
+            continue;
+        const epicPath = join(pmDir, epic.path);
+        try {
+            let content = readFileSync(epicPath, 'utf-8');
+            content = replaceFrontMatterField(content, 'status', derived);
+            writeFileSync(epicPath, content, 'utf-8');
+        }
+        catch {
+        }
+    }
+}
+function deriveSprintStatus(sprint, issueByPath) {
+    const issuePaths = sprint.issues.map(si => si.path);
+    if (issuePaths.length === 0)
+        return null;
+    const statuses = issuePaths.map(p => issueByPath.get(p)?.status).filter(Boolean);
+    if (statuses.length === 0)
+        return null;
+    const allFinished = statuses.every(s => s === 'done' || s === 'cancelled');
+    if (allFinished)
+        return 'completed';
+    const anyStarted = statuses.some(s => s === 'in_progress' || s === 'in_review');
+    if (anyStarted)
+        return 'active';
+    return null;
+}
+function reconcileSprintStatuses(pmDir, sprints, issueByPath) {
+    for (const sprint of sprints) {
+        const derived = deriveSprintStatus(sprint, issueByPath);
+        if (!derived || derived === sprint.status)
+            continue;
+        const sprintPath = join(pmDir, sprint.path);
+        try {
+            let content = readFileSync(sprintPath, 'utf-8');
+            content = replaceFrontMatterField(content, 'status', derived);
+            if (derived === 'completed' && !content.match(/^completed_at:/m)) {
+                const timestamp = new Date().toISOString().split('T')[0];
+                content = replaceFrontMatterField(content, 'completed_at', timestamp);
+            }
+            writeFileSync(sprintPath, content, 'utf-8');
+        }
+        catch {
+        }
+    }
+}
+export function tryCompleteParentEpic(workingDir, updatedIssue) {
+    if (!updatedIssue.epic)
+        return null;
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const boardMatch = updatedIssue.path.match(/^boards\/([^/]+)\//);
+    const issues = boardMatch
+        ? parseBoardDirectory(pmDir, boardMatch[1])?.issues
+        : parsePlanDirectory(workingDir)?.issues;
+    if (!issues)
+        return null;
+    const epic = issues.find(i => i.path === updatedIssue.epic);
+    if (!epic)
+        return null;
+    const issueByPath = new Map(issues.map(i => [i.path, i]));
+    const derived = deriveEpicStatus(epic, issueByPath);
+    if (derived !== 'done')
+        return null;
+    const epicFullPath = join(pmDir, epic.path);
+    try {
+        let content = readFileSync(epicFullPath, 'utf-8');
+        content = replaceFrontMatterField(content, 'status', 'done');
+        writeFileSync(epicFullPath, content, 'utf-8');
+        return epic.path;
+    }
+    catch {
+        return null;
+    }
+}
+export function reconcileState(workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    if (isBoardCentricFormat(pmDir)) {
+        reconcileBoardState(pmDir, workingDir, boardId);
+        return;
+    }
+    const statePath = join(pmDir, 'STATE.md');
+    if (!existsSync(statePath))
+        return;
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState)
+        return;
+    const { issues, sprints, project } = fullState;
+    const issueByPath = new Map(issues.map(i => [i.path, i]));
+    const categories = categorizeIssues(issues, issueByPath);
+    const warnings = computeWarnings(issues);
+    const content = readFileSync(statePath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const frontMatter = fmMatch ? fmMatch[1] : `project: "${project.name}"\ncurrent_sprint: null\nactive_milestone: null\npaused: false\nlast_session: null`;
+    reconcileEpicStatuses(pmDir, issues, issueByPath);
+    reconcileSprintStatuses(pmDir, sprints, issueByPath);
+    const recomputedActive = sprints.find(s => {
+        const derived = deriveSprintStatus(s, issueByPath);
+        return (derived ?? s.status) === 'active';
+    });
+    const updatedFM = replaceYamlField(frontMatter, 'current_sprint', recomputedActive ? recomputedActive.id : 'null');
+    const newContent = buildStateMarkdown(updatedFM, categories, warnings, issueByPath);
+    writeFileSync(statePath, newContent, 'utf-8');
+}
+function reconcileBoardState(pmDir, _workingDir, boardId) {
+    const effectiveBoardId = boardId ?? resolveActiveBoardId(pmDir);
+    if (!effectiveBoardId)
+        return;
+    const boardState = parseBoardDirectory(pmDir, effectiveBoardId);
+    if (!boardState)
+        return;
+    const statePath = join(pmDir, 'boards', effectiveBoardId, 'STATE.md');
+    if (!existsSync(statePath))
+        return;
+    const { board, issues } = boardState;
+    const issueByPath = new Map(issues.map(i => [i.path, i]));
+    reconcileEpicStatuses(pmDir, issues, issueByPath);
+    const categories = categorizeIssues(issues, issueByPath);
+    const warnings = computeWarnings(issues);
+    const content = readFileSync(statePath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const frontMatter = fmMatch ? fmMatch[1] : `board: "${board.id}"\npaused: false\nlast_session: null`;
+    const newContent = buildStateMarkdown(frontMatter, categories, warnings, issueByPath, '# Board State');
+    writeFileSync(statePath, newContent, 'utf-8');
+}
+function resolveActiveBoardId(pmDir) {
+    const wsPath = join(pmDir, 'workspace.json');
+    if (!existsSync(wsPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(wsPath, 'utf-8'));
+        return typeof parsed.activeBoardId === 'string' ? parsed.activeBoardId : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/services/plan/template-diff.js

@@ -0,0 +1,175 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
+export function parseSemver(input) {
+    if (typeof input !== 'string')
+        return null;
+    const match = input.trim().match(SEMVER_PATTERN);
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4],
+        build: match[5],
+    };
+}
+export function isSemver(input) {
+    return typeof input === 'string' && parseSemver(input) !== null;
+}
+function comparePrerelease(preA, preB) {
+    if (!preA && !preB)
+        return 0;
+    if (!preA)
+        return 1;
+    if (!preB)
+        return -1;
+    return preA < preB ? -1 : preA > preB ? 1 : 0;
+}
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb) {
+        if (a === b)
+            return 0;
+        return a < b ? -1 : 1;
+    }
+    if (pa.major !== pb.major)
+        return pa.major < pb.major ? -1 : 1;
+    if (pa.minor !== pb.minor)
+        return pa.minor < pb.minor ? -1 : 1;
+    if (pa.patch !== pb.patch)
+        return pa.patch < pb.patch ? -1 : 1;
+    return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+const ISSUE_DIFF_FIELDS = [
+    'type',
+    'title',
+    'priority',
+    'estimate',
+    'labels',
+    'epic',
+    'children',
+    'blocked_by',
+    'blocks',
+    'description',
+    'acceptance_criteria',
+    'technical_notes',
+    'files_to_modify',
+    'review_gate',
+    'output_type',
+    'output_file',
+    'model',
+    'effort_level',
+    'fast_mode',
+];
+function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return a == null && b == null;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => valuesEqual(v, b[i]));
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    return false;
+}
+function diffIssue(from, to) {
+    const changed = [];
+    const before = {};
+    const after = {};
+    for (const field of ISSUE_DIFF_FIELDS) {
+        if (!valuesEqual(from[field], to[field])) {
+            changed.push(String(field));
+            before[field] = from[field];
+            after[field] = to[field];
+        }
+    }
+    if (changed.length === 0)
+        return null;
+    return { id: from.id, changed, before, after };
+}
+function diffBoardFields(from, to) {
+    const boardChanged = [];
+    const boardFields = [
+        'title', 'goal', 'status', 'max_parallel_agents',
+        'strategy_approval_triggers', 'downstream_triggers',
+    ];
+    for (const f of boardFields) {
+        if (!valuesEqual(from.board?.[f], to.board?.[f]))
+            boardChanged.push(String(f));
+    }
+    return boardChanged;
+}
+function diffVariableFields(a, b) {
+    const fields = [];
+    if (a.description !== b.description)
+        fields.push('description');
+    if (a.default !== b.default)
+        fields.push('default');
+    if ((a.required ?? false) !== (b.required ?? false))
+        fields.push('required');
+    return fields;
+}
+function diffVariables(from, to) {
+    const oldVars = new Map((from.variables ?? []).map(v => [v.name, v]));
+    const newVars = new Map((to.variables ?? []).map(v => [v.name, v]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [name, v] of newVars) {
+        if (!oldVars.has(name))
+            added.push(v);
+    }
+    for (const [name, v] of oldVars) {
+        if (!newVars.has(name))
+            removed.push(v);
+        else {
+            const fields = diffVariableFields(v, newVars.get(name));
+            if (fields.length > 0)
+                changed.push({ name, changed: fields });
+        }
+    }
+    return { added, removed, changed };
+}
+function diffIssues(from, to) {
+    const oldIssues = new Map((from.issues ?? []).map(i => [i.id, i]));
+    const newIssues = new Map((to.issues ?? []).map(i => [i.id, i]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [id, issue] of newIssues) {
+        if (!oldIssues.has(id))
+            added.push(issue);
+        else {
+            const diff = diffIssue(oldIssues.get(id), issue);
+            if (diff)
+                changed.push(diff);
+        }
+    }
+    for (const [id, issue] of oldIssues) {
+        if (!newIssues.has(id))
+            removed.push(issue);
+    }
+    return { added, removed, changed };
+}
+export function compareTemplates(from, to) {
+    const variables = diffVariables(from, to);
+    const issues = diffIssues(from, to);
+    return {
+        from: { templateId: from.template_id, version: from.version ?? '0.0.0' },
+        to: { templateId: to.template_id, version: to.version ?? '0.0.0' },
+        boardChanged: diffBoardFields(from, to),
+        variablesAdded: variables.added,
+        variablesRemoved: variables.removed,
+        variablesChanged: variables.changed,
+        issuesAdded: issues.added,
+        issuesRemoved: issues.removed,
+        issuesChanged: issues.changed,
+    };
+}