hadara 0.1.0-rc.0

package/dist/cli/errors.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliErrorReport = createCliErrorReport;
+exports.cliErrorExitCode = cliErrorExitCode;
+exports.cliErrorCode = cliErrorCode;
+const args_1 = require("./args");
+function createCliErrorReport(args, error) {
+    return {
+        schemaVersion: 'hadara.cli.error.v1',
+        command: 'cli.error',
+        ok: false,
+        input: {
+            ...(args[0] ? { command: args[0] } : {}),
+            ...(args[1] && !args[1].startsWith('--') ? { subcommand: args[1] } : {})
+        },
+        issues: [
+            {
+                severity: 'error',
+                code: cliErrorCode(error),
+                message: error instanceof Error ? error.message : String(error)
+            }
+        ]
+    };
+}
+function cliErrorExitCode(args, error) {
+    if (isGlobalParseError(error))
+        return 1;
+    const command = args[0];
+    if (command === 'policy')
+        return 2;
+    if (command === 'doctor')
+        return 7;
+    if (command === 'run' || command === 'evidence' || command === 'harness')
+        return 6;
+    return 1;
+}
+function cliErrorCode(error) {
+    if (error instanceof args_1.CliArgsError)
+        return error.code;
+    const maybeCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+    const message = error instanceof Error ? error.message : String(error);
+    if (typeof maybeCode === 'string' && maybeCode.startsWith('WORKSPACE_'))
+        return maybeCode;
+    if (/unsupported permission mode/.test(message))
+        return 'PERMISSION_MODE_UNSUPPORTED';
+    if (/unsupported evidence result/.test(message))
+        return 'EVIDENCE_RESULT_UNSUPPORTED';
+    if (/unsupported evidence visibility/.test(message))
+        return 'EVIDENCE_VISIBILITY_UNSUPPORTED';
+    if (/unsupported harness validation level/.test(message))
+        return 'HARNESS_LEVEL_UNSUPPORTED';
+    return 'CLI_COMMAND_FAILED';
+}
+function isGlobalParseError(error) {
+    if (!(error instanceof args_1.CliArgsError))
+        return false;
+    return error.message.startsWith('--project ');
+}

package/dist/cli/evidence-json.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvidenceCollectReport = createEvidenceCollectReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const evidence_1 = require("../evidence/evidence");
+const task_capsule_1 = require("../task/task-capsule");
+const workspace_1 = require("../core/workspace");
+function createEvidenceCollectReport(projectRoot, input) {
+    const task = (0, task_capsule_1.listTaskCapsules)(projectRoot).find((item) => item.id === input.taskId);
+    if (!task) {
+        return {
+            schemaVersion: 'hadara.evidence.collect.v1',
+            command: 'evidence.collect',
+            ok: false,
+            issues: [
+                {
+                    severity: 'error',
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task Capsule not found: ${input.taskId}`
+                }
+            ]
+        };
+    }
+    let markdownPath;
+    try {
+        markdownPath = (0, evidence_1.appendEvidence)(projectRoot, {
+            taskId: input.taskId,
+            kind: input.kind,
+            path: input.path,
+            summary: input.summary,
+            result: input.result,
+            visibility: input.visibility
+        });
+    }
+    catch (error) {
+        if (error instanceof workspace_1.WorkspaceFileError || error instanceof evidence_1.EvidenceArtifactPolicyError) {
+            return {
+                schemaVersion: 'hadara.evidence.collect.v1',
+                command: 'evidence.collect',
+                ok: false,
+                issues: [
+                    {
+                        severity: 'error',
+                        code: error.code,
+                        message: error.message
+                    }
+                ]
+            };
+        }
+        throw error;
+    }
+    const indexRecord = readLastEvidenceIndexRecord(task.dir);
+    return {
+        schemaVersion: 'hadara.evidence.collect.v1',
+        command: 'evidence.collect',
+        ok: true,
+        evidence: {
+            ...indexRecord,
+            markdownPath: toPortablePath(node_path_1.default.relative(projectRoot, markdownPath))
+        },
+        issues: []
+    };
+}
+function readLastEvidenceIndexRecord(taskDir) {
+    const indexPath = node_path_1.default.join(taskDir, 'evidence.jsonl');
+    const lines = node_fs_1.default.readFileSync(indexPath, 'utf8').trim().split(/\r?\n/);
+    return JSON.parse(lines.at(-1) ?? '{}');
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/cli/evidence.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEvidenceCommand = handleEvidenceCommand;
+exports.parseEvidenceKind = parseEvidenceKind;
+exports.parseEvidenceResult = parseEvidenceResult;
+exports.parseEvidenceVisibility = parseEvidenceVisibility;
+const evidence_1 = require("../evidence/evidence");
+const evidence_json_1 = require("./evidence-json");
+const evidence_list_1 = require("../services/evidence-list");
+const args_1 = require("./args");
+function handleEvidenceCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'list') {
+        const taskId = (0, args_1.getRequiredStringOption)(input.args, '--task');
+        const report = (0, evidence_list_1.createEvidenceListReport)(input.projectRoot, {
+            taskId,
+            limit: (0, args_1.getIntegerOption)(input.args, '--limit', { min: 0, max: 500 }),
+            includePrivate: (0, args_1.getFlag)(input.args, '--include-private')
+        });
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            for (const record of report.records) {
+                console.log(`${record.time} | ${record.kind} | ${record.result} | ${record.visibility} | ${record.summary}`);
+            }
+            for (const issue of report.issues) {
+                console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (sub !== 'collect')
+        return false;
+    const taskId = (0, args_1.getRequiredStringOption)(input.args, '--task');
+    const kind = parseEvidenceKind((0, args_1.getStringOption)(input.args, '--kind', 'note') ?? 'note');
+    const summary = (0, args_1.getStringOption)(input.args, '--summary') ?? 'Manual evidence collection placeholder.';
+    const result = parseEvidenceResult((0, args_1.getStringOption)(input.args, '--result', 'unknown') ?? 'unknown');
+    const evidenceFile = (0, args_1.getStringOption)(input.args, '--path');
+    const visibility = parseEvidenceVisibility((0, args_1.getStringOption)(input.args, '--visibility', 'public') ?? 'public', (0, args_1.getFlag)(input.args, '--private'));
+    if (input.jsonOutput) {
+        const report = (0, evidence_json_1.createEvidenceCollectReport)(input.projectRoot, {
+            taskId,
+            kind,
+            path: evidenceFile,
+            summary,
+            result,
+            visibility
+        });
+        console.log(JSON.stringify(report, null, 2));
+        if (!report.ok)
+            process.exitCode = 6;
+    }
+    else {
+        const filePath = (0, evidence_1.appendEvidence)(input.projectRoot, { taskId, kind, path: evidenceFile, summary, result, visibility });
+        console.log(`[HADARA] Evidence updated: ${filePath}`);
+    }
+    return true;
+}
+function parseEvidenceKind(value) {
+    if (['test-log', 'command-log', 'diff-summary', 'screenshot', 'note'].includes(value)) {
+        return value;
+    }
+    throw new Error(`unsupported evidence kind: ${value}`);
+}
+function parseEvidenceResult(value) {
+    if (value === 'passed' || value === 'failed' || value === 'blocked' || value === 'unknown') {
+        return value;
+    }
+    throw new Error(`unsupported evidence result: ${value}`);
+}
+function parseEvidenceVisibility(value, privateFlag = false) {
+    if (privateFlag)
+        return 'private';
+    if (value === 'public' || value === 'private')
+        return value;
+    throw new Error(`unsupported evidence visibility: ${value}`);
+}

package/dist/cli/handoff.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHandoffCommand = handleHandoffCommand;
+const handoff_1 = require("../handoff/handoff");
+const args_1 = require("./args");
+function handleHandoffCommand(input) {
+    const sub = input.args[1];
+    if (sub !== 'update')
+        return false;
+    const taskId = (0, args_1.getStringOption)(input.args, '--task');
+    const summary = (0, args_1.getStringOption)(input.args, '--summary');
+    const nextStep = (0, args_1.getStringOption)(input.args, '--next');
+    const filePath = (0, handoff_1.updateHandoff)({ projectRoot: input.projectRoot, taskId, summary, nextStep });
+    console.log(`[HADARA] Handoff updated: ${filePath}`);
+    return true;
+}

package/dist/cli/harness.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHarnessCommand = handleHarnessCommand;
+exports.parseHarnessValidationLevel = parseHarnessValidationLevel;
+const replay_1 = require("../harness/replay");
+const harness_service_1 = require("../services/harness-service");
+const args_1 = require("./args");
+async function handleHarnessCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'validate') {
+        const taskId = (0, args_1.getRequiredStringOption)(input.args, '--task');
+        const level = parseHarnessValidationLevel((0, args_1.getStringOption)(input.args, '--level', 'draft') ?? 'draft');
+        const result = (0, harness_service_1.createHarnessValidateReport)(input.projectRoot, taskId, { level });
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            console.log(`[HADARA] Harness validation passed: ${result.task.id}`);
+        }
+        else {
+            console.log(`[HADARA] Harness validation failed: ${result.task.id}`);
+            for (const issue of result.issues) {
+                console.log(`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`);
+            }
+        }
+        if (!result.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (sub === 'replay') {
+        const scenarioPath = input.args[2];
+        if (!scenarioPath || scenarioPath.startsWith('--'))
+            throw new Error('harness replay requires <scenario.jsonl>');
+        const result = await (0, replay_1.replayScenario)(input.projectRoot, scenarioPath);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            console.log(`[HADARA] Harness replay passed: ${result.scenario}`);
+        }
+        else {
+            console.log(`[HADARA] Harness replay failed: ${result.scenario}`);
+            for (const issue of result.issues) {
+                console.log(`- ${issue.code}: ${issue.message}${issue.line ? ` (line ${issue.line})` : ''}`);
+            }
+        }
+        if (!result.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    return false;
+}
+function parseHarnessValidationLevel(value) {
+    if (value === 'draft' || value === 'done')
+        return value;
+    throw new Error(`unsupported harness validation level: ${value}`);
+}

package/dist/cli/hermes-json.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHermesDetectReport = createHermesDetectReport;
+exports.createHermesExportContextReport = createHermesExportContextReport;
+const node_path_1 = __importDefault(require("node:path"));
+const context_export_1 = require("../hermes/context-export");
+function createHermesDetectReport(projectRoot) {
+    return {
+        schemaVersion: 'hadara.hermes.detect.v1',
+        command: 'hermes.detect',
+        ok: true,
+        contextFiles: (0, context_export_1.detectHermesContext)(projectRoot)
+    };
+}
+function createHermesExportContextReport(projectRoot) {
+    const outputPath = (0, context_export_1.exportHadaraContext)(projectRoot);
+    return {
+        schemaVersion: 'hadara.hermes.export-context.v1',
+        command: 'hermes.export-context',
+        ok: true,
+        output: {
+            path: toPortablePath(node_path_1.default.relative(projectRoot, outputPath))
+        }
+    };
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/cli/hermes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHermesCommand = handleHermesCommand;
+const context_export_1 = require("../hermes/context-export");
+const hermes_json_1 = require("./hermes-json");
+function handleHermesCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'detect') {
+        if (input.jsonOutput) {
+            console.log(JSON.stringify((0, hermes_json_1.createHermesDetectReport)(input.projectRoot), null, 2));
+        }
+        else {
+            console.log(JSON.stringify((0, context_export_1.detectHermesContext)(input.projectRoot), null, 2));
+        }
+        return true;
+    }
+    if (sub === 'export-context') {
+        if (input.jsonOutput) {
+            console.log(JSON.stringify((0, hermes_json_1.createHermesExportContextReport)(input.projectRoot), null, 2));
+        }
+        else {
+            const filePath = (0, context_export_1.exportHadaraContext)(input.projectRoot);
+            console.log(`[HADARA] Exported Hermes/Harness context: ${filePath}`);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/cli/init.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+exports.parseInitProfile = parseInitProfile;
+exports.handleInitCommand = handleInitCommand;
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../core/paths");
+const fs_1 = require("../core/fs");
+const audit_1 = require("../core/audit");
+const args_1 = require("./args");
+function initProject(projectRoot, profile = 'minimal') {
+    const normalizedProfile = parseInitProfile(profile);
+    const paths = (0, paths_1.resolveHadaraPaths)({ projectRoot });
+    for (const dir of [
+        paths.dataRoot,
+        paths.configDir,
+        paths.secretsDir,
+        paths.sessionsDir,
+        paths.logsDir,
+        paths.auditDir,
+        paths.exportsDir,
+        paths.projectDocsDir,
+        paths.projectTasksDir,
+        paths.projectContextDir
+    ]) {
+        (0, fs_1.ensureDir)(dir);
+    }
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'PROJECT_STATE.md'), '# PROJECT_STATE\n\nStatus: Bootstrap initialized.\nPhase: bootstrap-development.\n\n## Current Phase\n\nbootstrap-development\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'TASK_BOARD.md'), '# TASK_BOARD\n\n| ID | Title | Status | Capsule | Notes |\n|---|---|---|---|---|\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'AGENT_HANDOFF.md'), '# AGENT_HANDOFF\n\nRead PROJECT_STATE.md and TASK_BOARD.md before continuing.\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'ARCHITECTURE.md'), createArchitectureDoc(normalizedProfile));
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'IMPLEMENTATION_SOP.md'), createImplementationSopDoc());
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'DEVELOPMENT_SLICES.md'), createDevelopmentSlicesDoc());
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'DECISIONS.md'), '# DECISIONS\n\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'REFACTOR_LOG.md'), '# REFACTOR_LOG\n\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'SECURITY_MODEL.md'), '# SECURITY_MODEL\n\nUse assisted mode by default.\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'TEST_STRATEGY.md'), '# TEST_STRATEGY\n\nRun unit, contract, harness, security, and release smoke tests.\n');
+    if (normalizedProfile === 'full' || normalizedProfile === 'hadara-protocol') {
+        (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'docs', 'ROADMAP.md'), createRoadmapDoc());
+    }
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'AGENTS.md'), '# AGENTS\n\nAgents must follow HADARA Task Capsule and Handoff Protocol.\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, '.hermes.md'), '# Hermes Agent Context\n\nRead `.hadara/context/HADARA_CONTEXT.md` when available.\n');
+    (0, fs_1.writeFileIfMissing)(node_path_1.default.join(projectRoot, 'HERMES.md'), '# HERMES\n\nThis project is HADARA-compatible.\n');
+    (0, audit_1.writeAuditEvent)(paths.auditDir, {
+        actor: 'system',
+        event_type: 'init',
+        summary: `Initialized project at ${projectRoot} with ${normalizedProfile} profile`,
+        payload: { projectRoot, profile: normalizedProfile }
+    });
+    console.log(`[HADARA] Initialized project: ${projectRoot}`);
+    console.log(`[HADARA] Init profile: ${normalizedProfile}`);
+}
+function parseInitProfile(value) {
+    if (value === 'minimal' || value === 'full' || value === 'hadara-protocol')
+        return value;
+    throw new Error(`unsupported init profile: ${value}`);
+}
+function handleInitCommand(input) {
+    initProject(input.projectRoot, parseInitProfile((0, args_1.getStringOption)(input.args, '--profile', 'minimal') ?? 'minimal'));
+    return true;
+}
+function createArchitectureDoc(profile) {
+    return `# ARCHITECTURE
+
+## Overview
+
+This project was initialized with HADARA using the \`${profile}\` profile.
+
+## Boundaries
+
+- Keep project source, docs, and Task Capsules in the repository.
+- Keep portable/local machine state under \`.hadara/local/\`.
+- Do not commit secrets, private logs, or machine-local state.
+
+## Current Components
+
+- Task Capsules in \`tasks/T-*/\`.
+- Evidence records in \`EVIDENCE.md\` and \`evidence.jsonl\`.
+- Handoff state in \`docs/AGENT_HANDOFF.md\`.
+`;
+}
+function createImplementationSopDoc() {
+    return `# IMPLEMENTATION_SOP
+
+## Session Start
+
+1. Read \`docs/PROJECT_STATE.md\`.
+2. Read \`docs/AGENT_HANDOFF.md\`.
+3. Read \`docs/TASK_BOARD.md\`.
+4. Pick or create one Task Capsule.
+5. Read the active Task Capsule files before implementation.
+
+## Implementation
+
+1. Keep work inside one Task Capsule whenever possible.
+2. Preserve the portable/project store boundary.
+3. Make the smallest coherent change that satisfies acceptance criteria.
+4. Update task-local docs when scope changes.
+
+## Validation
+
+1. Run relevant tests.
+2. Run \`hadara harness validate --task <task-id> --json\`.
+3. Record evidence in \`EVIDENCE.md\` and \`evidence.jsonl\`.
+
+## Session End
+
+1. Update Task Capsule status.
+2. Update \`docs/TASK_BOARD.md\`.
+3. Update \`docs/PROJECT_STATE.md\` when capability state changes.
+4. Update \`docs/AGENT_HANDOFF.md\` before stopping.
+`;
+}
+function createDevelopmentSlicesDoc() {
+    return `# DEVELOPMENT_SLICES
+
+HADARA development should proceed in small, evidence-backed slices.
+
+| Order | Slice | Capsule | Purpose | Done Evidence |
+|---|---|---|---|---|
+| 1 | First validated task | TBD | Create a Task Capsule, implement a small change, and attach evidence. | Harness validation passes. |
+`;
+}
+function createRoadmapDoc() {
+    return `# ROADMAP
+
+## Near Term
+
+- Define the first Task Capsule.
+- Attach evidence for meaningful checks.
+- Keep handoff current between sessions.
+
+## Deferred
+
+- Dashboard read model.
+- Real provider adapters.
+- MCP server expansion.
+`;
+}

package/dist/cli/install.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInstallCommand = handleInstallCommand;
+const install_plan_1 = require("../services/install-plan");
+const args_1 = require("./args");
+function handleInstallCommand(input) {
+    if (input.args[0] !== 'install' || input.args[1] !== 'plan')
+        return false;
+    const report = (0, install_plan_1.createInstallPlanReport)({
+        mode: (0, args_1.getStringOption)(input.args, '--mode', 'dry-run'),
+        platform: (0, args_1.getStringOption)(input.args, '--platform'),
+        source: (0, args_1.getStringOption)(input.args, '--source'),
+        sourceKind: (0, args_1.getStringOption)(input.args, '--source-kind'),
+        target: (0, args_1.getStringOption)(input.args, '--target'),
+        usbRoot: (0, args_1.getStringOption)(input.args, '--usb-root'),
+        prefix: (0, args_1.getStringOption)(input.args, '--prefix'),
+        launcher: (0, args_1.getStringOption)(input.args, '--launcher')
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'failed'} | install plan | ${report.platform} | ${report.mode}`);
+        for (const action of report.actions) {
+            console.log(`${action.wouldWrite ? 'would-write' : 'read'} | ${action.kind} | ${action.description}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}