@aionis/manifest 0.1.1

package/dist/parser/parseAst.js

@@ -0,0 +1,207 @@
+import { rangeFromOffsets } from "../scanner/scanSource.js";
+import { parseAionisPayload } from "./payload.js";
+function isFenceLine(line) {
+    return /^\s*```/.test(line);
+}
+function isHeadingLine(line) {
+    return /^#{1,6}\s+/.test(line);
+}
+function isDirectiveLine(line) {
+    return /^\s*@[A-Za-z][A-Za-z0-9_.-]*/.test(line);
+}
+function countNewlines(source, start, end) {
+    let count = 0;
+    for (let i = start; i < end; i += 1) {
+        if (source[i] === "\n")
+            count += 1;
+    }
+    return count;
+}
+function findDirectiveBlockEnd(source, braceStart) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = braceStart; i < source.length; i += 1) {
+        const char = source[i];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return -1;
+}
+function makeInvalidDirectiveDiagnostic(scan, start, end, message) {
+    return {
+        severity: "error",
+        code: "INVALID_PAYLOAD",
+        message,
+        loc: rangeFromOffsets(scan, start, end),
+        hint: "Directives must be followed by a balanced { ... } payload.",
+    };
+}
+export function parseAst(scan) {
+    const lines = scan.source.split("\n");
+    const children = [];
+    const diagnostics = [];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex];
+        const lineStart = scan.lineStarts[lineIndex] ?? scan.source.length;
+        if (line.trim().length === 0) {
+            continue;
+        }
+        if (isFenceLine(line)) {
+            const startOffset = lineStart;
+            const fenceStart = line.trim();
+            const info = fenceStart.slice(3).trim() || undefined;
+            let endLineIndex = lineIndex;
+            while (endLineIndex + 1 < lines.length) {
+                endLineIndex += 1;
+                if (isFenceLine(lines[endLineIndex])) {
+                    break;
+                }
+            }
+            const isClosed = endLineIndex !== lineIndex && isFenceLine(lines[endLineIndex]);
+            const endOffset = endLineIndex + 1 < scan.lineStarts.length ? scan.lineStarts[endLineIndex + 1] : scan.source.length;
+            const node = {
+                type: "CodeFenceNode",
+                fence: "```",
+                info,
+                content: lines.slice(lineIndex + 1, isClosed ? endLineIndex : endLineIndex + 1).join("\n"),
+                raw: scan.source.slice(startOffset, endOffset),
+                loc: rangeFromOffsets(scan, startOffset, endOffset),
+            };
+            children.push(node);
+            if (!isClosed) {
+                diagnostics.push({
+                    severity: "warning",
+                    code: "UNCLOSED_FENCE",
+                    message: "Code fence reaches end of file without a closing delimiter.",
+                    loc: node.loc,
+                });
+            }
+            lineIndex = endLineIndex;
+            continue;
+        }
+        if (isHeadingLine(line)) {
+            const match = /^(#{1,6})\s+(.*)$/.exec(line);
+            if (match) {
+                const node = {
+                    type: "HeadingNode",
+                    depth: match[1].length,
+                    text: match[2],
+                    raw: line,
+                    loc: rangeFromOffsets(scan, lineStart, lineStart + line.length),
+                };
+                children.push(node);
+                continue;
+            }
+        }
+        if (isDirectiveLine(line)) {
+            const match = /^(\s*)@([A-Za-z][A-Za-z0-9_.-]*)/.exec(line);
+            if (!match)
+                continue;
+            const directiveStart = lineStart + match[1].length;
+            const afterHead = directiveStart + 1 + match[2].length;
+            let payloadStart = afterHead;
+            while (payloadStart < scan.source.length && /\s/.test(scan.source[payloadStart])) {
+                payloadStart += 1;
+            }
+            if (scan.source[payloadStart] !== "{") {
+                const endOffset = lineStart + line.length;
+                const node = {
+                    type: "DirectiveNode",
+                    name: match[2],
+                    payload: null,
+                    raw: scan.source.slice(directiveStart, endOffset),
+                    loc: rangeFromOffsets(scan, directiveStart, endOffset),
+                    diagnostics: [
+                        makeInvalidDirectiveDiagnostic(scan, directiveStart, endOffset, "Directive is missing an object payload."),
+                    ],
+                };
+                children.push(node);
+                diagnostics.push(...(node.diagnostics ?? []));
+                continue;
+            }
+            const endOffset = findDirectiveBlockEnd(scan.source, payloadStart);
+            if (endOffset < 0) {
+                const node = {
+                    type: "DirectiveNode",
+                    name: match[2],
+                    payload: null,
+                    raw: scan.source.slice(directiveStart),
+                    loc: rangeFromOffsets(scan, directiveStart, scan.source.length),
+                    diagnostics: [
+                        makeInvalidDirectiveDiagnostic(scan, directiveStart, scan.source.length, "Directive payload ends before its closing brace."),
+                    ],
+                };
+                children.push(node);
+                diagnostics.push(...(node.diagnostics ?? []));
+                break;
+            }
+            const loc = rangeFromOffsets(scan, directiveStart, endOffset);
+            const payload = parseAionisPayload(scan.source.slice(payloadStart, endOffset), loc);
+            const node = {
+                type: "DirectiveNode",
+                name: match[2],
+                payload: payload.value,
+                raw: scan.source.slice(directiveStart, endOffset),
+                loc,
+                diagnostics: payload.diagnostics,
+            };
+            children.push(node);
+            diagnostics.push(...payload.diagnostics);
+            lineIndex += countNewlines(scan.source, directiveStart, endOffset);
+            continue;
+        }
+        const paragraphStart = lineStart;
+        let paragraphEndLine = lineIndex;
+        while (paragraphEndLine + 1 < lines.length) {
+            const next = lines[paragraphEndLine + 1];
+            if (next.trim().length === 0 ||
+                isFenceLine(next) ||
+                isHeadingLine(next) ||
+                isDirectiveLine(next)) {
+                break;
+            }
+            paragraphEndLine += 1;
+        }
+        const paragraphEndOffset = paragraphEndLine + 1 < scan.lineStarts.length ? scan.lineStarts[paragraphEndLine + 1] : scan.source.length;
+        const node = {
+            type: "ParagraphNode",
+            text: lines.slice(lineIndex, paragraphEndLine + 1).join("\n").trim(),
+            raw: scan.source.slice(paragraphStart, paragraphEndOffset),
+            loc: rangeFromOffsets(scan, paragraphStart, paragraphEndOffset),
+        };
+        children.push(node);
+        lineIndex = paragraphEndLine;
+    }
+    return {
+        type: "DocumentNode",
+        children,
+        diagnostics,
+        loc: rangeFromOffsets(scan, 0, scan.source.length),
+    };
+}

package/dist/parser/payload.d.ts

@@ -0,0 +1,6 @@
+import type { Diagnostic, SourceRange } from "../diagnostics/types.js";
+import type { AionisValue } from "../ir/types.js";
+export declare function parseAionisPayload(raw: string, loc: SourceRange): {
+    value: AionisValue | null;
+    diagnostics: Diagnostic[];
+};

package/dist/parser/payload.js

@@ -0,0 +1,211 @@
+class PayloadSyntaxError extends Error {
+    index;
+    constructor(message, index) {
+        super(message);
+        this.name = "PayloadSyntaxError";
+        this.index = index;
+    }
+}
+class PayloadParser {
+    text;
+    index = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    parse() {
+        this.skipWhitespace();
+        const value = this.parseValue();
+        this.skipWhitespace();
+        if (!this.isAtEnd()) {
+            throw new PayloadSyntaxError("Unexpected trailing content in directive payload.", this.index);
+        }
+        return value;
+    }
+    parseValue() {
+        const char = this.peek();
+        if (char === "{")
+            return this.parseObject();
+        if (char === "[")
+            return this.parseArray();
+        if (char === "\"" || char === "'")
+            return this.parseString();
+        if (char === "-" || this.isDigit(char))
+            return this.parseNumber();
+        if (this.isIdentifierStart(char))
+            return this.parseLiteral();
+        throw new PayloadSyntaxError(`Unexpected token '${char ?? "EOF"}' in payload.`, this.index);
+    }
+    parseObject() {
+        this.expect("{");
+        this.skipWhitespace();
+        const out = {};
+        if (this.peek() === "}") {
+            this.index += 1;
+            return out;
+        }
+        while (!this.isAtEnd()) {
+            const key = this.parseKey();
+            this.skipWhitespace();
+            this.expect(":");
+            this.skipWhitespace();
+            out[key] = this.parseValue();
+            this.skipWhitespace();
+            if (this.peek() === ",") {
+                this.index += 1;
+                this.skipWhitespace();
+            }
+            if (this.peek() === "}") {
+                this.index += 1;
+                return out;
+            }
+        }
+        throw new PayloadSyntaxError("Expected closing brace for object payload.", this.index);
+    }
+    parseArray() {
+        this.expect("[");
+        this.skipWhitespace();
+        const out = [];
+        if (this.peek() === "]") {
+            this.index += 1;
+            return out;
+        }
+        while (!this.isAtEnd()) {
+            out.push(this.parseValue());
+            this.skipWhitespace();
+            if (this.peek() === ",") {
+                this.index += 1;
+                this.skipWhitespace();
+                continue;
+            }
+            if (this.peek() === "]") {
+                this.index += 1;
+                return out;
+            }
+            throw new PayloadSyntaxError("Expected ',' or ']' inside array payload.", this.index);
+        }
+        throw new PayloadSyntaxError("Expected closing bracket for array payload.", this.index);
+    }
+    parseKey() {
+        const char = this.peek();
+        if (char === "\"" || char === "'") {
+            return this.parseString();
+        }
+        if (!this.isIdentifierStart(char)) {
+            throw new PayloadSyntaxError("Expected an object key.", this.index);
+        }
+        const start = this.index;
+        this.index += 1;
+        while (!this.isAtEnd() && this.isIdentifierPart(this.peek())) {
+            this.index += 1;
+        }
+        return this.text.slice(start, this.index);
+    }
+    parseString() {
+        const quote = this.peek();
+        if (quote !== "\"" && quote !== "'") {
+            throw new PayloadSyntaxError("Expected a quoted string.", this.index);
+        }
+        this.index += 1;
+        let out = "";
+        while (!this.isAtEnd()) {
+            const char = this.text[this.index];
+            if (char === "\\") {
+                const next = this.text[this.index + 1];
+                if (next === undefined) {
+                    throw new PayloadSyntaxError("String ends with a dangling escape.", this.index);
+                }
+                const escapes = {
+                    "\"": "\"",
+                    "'": "'",
+                    "\\": "\\",
+                    n: "\n",
+                    r: "\r",
+                    t: "\t",
+                };
+                out += escapes[next] ?? next;
+                this.index += 2;
+                continue;
+            }
+            if (char === quote) {
+                this.index += 1;
+                return out;
+            }
+            out += char;
+            this.index += 1;
+        }
+        throw new PayloadSyntaxError("Expected closing quote for string.", this.index);
+    }
+    parseNumber() {
+        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(this.text.slice(this.index));
+        if (!match) {
+            throw new PayloadSyntaxError("Invalid numeric literal.", this.index);
+        }
+        this.index += match[0].length;
+        return Number(match[0]);
+    }
+    parseLiteral() {
+        const start = this.index;
+        this.index += 1;
+        while (!this.isAtEnd() && this.isIdentifierPart(this.peek())) {
+            this.index += 1;
+        }
+        const literal = this.text.slice(start, this.index);
+        if (literal === "true")
+            return true;
+        if (literal === "false")
+            return false;
+        if (literal === "null")
+            return null;
+        throw new PayloadSyntaxError(`Unsupported bare literal '${literal}'. Use quoted strings for stability.`, start);
+    }
+    skipWhitespace() {
+        while (!this.isAtEnd() && /\s/.test(this.text[this.index])) {
+            this.index += 1;
+        }
+    }
+    expect(char) {
+        if (this.peek() !== char) {
+            throw new PayloadSyntaxError(`Expected '${char}' but found '${this.peek() ?? "EOF"}'.`, this.index);
+        }
+        this.index += 1;
+    }
+    peek() {
+        return this.text[this.index];
+    }
+    isAtEnd() {
+        return this.index >= this.text.length;
+    }
+    isDigit(char) {
+        return !!char && /[0-9]/.test(char);
+    }
+    isIdentifierStart(char) {
+        return !!char && /[A-Za-z_]/.test(char);
+    }
+    isIdentifierPart(char) {
+        return !!char && /[A-Za-z0-9_.-]/.test(char);
+    }
+}
+export function parseAionisPayload(raw, loc) {
+    try {
+        const parser = new PayloadParser(raw);
+        return {
+            value: parser.parse(),
+            diagnostics: [],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown payload parse failure.";
+        return {
+            value: null,
+            diagnostics: [
+                {
+                    severity: "error",
+                    code: "INVALID_PAYLOAD",
+                    message,
+                    loc,
+                    hint: "Check directive braces, quoted strings, and array separators.",
+                },
+            ],
+        };
+    }
+}

package/dist/plan/buildExecutionPlan.d.ts

@@ -0,0 +1,9 @@
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { ExecutionGraph } from "../graph/types.js";
+import type { AionisManifestIR } from "../ir/types.js";
+import { type ExecutionPlanV1 } from "./types.js";
+export declare function buildExecutionPlanV1(args: {
+    ir: AionisManifestIR;
+    graph: ExecutionGraph | null;
+    diagnostics?: Diagnostic[];
+}): ExecutionPlanV1;

package/dist/plan/buildExecutionPlan.js

@@ -0,0 +1,98 @@
+import { EXECUTION_PLAN_V1, } from "./types.js";
+function mergeContextFrames(frames) {
+    const merged = {};
+    for (const frame of frames) {
+        for (const [key, value] of Object.entries(frame)) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+function buildExecutionId(step, index) {
+    if (step.output_ref)
+        return step.output_ref;
+    if (step.module)
+        return `run.${step.module}.${index + 1}`;
+    if (step.tool)
+        return `run.${step.tool}.${index + 1}`;
+    if (step.agent)
+        return `run.${step.agent}.${index + 1}`;
+    return `run.execution_${index + 1}`;
+}
+function buildExecutionStep(step, index) {
+    return {
+        execution_id: buildExecutionId(step, index),
+        module: step.module,
+        tool: step.tool,
+        agent: step.agent,
+        input: step.input,
+        input_ref: step.input_ref,
+        output_ref: step.output_ref,
+        depends_on: step.depends_on ?? [],
+        deterministic: step.deterministic,
+        loc: step.loc,
+    };
+}
+function collectExpectedOutputs(ir) {
+    const replayOutputs = ir.replay.flatMap((entry) => entry.expected_outputs ?? []);
+    if (replayOutputs.length > 0)
+        return replayOutputs;
+    return ir.executions
+        .map((execution) => execution.output_ref)
+        .filter((value) => typeof value === "string" && value.length > 0);
+}
+function collectRequiredCapabilities(ir) {
+    const capabilities = new Set();
+    if (ir.executions.length > 0) {
+        capabilities.add("direct_execution");
+        capabilities.add("module_registry");
+    }
+    for (const replay of ir.replay) {
+        if (replay.mode === "deterministic")
+            capabilities.add("deterministic_replay");
+        if (replay.mode === "assisted")
+            capabilities.add("assisted_replay");
+        if (replay.executable)
+            capabilities.add("state_persistence");
+    }
+    if (ir.memory.some((entry) => entry.writeback)) {
+        capabilities.add("memory_writeback");
+    }
+    return [...capabilities];
+}
+function buildDeterminism(ir) {
+    const primaryReplay = ir.replay[0];
+    const executable = ir.replay.some((entry) => entry.executable === true) || ir.executions.length > 0;
+    return {
+        executable,
+        replay_mode: primaryReplay?.mode,
+        requires_resume_support: ir.replay.some((entry) => entry.executable === true),
+    };
+}
+export function buildExecutionPlanV1(args) {
+    const contextFrames = args.ir.context.map((entry) => entry.data);
+    const context = {
+        merged: mergeContextFrames(contextFrames),
+        frames: contextFrames,
+    };
+    return {
+        plan_version: EXECUTION_PLAN_V1,
+        doc: args.ir.doc
+            ? {
+                id: args.ir.doc.id,
+                version: args.ir.doc.version,
+                kind: args.ir.doc.kind,
+                title: args.ir.doc.title,
+                status: args.ir.doc.status,
+                tags: args.ir.doc.tags,
+            }
+            : null,
+        context,
+        executions: args.ir.executions.map(buildExecutionStep),
+        graph: args.graph,
+        expected_outputs: collectExpectedOutputs(args.ir),
+        required_capabilities: collectRequiredCapabilities(args.ir),
+        determinism: buildDeterminism(args.ir),
+        diagnostics: args.diagnostics ?? args.ir.diagnostics,
+    };
+}

package/dist/plan/types.d.ts

@@ -0,0 +1,44 @@
+import type { Diagnostic, SourceRange } from "../diagnostics/types.js";
+import type { ExecutionGraph } from "../graph/types.js";
+import type { AionisObject, ReplayIR } from "../ir/types.js";
+export declare const EXECUTION_PLAN_V1: "execution_plan_v1";
+export interface ExecutionPlanDocMeta {
+    id: string;
+    version: string;
+    kind?: string;
+    title?: string;
+    status?: string;
+    tags?: string[];
+}
+export interface ExecutionPlanContext {
+    merged: AionisObject;
+    frames: AionisObject[];
+}
+export interface ExecutionPlanStep {
+    execution_id: string;
+    module?: string;
+    tool?: string;
+    agent?: string;
+    input?: AionisObject;
+    input_ref?: string;
+    output_ref?: string;
+    depends_on: string[];
+    deterministic?: boolean;
+    loc?: SourceRange;
+}
+export interface ExecutionPlanDeterminism {
+    executable: boolean;
+    replay_mode?: ReplayIR["mode"];
+    requires_resume_support: boolean;
+}
+export interface ExecutionPlanV1 {
+    plan_version: typeof EXECUTION_PLAN_V1;
+    doc: ExecutionPlanDocMeta | null;
+    context: ExecutionPlanContext;
+    executions: ExecutionPlanStep[];
+    graph: ExecutionGraph | null;
+    expected_outputs: string[];
+    required_capabilities: string[];
+    determinism: ExecutionPlanDeterminism;
+    diagnostics: Diagnostic[];
+}

package/dist/plan/types.js

@@ -0,0 +1 @@
+export const EXECUTION_PLAN_V1 = "execution_plan_v1";

package/dist/publish-cli.d.ts

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