hadara 0.1.0-rc.0

package/dist/tui/cache.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTuiCacheRoot = resolveTuiCacheRoot;
+exports.readTuiCache = readTuiCache;
+exports.writeTuiCache = writeTuiCache;
+exports.buildTaskIndex = buildTaskIndex;
+exports.refreshTaskIndex = refreshTaskIndex;
+exports.collectTuiCacheSourceSignals = collectTuiCacheSourceSignals;
+exports.areTuiCacheSourceSignalsEqual = areTuiCacheSourceSignalsEqual;
+exports.createTuiReadModelWithCache = createTuiReadModelWithCache;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const workspace_1 = require("../core/workspace");
+const evidence_list_1 = require("../services/evidence-list");
+const read_model_1 = require("./read-model");
+const CACHE_FILE = 'read-model-cache.json';
+const TASK_CAPSULE_FILES = [
+    'TASK.md',
+    'PLAN.md',
+    'CONTEXT.md',
+    'ACCEPTANCE.md',
+    'FILES.md',
+    'TESTS.md',
+    'RISKS.md',
+    'DECISIONS.md',
+    'EVIDENCE.md',
+    'evidence.jsonl',
+    'HANDOFF.md'
+];
+function resolveTuiCacheRoot(projectRoot) {
+    return node_path_1.default.join(projectRoot, '.hadara', 'local', 'tui');
+}
+function readTuiCache(options) {
+    if (options.enabled === false)
+        return null;
+    try {
+        const cachePath = tuiCacheFilePath(options);
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(cachePath, 'utf8'));
+        return isTuiCacheRecord(parsed, options.projectRoot) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeTuiCache(options, record) {
+    if (options.enabled === false)
+        return;
+    const cacheRoot = normalizeTuiCacheRoot(options);
+    const cachePath = node_path_1.default.join(cacheRoot, CACHE_FILE);
+    assertTuiCachePath(options.projectRoot, cachePath, options.cacheRoot);
+    node_fs_1.default.mkdirSync(cacheRoot, { recursive: true });
+    node_fs_1.default.writeFileSync(cachePath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+}
+function buildTaskIndex(projectRoot) {
+    const model = (0, read_model_1.createTuiReadModel)(projectRoot);
+    return buildTaskIndexFromSummaries(projectRoot, model.tasks.tasks);
+}
+function refreshTaskIndex(projectRoot, previous) {
+    const previousById = new Map(previous.map((entry) => [entry.id, entry]));
+    return buildTaskIndexFromSummaries(projectRoot, previous.map((entry) => ({
+        id: entry.id,
+        title: entry.title,
+        status: entry.status,
+        slug: node_path_1.default.basename(entry.capsule).replace(/^T-\d{4}-/, ''),
+        capsule: entry.capsule
+    })), previousById);
+}
+function collectTuiCacheSourceSignals(projectRoot, selectedTask, previous) {
+    return {
+        taskBoard: fileSignal(projectRoot, 'docs/TASK_BOARD.md', true, previous?.taskBoard),
+        tasksDir: directorySignal(projectRoot, 'tasks'),
+        handoff: fileSignal(projectRoot, 'docs/AGENT_HANDOFF.md', true, previous?.handoff),
+        activeRun: fileSignal(projectRoot, '.hadara/local/state/active-run.json', true, previous?.activeRun),
+        selectedTask: selectedTask ? fileSignal(projectRoot, node_path_1.default.join(selectedTask.capsule, 'TASK.md'), true, previous?.selectedTask) : undefined,
+        selectedEvidence: selectedTask ? fileSignal(projectRoot, node_path_1.default.join(selectedTask.capsule, 'evidence.jsonl'), true, previous?.selectedEvidence) : undefined
+    };
+}
+function areTuiCacheSourceSignalsEqual(left, right) {
+    if (!left)
+        return false;
+    return (fileSignalsEqual(left.taskBoard, right.taskBoard) &&
+        directorySignalsEqual(left.tasksDir, right.tasksDir) &&
+        fileSignalsEqual(left.handoff, right.handoff) &&
+        fileSignalsEqual(left.activeRun, right.activeRun) &&
+        fileSignalsEqual(left.selectedTask, right.selectedTask) &&
+        fileSignalsEqual(left.selectedEvidence, right.selectedEvidence));
+}
+function sourceSignalsForCachedSelection(projectRoot, cached) {
+    return collectTuiCacheSourceSignals(projectRoot, cached.model.selectedTask?.summary ?? null, cached.sourceSignals);
+}
+function validateCachedRecord(projectRoot, cached) {
+    if (!cached)
+        return { valid: false, taskIndex: [] };
+    const sourceSignals = sourceSignalsForCachedSelection(projectRoot, cached);
+    if (!areTuiCacheSourceSignalsEqual(cached.sourceSignals, sourceSignals))
+        return { valid: false, taskIndex: [] };
+    const previousById = new Map(cached.taskIndex.map((entry) => [entry.id, entry]));
+    const taskIndex = buildTaskIndexFromSummaries(projectRoot, cached.model.tasks.tasks, previousById);
+    return { valid: taskIndexesEqual(cached.taskIndex, taskIndex), taskIndex };
+}
+function disablePrivateEvidenceCache(projectRoot, cachePath, refresh, options) {
+    return {
+        model: (0, read_model_1.createTuiReadModel)(projectRoot, options),
+        cache: {
+            enabled: false,
+            refresh,
+            hit: false,
+            path: (0, workspace_1.toProjectRelativePath)(projectRoot, cachePath),
+            issues: [
+                {
+                    severity: 'warning',
+                    code: 'TUI_PRIVATE_EVIDENCE_CACHE_DISABLED',
+                    message: 'TUI cache is disabled when includePrivateEvidence is true.'
+                }
+            ]
+        }
+    };
+}
+function createTuiReadModelWithCache(projectRoot, options = {}) {
+    const refresh = options.cache?.refresh ?? 'fast';
+    const cacheRoot = options.cache?.root ?? resolveTuiCacheRoot(projectRoot);
+    const cachePath = node_path_1.default.join(cacheRoot, CACHE_FILE);
+    const cacheOptions = { projectRoot, cacheRoot, enabled: options.cache?.enabled };
+    const issues = [];
+    if (options.includePrivateEvidence === true) {
+        return disablePrivateEvidenceCache(projectRoot, cachePath, refresh, options);
+    }
+    if (options.cache?.enabled === false || refresh === 'none') {
+        return {
+            model: (0, read_model_1.createTuiReadModel)(projectRoot, options),
+            cache: { enabled: options.cache?.enabled !== false, refresh, hit: false, path: (0, workspace_1.toProjectRelativePath)(projectRoot, cachePath), issues }
+        };
+    }
+    const cached = readTuiCache(cacheOptions);
+    const validation = validateCachedRecord(projectRoot, cached);
+    const valid = validation.valid;
+    if (refresh === 'detail' && cached && valid && options.selectedTaskId) {
+        const selectedSummary = cached.model.tasks.tasks.find((task) => task.id === options.selectedTaskId) ?? null;
+        if (selectedSummary) {
+            const model = {
+                ...cached.model,
+                generatedAt: new Date().toISOString(),
+                selectedTaskId: options.selectedTaskId,
+                selectedTask: createSelectedTask(projectRoot, selectedSummary, options)
+            };
+            writeTuiCache(cacheOptions, createCacheRecord(projectRoot, model, validation.taskIndex));
+            return { model, cache: { enabled: true, refresh, hit: true, path: (0, workspace_1.toProjectRelativePath)(projectRoot, cachePath), issues } };
+        }
+    }
+    if (refresh === 'fast' && cached && valid) {
+        return { model: cached.model, cache: { enabled: true, refresh, hit: true, path: (0, workspace_1.toProjectRelativePath)(projectRoot, cachePath), issues } };
+    }
+    const model = (0, read_model_1.createTuiReadModel)(projectRoot, options);
+    try {
+        writeTuiCache(cacheOptions, createCacheRecord(projectRoot, model, buildTaskIndexFromSummaries(projectRoot, model.tasks.tasks)));
+    }
+    catch (error) {
+        issues.push({
+            severity: 'warning',
+            code: 'TUI_CACHE_WRITE_FAILED',
+            message: `TUI cache could not be written: ${error instanceof Error ? error.message : String(error)}`
+        });
+    }
+    return { model, cache: { enabled: true, refresh, hit: false, path: (0, workspace_1.toProjectRelativePath)(projectRoot, cachePath), issues } };
+}
+function createSelectedTask(projectRoot, summary, options) {
+    const detail = createTaskReadReportFromSummary(projectRoot, summary, options);
+    const evidenceRecords = detail.evidenceIndex ?? [];
+    const limit = Math.max(0, Math.floor(options.evidenceLimit ?? 20));
+    return {
+        summary,
+        detail,
+        evidence: {
+            schemaVersion: 'hadara.evidence.list.v1',
+            command: 'evidence.list',
+            ok: detail.ok,
+            taskId: summary.id,
+            count: evidenceRecords.slice(0, limit).length,
+            records: evidenceRecords.slice(0, limit),
+            issues: detail.issues
+        }
+    };
+}
+function createTaskReadReportFromSummary(projectRoot, summary, options) {
+    const taskDir = node_path_1.default.join(projectRoot, summary.capsule);
+    (0, workspace_1.assertInsideProject)(projectRoot, taskDir, summary.capsule);
+    const files = Object.fromEntries(TASK_CAPSULE_FILES.map((fileName) => {
+        const filePath = node_path_1.default.join(taskDir, fileName);
+        return [fileName, node_fs_1.default.existsSync(filePath) ? node_fs_1.default.readFileSync(filePath, 'utf8') : ''];
+    }));
+    const parsed = (0, evidence_list_1.parseEvidenceIndexFile)(node_path_1.default.join(taskDir, 'evidence.jsonl'), summary.id);
+    const includePrivate = options.includePrivateEvidence === true;
+    const evidenceIndex = parsed.records.filter((record) => includePrivate || record.visibility !== 'private');
+    files['evidence.jsonl'] = evidenceIndex.length ? `${evidenceIndex.map((record) => JSON.stringify(record)).join('\n')}\n` : '';
+    return {
+        schemaVersion: 'hadara.task.read.v1',
+        command: 'task.read',
+        ok: !parsed.issues.some((issue) => issue.severity === 'error'),
+        task: summary,
+        files,
+        evidenceIndex,
+        issues: parsed.issues
+    };
+}
+function createCacheRecord(projectRoot, model, taskIndex) {
+    return {
+        schemaVersion: 'hadara.tui.cache.v1',
+        projectRoot: '.',
+        generatedAt: new Date().toISOString(),
+        sourceSignals: collectTuiCacheSourceSignals(projectRoot, model.selectedTask?.summary ?? null),
+        taskIndex,
+        model
+    };
+}
+function buildTaskIndexFromSummaries(projectRoot, tasks, previousById = new Map()) {
+    return tasks.map((task) => {
+        const taskPath = node_path_1.default.join(projectRoot, task.capsule, 'TASK.md');
+        const previous = previousById.get(task.id);
+        if (!node_fs_1.default.existsSync(taskPath)) {
+            return {
+                id: task.id,
+                title: task.title,
+                status: task.status,
+                capsule: task.capsule,
+                mtimeMs: 0,
+                size: 0
+            };
+        }
+        const stat = node_fs_1.default.statSync(taskPath);
+        const hash = previous && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size && previous.hash
+            ? previous.hash
+            : node_crypto_1.default.createHash('sha256').update(node_fs_1.default.readFileSync(taskPath)).digest('hex');
+        return {
+            id: task.id,
+            title: task.title,
+            status: task.status,
+            capsule: task.capsule,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            hash
+        };
+    });
+}
+function taskIndexesEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((entry, index) => {
+        const other = right[index];
+        return Boolean(other &&
+            entry.id === other.id &&
+            entry.capsule === other.capsule &&
+            entry.mtimeMs === other.mtimeMs &&
+            entry.size === other.size &&
+            entry.hash === other.hash);
+    });
+}
+function tuiCacheFilePath(options) {
+    const cacheRoot = normalizeTuiCacheRoot(options);
+    const cachePath = node_path_1.default.join(cacheRoot, CACHE_FILE);
+    assertTuiCachePath(options.projectRoot, cachePath, options.cacheRoot);
+    return cachePath;
+}
+function normalizeTuiCacheRoot(options) {
+    return options.cacheRoot ?? resolveTuiCacheRoot(options.projectRoot);
+}
+function assertTuiCachePath(projectRoot, candidatePath, explicitRoot) {
+    const root = explicitRoot ?? resolveTuiCacheRoot(projectRoot);
+    (0, workspace_1.assertInsideProject)(projectRoot, root);
+    if (node_path_1.default.relative(resolveTuiCacheRoot(projectRoot), root).startsWith('..')) {
+        throw new Error('TUI cache root must stay under .hadara/local/tui.');
+    }
+    if (node_path_1.default.relative(root, candidatePath).startsWith('..')) {
+        throw new Error('TUI cache path must stay under the configured cache root.');
+    }
+}
+function isTuiCacheRecord(value, projectRoot) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return (record.schemaVersion === 'hadara.tui.cache.v1' &&
+        record.projectRoot === '.' &&
+        typeof record.generatedAt === 'string' &&
+        typeof record.sourceSignals === 'object' &&
+        record.sourceSignals !== null &&
+        Array.isArray(record.taskIndex) &&
+        typeof record.model === 'object' &&
+        record.model !== null &&
+        record.model.schemaVersion === 'hadara.tui.read_model.internal.v1');
+}
+function fileSignal(projectRoot, relativePath, includeHash, previous) {
+    const filePath = node_path_1.default.join(projectRoot, relativePath);
+    if (!node_fs_1.default.existsSync(filePath))
+        return undefined;
+    const stat = node_fs_1.default.statSync(filePath);
+    if (!stat.isFile())
+        return undefined;
+    const signal = {
+        mtimeMs: stat.mtimeMs,
+        size: stat.size
+    };
+    if (includeHash) {
+        signal.hash =
+            previous && previous.mtimeMs === signal.mtimeMs && previous.size === signal.size && previous.hash
+                ? previous.hash
+                : node_crypto_1.default.createHash('sha256').update(node_fs_1.default.readFileSync(filePath)).digest('hex');
+    }
+    return signal;
+}
+function directorySignal(projectRoot, relativePath) {
+    const dirPath = node_path_1.default.join(projectRoot, relativePath);
+    if (!node_fs_1.default.existsSync(dirPath))
+        return undefined;
+    const stat = node_fs_1.default.statSync(dirPath);
+    if (!stat.isDirectory())
+        return undefined;
+    return {
+        entries: node_fs_1.default
+            .readdirSync(dirPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && /^T-\d{4}-/.test(entry.name))
+            .map((entry) => entry.name)
+            .sort(),
+        mtimeMs: stat.mtimeMs
+    };
+}
+function fileSignalsEqual(left, right) {
+    if (!left || !right)
+        return left === right;
+    return left.mtimeMs === right.mtimeMs && left.size === right.size && left.hash === right.hash;
+}
+function directorySignalsEqual(left, right) {
+    if (!left || !right)
+        return left === right;
+    return left.mtimeMs === right.mtimeMs && stringArraysEqual(left.entries, right.entries);
+}
+function stringArraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/tui/constants.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUI_DOCUMENT_TABS = exports.TUI_PANEL_LABELS = exports.TUI_PANEL_IDS = void 0;
+exports.resolveTuiPanelId = resolveTuiPanelId;
+exports.resolveTuiDocumentTab = resolveTuiDocumentTab;
+exports.tuiDetailDocumentRowsForAvailableRows = tuiDetailDocumentRowsForAvailableRows;
+exports.tuiDetailPanelRowsForAvailableRows = tuiDetailPanelRowsForAvailableRows;
+exports.tuiTaskVisibleRowsForAvailableRows = tuiTaskVisibleRowsForAvailableRows;
+exports.TUI_PANEL_IDS = ['overview', 'tasks', 'detail', 'help'];
+const DETAIL_DOCUMENT_MAX_ROWS = 18;
+exports.TUI_PANEL_LABELS = {
+    overview: 'Overview',
+    tasks: 'Tasks',
+    detail: 'Detail',
+    help: 'Help'
+};
+exports.TUI_DOCUMENT_TABS = [
+    { label: 'Task', file: 'TASK.md', key: 't', shortLabel: 'TASK' },
+    { label: 'Plan', file: 'PLAN.md', key: 'p', shortLabel: 'PLAN' },
+    { label: 'Decisions', file: 'DECISIONS.md', key: 'd', shortLabel: 'DEC' },
+    { label: 'Acceptance', file: 'ACCEPTANCE.md', key: 'a', shortLabel: 'ACC' },
+    { label: 'Evidence', file: 'EVIDENCE.md', key: 'e', shortLabel: 'EVD' },
+    { label: 'Handoff', file: 'HANDOFF.md', key: 'h', shortLabel: 'HAND' },
+    { label: 'Files', file: 'FILES.md', key: 'f', shortLabel: 'FILE' },
+    { label: 'Risks', file: 'RISKS.md', key: 'k', shortLabel: 'RISK' },
+    { label: 'Tests', file: 'TESTS.md', key: 's', shortLabel: 'TEST' }
+];
+function resolveTuiPanelId(value, fallback = 'overview') {
+    const normalized = String(value ?? '').toLowerCase();
+    return exports.TUI_PANEL_IDS.find((panel) => panel === normalized) ?? fallback;
+}
+function resolveTuiDocumentTab(file) {
+    const normalized = String(file ?? '').toLowerCase();
+    return (exports.TUI_DOCUMENT_TABS.find((tab) => [tab.label, tab.file, tab.key, tab.shortLabel].some((candidate) => candidate.toLowerCase() === normalized)) ?? exports.TUI_DOCUMENT_TABS[0]);
+}
+function tuiDetailDocumentRowsForAvailableRows(availableRows) {
+    return Math.max(1, Math.min(DETAIL_DOCUMENT_MAX_ROWS, Math.floor(availableRows) - 9));
+}
+function tuiDetailPanelRowsForAvailableRows(availableRows) {
+    return tuiDetailDocumentRowsForAvailableRows(availableRows) + 9;
+}
+function tuiTaskVisibleRowsForAvailableRows(availableRows) {
+    return Math.max(1, tuiDetailPanelRowsForAvailableRows(availableRows) - 3);
+}

package/dist/tui/layout.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.visibleWidth = visibleWidth;
+exports.repeat = repeat;
+exports.fit = fit;
+exports.fitAnsi = fitAnsi;
+exports.trimFit = trimFit;
+exports.trimFitAnsi = trimFitAnsi;
+exports.pad = pad;
+exports.padAnsi = padAnsi;
+exports.divider = divider;
+exports.badge = badge;
+exports.statusRole = statusRole;
+exports.card = card;
+exports.columns = columns;
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+function stripAnsi(text) {
+    return String(text).replace(ANSI_PATTERN, '');
+}
+function visibleWidth(text) {
+    let width = 0;
+    for (const char of Array.from(stripAnsi(text))) {
+        width += (char.codePointAt(0) ?? 0) > 0x2e80 ? 2 : 1;
+    }
+    return width;
+}
+function repeat(char, width) {
+    return char.repeat(Math.max(0, width));
+}
+function fit(input, width) {
+    const target = Math.max(0, width);
+    const text = stripAnsi(input);
+    if (visibleWidth(text) <= target)
+        return `${text}${repeat(' ', target - visibleWidth(text))}`;
+    if (target <= 1)
+        return text.slice(0, target);
+    let out = '';
+    let used = 0;
+    for (const char of Array.from(text)) {
+        const charWidth = (char.codePointAt(0) ?? 0) > 0x2e80 ? 2 : 1;
+        if (used + charWidth > target - 1)
+            break;
+        out += char;
+        used += charWidth;
+    }
+    return `${out}…${repeat(' ', Math.max(0, target - used - 1))}`;
+}
+function fitAnsi(input, width) {
+    const target = Math.max(0, width);
+    const text = String(input);
+    const currentWidth = visibleWidth(text);
+    if (currentWidth <= target)
+        return `${text}${repeat(' ', target - currentWidth)}`;
+    return truncateAnsi(text, target);
+}
+function trimFit(input, width) {
+    return fit(input, width).trimEnd();
+}
+function trimFitAnsi(input, width) {
+    return fitAnsi(input, width).trimEnd();
+}
+function pad(input, width) {
+    const text = String(input);
+    const length = visibleWidth(text);
+    if (length > width)
+        return fit(text, width);
+    return `${text}${repeat(' ', width - length)}`;
+}
+function padAnsi(input, width) {
+    const text = String(input);
+    const length = visibleWidth(text);
+    if (length > width)
+        return fitAnsi(text, width);
+    return `${text}${repeat(' ', width - length)}`;
+}
+function divider(width) {
+    return repeat('─', Math.max(0, width));
+}
+function badge(text, kind = 'LIVE') {
+    return `[${String(text || kind).toUpperCase()}]`;
+}
+function statusRole(value) {
+    const normalized = String(value ?? '').toLowerCase();
+    if (['ok', 'done', 'passed', 'true', 'read', 'preview'].includes(normalized))
+        return 'pass';
+    if (['warning', 'partial', 'draft', 'medium'].includes(normalized))
+        return 'warn';
+    if (['error', 'failed', 'high', 'disabled', 'blocked'].includes(normalized))
+        return 'fail';
+    return 'teal';
+}
+function card(title, lines, width) {
+    const inner = Math.max(8, width - 4);
+    const head = ` ${title} `;
+    return [
+        `╭─${fit(head, Math.min(visibleWidth(head), inner))}${repeat('─', Math.max(0, inner - visibleWidth(head)))}─╮`,
+        ...lines.map((line) => `│ ${pad(line, inner)} │`),
+        `╰${repeat('─', inner + 2)}╯`
+    ];
+}
+function columns(left, right, width, ratio = 0.52) {
+    const gap = 2;
+    const leftWidth = Math.max(20, Math.floor((width - gap) * ratio));
+    const rightWidth = Math.max(20, width - gap - leftWidth);
+    const rows = Math.max(left.length, right.length);
+    const output = [];
+    for (let index = 0; index < rows; index += 1) {
+        output.push(`${pad(left[index] ?? '', leftWidth)}${repeat(' ', gap)}${pad(right[index] ?? '', rightWidth)}`);
+    }
+    return output;
+}
+function truncateAnsi(text, width) {
+    if (width <= 0)
+        return '';
+    if (width <= 1)
+        return stripAnsi(text).slice(0, width);
+    let output = '';
+    let used = 0;
+    let index = 0;
+    let sawAnsi = false;
+    while (index < text.length) {
+        const ansi = text.slice(index).match(/^\x1b\[[0-9;?]*[ -/]*[@-~]/);
+        if (ansi) {
+            output += ansi[0];
+            sawAnsi = true;
+            index += ansi[0].length;
+            continue;
+        }
+        const char = Array.from(text.slice(index))[0] ?? '';
+        const charWidth = (char.codePointAt(0) ?? 0) > 0x2e80 ? 2 : 1;
+        if (used + charWidth > width - 1)
+            break;
+        output += char;
+        used += charWidth;
+        index += char.length;
+    }
+    const suffix = `${output}…${repeat(' ', Math.max(0, width - used - 1))}`;
+    return sawAnsi ? `${suffix}\x1b[0m` : suffix;
+}