hadara 0.1.0-rc.0

package/dist/services/task-read-model.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskListReport = createTaskListReport;
+exports.createTaskShowReport = createTaskShowReport;
+exports.createTaskReadReport = createTaskReadReport;
+exports.formatTaskListReport = formatTaskListReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const task_capsule_1 = require("../task/task-capsule");
+const evidence_list_1 = require("./evidence-list");
+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 createTaskListReport(projectRoot) {
+    const tasks = (0, task_capsule_1.listTaskCapsules)(projectRoot).map((task) => summarizeTask(projectRoot, task));
+    return {
+        schemaVersion: 'hadara.task.list.v1',
+        command: 'task.list',
+        ok: true,
+        count: tasks.length,
+        tasks
+    };
+}
+function createTaskShowReport(projectRoot, taskId) {
+    const task = (0, task_capsule_1.listTaskCapsules)(projectRoot).find((item) => item.id === taskId);
+    if (!task) {
+        return {
+            schemaVersion: 'hadara.task.show.v1',
+            command: 'task.show',
+            ok: false,
+            issues: [
+                {
+                    severity: 'error',
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task Capsule not found: ${taskId}`
+                }
+            ]
+        };
+    }
+    return {
+        schemaVersion: 'hadara.task.show.v1',
+        command: 'task.show',
+        ok: true,
+        task: {
+            ...summarizeTask(projectRoot, task),
+            taskMarkdown: node_fs_1.default.readFileSync(node_path_1.default.join(task.dir, 'TASK.md'), 'utf8')
+        },
+        issues: []
+    };
+}
+function createTaskReadReport(projectRoot, taskId, options = {}) {
+    const task = (0, task_capsule_1.listTaskCapsules)(projectRoot).find((item) => item.id === taskId);
+    if (!task) {
+        return {
+            schemaVersion: 'hadara.task.read.v1',
+            command: 'task.read',
+            ok: false,
+            issues: [
+                {
+                    severity: 'error',
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task Capsule not found: ${taskId}`
+                }
+            ]
+        };
+    }
+    const files = Object.fromEntries(TASK_CAPSULE_FILES.map((fileName) => {
+        const filePath = node_path_1.default.join(task.dir, fileName);
+        return [fileName, node_fs_1.default.existsSync(filePath) ? node_fs_1.default.readFileSync(filePath, 'utf8') : ''];
+    }));
+    const evidenceParse = (0, evidence_list_1.parseEvidenceIndexFile)(node_path_1.default.join(task.dir, 'evidence.jsonl'), task.id);
+    const includePrivate = options.includePrivate === true;
+    const evidenceRecords = evidenceParse.records.filter((record) => includePrivate || record.visibility !== 'private');
+    files['evidence.jsonl'] = formatEvidenceIndexFile(evidenceRecords);
+    return {
+        schemaVersion: 'hadara.task.read.v1',
+        command: 'task.read',
+        ok: !evidenceParse.issues.some((issue) => issue.severity === 'error'),
+        task: summarizeTask(projectRoot, task),
+        files,
+        evidenceIndex: evidenceRecords,
+        issues: evidenceParse.issues
+    };
+}
+function formatTaskListReport(report) {
+    return report.tasks.map((task) => `${task.id}\t${task.title}\t${task.capsule}`).join('\n');
+}
+function formatEvidenceIndexFile(records) {
+    if (records.length === 0)
+        return '';
+    return `${records.map((record) => JSON.stringify(record)).join('\n')}\n`;
+}
+function summarizeTask(projectRoot, task) {
+    return {
+        id: task.id,
+        title: task.title,
+        status: readTaskStatus(task),
+        slug: task.slug,
+        capsule: toPortablePath(node_path_1.default.relative(projectRoot, task.dir))
+    };
+}
+function readTaskStatus(task) {
+    const taskPath = node_path_1.default.join(task.dir, 'TASK.md');
+    if (!node_fs_1.default.existsSync(taskPath))
+        return 'Unknown';
+    const content = node_fs_1.default.readFileSync(taskPath, 'utf8');
+    const match = content.match(/^## Status\s*\n+([\s\S]*?)(?:\n## |\s*$)/m);
+    return match?.[1]?.trim().split(/\r?\n/)[0]?.trim() || 'Unknown';
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/services/tools-list.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolsListReport = createToolsListReport;
+const capability_registry_1 = require("./capability-registry");
+function createToolsListReport(options = {}) {
+    return {
+        schemaVersion: 'hadara.tools.list.v1',
+        command: 'tools.list',
+        ok: true,
+        surfaces: {
+            cli: capability_registry_1.HADARA_CLI_CAPABILITIES.map((surface) => ({ ...surface })),
+            mcp: createMcpSurfaces(options)
+        },
+        disabled: capability_registry_1.HADARA_DISABLED_CAPABILITIES.map((surface) => ({ ...surface })),
+        issues: []
+    };
+}
+function createMcpSurfaces(options) {
+    const readTools = capability_registry_1.HADARA_MCP_READ_CAPABILITIES.map((capability) => ({ ...capability.surface }));
+    const evidenceAttach = {
+        ...capability_registry_1.HADARA_MCP_EVIDENCE_ATTACH_CAPABILITY.surface,
+        enabledByDefault: options.enableEvidenceAttach === true,
+        availability: options.enableEvidenceAttach === true ? 'default' : capability_registry_1.HADARA_MCP_EVIDENCE_ATTACH_CAPABILITY.surface.availability
+    };
+    return [...readTools, evidenceAttach];
+}

package/dist/services/write-preflight.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWritePreflightReport = createWritePreflightReport;
+exports.assertWritePreflightSchema = assertWritePreflightSchema;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const schema_1 = require("../core/schema");
+const fs_1 = require("../core/fs");
+const TASK_FILE_NAMES = [
+    'TASK.md',
+    'PLAN.md',
+    'CONTEXT.md',
+    'FILES.md',
+    'ACCEPTANCE.md',
+    'TESTS.md',
+    'RISKS.md',
+    'DECISIONS.md',
+    'EVIDENCE.md',
+    'evidence.jsonl',
+    'HANDOFF.md'
+];
+function createWritePreflightReport(projectRoot, targetArgs) {
+    const args = normalizeTargetArgs(targetArgs);
+    const command = identifyCommand(args);
+    let report;
+    switch (command) {
+        case 'task.create':
+            report = taskCreateReport(projectRoot, args);
+            break;
+        case 'evidence.collect':
+            report = evidenceCollectReport(projectRoot, args);
+            break;
+        case 'handoff.update':
+            report = simpleProjectWriteReport('handoff.update', ['docs/AGENT_HANDOFF.md']);
+            break;
+        case 'run-state.start':
+        case 'run-state.update':
+        case 'run-state.complete':
+            report = simpleProjectWriteReport(command, ['.hadara/local/state/active-run.json'], [
+                {
+                    severity: 'warning',
+                    code: 'WRITE_COMMAND_DEFERRED',
+                    message: `${command} is a planned CLI-owned write boundary; the mutation command is not implemented yet.`
+                }
+            ]);
+            break;
+        case 'debt.add':
+        case 'debt.update':
+            report = {
+                ...simpleProjectWriteReport(command, ['docs/OPERATIONAL_DEBT.md'], [
+                    {
+                        severity: 'warning',
+                        code: 'DEBT_WRITE_STORE_DEFERRED',
+                        message: 'Operational debt mutation is deferred; the durable write store is not implemented yet.'
+                    }
+                ]),
+                risk: 'medium',
+                requiresApproval: true
+            };
+            break;
+        default:
+            report = {
+                schemaVersion: 'hadara.write.preflight.v1',
+                ok: false,
+                command: 'unknown',
+                risk: 'low',
+                requiresApproval: false,
+                workspaceBoundary: 'project',
+                writes: [],
+                issues: [
+                    {
+                        severity: 'error',
+                        code: 'UNSUPPORTED_WRITE_COMMAND',
+                        message: `Unsupported write preflight target: ${args.join(' ') || '(empty)'}`
+                    }
+                ]
+            };
+    }
+    assertWritePreflightSchema(report);
+    return report;
+}
+function assertWritePreflightSchema(report) {
+    (0, schema_1.assertSchema)('hadara.write.preflight.v1', report);
+}
+function taskCreateReport(projectRoot, args) {
+    const title = extractValueAfterPrefix(args, ['task', 'create']);
+    const issues = [];
+    const taskId = nextTaskIdForPreflight(node_path_1.default.join(projectRoot, 'tasks'));
+    const slug = (0, fs_1.slugify)(title || 'task');
+    const capsule = `tasks/${taskId}-${slug}`;
+    if (!title) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_TITLE_REQUIRED',
+            message: 'task create preflight requires a title.'
+        });
+    }
+    return {
+        schemaVersion: 'hadara.write.preflight.v1',
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        command: 'task.create',
+        risk: 'low',
+        requiresApproval: false,
+        workspaceBoundary: 'project',
+        writes: [...TASK_FILE_NAMES.map((fileName) => `${capsule}/${fileName}`), 'docs/TASK_BOARD.md'],
+        issues
+    };
+}
+function evidenceCollectReport(projectRoot, args) {
+    const taskId = getOptionValue(args, '--task');
+    const kind = getOptionValue(args, '--kind') ?? 'note';
+    const artifactPath = getOptionValue(args, '--path');
+    const visibility = args.includes('--private') ? 'private' : getOptionValue(args, '--visibility') ?? 'public';
+    const issues = [];
+    if (!taskId) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_ID_REQUIRED',
+            message: 'evidence collect preflight requires --task <task-id>.'
+        });
+    }
+    const capsule = taskId ? findTaskCapsulePath(projectRoot, taskId) : null;
+    if (taskId && !capsule) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_CAPSULE_NOT_FOUND',
+            message: `Task Capsule not found: ${taskId}`
+        });
+    }
+    const writes = capsule ? [`${capsule}/EVIDENCE.md`, `${capsule}/evidence.jsonl`] : [];
+    if (capsule && artifactPath && visibility === 'public') {
+        writes.push(`${capsule}/artifacts/${kind}/<timestamp>-${safeFilePart(node_path_1.default.basename(artifactPath))}`);
+    }
+    if (taskId && artifactPath && visibility === 'private') {
+        writes.push(`.hadara/local/portable/data/private-evidence/${taskId}/<evidence-id>.bin`);
+        writes.push(`.hadara/local/portable/data/private-evidence/${taskId}/manifest.jsonl`);
+        writes.push('.hadara/local/portable/data/audit/audit.jsonl');
+    }
+    return {
+        schemaVersion: 'hadara.write.preflight.v1',
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        command: 'evidence.collect',
+        risk: visibility === 'private' ? 'medium' : 'low',
+        requiresApproval: visibility === 'private',
+        workspaceBoundary: visibility === 'private' ? 'project+private-portable' : 'project',
+        writes,
+        issues
+    };
+}
+function simpleProjectWriteReport(command, writes, issues = []) {
+    return {
+        schemaVersion: 'hadara.write.preflight.v1',
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        command,
+        risk: 'low',
+        requiresApproval: false,
+        workspaceBoundary: 'project',
+        writes,
+        issues
+    };
+}
+function identifyCommand(args) {
+    const [root, sub] = args;
+    if (root === 'task' && sub === 'create')
+        return 'task.create';
+    if (root === 'evidence' && sub === 'collect')
+        return 'evidence.collect';
+    if (root === 'handoff' && sub === 'update')
+        return 'handoff.update';
+    if (root === 'run-state' && (sub === 'start' || sub === 'update' || sub === 'complete'))
+        return `run-state.${sub}`;
+    if (root === 'debt' && (sub === 'add' || sub === 'update'))
+        return `debt.${sub}`;
+    return 'unknown';
+}
+function normalizeTargetArgs(args) {
+    const normalized = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--')
+            continue;
+        if (value === '--json')
+            continue;
+        if (value === '--project') {
+            index += 1;
+            continue;
+        }
+        normalized.push(value);
+    }
+    return normalized;
+}
+function extractValueAfterPrefix(args, prefix) {
+    return args
+        .slice(prefix.length)
+        .filter((value, index, values) => {
+        if (value.startsWith('--'))
+            return false;
+        const previous = values[index - 1];
+        return previous !== '--project';
+    })
+        .join(' ')
+        .trim();
+}
+function getOptionValue(args, option) {
+    const index = args.indexOf(option);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        return undefined;
+    return value;
+}
+function nextTaskIdForPreflight(tasksDir) {
+    if (!node_fs_1.default.existsSync(tasksDir))
+        return 'T-0001';
+    const max = node_fs_1.default
+        .readdirSync(tasksDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name.match(/^T-(\d{4})-/)?.[1])
+        .filter((value) => Boolean(value))
+        .map(Number)
+        .reduce((acc, value) => Math.max(acc, value), 0);
+    return `T-${String(max + 1).padStart(4, '0')}`;
+}
+function findTaskCapsulePath(projectRoot, taskId) {
+    const tasksDir = node_path_1.default.join(projectRoot, 'tasks');
+    if (!node_fs_1.default.existsSync(tasksDir))
+        return null;
+    const entry = node_fs_1.default.readdirSync(tasksDir).find((name) => name.startsWith(`${taskId}-`));
+    return entry ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(tasksDir, entry))) : null;
+}
+function safeFilePart(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'artifact';
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/task/task-capsule.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_FILES = void 0;
+exports.isTaskCapsuleScaffoldContent = isTaskCapsuleScaffoldContent;
+exports.nextTaskId = nextTaskId;
+exports.createTaskCapsule = createTaskCapsule;
+exports.listTaskCapsules = listTaskCapsules;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../core/fs");
+exports.TASK_FILES = {
+    'TASK.md': (task) => `# ${task.id} ${task.title}\n\n## Goal\n\nTBD.\n\n## Scope\n\nTBD.\n\n## Out of Scope\n\nTBD.\n\n## Status\n\nDraft\n`,
+    'PLAN.md': () => `# Plan\n\n1. Read relevant docs.\n2. Implement the smallest useful slice.\n3. Run tests.\n4. Attach evidence.\n5. Update handoff.\n`,
+    'CONTEXT.md': () => `# Context\n\nRelevant documents, files, assumptions, and constraints.\n`,
+    'FILES.md': () => `# Files\n\n| Path | Action | Reason |\n|---|---|---|\n`,
+    'ACCEPTANCE.md': () => `# Acceptance Criteria\n\n- [ ] Scope is implemented.\n- [ ] Tests or explicit constraints are recorded.\n- [ ] Evidence is attached.\n- [ ] Handoff is updated.\n`,
+    'TESTS.md': () => `# Tests\n\n## Required\n\n- npm test\n\n## Optional\n\n- npm run check\n`,
+    'RISKS.md': () => `# Risks\n\n| Risk | Mitigation |\n|---|---|\n`,
+    'DECISIONS.md': () => `# Decisions\n\nRecord task-local design decisions here.\n`,
+    'EVIDENCE.md': () => `# Evidence\n\n| Time | Kind | Summary | Result |\n|---|---|---|---|\n`,
+    'evidence.jsonl': () => '',
+    'HANDOFF.md': () => `# Handoff\n\n## Last Completed\n\nTBD.\n\n## Next Recommended Step\n\nTBD.\n`
+};
+function isTaskCapsuleScaffoldContent(task, fileName, content) {
+    if (fileName === 'TASK.md') {
+        return ['## Goal', '## Scope', '## Out of Scope'].some((heading) => isPlaceholderSection(readMarkdownSection(content, heading)));
+    }
+    if (fileName === 'ACCEPTANCE.md') {
+        return acceptanceChecklistText(content).join('\n') === [
+            'Scope is implemented.',
+            'Tests or explicit constraints are recorded.',
+            'Evidence is attached.',
+            'Handoff is updated.'
+        ].join('\n');
+    }
+    const factory = exports.TASK_FILES[fileName];
+    if (!factory)
+        return false;
+    return normalizeMarkdown(content) === normalizeMarkdown(factory(task));
+}
+function nextTaskId(tasksDir) {
+    (0, fs_1.ensureDir)(tasksDir);
+    const max = node_fs_1.default
+        .readdirSync(tasksDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name.match(/^T-(\d{4})-/)?.[1])
+        .filter((value) => Boolean(value))
+        .map(Number)
+        .reduce((acc, value) => Math.max(acc, value), 0);
+    return `T-${String(max + 1).padStart(4, '0')}`;
+}
+function createTaskCapsule(projectRoot, title) {
+    const tasksDir = node_path_1.default.join(projectRoot, 'tasks');
+    const id = nextTaskId(tasksDir);
+    const slug = (0, fs_1.slugify)(title);
+    const dir = node_path_1.default.join(tasksDir, `${id}-${slug}`);
+    const task = { id, title, slug, dir };
+    (0, fs_1.ensureDir)(dir);
+    for (const [fileName, factory] of Object.entries(exports.TASK_FILES)) {
+        (0, fs_1.writeFileIfMissing)(node_path_1.default.join(dir, fileName), factory(task));
+    }
+    const taskBoard = node_path_1.default.join(projectRoot, 'docs', 'TASK_BOARD.md');
+    (0, fs_1.ensureDir)(node_path_1.default.dirname(taskBoard));
+    const line = `| ${id} | ${title.replace(/\|/g, '/')} | Draft | ${node_path_1.default.relative(projectRoot, dir)} | |\n`;
+    if (!node_fs_1.default.existsSync(taskBoard)) {
+        node_fs_1.default.writeFileSync(taskBoard, `# TASK_BOARD\n\n| ID | Title | Status | Capsule | Notes |\n|---|---|---|---|---|\n${line}`, 'utf8');
+    }
+    else {
+        const current = node_fs_1.default.readFileSync(taskBoard, 'utf8');
+        if (!current.includes(`| ${id} |`)) {
+            node_fs_1.default.appendFileSync(taskBoard, line, 'utf8');
+        }
+    }
+    return task;
+}
+function listTaskCapsules(projectRoot) {
+    const tasksDir = node_path_1.default.join(projectRoot, 'tasks');
+    if (!node_fs_1.default.existsSync(tasksDir))
+        return [];
+    return node_fs_1.default
+        .readdirSync(tasksDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && /^T-\d{4}-/.test(entry.name))
+        .map((entry) => {
+        const [id, ...slugParts] = entry.name.split('-');
+        const number = slugParts.shift();
+        const fullId = `${id}-${number}`;
+        const slug = slugParts.join('-');
+        const dir = node_path_1.default.join(tasksDir, entry.name);
+        const taskMd = node_path_1.default.join(dir, 'TASK.md');
+        const title = node_fs_1.default.existsSync(taskMd)
+            ? node_fs_1.default.readFileSync(taskMd, 'utf8').split('\n')[0].replace(/^#\s*T-\d{4}\s*/, '').trim()
+            : slug;
+        return { id: fullId, title, slug, dir };
+    })
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+function readMarkdownSection(content, heading) {
+    const start = content.indexOf(heading);
+    if (start < 0)
+        return '';
+    const afterHeading = content.slice(start + heading.length);
+    const nextHeading = afterHeading.search(/\n##\s+/);
+    return nextHeading >= 0 ? afterHeading.slice(0, nextHeading) : afterHeading;
+}
+function isPlaceholderSection(value) {
+    const normalized = value.trim();
+    return normalized.length === 0 || /^TBD\.?$/i.test(normalized);
+}
+function normalizeMarkdown(value) {
+    return value.replace(/\r\n/g, '\n').trim();
+}
+function acceptanceChecklistText(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^-\s+\[[ xX]\]/.test(line))
+        .map((line) => line.replace(/^-\s+\[[ xX]\]\s*/, '').trim());
+}

package/dist/tools/fake-shell.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFakeShellCommand = runFakeShellCommand;
+const policy_1 = require("../policy/policy");
+const preflight_1 = require("../policy/preflight");
+function runFakeShellCommand(input) {
+    const mode = (0, policy_1.parsePermissionMode)(input.mode);
+    const preflight = (0, preflight_1.createShellExecutionPreflight)(input.command, mode);
+    if (preflight.execution.status === 'denied') {
+        return toObservation(input.command, mode, preflight, {
+            status: 'policy_denied',
+            exitCode: preflight.execution.exitCodeIfBlocked ?? 2,
+            stdout: '',
+            stderr: preflight.decision.reason,
+            reason: preflight.decision.reason
+        });
+    }
+    if (preflight.execution.status === 'requires_approval') {
+        return toObservation(input.command, mode, preflight, {
+            status: 'requires_approval',
+            exitCode: 0,
+            stdout: '',
+            stderr: '',
+            reason: preflight.decision.reason
+        });
+    }
+    const result = input.fixtures[input.command];
+    if (!result) {
+        return toObservation(input.command, mode, preflight, {
+            status: 'not_configured',
+            exitCode: 127,
+            stdout: '',
+            stderr: `No fake shell fixture configured for command: ${input.command}`,
+            reason: 'Fake shell fixtures must explicitly define allowed command outputs.'
+        });
+    }
+    return toObservation(input.command, mode, preflight, {
+        status: 'completed',
+        exitCode: result.exitCode,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? ''
+    });
+}
+function toObservation(commandText, mode, preflight, result) {
+    return {
+        schemaVersion: 'hadara.tools.fake-shell.v1',
+        command: 'tools.fake-shell.run',
+        ok: result.status === 'completed' && result.exitCode === 0,
+        input: {
+            mode,
+            command: commandText
+        },
+        preflight,
+        result
+    };
+}