hadara 0.3.3 → 0.4.0-rc.0

package/dist/cli/legacy-boundary.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLegacyMutationBlockedReport = createLegacyMutationBlockedReport;
+exports.printLegacyMutationBlockedReport = printLegacyMutationBlockedReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function createLegacyMutationBlockedReport(projectRoot, command) {
+    const scaffoldPath = node_path_1.default.join(projectRoot, '.hadara', 'scaffold.json');
+    if (!node_fs_1.default.existsSync(scaffoldPath)) {
+        return report(command, null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_MISSING',
+            path: '.hadara/scaffold.json',
+            message: 'This project does not declare HADARA protocol metadata. 0.4 mutation commands are disabled.'
+        });
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(scaffoldPath, 'utf8'));
+        if (parsed.hadaraProtocol === '0.4')
+            return null;
+        return report(command, typeof parsed.hadaraProtocol === 'string' ? parsed.hadaraProtocol : null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_UNSUPPORTED',
+            path: '.hadara/scaffold.json',
+            message: `.hadara/scaffold.json must declare hadaraProtocol "0.4" before running 0.4 mutation commands.`
+        });
+    }
+    catch (error) {
+        return report(command, null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_UNSUPPORTED',
+            path: '.hadara/scaffold.json',
+            message: `.hadara/scaffold.json could not be parsed: ${error instanceof Error ? error.message : String(error)}`
+        });
+    }
+}
+function printLegacyMutationBlockedReport(report, jsonOutput) {
+    if (jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`[HADARA] ${report.command} blocked: legacy or unsupported HADARA project`);
+    for (const issue of report.issues)
+        console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+}
+function report(command, detectedProtocol, issue) {
+    return {
+        schemaVersion: 'hadara.legacyProjectBoundary.v1',
+        command,
+        ok: false,
+        mutationAllowed: false,
+        detectedProtocol,
+        supportedProtocol: '0.4',
+        issues: [
+            issue,
+            {
+                severity: 'error',
+                code: 'HADARA_LEGACY_PROJECT_MUTATION_BLOCKED',
+                path: '.hadara/scaffold.json',
+                message: `${command} is a 0.4 mutation command and will not write into a legacy or unsupported project.`
+            }
+        ],
+        nextActions: [
+            {
+                label: 'Use the previous HADARA line for this project',
+                command: 'npx hadara@0.3.3 doctor --json'
+            },
+            {
+                label: 'Initialize a new HADARA 0.4 project',
+                command: 'hadara init --json'
+            }
+        ]
+    };
+}

package/dist/cli/main.js

@@ -34,11 +34,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGlobalArgs = normalizeGlobalArgs;
+exports.main = main;
 const paths_1 = require("../core/paths");
 const args_1 = require("./args");
 const errors_1 = require("./errors");
 const help_1 = require("./help");
+const GLOBAL_FLAGS = new Set(['--json']);
+const GLOBAL_OPTIONS_WITH_VALUES = new Set(['--project']);
+function normalizeGlobalArgs(args) {
+    let commandIndex = -1;
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (GLOBAL_FLAGS.has(value) || value === '--help' || value === '-h')
+            continue;
+        if (GLOBAL_OPTIONS_WITH_VALUES.has(value)) {
+            index += 1;
+            continue;
+        }
+        commandIndex = index;
+        break;
+    }
+    if (commandIndex <= 0)
+        return args;
+    return [args[commandIndex], ...args.slice(commandIndex + 1), ...args.slice(0, commandIndex)];
+}
 async function main(args = process.argv.slice(2)) {
+    args = normalizeGlobalArgs(args);
     const command = args[0];
     if (!command || command === '--help' || command === '-h') {
         console.log((0, help_1.renderDefaultHelp)());
@@ -101,6 +123,12 @@ async function main(args = process.argv.slice(2)) {
                 return;
             break;
         }
+        case 'validation': {
+            const { handleValidationCommand } = await Promise.resolve().then(() => __importStar(require('./validation')));
+            if (handleValidationCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
         case 'proof': {
             const { handleProofCommand } = await Promise.resolve().then(() => __importStar(require('./proof')));
             if (handleProofCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
@@ -222,6 +250,9 @@ async function main(args = process.argv.slice(2)) {
             break;
         }
         case 'release': {
+            const { handleReleaseCloseoutCommand } = await Promise.resolve().then(() => __importStar(require('./release-closeout')));
+            if (handleReleaseCloseoutCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
             const { handleReleaseDryRunCommand } = await Promise.resolve().then(() => __importStar(require('./release-dry-run')));
             if (handleReleaseDryRunCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
                 return;

package/dist/cli/package-smoke.js

@@ -1,10 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePackageCommand = handlePackageCommand;
+const package_recycle_1 = require("../services/package-recycle");
 const package_smoke_1 = require("../services/package-smoke");
 const args_1 = require("./args");
 function handlePackageCommand(input) {
-    if (input.args[0] !== 'package' || input.args[1] !== 'smoke')
+    if (input.args[0] !== 'package')
+        return false;
+    if (input.args[1] === 'recycle') {
+        const report = (0, package_recycle_1.createPackageRecycleReport)({
+            paths: input.paths,
+            execute: (0, args_1.getFlag)(input.args, '--execute'),
+            packageSpecifier: (0, args_1.getStringOption)(input.args, '--package'),
+            expectedVersion: (0, args_1.getStringOption)(input.args, '--expected-version'),
+            workspace: (0, args_1.getStringOption)(input.args, '--workspace'),
+            taskId: (0, args_1.getStringOption)(input.args, '--task'),
+            attachEvidence: (0, args_1.getFlag)(input.args, '--attach-evidence'),
+            noEvidence: (0, args_1.getFlag)(input.args, '--no-evidence'),
+            keepTemp: (0, args_1.getFlag)(input.args, '--keep-temp'),
+            includeGraph: (0, args_1.getFlag)(input.args, '--include-graph'),
+            timeoutSeconds: (0, args_1.getIntegerOption)(input.args, '--timeout', { min: 1 })
+        });
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`${report.ok ? 'passed' : 'failed'} | package recycle | ${report.mode}`);
+            for (const step of report.steps) {
+                console.log(`${step.status} | ${step.label} | ${step.summary}`);
+            }
+            for (const issue of report.issues) {
+                console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (input.args[1] !== 'smoke')
         return false;
     const options = {
         paths: input.paths,

package/dist/cli/release-artifact.js

@@ -5,9 +5,18 @@ const evidence_1 = require("../evidence/evidence");
 const release_artifact_evidence_1 = require("../services/release-artifact-evidence");
 const release_artifact_1 = require("../services/release-artifact");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 function handleReleaseArtifactCommand(input) {
     if (input.args[0] !== 'release' || input.args[1] !== 'artifact')
         return false;
+    if ((0, args_1.getFlag)(input.args, '--execute')) {
+        const legacyReport = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.paths.projectRoot, 'release.artifact');
+        if (legacyReport) {
+            (0, legacy_boundary_1.printLegacyMutationBlockedReport)(legacyReport, input.jsonOutput);
+            process.exitCode = 6;
+            return true;
+        }
+    }
     const report = (0, release_artifact_1.createReleaseArtifactReport)({
         paths: input.paths,
         execute: (0, args_1.getFlag)(input.args, '--execute'),

package/dist/cli/release-closeout.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReleaseCloseoutCommand = handleReleaseCloseoutCommand;
+const release_closeout_1 = require("../services/release-closeout");
+const args_1 = require("./args");
+function handleReleaseCloseoutCommand(input) {
+    if (input.args[0] !== 'release' || input.args[1] !== 'closeout')
+        return false;
+    const report = (0, release_closeout_1.createReleaseCloseoutReport)(input.projectRoot, {
+        version: (0, args_1.getStringOption)(input.args, '--version'),
+        taskId: (0, args_1.getStringOption)(input.args, '--task')
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log((0, release_closeout_1.formatReleaseCloseoutReport)(report));
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/cli/release-publish.js

@@ -3,10 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleReleasePublishCommand = handleReleasePublishCommand;
 const release_publish_1 = require("../services/release-publish");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 function handleReleasePublishCommand(input) {
     if (input.args[0] !== 'release' || input.args[1] !== 'publish')
         return false;
     const mode = parseMode(input.args);
+    if (mode === 'execute') {
+        const legacyReport = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.paths.projectRoot, 'release.publish');
+        if (legacyReport) {
+            (0, legacy_boundary_1.printLegacyMutationBlockedReport)(legacyReport, input.jsonOutput);
+            process.exitCode = 6;
+            return true;
+        }
+    }
     const report = (0, release_publish_1.createReleasePublishReport)({
         projectRoot: input.paths.projectRoot,
         auditDir: input.paths.auditDir,

package/dist/cli/task.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleTaskCommand = handleTaskCommand;
 exports.extractTaskCreateTitle = extractTaskCreateTitle;
 const task_close_1 = require("../task/task-close");
-const task_close_repair_plan_1 = require("../task/task-close-repair-plan");
 const task_complete_flow_1 = require("../task/task-complete-flow");
 const task_create_1 = require("../task/task-create");
 const task_finalize_1 = require("../task/task-finalize");
@@ -15,10 +14,14 @@ const task_upgrade_scaffold_1 = require("../task/task-upgrade-scaffold");
 const task_workbench_1 = require("../services/task-workbench");
 const actor_1 = require("./actor");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 const task_json_1 = require("./task-json");
 function handleTaskCommand(input) {
+    const startedAtMs = Date.now();
     const sub = input.args[1];
     if (sub === 'create') {
+        if (blockLegacyMutation(input, 'task.create'))
+            return true;
         const title = extractTaskCreateTitle(input.args);
         if (!title)
             throw new Error('task create requires a title');
@@ -74,6 +77,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'upgrade-scaffold') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.upgrade-scaffold'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task upgrade-scaffold requires --task <task-id>');
@@ -91,6 +96,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'close') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.close'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task close requires --task <task-id>');
@@ -112,11 +119,46 @@ function handleTaskCommand(input) {
             process.exitCode = 6;
         return true;
     }
-    if (sub === 'status') {
+    if (sub === 'close-source') {
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
-            throw new Error('task status requires --task <task-id>');
-        const report = (0, task_workbench_1.createTaskWorkbenchReport)(input.projectRoot, id);
+            throw new Error('task close-source requires --task <task-id>');
+        const report = (0, task_close_1.createTaskCloseSourceReport)(input.projectRoot, id);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`[HADARA] task close-source ${id}: ${report.ok ? 'ok' : 'issues'}`);
+            console.log(`sourceHash\t${report.sourceHash}`);
+            for (const unit of report.sourceUnits)
+                console.log(`${unit.closeSourceRole}\t${unit.kind}\t${unit.path}\t${unit.selector ?? ''}\t${unit.sha256}`);
+            for (const issue of report.issues)
+                console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (sub === 'status') {
+        const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
+        if (!id || id.startsWith('--')) {
+            const report = (0, task_workbench_1.createTaskStatusSelectionReport)(input.projectRoot);
+            attachCliDiagnostics(report, startedAtMs, 'task.status');
+            if (input.jsonOutput) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                console.log((0, task_workbench_1.formatTaskStatusSelectionReport)(report));
+            }
+            if (!report.ok)
+                process.exitCode = 6;
+            return true;
+        }
+        const detail = (0, args_1.getStringOption)(input.args, '--detail');
+        if (detail && detail !== 'fast' && detail !== 'full')
+            throw new Error('task status --detail must be fast or full');
+        const report = (0, task_workbench_1.createTaskWorkbenchReport)(input.projectRoot, id, new Date(), { detail: detail === 'full' ? 'full' : 'fast' });
+        attachCliDiagnostics(report, startedAtMs, 'task.status');
         if (input.jsonOutput) {
             console.log(JSON.stringify(report, null, 2));
         }
@@ -128,6 +170,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'complete') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.complete'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task complete requires --task <task-id>');
@@ -143,14 +187,19 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'finalize') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.finalize'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task finalize requires --task <task-id>');
+        const executeRequested = (0, args_1.getFlag)(input.args, '--execute');
         const report = (0, task_finalize_1.createTaskFinalizeReport)(input.projectRoot, id, {
-            executeRequested: (0, args_1.getFlag)(input.args, '--execute'),
+            executeRequested,
             planHash: (0, args_1.getStringOption)(input.args, '--plan-hash'),
-            actor: (0, actor_1.getActorContextOption)(input.args)
+            actor: (0, actor_1.getActorContextOption)(input.args),
+            onProgress: executeRequested ? createTaskFinalizeProgressWriter(id) : undefined
         });
+        attachCliDiagnostics(report, startedAtMs, 'task.finalize');
         if (input.jsonOutput) {
             console.log(JSON.stringify(report, null, 2));
         }
@@ -176,22 +225,9 @@ function handleTaskCommand(input) {
             process.exitCode = 6;
         return true;
     }
-    if (sub === 'close-repair-plan') {
-        const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
-        if (!id || id.startsWith('--'))
-            throw new Error('task close-repair-plan requires --task <task-id>');
-        const report = (0, task_close_repair_plan_1.createTaskCloseRepairPlanReport)(input.projectRoot, id, { actor: (0, actor_1.getActorContextOption)(input.args) });
-        if (input.jsonOutput) {
-            console.log(JSON.stringify(report, null, 2));
-        }
-        else {
-            console.log((0, task_close_repair_plan_1.formatTaskCloseRepairPlanReport)(report));
-        }
-        if (!report.ok)
-            process.exitCode = 6;
-        return true;
-    }
     if (sub === 'finish') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.finish'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task finish requires --task <task-id>');
@@ -245,6 +281,34 @@ function handleTaskCommand(input) {
     }
     return false;
 }
+function createTaskFinalizeProgressWriter(taskId) {
+    return (event) => {
+        const ok = event.ok === undefined ? '' : ` ok=${event.ok}`;
+        process.stderr.write(`[HADARA] task finalize ${taskId}: ${event.step} ${event.phase}${ok} - ${event.summary}\n`);
+    };
+}
+function attachCliDiagnostics(report, startedAtMs, commandPath) {
+    const durationMs = Math.max(0, Date.now() - startedAtMs);
+    const slowThresholdMs = 10000;
+    const slow = durationMs >= slowThresholdMs;
+    report.diagnostics = {
+        generatedBy: 'cli',
+        commandPath,
+        durationMs,
+        slowThresholdMs,
+        slow,
+        ...(slow ? { note: 'This command was slow enough to affect interactive agent UX; prefer narrower diagnostics or progress-aware follow-up work if this repeats.' } : {})
+    };
+    return report;
+}
+function blockLegacyMutation(input, command) {
+    const report = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.projectRoot, command);
+    if (!report)
+        return false;
+    (0, legacy_boundary_1.printLegacyMutationBlockedReport)(report, input.jsonOutput);
+    process.exitCode = 6;
+    return true;
+}
 function extractTaskCreateTitle(args) {
     const explicitTitle = (0, args_1.getStringOption)(args, '--title');
     if (explicitTitle)

package/dist/cli/validation.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleValidationCommand = handleValidationCommand;
+const validation_run_1 = require("../services/validation-run");
+const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
+function handleValidationCommand(input) {
+    const sub = input.args[1];
+    if (sub !== 'run')
+        return false;
+    if (blockLegacyMutation(input, 'validation.run'))
+        return true;
+    const separator = input.args.indexOf('--');
+    const commandArgs = separator >= 0 ? input.args.slice(separator + 1) : [];
+    const optionArgs = separator >= 0 ? input.args.slice(0, separator) : input.args;
+    const taskId = (0, args_1.getRequiredStringOption)(optionArgs, '--task');
+    const check = (0, args_1.getRequiredStringOption)(optionArgs, '--check');
+    const report = (0, validation_run_1.createValidationRunReport)(input.projectRoot, {
+        taskId,
+        check,
+        argv: commandArgs,
+        tags: resolutionTagsFromArgs(optionArgs),
+        timeoutMs: (0, args_1.getIntegerOption)(optionArgs, '--timeout-ms', { min: 1, max: 3_600_000 }),
+        updateTask: (0, args_1.getFlag)(optionArgs, '--update-task')
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`[HADARA] validation run ${taskId}: ${report.result}`);
+        if (report.evidence)
+            console.log(`evidence=${report.evidence.id}`);
+        if (!report.taskValidationRow.updated)
+            console.log(`taskValidationRow=${report.taskValidationRow.mode}`);
+        for (const issue of report.issues)
+            console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+        for (const action of report.nextActions)
+            console.log(`next=${action.command ?? action.message}`);
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}
+function blockLegacyMutation(input, command) {
+    const report = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.projectRoot, command);
+    if (!report)
+        return false;
+    (0, legacy_boundary_1.printLegacyMutationBlockedReport)(report, input.jsonOutput);
+    process.exitCode = 6;
+    return true;
+}
+function resolutionTagsFromArgs(args) {
+    const tags = [];
+    for (const id of getRepeatedStringOptions(args, '--resolves'))
+        tags.push(`resolves:${id}`);
+    for (const id of getRepeatedStringOptions(args, '--supersedes'))
+        tags.push(`supersedes:${id}`);
+    return tags.length > 0 ? tags : undefined;
+}
+function getRepeatedStringOptions(args, option) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== option)
+            continue;
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new Error(`missing value for ${option}`);
+        values.push(value);
+    }
+    return values;
+}