@aionis/manifest 0.1.1

package/dist/runtime-handoff.js

@@ -0,0 +1,383 @@
+import { z } from "zod";
+import { AIONIS_MANIFEST_COMPILE_RESULT_VERSION, AionisManifestCompileEnvelopeSchema, } from "./contracts.js";
+import { buildExecutionPlanV1 } from "./plan/buildExecutionPlan.js";
+export const AIONIS_MANIFEST_RUNTIME_HANDOFF_VERSION = "aionis_manifest_runtime_handoff_v1";
+const RuntimeExecutionStageSchema = z.enum(["triage", "patch", "review", "resume"]);
+const RuntimeExecutionRoleSchema = z.enum(["orchestrator", "triage", "patch", "review", "resume"]);
+const RuntimeStringListSchema = z.array(z.string().min(1));
+export const RuntimeReviewerContractSchema = z.object({
+    standard: z.string().trim().min(1),
+    required_outputs: RuntimeStringListSchema,
+    acceptance_checks: RuntimeStringListSchema,
+    rollback_required: z.boolean(),
+});
+export const RuntimeResumeAnchorSchema = z.object({
+    anchor: z.string().trim().min(1),
+    file_path: z.string().trim().min(1).nullable(),
+    symbol: z.string().trim().min(1).nullable(),
+    repo_root: z.string().trim().min(1).nullable(),
+});
+export const RuntimeExecutionStateSchema = z.object({
+    state_id: z.string().trim().min(1),
+    scope: z.string().trim().min(1),
+    task_brief: z.string().trim().min(1),
+    current_stage: RuntimeExecutionStageSchema,
+    active_role: RuntimeExecutionRoleSchema,
+    owned_files: z.array(z.string()),
+    modified_files: z.array(z.string()),
+    pending_validations: z.array(z.string()),
+    completed_validations: z.array(z.string()),
+    last_accepted_hypothesis: z.string().trim().min(1).nullable(),
+    rejected_paths: z.array(z.string()),
+    unresolved_blockers: z.array(z.string()),
+    rollback_notes: z.array(z.string()),
+    reviewer_contract: RuntimeReviewerContractSchema.nullable(),
+    resume_anchor: RuntimeResumeAnchorSchema.nullable(),
+    updated_at: z.string().min(1),
+    version: z.literal(1),
+});
+export const RuntimeExecutionPacketSchema = z.object({
+    version: z.literal(1),
+    state_id: z.string().trim().min(1),
+    current_stage: RuntimeExecutionStageSchema,
+    active_role: RuntimeExecutionRoleSchema,
+    task_brief: z.string().trim().min(1),
+    target_files: z.array(z.string()),
+    next_action: z.string().trim().min(1).nullable(),
+    hard_constraints: z.array(z.string()),
+    accepted_facts: z.array(z.string()),
+    rejected_paths: z.array(z.string()),
+    pending_validations: z.array(z.string()),
+    unresolved_blockers: z.array(z.string()),
+    rollback_notes: z.array(z.string()),
+    review_contract: RuntimeReviewerContractSchema.nullable(),
+    resume_anchor: RuntimeResumeAnchorSchema.nullable(),
+    artifact_refs: z.array(z.string()),
+    evidence_refs: z.array(z.string()),
+});
+export const RuntimeExecutionReadyHandoffSchema = z.object({
+    anchor: z.string().trim().min(1),
+    handoff_kind: z.literal("task_handoff"),
+    summary: z.string().trim().min(1).nullable(),
+    handoff_text: z.string().trim().min(1),
+    acceptance_checks: z.array(z.string()),
+    target_files: z.array(z.string()),
+    next_action: z.string().trim().min(1).nullable(),
+});
+export const RuntimeGraphSummarySchema = z.object({
+    graph_id: z.string().trim().min(1).nullable(),
+    execution_count: z.number().int().nonnegative(),
+    graph_node_count: z.number().int().nonnegative(),
+    graph_edge_count: z.number().int().nonnegative(),
+    module_refs: z.array(z.string()),
+    output_refs: z.array(z.string()),
+    expected_outputs: z.array(z.string()),
+    artifact_count: z.number().int().nonnegative(),
+    evidence_count: z.number().int().nonnegative(),
+});
+export const RuntimeExecutionArtifactSchema = z.object({
+    ref: z.string().trim().min(1),
+    execution_id: z.string().trim().min(1),
+    module: z.string().trim().min(1).optional(),
+    value: z.unknown(),
+});
+export const RuntimeExecutionEvidenceSchema = z.object({
+    ref: z.string().trim().min(1),
+    execution_id: z.string().trim().min(1),
+    module: z.string().trim().min(1).optional(),
+    value: z.unknown(),
+});
+export const RuntimeExecutionResultSummarySchema = z.object({
+    runtime_id: z.string().trim().min(1),
+    status: z.enum(["success", "failed"]),
+    output_refs: z.array(z.string()),
+    artifact_count: z.number().int().nonnegative(),
+    evidence_count: z.number().int().nonnegative(),
+});
+export const AionisManifestRuntimeHandoffSchema = z.object({
+    runtime_handoff_version: z.literal(AIONIS_MANIFEST_RUNTIME_HANDOFF_VERSION),
+    source_compile_result_version: z.literal(AIONIS_MANIFEST_COMPILE_RESULT_VERSION),
+    generated_at: z.string().min(1),
+    source_doc_id: z.string().trim().min(1),
+    source_doc_version: z.string().trim().min(1),
+    scope: z.string().trim().min(1),
+    task_brief: z.string().trim().min(1),
+    graph_summary: RuntimeGraphSummarySchema,
+    execution_result_summary: RuntimeExecutionResultSummarySchema.nullable(),
+    execution_artifacts: z.array(RuntimeExecutionArtifactSchema),
+    execution_evidence: z.array(RuntimeExecutionEvidenceSchema),
+    execution_state_v1: RuntimeExecutionStateSchema,
+    execution_packet_v1: RuntimeExecutionPacketSchema,
+    execution_ready_handoff: RuntimeExecutionReadyHandoffSchema,
+});
+export class AionisManifestRuntimeHandoffError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AionisManifestRuntimeHandoffError";
+    }
+}
+function inferTaskBrief(result) {
+    const title = result.ir.doc?.title?.trim();
+    if (title)
+        return title;
+    const objective = result.ir.context.find((entry) => typeof entry.objective === "string" && entry.objective.trim().length > 0)?.objective?.trim();
+    if (objective)
+        return objective;
+    if (result.ir.doc?.kind)
+        return `Execute AionisManifest ${result.ir.doc.kind}`;
+    return `Execute AionisManifest ${result.ir.doc?.id ?? "unknown"}`;
+}
+function inferStage(result) {
+    if (result.ir.executions.length > 0)
+        return "patch";
+    return "triage";
+}
+function inferRole(stage) {
+    if (stage === "patch")
+        return "patch";
+    if (stage === "review")
+        return "review";
+    if (stage === "resume")
+        return "resume";
+    return "triage";
+}
+function collectContextConstraints(result) {
+    return result.ir.context.flatMap((entry) => entry.constraints ?? []);
+}
+function collectExpectedOutputs(result) {
+    return result.ir.replay.flatMap((entry) => entry.expected_outputs ?? []);
+}
+function collectEvidenceRefs(result) {
+    const refs = [];
+    for (const evidence of result.ir.evidence) {
+        for (const source of evidence.sources ?? []) {
+            if (!source || typeof source !== "object" || Array.isArray(source))
+                continue;
+            const ref = "ref" in source && typeof source.ref === "string"
+                ? String(source.ref)
+                : null;
+            if (ref)
+                refs.push(ref);
+        }
+    }
+    return refs;
+}
+function buildExecutionArtifactRecords(executionResult) {
+    const records = executionResult?.artifacts ?? [];
+    return records.map((record, index) => RuntimeExecutionArtifactSchema.parse({
+        ref: `artifact:${record.execution_id}:${index + 1}`,
+        execution_id: record.execution_id,
+        module: record.module,
+        value: record.value,
+    }));
+}
+function buildExecutionEvidenceRecords(executionResult) {
+    const records = executionResult?.evidence ?? [];
+    return records.map((record, index) => RuntimeExecutionEvidenceSchema.parse({
+        ref: `evidence:${record.execution_id}:${index + 1}`,
+        execution_id: record.execution_id,
+        module: record.module,
+        value: record.value,
+    }));
+}
+function collectModuleRefs(result) {
+    return result.ir.executions.flatMap((entry) => (entry.module ? [entry.module] : []));
+}
+function collectOutputRefs(result) {
+    return result.ir.executions.flatMap((entry) => (entry.output_ref ? [entry.output_ref] : []));
+}
+function collectAcceptedFacts(result) {
+    const facts = new Set();
+    if (result.ir.doc?.id)
+        facts.add(`doc_id:${result.ir.doc.id}`);
+    if (result.ir.doc?.version)
+        facts.add(`doc_version:${result.ir.doc.version}`);
+    for (const moduleRef of collectModuleRefs(result)) {
+        facts.add(`module:${moduleRef}`);
+    }
+    for (const outputRef of collectOutputRefs(result)) {
+        facts.add(`output_ref:${outputRef}`);
+    }
+    for (const decision of result.ir.decisions) {
+        if (decision.decision)
+            facts.add(`decision:${decision.decision}`);
+    }
+    return [...facts];
+}
+function inferNextAction(result, expectedOutputs) {
+    if (expectedOutputs.length > 0) {
+        return `Produce expected outputs: ${expectedOutputs.join(" | ")}`;
+    }
+    const firstModule = result.ir.executions.find((entry) => entry.module)?.module;
+    if (firstModule) {
+        return `Execute module chain starting with ${firstModule}`;
+    }
+    return null;
+}
+function buildReviewerContract(result, expectedOutputs, acceptanceChecks) {
+    if (expectedOutputs.length === 0 && acceptanceChecks.length === 0) {
+        return null;
+    }
+    return RuntimeReviewerContractSchema.parse({
+        standard: "aionis_manifest_runtime_handoff_v1",
+        required_outputs: expectedOutputs,
+        acceptance_checks: acceptanceChecks,
+        rollback_required: false,
+    });
+}
+function ensureRunnable(result, requireErrorFree) {
+    if (!result.ir.doc) {
+        throw new AionisManifestRuntimeHandoffError("Runtime handoff requires a compiled manifest with @manifest metadata. Legacy @doc is still accepted.");
+    }
+    if (requireErrorFree && result.diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+        throw new AionisManifestRuntimeHandoffError("Runtime handoff requires an error-free compile result.");
+    }
+}
+export function buildRuntimeHandoffV1(args) {
+    const scope = args.scope?.trim() || "default";
+    const generatedAt = args.generatedAt ?? new Date().toISOString();
+    const requireErrorFree = args.requireErrorFree ?? true;
+    ensureRunnable(args.result, requireErrorFree);
+    const doc = args.result.ir.doc;
+    const taskBrief = inferTaskBrief(args.result);
+    const currentStage = args.currentStage ?? inferStage(args.result);
+    const activeRole = args.activeRole ?? inferRole(currentStage);
+    const expectedOutputs = collectExpectedOutputs(args.result);
+    const hardConstraints = collectContextConstraints(args.result);
+    const executionArtifacts = buildExecutionArtifactRecords(args.executionResult);
+    const executionEvidence = buildExecutionEvidenceRecords(args.executionResult);
+    const artifactRefs = executionArtifacts.map((record) => record.ref);
+    const evidenceRefs = [
+        ...collectEvidenceRefs(args.result),
+        ...executionEvidence.map((record) => record.ref),
+    ];
+    const acceptedFacts = collectAcceptedFacts(args.result);
+    const nextAction = inferNextAction(args.result, expectedOutputs);
+    const reviewerContract = buildReviewerContract(args.result, expectedOutputs, hardConstraints);
+    const executionResultSummary = args.executionResult
+        ? RuntimeExecutionResultSummarySchema.parse({
+            runtime_id: args.executionResult.runtime_id,
+            status: args.executionResult.status,
+            output_refs: Object.keys(args.executionResult.outputs),
+            artifact_count: executionArtifacts.length,
+            evidence_count: executionEvidence.length,
+        })
+        : null;
+    const stateId = `aionis-manifest:${doc.id}`;
+    const resumeAnchor = RuntimeResumeAnchorSchema.parse({
+        anchor: stateId,
+        file_path: args.filePath ?? null,
+        symbol: args.symbol ?? null,
+        repo_root: args.repoRoot ?? null,
+    });
+    const executionState = RuntimeExecutionStateSchema.parse({
+        state_id: stateId,
+        scope,
+        task_brief: taskBrief,
+        current_stage: currentStage,
+        active_role: activeRole,
+        owned_files: [],
+        modified_files: [],
+        pending_validations: expectedOutputs,
+        completed_validations: [],
+        last_accepted_hypothesis: null,
+        rejected_paths: [],
+        unresolved_blockers: [],
+        rollback_notes: [],
+        reviewer_contract: reviewerContract,
+        resume_anchor: resumeAnchor,
+        updated_at: generatedAt,
+        version: 1,
+    });
+    const executionPacket = RuntimeExecutionPacketSchema.parse({
+        version: 1,
+        state_id: stateId,
+        current_stage: currentStage,
+        active_role: activeRole,
+        task_brief: taskBrief,
+        target_files: [],
+        next_action: nextAction,
+        hard_constraints: hardConstraints,
+        accepted_facts: acceptedFacts,
+        rejected_paths: [],
+        pending_validations: expectedOutputs,
+        unresolved_blockers: [],
+        rollback_notes: [],
+        review_contract: reviewerContract,
+        resume_anchor: resumeAnchor,
+        artifact_refs: artifactRefs,
+        evidence_refs: evidenceRefs,
+    });
+    const executionReadyHandoff = RuntimeExecutionReadyHandoffSchema.parse({
+        anchor: stateId,
+        handoff_kind: "task_handoff",
+        summary: doc.title ?? taskBrief,
+        handoff_text: taskBrief,
+        acceptance_checks: reviewerContract?.acceptance_checks ?? [],
+        target_files: [],
+        next_action: nextAction,
+    });
+    return AionisManifestRuntimeHandoffSchema.parse({
+        runtime_handoff_version: AIONIS_MANIFEST_RUNTIME_HANDOFF_VERSION,
+        source_compile_result_version: AIONIS_MANIFEST_COMPILE_RESULT_VERSION,
+        generated_at: generatedAt,
+        source_doc_id: doc.id,
+        source_doc_version: doc.version,
+        scope,
+        task_brief: taskBrief,
+        graph_summary: {
+            graph_id: args.result.graph?.graph_id ?? null,
+            execution_count: args.result.ir.executions.length,
+            graph_node_count: args.result.graph?.nodes.length ?? 0,
+            graph_edge_count: args.result.graph?.edges.length ?? 0,
+            module_refs: collectModuleRefs(args.result),
+            output_refs: collectOutputRefs(args.result),
+            expected_outputs: expectedOutputs,
+            artifact_count: executionArtifacts.length,
+            evidence_count: executionEvidence.length,
+        },
+        execution_result_summary: executionResultSummary,
+        execution_artifacts: executionArtifacts,
+        execution_evidence: executionEvidence,
+        execution_state_v1: executionState,
+        execution_packet_v1: executionPacket,
+        execution_ready_handoff: executionReadyHandoff,
+    });
+}
+export function buildRuntimeHandoffV1FromEnvelope(args) {
+    const envelope = AionisManifestCompileEnvelopeSchema.parse(args.envelope);
+    if (!envelope.artifacts.ir) {
+        throw new AionisManifestRuntimeHandoffError(`Runtime handoff requires an envelope with IR artifacts. Re-run compile-aionis-manifest with --emit all or --emit ir; current selected_artifact is '${envelope.selected_artifact}'.`);
+    }
+    const result = compileResultFromEnvelope(envelope);
+    return buildRuntimeHandoffV1({
+        inputPath: envelope.input_path,
+        result,
+        ...args,
+    });
+}
+function compileResultFromEnvelope(envelope) {
+    const ir = envelope.artifacts.ir;
+    const graph = envelope.artifacts.graph;
+    return {
+        ast: (envelope.artifacts.ast ??
+            {
+                type: "DocumentNode",
+                children: [],
+                diagnostics: envelope.diagnostics,
+                loc: {
+                    start: { line: 1, column: 1, offset: 0 },
+                    end: { line: 1, column: 1, offset: 0 },
+                },
+            }),
+        ir,
+        graph,
+        plan: (envelope.artifacts.plan ??
+            buildExecutionPlanV1({
+                ir,
+                graph,
+                diagnostics: envelope.diagnostics,
+            })),
+        diagnostics: envelope.diagnostics,
+    };
+}

package/dist/scanner/scanSource.d.ts

@@ -0,0 +1,9 @@
+import type { SourcePos, SourceRange } from "../diagnostics/types.js";
+export interface ScanResult {
+    source: string;
+    lineStarts: number[];
+}
+export declare function scanSource(source: string): ScanResult;
+export declare function findLineIndexAtOffset(scan: ScanResult, offset: number): number;
+export declare function offsetToSourcePos(scan: ScanResult, offset: number): SourcePos;
+export declare function rangeFromOffsets(scan: ScanResult, start: number, end: number): SourceRange;

package/dist/scanner/scanSource.js

@@ -0,0 +1,43 @@
+export function scanSource(source) {
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i += 1) {
+        if (source[i] === "\n") {
+            lineStarts.push(i + 1);
+        }
+    }
+    return { source, lineStarts };
+}
+export function findLineIndexAtOffset(scan, offset) {
+    let low = 0;
+    let high = scan.lineStarts.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const start = scan.lineStarts[mid];
+        const next = mid + 1 < scan.lineStarts.length ? scan.lineStarts[mid + 1] : scan.source.length + 1;
+        if (offset < start) {
+            high = mid - 1;
+        }
+        else if (offset >= next) {
+            low = mid + 1;
+        }
+        else {
+            return mid;
+        }
+    }
+    return Math.max(0, scan.lineStarts.length - 1);
+}
+export function offsetToSourcePos(scan, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, scan.source.length));
+    const lineIndex = findLineIndexAtOffset(scan, safeOffset);
+    return {
+        line: lineIndex + 1,
+        column: safeOffset - scan.lineStarts[lineIndex] + 1,
+        offset: safeOffset,
+    };
+}
+export function rangeFromOffsets(scan, start, end) {
+    return {
+        start: offsetToSourcePos(scan, start),
+        end: offsetToSourcePos(scan, end),
+    };
+}

package/dist/schema/validateIrSchemas.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { AionisManifestIR } from "../ir/types.js";
+export declare function validateIrSchemas(ir: AionisManifestIR): Diagnostic[];

package/dist/schema/validateIrSchemas.js

@@ -0,0 +1,64 @@
+export function validateIrSchemas(ir) {
+    const diagnostics = [];
+    if (!ir.doc) {
+        diagnostics.push({
+            severity: "error",
+            code: "MISSING_MANIFEST",
+            message: "Manifest is missing a @manifest metadata directive. Legacy @doc is still accepted.",
+            loc: ir.executions[0]?.loc ?? ir.context[0]?.loc ?? ir.replay[0]?.loc ?? ir.diagnostics[0]?.loc ?? {
+                start: { line: 1, column: 1, offset: 0 },
+                end: { line: 1, column: 1, offset: 0 },
+            },
+        });
+        return diagnostics;
+    }
+    if (ir.doc.id.trim().length === 0) {
+        diagnostics.push({
+            severity: "error",
+            code: "INVALID_SCHEMA",
+            message: "@manifest.id must be a non-empty string.",
+            loc: ir.doc.loc ?? {
+                start: { line: 1, column: 1, offset: 0 },
+                end: { line: 1, column: 1, offset: 0 },
+            },
+        });
+    }
+    if (ir.doc.version.trim().length === 0) {
+        diagnostics.push({
+            severity: "error",
+            code: "INVALID_SCHEMA",
+            message: "@manifest.version must be a non-empty string.",
+            loc: ir.doc.loc ?? {
+                start: { line: 1, column: 1, offset: 0 },
+                end: { line: 1, column: 1, offset: 0 },
+            },
+        });
+    }
+    for (const execution of ir.executions) {
+        if (!execution.module && !execution.tool && !execution.agent) {
+            diagnostics.push({
+                severity: "error",
+                code: "INVALID_SCHEMA",
+                message: "@execute requires at least one of module, tool, or agent.",
+                loc: execution.loc ?? ir.doc.loc ?? {
+                    start: { line: 1, column: 1, offset: 0 },
+                    end: { line: 1, column: 1, offset: 0 },
+                },
+            });
+        }
+    }
+    for (const replay of ir.replay) {
+        if (replay.mode && !["deterministic", "assisted", "advisory"].includes(replay.mode)) {
+            diagnostics.push({
+                severity: "error",
+                code: "INVALID_SCHEMA",
+                message: `Unsupported replay mode '${replay.mode}'.`,
+                loc: replay.loc ?? ir.doc.loc ?? {
+                    start: { line: 1, column: 1, offset: 0 },
+                    end: { line: 1, column: 1, offset: 0 },
+                },
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/validate-module-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/validate-module-cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { resolveOutputPath, validateAionisManifestModule, writeValidationOutput } from "./validate.js";
+class CliUsageError extends Error {
+}
+function printHelp() {
+    process.stdout.write([
+        "validate-aionis-manifest-module",
+        "",
+        "Usage:",
+        "  validate-aionis-manifest-module <entry-file> [--declared-module <module>] [--out <path>] [--compact]",
+        "",
+        "Options:",
+        "  --declared-module <module>  Require the entry manifest to match the declared module id",
+        "  --out <path>                Write output JSON to a file instead of stdout",
+        "  --compact                   Print compact JSON instead of pretty JSON",
+        "  --help                      Show this message",
+        "",
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    let entryPath = null;
+    const flags = {
+        declaredModule: null,
+        out: null,
+        compact: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token === "--help" || token === "-h") {
+            flags.help = true;
+            continue;
+        }
+        if (token === "--compact") {
+            flags.compact = true;
+            continue;
+        }
+        if (token === "--declared-module") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --declared-module.");
+            flags.declaredModule = next;
+            i += 1;
+            continue;
+        }
+        if (token === "--out") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --out.");
+            flags.out = next;
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("--"))
+            throw new CliUsageError(`Unknown flag '${token}'.`);
+        if (entryPath)
+            throw new CliUsageError("Only one entry file may be provided.");
+        entryPath = token;
+    }
+    return { entryPath, flags };
+}
+async function main() {
+    const { entryPath, flags } = parseArgs(process.argv.slice(2));
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    if (!entryPath)
+        throw new CliUsageError("An entry file path is required.");
+    const result = await validateAionisManifestModule({
+        entryPath,
+        declaredModule: flags.declaredModule ?? undefined,
+        cwd: process.cwd(),
+    });
+    const rendered = flags.compact ? JSON.stringify(result) : `${JSON.stringify(result, null, 2)}\n`;
+    if (flags.out) {
+        await writeValidationOutput(resolveOutputPath(flags.out), rendered);
+        return;
+    }
+    process.stdout.write(rendered);
+}
+main().catch((error) => {
+    if (error instanceof CliUsageError) {
+        process.stderr.write(`${error.message}\n`);
+        printHelp();
+        process.exitCode = 2;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/validate-registry-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/validate-registry-cli.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import process from "node:process";
+import { resolveOutputPath, validateAionisManifestRegistry, writeValidationOutput } from "./validate.js";
+class CliUsageError extends Error {
+}
+function printHelp() {
+    process.stdout.write([
+        "validate-aionis-manifest-registry",
+        "",
+        "Usage:",
+        "  validate-aionis-manifest-registry <registry-file> [--out <path>] [--compact]",
+        "",
+        "Options:",
+        "  --out <path>      Write output JSON to a file instead of stdout",
+        "  --compact         Print compact JSON instead of pretty JSON",
+        "  --help            Show this message",
+        "",
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    let registryPath = null;
+    const flags = {
+        out: null,
+        compact: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token === "--help" || token === "-h") {
+            flags.help = true;
+            continue;
+        }
+        if (token === "--compact") {
+            flags.compact = true;
+            continue;
+        }
+        if (token === "--out") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --out.");
+            flags.out = next;
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("--"))
+            throw new CliUsageError(`Unknown flag '${token}'.`);
+        if (registryPath)
+            throw new CliUsageError("Only one registry file may be provided.");
+        registryPath = token;
+    }
+    return { registryPath, flags };
+}
+async function main() {
+    const { registryPath, flags } = parseArgs(process.argv.slice(2));
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    if (!registryPath)
+        throw new CliUsageError("A registry file path is required.");
+    const result = await validateAionisManifestRegistry({
+        registryPath: resolve(process.cwd(), registryPath),
+    });
+    const rendered = flags.compact ? JSON.stringify(result) : `${JSON.stringify(result, null, 2)}\n`;
+    if (flags.out) {
+        await writeValidationOutput(resolveOutputPath(flags.out), rendered);
+        return;
+    }
+    process.stdout.write(rendered);
+}
+main().catch((error) => {
+    if (error instanceof CliUsageError) {
+        process.stderr.write(`${error.message}\n`);
+        printHelp();
+        process.exitCode = 2;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});