@minionry/minion 0.7.36

package/dist/server/services/plan/metrics-collector.js

@@ -0,0 +1,272 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+export const KNOWN_METRIC_TYPES = [
+    'users_acquired',
+    'revenue',
+    'ad_spend',
+    'conversion_rate',
+    'cac',
+    'ltv',
+    'page_views',
+    'signups',
+    'churn_rate',
+    'mrr',
+    'arr',
+];
+const METRIC_TYPE_ALIASES = {
+    users: 'users_acquired',
+    user_acquisitions: 'users_acquired',
+    new_users: 'users_acquired',
+    sales: 'revenue',
+    sales_revenue: 'revenue',
+    total_revenue: 'revenue',
+    spend: 'ad_spend',
+    ad_budget: 'ad_spend',
+    conversion: 'conversion_rate',
+    conv_rate: 'conversion_rate',
+    cost_per_acquisition: 'cac',
+    customer_acquisition_cost: 'cac',
+    lifetime_value: 'ltv',
+    pageviews: 'page_views',
+    visits: 'page_views',
+    signup_count: 'signups',
+    churn: 'churn_rate',
+    monthly_recurring_revenue: 'mrr',
+    annual_recurring_revenue: 'arr',
+};
+export function collectMetrics(options) {
+    const warnings = [];
+    const metrics = [];
+    const outDir = join(options.boardDir, 'out');
+    const now = options.now ?? (() => new Date());
+    if (!existsSync(outDir)) {
+        return { metrics, warnings, extractionRate: 0, filesScanned: 0, filesWithMetrics: 0 };
+    }
+    let files;
+    try {
+        files = readdirSync(outDir).filter((f) => f.endsWith('.md'));
+    }
+    catch (err) {
+        warnings.push({ file: outDir, message: `failed to read out dir: ${errMsg(err)}` });
+        return { metrics, warnings, extractionRate: 0, filesScanned: 0, filesWithMetrics: 0 };
+    }
+    let filesWithMetrics = 0;
+    for (const file of files) {
+        const fullPath = join(outDir, file);
+        let content;
+        try {
+            if (!statSync(fullPath).isFile())
+                continue;
+            content = readFileSync(fullPath, 'utf-8');
+        }
+        catch (err) {
+            warnings.push({ file, message: `failed to read: ${errMsg(err)}` });
+            continue;
+        }
+        const extracted = extractFromMarkdown(content, file, warnings, now);
+        if (extracted.length > 0) {
+            filesWithMetrics += 1;
+            metrics.push(...extracted);
+        }
+    }
+    const extractionRate = files.length === 0 ? 0 : filesWithMetrics / files.length;
+    return {
+        metrics,
+        warnings,
+        extractionRate,
+        filesScanned: files.length,
+        filesWithMetrics,
+    };
+}
+function extractFromMarkdown(content, file, warnings, now) {
+    const sourceIssueId = inferIssueId(file);
+    const out = [];
+    const seenRanges = [];
+    for (const block of findFencedBlocks(content, /^metrics$/i)) {
+        seenRanges.push([block.start, block.end]);
+        parseBlock(block.body, file, sourceIssueId, warnings, now, out);
+    }
+    for (const block of findFencedBlocks(content, /^json$/i)) {
+        if (rangesOverlap(seenRanges, block.start, block.end))
+            continue;
+        if (!looksLikeMetrics(block.body))
+            continue;
+        parseBlock(block.body, file, sourceIssueId, warnings, now, out);
+    }
+    return out;
+}
+function findFencedBlocks(content, tag) {
+    const blocks = [];
+    const fence = /```([^\n`]*)\n([\s\S]*?)```/g;
+    let match = fence.exec(content);
+    while (match !== null) {
+        const info = match[1].trim();
+        if (tag.test(info)) {
+            blocks.push({ body: match[2], start: match.index, end: match.index + match[0].length });
+        }
+        match = fence.exec(content);
+    }
+    return blocks;
+}
+function rangesOverlap(ranges, start, end) {
+    return ranges.some(([s, e]) => !(end <= s || start >= e));
+}
+function looksLikeMetrics(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return false;
+    }
+    return isMetricsShape(parsed);
+}
+function isMetricsShape(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0 && value.every((v) => isSingleMetricObject(v));
+    }
+    if (value && typeof value === 'object') {
+        const obj = value;
+        if (Array.isArray(obj.metrics))
+            return obj.metrics.every((v) => isSingleMetricObject(v));
+        return isSingleMetricObject(obj);
+    }
+    return false;
+}
+function isSingleMetricObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const obj = value;
+    const hasType = typeof (obj.type ?? obj.metric ?? obj.metricType ?? obj.name) === 'string';
+    const rawValue = obj.value ?? obj.amount ?? obj.count;
+    const hasValue = typeof rawValue === 'number' || (typeof rawValue === 'string' && rawValue.trim() !== '');
+    return hasType && hasValue;
+}
+function parseBlock(body, file, sourceIssueId, warnings, now, out) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (err) {
+        warnings.push({ file, message: `invalid JSON in metrics block: ${errMsg(err)}` });
+        return;
+    }
+    const list = normaliseToList(parsed);
+    if (list.length === 0) {
+        warnings.push({ file, message: 'metrics block did not contain any metric-shaped entries' });
+        return;
+    }
+    for (const entry of list) {
+        const metric = normaliseMetric(entry, file, sourceIssueId, warnings, now);
+        if (metric)
+            out.push(metric);
+    }
+}
+function normaliseToList(parsed) {
+    if (Array.isArray(parsed)) {
+        return parsed.filter((v) => !!v && typeof v === 'object' && !Array.isArray(v));
+    }
+    if (parsed && typeof parsed === 'object') {
+        const obj = parsed;
+        if (Array.isArray(obj.metrics)) {
+            return obj.metrics.filter((v) => !!v && typeof v === 'object' && !Array.isArray(v));
+        }
+        return [obj];
+    }
+    return [];
+}
+function parseMetricCore(raw, file, warnings) {
+    const rawTypeVal = raw.type ?? raw.metric ?? raw.metricType ?? raw.name;
+    if (typeof rawTypeVal !== 'string' || rawTypeVal.trim() === '') {
+        warnings.push({ file, message: 'metric entry missing type/metric/metricType/name' });
+        return null;
+    }
+    const value = coerceNumber(raw.value ?? raw.amount ?? raw.count);
+    if (value === null) {
+        warnings.push({ file, message: `metric "${rawTypeVal}" has non-numeric value` });
+        return null;
+    }
+    return { rawType: rawTypeVal, metricType: canonicaliseMetricType(rawTypeVal), value };
+}
+function coerceMetadata(metadataRaw) {
+    if (metadataRaw && typeof metadataRaw === 'object' && !Array.isArray(metadataRaw)) {
+        return { ...metadataRaw };
+    }
+    return undefined;
+}
+function normaliseMetric(raw, file, sourceIssueId, warnings, now) {
+    const core = parseMetricCore(raw, file, warnings);
+    if (!core)
+        return null;
+    const { rawType, metricType, value } = core;
+    const unit = firstString(raw.unit, raw.units, raw.currency);
+    const channel = firstString(raw.channel, raw.source, raw.attribution);
+    const recordedAt = firstString(raw.recordedAt, raw.recorded_at, raw.timestamp, raw.at);
+    const iso = recordedAt ? coerceIsoDate(recordedAt) : now().toISOString();
+    if (recordedAt && !iso) {
+        warnings.push({ file, message: `metric "${rawType}" has unparseable recordedAt "${recordedAt}"` });
+    }
+    const metadata = coerceMetadata(raw.metadata);
+    if (!KNOWN_METRIC_TYPES.includes(metricType)) {
+        warnings.push({
+            file,
+            message: `metric type "${rawType}" is not in the known enum — forwarding to server for validation`,
+        });
+    }
+    return {
+        metricType,
+        value,
+        ...(unit ? { unit } : {}),
+        ...(channel ? { channel } : {}),
+        ...(metadata ? { metadata } : {}),
+        recordedAt: iso ?? now().toISOString(),
+        ...(sourceIssueId ? { sourceIssueId } : {}),
+        sourceFile: basename(file),
+    };
+}
+function canonicaliseMetricType(raw) {
+    const lower = raw.trim().toLowerCase().replace(/[\s-]+/g, '_');
+    if (lower in METRIC_TYPE_ALIASES)
+        return METRIC_TYPE_ALIASES[lower];
+    return lower;
+}
+function coerceNumber(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'string') {
+        const cleaned = value.trim().replace(/[$,€£¥]/g, '').replace(/%$/, '').trim();
+        if (cleaned === '')
+            return null;
+        const n = Number(cleaned);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function firstString(...candidates) {
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.trim() !== '')
+            return c.trim();
+    }
+    return undefined;
+}
+function coerceIsoDate(raw) {
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime()))
+        return null;
+    return parsed.toISOString();
+}
+function inferIssueId(file) {
+    const match = /^((?:IS|EP|BG|TK)-\d+)/i.exec(basename(file));
+    return match ? match[1].toUpperCase() : undefined;
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/server/services/plan/output-manager.js

@@ -0,0 +1,77 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { extractIssueStatus } from './issue-writer.js';
+import { defaultPmDir, resolvePmDir } from './parser.js';
+export function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60);
+}
+export function resolveOutputPath(issue, workingDir, sprintSandboxDir) {
+    if (sprintSandboxDir) {
+        return join(sprintSandboxDir, 'out', `${issue.id}-${slugify(issue.title)}.md`);
+    }
+    const pmDir = resolvePmDir(workingDir);
+    const outDir = pmDir ? join(pmDir, 'out') : join(defaultPmDir(workingDir), 'out');
+    return join(outDir, `${issue.id}-${slugify(issue.title)}.md`);
+}
+export function listExistingDocs(workingDir, sprintSandboxDir) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return [];
+    const dirs = [];
+    if (sprintSandboxDir)
+        dirs.push(join(sprintSandboxDir, 'out'));
+    dirs.push(join(pmDir, 'out'));
+    const docs = [];
+    for (const dir of dirs) {
+        if (!existsSync(dir))
+            continue;
+        try {
+            docs.push(...readdirSync(dir).filter(f => f.endsWith('.md')).map(f => join(dir, f)));
+        }
+        catch {   }
+    }
+    return docs;
+}
+export function publishOutputs(issues, workingDir, sprintSandboxDir, callbacks) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    for (const issue of issues) {
+        publishSingleOutput(issue, pmDir, workingDir, sprintSandboxDir, callbacks);
+    }
+}
+function publishSingleOutput(issue, pmDir, workingDir, sprintSandboxDir, callbacks) {
+    if (!issue.outputFile)
+        return;
+    try {
+        const content = readFileSync(join(pmDir, issue.path), 'utf-8');
+        if (extractIssueStatus(content) !== 'done')
+            return;
+    }
+    catch {
+        return;
+    }
+    const srcPath = resolveOutputPath(issue, workingDir, sprintSandboxDir);
+    if (!existsSync(srcPath))
+        return;
+    const destPath = resolve(workingDir, issue.outputFile);
+    if (!destPath.startsWith(`${workingDir}/`) && destPath !== workingDir) {
+        callbacks?.onWarning?.(issue.id, `output_file "${issue.outputFile}" escapes project directory — skipping`);
+        return;
+    }
+    try {
+        const destDir = join(destPath, '..');
+        if (!existsSync(destDir))
+            mkdirSync(destDir, { recursive: true });
+        copyFileSync(srcPath, destPath);
+    }
+    catch {
+        callbacks?.onWarning?.(issue.id, `could not copy output to ${issue.outputFile}`);
+    }
+}