hadara 0.1.0-rc.0

package/dist/tui/read-model.js

@@ -0,0 +1,502 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTuiLoadingReadModel = createTuiLoadingReadModel;
+exports.createTuiReadModel = createTuiReadModel;
+exports.createTuiFastReadModel = createTuiFastReadModel;
+const active_run_state_1 = require("../services/active-run-state");
+const active_run_state_2 = require("../services/active-run-state");
+const evidence_list_1 = require("../services/evidence-list");
+const operational_debt_1 = require("../services/operational-debt");
+const operations_status_service_1 = require("../services/operations-status-service");
+const project_read_model_1 = require("../services/project-read-model");
+const task_read_model_1 = require("../services/task-read-model");
+const tools_list_1 = require("../services/tools-list");
+const write_preflight_1 = require("../services/write-preflight");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_EVIDENCE_LIMIT = 20;
+const DEFAULT_WRITE_PREVIEW_TITLE = 'TUI Follow-up';
+function createTuiLoadingReadModel() {
+    const generatedAt = new Date().toISOString();
+    return {
+        schemaVersion: 'hadara.tui.read_model.internal.v1',
+        command: 'tui.read-model',
+        ok: true,
+        generatedAt,
+        selectedTaskId: null,
+        overview: {
+            currentWork: null,
+            previousWork: null,
+            currentDetail: null,
+            previousDetail: null,
+            health: 'loading',
+            phase: 'loading read models',
+            branch: '...'
+        },
+        status: {
+            schemaVersion: 'hadara.ops.status.v1',
+            command: 'ops.status',
+            ok: true,
+            health: 'loading',
+            project: { branch: '...', phase: 'loading read models' },
+            tasks: {
+                counts: { done: 0, draft: 0, partial: 0, superseded: 0, inProgress: 0, unknown: 0 },
+                rawStatusCounts: {},
+                normalizedStatusCounts: {},
+                lastCompleted: [],
+                nextRecommended: 'Reading HADARA project state...'
+            },
+            handoff: { currentState: [], knownProblems: [], nextRecommendedStep: [] },
+            validation: { latestFullCheck: 'loading', latestDoneLevelValidation: null },
+            activeRun: {
+                schemaVersion: 'hadara.active_run.projection.v1',
+                command: 'active-run.projection',
+                ok: true,
+                path: '.hadara/local/state/active-run.json',
+                activeRun: null,
+                handoff: { fresh: true, staleReason: null },
+                resume: null,
+                issues: []
+            },
+            debt: { total: 0, open: 0, tracked: 0, mitigated: 0, candidate: 0, highOpen: 0, bySeverity: {} },
+            mcp: {
+                defaultMode: 'read-only',
+                evidenceAttach: { enabledByDefault: false, requiresFlag: '--enable-evidence-attach', requiresApproval: true, audited: true }
+            },
+            issues: []
+        },
+        tasks: {
+            schemaVersion: 'hadara.task.list.v1',
+            command: 'task.list',
+            ok: true,
+            count: 0,
+            tasks: [],
+            issues: []
+        },
+        selectedTask: null,
+        activeRun: {
+            projection: {
+                schemaVersion: 'hadara.active_run.projection.v1',
+                command: 'active-run.projection',
+                ok: true,
+                path: '.hadara/local/state/active-run.json',
+                activeRun: null,
+                handoff: { fresh: true, staleReason: null },
+                resume: null,
+                issues: []
+            },
+            resume: {
+                schemaVersion: 'hadara.active_run.resume.v1',
+                command: 'active-run.resume',
+                ok: true,
+                activeRun: null,
+                resumePrompt: {
+                    summary: 'Reading active-run state...',
+                    mustRead: [],
+                    nextActions: [],
+                    constraints: ['Read-only mode remains enforced.']
+                },
+                issues: []
+            }
+        },
+        debt: {
+            schemaVersion: 'hadara.operational_debt.list.v1',
+            command: 'debt.list',
+            ok: true,
+            aggregate: { total: 0, open: 0, tracked: 0, mitigated: 0, candidate: 0, highOpen: 0, bySeverity: {} },
+            records: [],
+            debts: [],
+            capsuleSizeIndicators: [],
+            issues: []
+        },
+        releaseGate: {
+            schemaVersion: 'hadara.releaseGate.v1',
+            command: 'release.gate',
+            ok: true,
+            mode: 'advisory',
+            checks: [],
+            issues: []
+        },
+        tools: {
+            schemaVersion: 'hadara.tools.list.v1',
+            command: 'tools.list',
+            ok: true,
+            tools: [],
+            surfaces: [],
+            disabled: [],
+            issues: []
+        },
+        writePreview: {
+            schemaVersion: 'hadara.write.preflight.v1',
+            command: 'unknown',
+            ok: true,
+            writes: [],
+            risk: 'low',
+            requiresApproval: false,
+            workspaceBoundary: 'project',
+            issues: []
+        },
+        issues: []
+    };
+}
+function createTuiReadModel(projectRoot, options = {}) {
+    if (options.profile === 'fast')
+        return createTuiFastReadModel(projectRoot, options);
+    const status = (0, operations_status_service_1.createOpsStatusReport)(projectRoot);
+    const tasks = (0, task_read_model_1.createTaskListReport)(projectRoot);
+    const selectedTaskId = resolveSelectedTaskId(tasks.tasks, status, options.selectedTaskId);
+    const selectedSummary = selectedTaskId ? tasks.tasks.find((task) => task.id === selectedTaskId) ?? null : null;
+    const selectedTask = selectedSummary
+        ? {
+            summary: selectedSummary,
+            detail: (0, task_read_model_1.createTaskReadReport)(projectRoot, selectedSummary.id, { includePrivate: options.includePrivateEvidence }),
+            evidence: (0, evidence_list_1.createEvidenceListReport)(projectRoot, {
+                taskId: selectedSummary.id,
+                limit: options.evidenceLimit ?? DEFAULT_EVIDENCE_LIMIT,
+                includePrivate: options.includePrivateEvidence
+            })
+        }
+        : null;
+    const activeRunResume = (0, active_run_state_1.createActiveRunResumeReport)(projectRoot);
+    const debt = (0, operational_debt_1.createOperationalDebtReport)(projectRoot);
+    const releaseGate = (0, operational_debt_1.createReleaseGateReport)(projectRoot, 'advisory');
+    const tools = (0, tools_list_1.createToolsListReport)();
+    const writePreview = (0, write_preflight_1.createWritePreflightReport)(projectRoot, ['task', 'create', options.writePreviewTitle ?? DEFAULT_WRITE_PREVIEW_TITLE]);
+    const overview = createOverview(projectRoot, tasks.tasks, selectedTask, status, options.includePrivateEvidence);
+    const issues = collectIssues({
+        status,
+        activeRunResume,
+        selectedTask,
+        releaseGate,
+        writePreview,
+        selectedTaskId,
+        explicitSelectedTaskId: options.selectedTaskId ?? null
+    });
+    return {
+        schemaVersion: 'hadara.tui.read_model.internal.v1',
+        command: 'tui.read-model',
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        generatedAt: new Date().toISOString(),
+        selectedTaskId,
+        overview,
+        status,
+        tasks,
+        selectedTask,
+        activeRun: {
+            projection: status.activeRun,
+            resume: activeRunResume
+        },
+        debt,
+        releaseGate,
+        tools,
+        writePreview,
+        issues
+    };
+}
+function createTuiFastReadModel(projectRoot, options = {}) {
+    const sources = (0, project_read_model_1.readProjectSources)(projectRoot);
+    const tasks = (0, task_read_model_1.createTaskListReport)(projectRoot);
+    const activeRunProjection = (0, active_run_state_2.safeCreateActiveRunProjection)(projectRoot);
+    const status = createFastOpsStatusReport(projectRoot, sources, tasks, activeRunProjection);
+    const selectedTaskId = resolveSelectedTaskId(tasks.tasks, status, options.selectedTaskId);
+    const selectedSummary = selectedTaskId ? tasks.tasks.find((task) => task.id === selectedTaskId) ?? null : null;
+    const selectedTask = selectedSummary
+        ? {
+            summary: selectedSummary,
+            detail: (0, task_read_model_1.createTaskReadReport)(projectRoot, selectedSummary.id, { includePrivate: options.includePrivateEvidence }),
+            evidence: (0, evidence_list_1.createEvidenceListReport)(projectRoot, {
+                taskId: selectedSummary.id,
+                limit: options.evidenceLimit ?? DEFAULT_EVIDENCE_LIMIT,
+                includePrivate: options.includePrivateEvidence
+            })
+        }
+        : null;
+    const activeRunResume = (0, active_run_state_1.createActiveRunResumeReport)(projectRoot);
+    const deferredIssue = {
+        source: 'tui-read-model',
+        severity: 'warning',
+        code: 'TUI_HEAVY_READS_DEFERRED',
+        message: 'TUI fast read model deferred debt, release-gate, tools, and write-preflight reads.'
+    };
+    const issues = [
+        ...collectIssues({
+            status,
+            activeRunResume,
+            selectedTask,
+            releaseGate: createDeferredReleaseGateReport(),
+            writePreview: createDeferredWritePreflightReport(),
+            selectedTaskId,
+            explicitSelectedTaskId: options.selectedTaskId ?? null
+        }),
+        deferredIssue
+    ];
+    return {
+        schemaVersion: 'hadara.tui.read_model.internal.v1',
+        command: 'tui.read-model',
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        generatedAt: new Date().toISOString(),
+        selectedTaskId,
+        overview: createOverview(projectRoot, tasks.tasks, selectedTask, status, options.includePrivateEvidence),
+        status,
+        tasks,
+        selectedTask,
+        activeRun: {
+            projection: status.activeRun,
+            resume: activeRunResume
+        },
+        debt: createDeferredDebtReport(),
+        releaseGate: createDeferredReleaseGateReport(),
+        tools: createDeferredToolsListReport(),
+        writePreview: createDeferredWritePreflightReport(),
+        issues
+    };
+}
+function createFastOpsStatusReport(projectRoot, sources, tasks, activeRun) {
+    const counts = countTaskStatuses(tasks.tasks);
+    const validation = {
+        latestFullCheck: extractValidationLine(sources.handoff.content, 'Latest full check') ?? extractValidationHistoryLine(sources.validationHistory.content, 'Docker check'),
+        latestDoneLevelValidation: extractValidationLine(sources.handoff.content, 'Latest done-level validation') ??
+            extractValidationHistoryLine(sources.validationHistory.content, 'harness validate')
+    };
+    const issues = [];
+    if (!sources.projectState.exists)
+        issues.push({ severity: 'warning', code: 'PROJECT_STATE_MISSING', message: 'docs/PROJECT_STATE.md is missing.' });
+    if (!sources.handoff.exists)
+        issues.push({ severity: 'warning', code: 'AGENT_HANDOFF_MISSING', message: 'docs/AGENT_HANDOFF.md is missing.' });
+    if (!sources.taskBoard.exists)
+        issues.push({ severity: 'warning', code: 'TASK_BOARD_MISSING', message: 'docs/TASK_BOARD.md is missing.' });
+    if (!sources.developmentSlices.exists)
+        issues.push({ severity: 'warning', code: 'DEVELOPMENT_SLICES_MISSING', message: 'docs/DEVELOPMENT_SLICES.md is missing.' });
+    if (!validation.latestFullCheck && !validation.latestDoneLevelValidation) {
+        issues.push({ severity: 'warning', code: 'VALIDATION_BASELINE_MISSING', message: 'No latest validation baseline was found in handoff or validation history.' });
+    }
+    issues.push(...activeRun.issues);
+    return {
+        schemaVersion: 'hadara.ops.status.v1',
+        command: 'ops.status',
+        ok: true,
+        health: issues.some((issue) => issue.severity === 'error') ? 'error' : issues.length > 0 ? 'degraded' : 'ok',
+        project: {
+            branch: readGitBranch(projectRoot),
+            phase: extractProjectPhase(sources.projectState.content)
+        },
+        tasks: {
+            counts: counts.counts,
+            rawStatusCounts: counts.rawStatusCounts,
+            normalizedStatusCounts: counts.normalizedStatusCounts,
+            lastCompleted: extractLastCompletedTaskIds(sources.handoff.content),
+            nextRecommended: extractListSection(sources.handoff.content, '## Next Recommended Step')[0] ?? null
+        },
+        handoff: {
+            currentState: extractListSection(sources.handoff.content, '## Current State'),
+            knownProblems: extractListSection(sources.handoff.content, '## Current Known Problems'),
+            nextRecommendedStep: extractListSection(sources.handoff.content, '## Next Recommended Step')
+        },
+        validation,
+        activeRun,
+        debt: { total: 0, open: 0, tracked: 0, mitigated: 0, candidate: 0, highOpen: 0, bySeverity: { high: 0, medium: 0, low: 0 } },
+        mcp: {
+            defaultMode: 'read-only',
+            evidenceAttach: {
+                enabledByDefault: false,
+                requiresFlag: '--enable-evidence-attach',
+                requiresApproval: true,
+                audited: true
+            }
+        },
+        issues
+    };
+}
+function resolveSelectedTaskId(tasks, status, explicitSelectedTaskId) {
+    if (explicitSelectedTaskId)
+        return explicitSelectedTaskId;
+    const activeTaskId = status.activeRun.activeRun?.taskId;
+    if (activeTaskId && tasks.some((task) => task.id === activeTaskId))
+        return activeTaskId;
+    return tasks.at(-1)?.id ?? null;
+}
+function createOverview(projectRoot, tasks, selectedTask, status, includePrivateEvidence) {
+    const latestRows = [...tasks].reverse();
+    const currentWork = latestRows[0] ?? null;
+    const previousWork = latestRows[1] ?? null;
+    const readDetail = (task) => {
+        if (!task)
+            return null;
+        if (selectedTask?.summary.id === task.id)
+            return selectedTask.detail;
+        return (0, task_read_model_1.createTaskReadReport)(projectRoot, task.id, { includePrivate: includePrivateEvidence });
+    };
+    return {
+        currentWork,
+        previousWork,
+        currentDetail: readDetail(currentWork),
+        previousDetail: readDetail(previousWork),
+        health: status.health,
+        phase: status.project.phase,
+        branch: status.project.branch
+    };
+}
+function collectIssues(input) {
+    const issues = [
+        ...input.status.issues.map((issue) => ({ source: 'status', ...issue })),
+        ...input.activeRunResume.issues.map((issue) => ({ source: 'active-run-resume', ...issue })),
+        ...input.releaseGate.issues.map((issue) => ({ source: 'release-gate', ...issue })),
+        ...input.writePreview.issues.map((issue) => ({ source: 'write-preflight', ...issue }))
+    ];
+    if (input.selectedTask) {
+        issues.push(...input.selectedTask.detail.issues.map((issue) => ({ source: 'task-detail', ...issue })));
+        issues.push(...input.selectedTask.evidence.issues.map((issue) => ({ source: 'evidence', ...issue })));
+    }
+    else if (input.explicitSelectedTaskId || input.selectedTaskId) {
+        const taskId = input.explicitSelectedTaskId ?? input.selectedTaskId ?? '(unknown)';
+        issues.push({
+            source: 'tui-read-model',
+            severity: 'error',
+            code: 'TUI_SELECTED_TASK_NOT_FOUND',
+            message: `Selected Task Capsule not found: ${taskId}`
+        });
+    }
+    return issues;
+}
+function countTaskStatuses(tasks) {
+    const counts = {
+        done: 0,
+        draft: 0,
+        partial: 0,
+        superseded: 0,
+        inProgress: 0,
+        unknown: 0
+    };
+    const rawStatusCounts = {};
+    const normalizedStatusCounts = {};
+    for (const task of tasks) {
+        const rawStatus = task.status || 'Unknown';
+        const normalizedStatus = normalizeStatus(rawStatus);
+        const aggregate = aggregateStatus(normalizedStatus);
+        counts[aggregate] += 1;
+        rawStatusCounts[rawStatus] = (rawStatusCounts[rawStatus] ?? 0) + 1;
+        normalizedStatusCounts[normalizedStatus] = (normalizedStatusCounts[normalizedStatus] ?? 0) + 1;
+    }
+    return { counts, rawStatusCounts, normalizedStatusCounts };
+}
+function readGitBranch(projectRoot) {
+    const headPath = node_path_1.default.join(projectRoot, '.git', 'HEAD');
+    if (!node_fs_1.default.existsSync(headPath))
+        return 'unknown';
+    const head = node_fs_1.default.readFileSync(headPath, 'utf8').trim();
+    const refPrefix = 'ref: refs/heads/';
+    if (head.startsWith(refPrefix))
+        return head.slice(refPrefix.length);
+    return head.length > 0 ? 'detached' : 'unknown';
+}
+function extractProjectPhase(projectState) {
+    const section = (0, project_read_model_1.extractSection)(projectState, '## Current Phase');
+    const line = section
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .find(Boolean);
+    if (!line)
+        return 'unknown';
+    const explicit = line.match(/^Phase:\s*(.+)$/i);
+    if (explicit)
+        return explicit[1].trim();
+    if (/Phase 0\s*\/\s*Phase 1 boundary/i.test(line))
+        return 'bootstrap-development';
+    return line;
+}
+function extractListSection(content, heading) {
+    const section = (0, project_read_model_1.extractSection)(content, heading);
+    return section
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/^[-*]\s+/, ''))
+        .filter(Boolean);
+}
+function extractLastCompletedTaskIds(handoff) {
+    return extractListSection(handoff, '## Last 3 Completed Tasks')
+        .map((line) => line.match(/^(T-\d{4})\b/)?.[1])
+        .filter((value) => Boolean(value));
+}
+function extractValidationLine(handoff, label) {
+    const validation = extractListSection(handoff, '## Validation Baseline');
+    const prefix = `${label}:`;
+    const line = validation.find((item) => item.startsWith(prefix));
+    return line ? line.slice(prefix.length).trim().replace(/\.$/, '') : null;
+}
+function extractValidationHistoryLine(validationHistory, pattern) {
+    const lines = validationHistory
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/^[-*]\s+/, ''))
+        .filter((line) => line.includes(pattern));
+    return lines.at(-1)?.replace(/\.$/, '') ?? null;
+}
+function normalizeStatus(status) {
+    const value = status.trim().toLowerCase().replace(/[\s_-]+(.)/g, (_match, letter) => letter.toUpperCase());
+    return value || 'unknown';
+}
+function aggregateStatus(status) {
+    if (status === 'done')
+        return 'done';
+    if (status === 'draft')
+        return 'draft';
+    if (status === 'partial')
+        return 'partial';
+    if (status === 'superseded')
+        return 'superseded';
+    if (status === 'inProgress' || status === 'active' || status === 'doing')
+        return 'inProgress';
+    return 'unknown';
+}
+function createDeferredDebtReport() {
+    return {
+        schemaVersion: 'hadara.operational_debt.v1',
+        command: 'operational-debt.report',
+        ok: true,
+        records: [],
+        aggregate: { total: 0, open: 0, tracked: 0, mitigated: 0, candidate: 0, highOpen: 0, bySeverity: { high: 0, medium: 0, low: 0 } },
+        capsuleSizeIndicators: [],
+        issues: []
+    };
+}
+function createDeferredReleaseGateReport() {
+    return {
+        schemaVersion: 'hadara.releaseGate.v1',
+        command: 'release.gate',
+        mode: 'advisory',
+        ok: true,
+        checks: [
+            {
+                code: 'TUI_FAST_RELEASE_GATE_DEFERRED',
+                name: 'Deferred release-gate check',
+                status: 'warning',
+                summary: 'Release-gate debt scan is deferred in the TUI fast read model.'
+            }
+        ],
+        issues: []
+    };
+}
+function createDeferredToolsListReport() {
+    return {
+        schemaVersion: 'hadara.tools.list.v1',
+        command: 'tools.list',
+        ok: true,
+        tools: [],
+        surfaces: [],
+        disabled: [],
+        issues: []
+    };
+}
+function createDeferredWritePreflightReport() {
+    return {
+        schemaVersion: 'hadara.write.preflight.v1',
+        command: 'unknown',
+        ok: true,
+        writes: [],
+        risk: 'low',
+        requiresApproval: false,
+        workspaceBoundary: 'project',
+        issues: []
+    };
+}