@bbigbang/core 0.1.0

package/dist/services/missionTrace.js

@@ -0,0 +1,158 @@
+import { deriveMissionEvidence } from './missionEvidence.js';
+/**
+ * Build interpreted trace rows from the same raw mission evidence used by the
+ * evidence registry. Each trace row carries a role, operation, and confidence
+ * classification so consumers can reason about how the interpretation was
+ * produced.
+ */
+export function deriveMissionTrace(input) {
+    const evidence = deriveMissionEvidence(input);
+    return evidence.map((item) => evidenceToTrace(item));
+}
+export function filterMissionTrace(traces, filter) {
+    let result = traces;
+    if (filter.role) {
+        result = result.filter((trace) => trace.role === filter.role);
+    }
+    if (filter.operation) {
+        result = result.filter((trace) => trace.operation === filter.operation);
+    }
+    if (filter.confidence) {
+        result = result.filter((trace) => trace.confidence === filter.confidence);
+    }
+    if (typeof filter.after === 'number' && Number.isFinite(filter.after)) {
+        const after = filter.after;
+        result = result.filter((trace) => trace.time > after);
+    }
+    if (typeof filter.limit === 'number' && Number.isFinite(filter.limit) && filter.limit > 0) {
+        const limit = filter.limit;
+        result = result.slice(0, Math.min(limit, 1_000));
+    }
+    return result;
+}
+function evidenceToTrace(evidence) {
+    return {
+        traceId: `trace:${evidence.evidenceId}`,
+        missionId: evidence.missionId,
+        runtimeProvider: evidence.runtimeProvider,
+        time: evidence.eventTime,
+        role: evidence.roleHint,
+        operation: inferOperation(evidence),
+        confidence: inferConfidence(evidence),
+        summary: evidence.payloadPreview,
+        details: evidence.payloadJson,
+        evidenceIds: [evidence.evidenceId],
+    };
+}
+function inferOperation(evidence) {
+    switch (evidence.sourceType) {
+        case 'mission_event': {
+            const eventType = String(evidence.payloadJson.eventType ?? '').toLowerCase();
+            if (eventType === 'mission_features_parsed' || eventType === 'mission_planning_started' || eventType === 'mission_planning_completed') {
+                return 'mission_plan';
+            }
+            if (eventType === 'milestone_started' || eventType === 'milestone_completed') {
+                return 'milestone_start';
+            }
+            if (eventType === 'feature_queued')
+                return 'feature_queued';
+            if (eventType === 'feature_accepted')
+                return 'feature_started';
+            if (eventType.startsWith('feature_'))
+                return 'feature_lifecycle';
+            if (eventType === 'worker_prompt_built')
+                return 'worker_prompt_built';
+            if (eventType === 'worker_output_received')
+                return 'worker_output_received';
+            if (eventType === 'handoff_created')
+                return 'handoff_created';
+            if (eventType === 'handoff_items_dismissed')
+                return 'handoff_items_dismissed';
+            if (eventType === 'mission_worker_transcript')
+                return 'worker_tool_call';
+            if (eventType.includes('validation_started'))
+                return 'validation_started';
+            if (eventType.includes('validation'))
+                return 'validation_result';
+            if (eventType === 'retry_scheduled')
+                return 'retry_scheduled';
+            if (eventType === 'mission_interaction_queued'
+                || eventType === 'mission_interaction_accepted'
+                || eventType === 'mission_interaction_delivered') {
+                return 'interaction_queued';
+            }
+            if (eventType === 'mission_interaction_observed')
+                return 'interaction_observed';
+            if (eventType === 'mission_interaction_applied')
+                return 'interaction_applied';
+            if (eventType === 'report_generated')
+                return 'report_generated';
+            if (eventType === 'artifact_written')
+                return 'artifact_written';
+            if (eventType === 'mission_pause_requested')
+                return 'pause_requested';
+            if (eventType === 'mission_pause_effective')
+                return 'pause_effective';
+            if (eventType === 'mission_resume_requested')
+                return 'resume_requested';
+            if (eventType === 'mission_resume_effective')
+                return 'resume_effective';
+            if (eventType === 'mission_cancellation_requested')
+                return 'cancellation_requested';
+            if (eventType === 'mission_cancellation_effective')
+                return 'cancellation_effective';
+            if (eventType.startsWith('mission_'))
+                return 'mission_lifecycle';
+            return 'mission_event';
+        }
+        case 'mission_attempt':
+            return 'worker_dispatch';
+        case 'mission_snapshot': {
+            const section = String(evidence.payloadJson.section ?? '');
+            switch (section) {
+                case 'overview':
+                    return 'artifact_written';
+                case 'feature':
+                    return 'feature_lifecycle';
+                case 'handoff':
+                    return 'handoff_created';
+                case 'assertion':
+                    return 'validation_result';
+                case 'report':
+                    return 'report_generated';
+                default:
+                    return 'artifact_written';
+            }
+        }
+        case 'mission_feature':
+            return 'feature_lifecycle';
+        case 'mission_assertion': {
+            const status = String(evidence.payloadJson.status ?? '').toLowerCase();
+            return status === 'pending' ? 'validation_assertion' : 'validation_result';
+        }
+        case 'mission_interaction':
+            return 'interaction_queued';
+        default:
+            return 'mission_event';
+    }
+}
+function inferConfidence(evidence) {
+    switch (evidence.sourceType) {
+        case 'mission_event':
+        case 'mission_attempt':
+        case 'mission_interaction':
+            return 'observed';
+        case 'mission_snapshot':
+            return 'derived';
+        case 'mission_feature': {
+            const status = String(evidence.payloadJson.status ?? '').toLowerCase();
+            return status === 'pending' ? 'inferred' : 'derived';
+        }
+        case 'mission_assertion': {
+            const status = String(evidence.payloadJson.status ?? '').toLowerCase();
+            return status === 'pending' ? 'inferred' : 'derived';
+        }
+        default:
+            return 'unknown';
+    }
+}

package/dist/services/nativeMissionBriefParser.js

@@ -0,0 +1,120 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Parse a mission description into an ordered list of features grouped by milestone.
+ *
+ * Supports a lightweight markdown convention:
+ * - `## Milestone <name>` starts a milestone. All features after it belong to this
+ *   milestone until another milestone header appears.
+ * - `### Feature <name>` starts a feature. The text until the next header or list
+ *   section is the feature description.
+ * - `**Preconditions:**` followed by a `-` bullet list defines preconditions.
+ * - `**Expected behavior:**` or `**Expected Behavior:**` followed by a `-` bullet
+ *   list defines expected behavior assertions.
+ *
+ * If the description is empty or contains only whitespace, an empty array is returned.
+ * If the description has no milestone/feature headers, the whole text becomes a single
+ * feature in a `default` milestone.
+ */
+export function parseMissionBrief(description) {
+    const text = (description ?? '').trim();
+    if (!text)
+        return [];
+    const lines = text.split('\n');
+    const hasStructure = lines.some((line) => /^(#{2,3})\s+/.test(line.trim()));
+    if (!hasStructure) {
+        return [createFeature('default', 0, text)];
+    }
+    const features = [];
+    let currentMilestone = 'default';
+    let currentFeature = null;
+    let ordering = 0;
+    function flushFeature() {
+        if (!currentFeature)
+            return;
+        features.push(createFeature(currentMilestone, ordering++, currentFeature.title, currentFeature.bodyLines, currentFeature.preconditions, currentFeature.expectedBehavior));
+        currentFeature = null;
+    }
+    for (let index = 0; index < lines.length; index++) {
+        const rawLine = lines[index];
+        const line = rawLine.trimEnd();
+        const trimmed = line.trim();
+        const milestoneMatch = trimmed.match(/^##\s+(.+)$/);
+        if (milestoneMatch) {
+            flushFeature();
+            currentMilestone = milestoneMatch[1].trim() || 'default';
+            continue;
+        }
+        const featureMatch = trimmed.match(/^###\s+(.+)$/);
+        if (featureMatch) {
+            flushFeature();
+            currentFeature = {
+                title: featureMatch[1].trim() || 'Untitled feature',
+                bodyLines: [],
+                preconditions: [],
+                expectedBehavior: [],
+                listContext: null,
+            };
+            continue;
+        }
+        if (!currentFeature)
+            continue;
+        const lower = trimmed.toLowerCase();
+        if (lower === '**preconditions:**'
+            || lower === 'preconditions:'
+            || lower === '**preconditions**') {
+            currentFeature.listContext = 'preconditions';
+            continue;
+        }
+        if (lower === '**expected behavior:**'
+            || lower === 'expected behavior:'
+            || lower === '**expected behavior**'
+            || lower === '**expectedbehaviour:**'
+            || lower === 'expected behaviour:') {
+            currentFeature.listContext = 'expectedBehavior';
+            continue;
+        }
+        const bulletMatch = trimmed.match(/^[-*]\s+(.*)$/);
+        if (bulletMatch) {
+            const item = bulletMatch[1].trim();
+            if (currentFeature.listContext === 'preconditions') {
+                currentFeature.preconditions.push(item);
+            }
+            else if (currentFeature.listContext === 'expectedBehavior') {
+                currentFeature.expectedBehavior.push(item);
+            }
+            else {
+                currentFeature.bodyLines.push(rawLine);
+            }
+            continue;
+        }
+        // Non-bullet, non-header line resets list context and contributes to the body.
+        if (trimmed.length > 0) {
+            currentFeature.listContext = null;
+            currentFeature.bodyLines.push(rawLine);
+        }
+        else if (currentFeature.listContext == null) {
+            // Preserve blank lines as paragraph breaks in the body.
+            currentFeature.bodyLines.push('');
+        }
+    }
+    flushFeature();
+    return features;
+}
+function createFeature(milestone, ordering, title, bodyLines = [], preconditions = [], expectedBehavior = []) {
+    const description = bodyLines
+        .map((line) => line.trimEnd())
+        .join('\n')
+        .replace(/\n{2,}/g, '\n\n')
+        .trim();
+    return {
+        featureId: randomUUID(),
+        milestone: milestone.trim() || 'default',
+        description: description || title,
+        skillName: null,
+        status: 'pending',
+        ordering,
+        preconditions,
+        expectedBehavior,
+        retryCount: 0,
+    };
+}