@aionis/manifest 0.1.1

package/dist/contracts.js

@@ -0,0 +1,401 @@
+import { z } from "zod";
+import { AIONIS_MANIFEST_MODULE_REGISTRY_VERSION, AIONIS_MANIFEST_NPM_MODULE_REGISTRY_VERSION } from "./registry/types.js";
+import { EXECUTION_PLAN_V1 } from "./plan/types.js";
+export const AIONIS_MANIFEST_COMPILE_RESULT_VERSION = "aionis_manifest_compile_result_v1";
+export const AIONIS_MANIFEST_EXECUTION_RESULT_VERSION = "aionis_manifest_execution_result_v1";
+export const AionisManifestRunInputKindSchema = z.enum(["source", "compile-envelope", "plan"]);
+export const EmitModeSchema = z.enum(["all", "ast", "ir", "graph", "plan", "diagnostics"]);
+export const SourcePosSchema = z.object({
+    line: z.number().int().nonnegative(),
+    column: z.number().int().nonnegative(),
+    offset: z.number().int().nonnegative(),
+});
+export const SourceRangeSchema = z.object({
+    start: SourcePosSchema,
+    end: SourcePosSchema,
+});
+export const DiagnosticSchema = z.object({
+    severity: z.enum(["error", "warning", "info"]),
+    code: z.string().min(1),
+    message: z.string().min(1),
+    loc: SourceRangeSchema,
+    hint: z.string().optional(),
+});
+export const AionisValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(AionisValueSchema),
+    z.record(AionisValueSchema),
+]));
+export const HeadingNodeSchema = z.object({
+    type: z.literal("HeadingNode"),
+    depth: z.number().int().positive(),
+    text: z.string(),
+    raw: z.string().optional(),
+    loc: SourceRangeSchema,
+});
+export const ParagraphNodeSchema = z.object({
+    type: z.literal("ParagraphNode"),
+    text: z.string(),
+    raw: z.string().optional(),
+    loc: SourceRangeSchema,
+});
+export const CodeFenceNodeSchema = z.object({
+    type: z.literal("CodeFenceNode"),
+    fence: z.literal("```"),
+    info: z.string().optional(),
+    content: z.string(),
+    raw: z.string().optional(),
+    loc: SourceRangeSchema,
+});
+export const DirectiveNodeSchema = z.object({
+    type: z.literal("DirectiveNode"),
+    name: z.string().min(1),
+    payload: AionisValueSchema.nullable(),
+    diagnostics: z.array(DiagnosticSchema).optional(),
+    raw: z.string().optional(),
+    loc: SourceRangeSchema,
+});
+export const AstNodeSchema = z.lazy(() => z.union([HeadingNodeSchema, ParagraphNodeSchema, CodeFenceNodeSchema, DirectiveNodeSchema]));
+export const DocumentNodeSchema = z.object({
+    type: z.literal("DocumentNode"),
+    children: z.array(AstNodeSchema),
+    diagnostics: z.array(DiagnosticSchema),
+    raw: z.string().optional(),
+    loc: SourceRangeSchema,
+});
+export const DocMetaIRSchema = z.object({
+    id: z.string(),
+    version: z.string(),
+    kind: z.string().optional(),
+    title: z.string().optional(),
+    status: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const ContextIRSchema = z.object({
+    objective: z.string().optional(),
+    audience: z.array(z.string()).optional(),
+    constraints: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const PlanIRSchema = z.object({
+    steps: z.array(z.string()).optional(),
+    success_criteria: z.array(z.string()).optional(),
+    checkpoints: z.array(z.string()).optional(),
+    fallbacks: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const ExecuteIRSchema = z.object({
+    module: z.string().optional(),
+    tool: z.string().optional(),
+    agent: z.string().optional(),
+    input: z.record(AionisValueSchema).optional(),
+    input_ref: z.string().optional(),
+    output_ref: z.string().optional(),
+    deterministic: z.boolean().optional(),
+    depends_on: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const DecisionIRSchema = z.object({
+    decision: z.string().optional(),
+    rationale: z.string().optional(),
+    confidence: z.number().optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const EvidenceIRSchema = z.object({
+    sources: z.array(AionisValueSchema).optional(),
+    confidence: z.number().optional(),
+    claims_supported: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const ReplayIRSchema = z.object({
+    executable: z.boolean().optional(),
+    mode: z.enum(["deterministic", "assisted", "advisory"]).optional(),
+    workflow_id: z.string().optional(),
+    expected_outputs: z.array(z.string()).optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const MemoryIRSchema = z.object({
+    topics: z.array(z.string()).optional(),
+    entities: z.array(z.string()).optional(),
+    writeback: z.boolean().optional(),
+    summary_layer: z.string().optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const StateIRSchema = z.object({
+    phase: z.string().optional(),
+    run_id: z.string().optional(),
+    owner: z.string().optional(),
+    data: z.record(AionisValueSchema),
+    loc: SourceRangeSchema.optional(),
+});
+export const AionisManifestIRSchema = z.object({
+    doc: DocMetaIRSchema.nullable(),
+    context: z.array(ContextIRSchema),
+    plans: z.array(PlanIRSchema),
+    executions: z.array(ExecuteIRSchema),
+    decisions: z.array(DecisionIRSchema),
+    evidence: z.array(EvidenceIRSchema),
+    replay: z.array(ReplayIRSchema),
+    memory: z.array(MemoryIRSchema),
+    state: z.array(StateIRSchema),
+    diagnostics: z.array(DiagnosticSchema),
+});
+export const ExecutionNodeSchema = z.object({
+    id: z.string().min(1),
+    type: z.enum([
+        "context_node",
+        "execute_node",
+        "decision_node",
+        "evidence_node",
+        "output_node",
+        "memory_write_node",
+        "replay_node",
+    ]),
+    label: z.string().optional(),
+    module: z.string().optional(),
+    input_ref: z.string().optional(),
+    output_ref: z.string().optional(),
+    payload: z.record(AionisValueSchema).optional(),
+    loc: SourceRangeSchema.optional(),
+});
+export const ExecutionEdgeSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    type: z.enum([
+        "data_dependency",
+        "sequence_dependency",
+        "evidence_attachment",
+        "memory_writeback",
+        "replay_anchor",
+    ]),
+});
+export const ExecutionGraphSchema = z.object({
+    graph_id: z.string().min(1),
+    doc_id: z.string().min(1),
+    nodes: z.array(ExecutionNodeSchema),
+    edges: z.array(ExecutionEdgeSchema),
+    diagnostics: z.array(DiagnosticSchema).optional(),
+});
+export const ExecutionPlanDocMetaSchema = z.object({
+    id: z.string().min(1),
+    version: z.string().min(1),
+    kind: z.string().optional(),
+    title: z.string().optional(),
+    status: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+});
+export const ExecutionPlanContextSchema = z.object({
+    merged: z.record(AionisValueSchema),
+    frames: z.array(z.record(AionisValueSchema)),
+});
+export const ExecutionPlanStepSchema = z.object({
+    execution_id: z.string().min(1),
+    module: z.string().optional(),
+    tool: z.string().optional(),
+    agent: z.string().optional(),
+    input: z.record(AionisValueSchema).optional(),
+    input_ref: z.string().optional(),
+    output_ref: z.string().optional(),
+    depends_on: z.array(z.string()),
+    deterministic: z.boolean().optional(),
+    loc: SourceRangeSchema.optional(),
+});
+export const ExecutionPlanDeterminismSchema = z.object({
+    executable: z.boolean(),
+    replay_mode: z.enum(["deterministic", "assisted", "advisory"]).optional(),
+    requires_resume_support: z.boolean(),
+});
+export const ExecutionPlanSchema = z.object({
+    plan_version: z.literal(EXECUTION_PLAN_V1),
+    doc: ExecutionPlanDocMetaSchema.nullable(),
+    context: ExecutionPlanContextSchema,
+    executions: z.array(ExecutionPlanStepSchema),
+    graph: ExecutionGraphSchema.nullable(),
+    expected_outputs: z.array(z.string()),
+    required_capabilities: z.array(z.string()),
+    determinism: ExecutionPlanDeterminismSchema,
+    diagnostics: z.array(DiagnosticSchema),
+});
+export const CompileArtifactsSchema = z.object({
+    ast: DocumentNodeSchema.nullable(),
+    ir: AionisManifestIRSchema.nullable(),
+    graph: ExecutionGraphSchema.nullable(),
+    plan: ExecutionPlanSchema.nullable(),
+});
+export const CompileSummarySchema = z.object({
+    has_errors: z.boolean(),
+    error_count: z.number().int().nonnegative(),
+    warning_count: z.number().int().nonnegative(),
+    info_count: z.number().int().nonnegative(),
+    ast_node_count: z.number().int().nonnegative(),
+    execution_count: z.number().int().nonnegative(),
+    graph_node_count: z.number().int().nonnegative(),
+    graph_edge_count: z.number().int().nonnegative(),
+});
+export const AionisManifestCompileEnvelopeSchema = z.object({
+    command: z.literal("compile-aionis-manifest"),
+    compile_result_version: z.literal(AIONIS_MANIFEST_COMPILE_RESULT_VERSION),
+    generated_at: z.string().min(1),
+    input_path: z.string().min(1),
+    selected_artifact: EmitModeSchema,
+    diagnostics: z.array(DiagnosticSchema),
+    summary: CompileSummarySchema,
+    artifacts: CompileArtifactsSchema,
+});
+export const ExecutionNodeResultSchema = z.object({
+    execution_id: z.string().min(1),
+    module: z.string().optional(),
+    tool: z.string().optional(),
+    agent: z.string().optional(),
+    status: z.enum(["success", "failed", "skipped"]),
+    input_ref: z.string().optional(),
+    output_ref: z.string().optional(),
+    output: AionisValueSchema.optional(),
+    artifacts: z.array(AionisValueSchema).optional(),
+    evidence: z.array(AionisValueSchema).optional(),
+    error: z.string().optional(),
+});
+export const ExecutionArtifactRecordSchema = z.object({
+    execution_id: z.string().min(1),
+    module: z.string().optional(),
+    value: AionisValueSchema,
+});
+export const ExecutionEvidenceRecordSchema = z.object({
+    execution_id: z.string().min(1),
+    module: z.string().optional(),
+    value: AionisValueSchema,
+});
+export const AionisManifestExecutionResultSchema = z.object({
+    execution_result_version: z.literal(AIONIS_MANIFEST_EXECUTION_RESULT_VERSION),
+    runtime_id: z.string().min(1),
+    executed_at: z.string().min(1),
+    plan_version: z.literal(EXECUTION_PLAN_V1),
+    doc_id: z.string().nullable(),
+    status: z.enum(["success", "failed"]),
+    outputs: z.record(AionisValueSchema),
+    artifacts: z.array(ExecutionArtifactRecordSchema),
+    evidence: z.array(ExecutionEvidenceRecordSchema),
+    node_results: z.array(ExecutionNodeResultSchema),
+    expected_outputs: z.array(z.string()),
+    warnings: z.array(z.string()),
+    errors: z.array(z.string()),
+    diagnostics: z.array(DiagnosticSchema),
+});
+export const ExecutionRuntimeCapabilitySchema = z.enum([
+    "direct_execution",
+    "deterministic_replay",
+    "state_persistence",
+    "memory_publish",
+    "handoff_recover",
+    "module_registry",
+    "evidence_capture",
+]);
+export const ExecutionModuleValueContractSchema = z.lazy(() => z.object({
+    kind: z.enum(["any", "string", "number", "boolean", "null", "array", "object"]),
+    description: z.string().optional(),
+    properties: z.record(ExecutionModuleValueContractSchema).optional(),
+    required: z.array(z.string()).optional(),
+    items: ExecutionModuleValueContractSchema.optional(),
+    additional_properties: z.boolean().optional(),
+}));
+export const ExecutionModuleManifestSchema = z.object({
+    module: z.string().min(1),
+    version: z.string().min(1),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    deterministic: z.boolean().optional(),
+    required_capabilities: z.array(ExecutionRuntimeCapabilitySchema).optional(),
+    input_contract: ExecutionModuleValueContractSchema.optional(),
+    output_contract: ExecutionModuleValueContractSchema.optional(),
+    artifact_contract: ExecutionModuleValueContractSchema.optional(),
+    evidence_contract: ExecutionModuleValueContractSchema.optional(),
+});
+export const ModuleRegistryFileEntrySchema = z.object({
+    module: z.string().min(1),
+    entry: z.string().min(1),
+});
+export const ModuleRegistryFileSchema = z.object({
+    version: z.literal(AIONIS_MANIFEST_MODULE_REGISTRY_VERSION),
+    modules: z.array(ModuleRegistryFileEntrySchema),
+});
+export const NpmModuleRegistryFileEntrySchema = z.object({
+    module: z.string().min(1),
+    package: z.string().min(1),
+    export: z.string().min(1).optional(),
+});
+export const NpmModuleRegistryFileSchema = z.object({
+    version: z.literal(AIONIS_MANIFEST_NPM_MODULE_REGISTRY_VERSION),
+    modules: z.array(NpmModuleRegistryFileEntrySchema),
+});
+export const AnyModuleRegistryFileSchema = z.union([ModuleRegistryFileSchema, NpmModuleRegistryFileSchema]);
+function selectArtifacts(result, emit) {
+    if (emit === "all") {
+        return {
+            ast: result.ast,
+            ir: result.ir,
+            graph: result.graph,
+            plan: result.plan,
+        };
+    }
+    return {
+        ast: emit === "ast" ? result.ast : null,
+        ir: emit === "ir" ? result.ir : null,
+        graph: emit === "graph" ? result.graph : null,
+        plan: emit === "plan" ? result.plan : null,
+    };
+}
+function summarizeCompileResult(result) {
+    const errorCount = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+    const warningCount = result.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
+    const infoCount = result.diagnostics.filter((diagnostic) => diagnostic.severity === "info").length;
+    return {
+        has_errors: errorCount > 0,
+        error_count: errorCount,
+        warning_count: warningCount,
+        info_count: infoCount,
+        ast_node_count: result.ast.children.length,
+        execution_count: result.ir.executions.length,
+        graph_node_count: result.graph?.nodes.length ?? 0,
+        graph_edge_count: result.graph?.edges.length ?? 0,
+    };
+}
+export function buildCompileEnvelope(args) {
+    const envelope = {
+        command: "compile-aionis-manifest",
+        compile_result_version: AIONIS_MANIFEST_COMPILE_RESULT_VERSION,
+        generated_at: args.generatedAt ?? new Date().toISOString(),
+        input_path: args.inputPath,
+        selected_artifact: args.emit,
+        diagnostics: args.result.diagnostics,
+        summary: summarizeCompileResult(args.result),
+        artifacts: selectArtifacts(args.result, args.emit),
+    };
+    return AionisManifestCompileEnvelopeSchema.parse(envelope);
+}
+export function validateCompileEnvelope(value) {
+    return AionisManifestCompileEnvelopeSchema.parse(value);
+}
+export function validateExecutionModuleManifest(value) {
+    ExecutionModuleManifestSchema.parse(value);
+    return value;
+}
+export function validateModuleRegistryFile(value) {
+    ModuleRegistryFileSchema.parse(value);
+    return value;
+}
+export function validateAnyModuleRegistryFile(value) {
+    AnyModuleRegistryFileSchema.parse(value);
+    return value;
+}

package/dist/diagnostics/types.d.ts

@@ -0,0 +1,17 @@
+export interface SourcePos {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface SourceRange {
+    start: SourcePos;
+    end: SourcePos;
+}
+export type DiagnosticSeverity = "error" | "warning" | "info";
+export interface Diagnostic {
+    severity: DiagnosticSeverity;
+    code: string;
+    message: string;
+    loc: SourceRange;
+    hint?: string;
+}

package/dist/diagnostics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/execute/localRuntime.d.ts

@@ -0,0 +1,5 @@
+import { ModuleRegistryExecutionRuntime, StaticModuleRegistry } from "./moduleRuntime.js";
+export declare function createLocalDemoModuleRegistry(): StaticModuleRegistry;
+export declare class LocalExecutionRuntime extends ModuleRegistryExecutionRuntime {
+    constructor();
+}

package/dist/execute/localRuntime.js

@@ -0,0 +1,165 @@
+import { ModuleRegistryExecutionRuntime, StaticModuleRegistry, createExecutionRuntimeCapabilities, } from "./moduleRuntime.js";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const LOCAL_DEMO_MODULES = [
+    {
+        manifest: {
+            module: "demo.hello.v1",
+            version: "1.0.0",
+            description: "Return a greeting payload from document context.",
+            deterministic: true,
+            required_capabilities: ["direct_execution"],
+            input_contract: {
+                kind: "object",
+                properties: {
+                    objective: { kind: "string" },
+                },
+                additional_properties: true,
+            },
+            output_contract: {
+                kind: "object",
+                properties: {
+                    message: { kind: "string" },
+                },
+                required: ["message"],
+                additional_properties: false,
+            },
+        },
+        handler: (input) => {
+            const objective = isObject(input) && typeof input.objective === "string" ? input.objective : null;
+            return {
+                message: objective ? `Hello from AionisManifest: ${objective}` : "Hello from AionisManifest.",
+            };
+        },
+    },
+    {
+        manifest: {
+            module: "research.claims.v1",
+            version: "1.0.0",
+            description: "Generate short product claims from context fields.",
+            deterministic: true,
+            required_capabilities: ["direct_execution"],
+            input_contract: {
+                kind: "object",
+                properties: {
+                    product: { kind: "string" },
+                    audience: {
+                        kind: "array",
+                        items: { kind: "string" },
+                    },
+                },
+                additional_properties: true,
+            },
+            output_contract: {
+                kind: "object",
+                properties: {
+                    claims: {
+                        kind: "array",
+                        items: { kind: "string" },
+                    },
+                },
+                required: ["claims"],
+                additional_properties: false,
+            },
+        },
+        handler: (input) => {
+            const product = isObject(input) && typeof input.product === "string" ? input.product : "Aionis";
+            const audience = isObject(input) && Array.isArray(input.audience)
+                ? input.audience.filter((item) => typeof item === "string")
+                : [];
+            const audienceText = audience.length > 0 ? audience.join(" and ") : "teams";
+            return {
+                claims: [
+                    `${product} helps ${audienceText} continue work without rediscovery.`,
+                    `${product} turns executable documents into continuity-aware workflows.`,
+                ],
+            };
+        },
+    },
+    {
+        manifest: {
+            module: "copy.hero.v1",
+            version: "1.0.0",
+            description: "Map a claims array into a single hero line.",
+            deterministic: true,
+            required_capabilities: ["direct_execution"],
+            input_contract: {
+                kind: "object",
+                properties: {
+                    claims: {
+                        kind: "array",
+                        items: { kind: "string" },
+                    },
+                },
+                additional_properties: true,
+            },
+            output_contract: {
+                kind: "object",
+                properties: {
+                    hero: { kind: "string" },
+                },
+                required: ["hero"],
+                additional_properties: false,
+            },
+        },
+        handler: (input) => {
+            const claims = isObject(input) && Array.isArray(input.claims)
+                ? input.claims.filter((item) => typeof item === "string")
+                : [];
+            return {
+                hero: claims[0] ?? "Portable execution starts with one document.",
+            };
+        },
+    },
+    {
+        manifest: {
+            module: "copy.summary.v1",
+            version: "1.0.0",
+            description: "Map a claims array into a summary paragraph.",
+            deterministic: true,
+            required_capabilities: ["direct_execution"],
+            input_contract: {
+                kind: "object",
+                properties: {
+                    claims: {
+                        kind: "array",
+                        items: { kind: "string" },
+                    },
+                },
+                additional_properties: true,
+            },
+            output_contract: {
+                kind: "object",
+                properties: {
+                    summary: { kind: "string" },
+                },
+                required: ["summary"],
+                additional_properties: false,
+            },
+        },
+        handler: (input) => {
+            const claims = isObject(input) && Array.isArray(input.claims)
+                ? input.claims.filter((item) => typeof item === "string")
+                : [];
+            return {
+                summary: claims.join(" ") || "AionisManifest produced an execution summary.",
+            };
+        },
+    },
+];
+export function createLocalDemoModuleRegistry() {
+    return new StaticModuleRegistry(LOCAL_DEMO_MODULES);
+}
+export class LocalExecutionRuntime extends ModuleRegistryExecutionRuntime {
+    constructor() {
+        super({
+            runtime_id: "local_demo_runtime_v1",
+            registry: createLocalDemoModuleRegistry(),
+            capabilities: createExecutionRuntimeCapabilities({
+                direct_execution: true,
+                module_registry: true,
+            }),
+        });
+    }
+}

package/dist/execute/moduleRuntime.d.ts

@@ -0,0 +1,25 @@
+import type { AionisValue } from "../ir/types.js";
+import type { ExecutionPlanV1, ExecutionPlanStep } from "../plan/types.js";
+import { type ExecutionModuleDefinition, type ExecutionModuleManifest, type ExecutionModuleRegistry, type ExecutionResultV1, type ExecutionRuntime, type ExecutionRuntimeCapabilities } from "./types.js";
+export declare function resolveExecutionInput(plan: ExecutionPlanV1, outputs: Record<string, AionisValue>, step: ExecutionPlanStep): AionisValue;
+export declare function createExecutionRuntimeCapabilities(overrides?: Partial<ExecutionRuntimeCapabilities>): ExecutionRuntimeCapabilities;
+export declare class StaticModuleRegistry implements ExecutionModuleRegistry {
+    #private;
+    constructor(modules: ExecutionModuleDefinition[]);
+    has(moduleName: string): boolean;
+    get(moduleName: string): ExecutionModuleDefinition | undefined;
+    getManifest(moduleName: string): ExecutionModuleManifest | undefined;
+    list(): ExecutionModuleDefinition[];
+    listManifests(): ExecutionModuleManifest[];
+}
+export declare class ModuleRegistryExecutionRuntime implements ExecutionRuntime {
+    #private;
+    readonly runtime_id: string;
+    constructor(args: {
+        runtime_id: string;
+        registry: ExecutionModuleRegistry;
+        capabilities?: Partial<ExecutionRuntimeCapabilities>;
+    });
+    capabilities(): ExecutionRuntimeCapabilities;
+    execute(plan: ExecutionPlanV1): Promise<ExecutionResultV1>;
+}