@aionis/manifest 0.1.1

package/dist/graph/buildExecutionGraph.js

@@ -0,0 +1,69 @@
+export function buildExecutionGraph(ir) {
+    if (!ir.doc) {
+        return { value: null, diagnostics: [] };
+    }
+    const diagnostics = [];
+    const nodes = [];
+    const edges = [];
+    const nodeByOutputRef = new Map();
+    const nodeById = new Map();
+    ir.executions.forEach((execution, index) => {
+        const id = `exec_${index + 1}`;
+        const node = {
+            id,
+            type: "execute_node",
+            label: execution.module ?? execution.tool ?? execution.agent ?? `execute_${index + 1}`,
+            module: execution.module,
+            input_ref: execution.input_ref,
+            output_ref: execution.output_ref,
+            payload: execution.data,
+            loc: execution.loc,
+        };
+        nodes.push(node);
+        nodeById.set(id, id);
+        if (execution.output_ref) {
+            nodeByOutputRef.set(execution.output_ref, id);
+        }
+        if (execution.input_ref) {
+            const upstream = nodeByOutputRef.get(execution.input_ref);
+            if (upstream) {
+                edges.push({
+                    from: upstream,
+                    to: id,
+                    type: "data_dependency",
+                });
+            }
+        }
+        for (const dependency of execution.depends_on ?? []) {
+            const upstream = nodeByOutputRef.get(dependency) ?? nodeById.get(dependency);
+            if (upstream) {
+                edges.push({
+                    from: upstream,
+                    to: id,
+                    type: "sequence_dependency",
+                });
+            }
+            else {
+                diagnostics.push({
+                    severity: "warning",
+                    code: "UNKNOWN_DEPENDENCY",
+                    message: `Dependency '${dependency}' does not match a previous node or output ref.`,
+                    loc: execution.loc ?? ir.doc?.loc ?? {
+                        start: { line: 1, column: 1, offset: 0 },
+                        end: { line: 1, column: 1, offset: 0 },
+                    },
+                });
+            }
+        }
+    });
+    return {
+        value: {
+            graph_id: `graph:${ir.doc.id}`,
+            doc_id: ir.doc.id,
+            nodes,
+            edges,
+            diagnostics,
+        },
+        diagnostics,
+    };
+}

package/dist/graph/types.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic, SourceRange } from "../diagnostics/types.js";
+import type { AionisObject } from "../ir/types.js";
+export interface ExecutionGraph {
+    graph_id: string;
+    doc_id: string;
+    nodes: ExecutionNode[];
+    edges: ExecutionEdge[];
+    diagnostics?: Diagnostic[];
+}
+export interface ExecutionNode {
+    id: string;
+    type: "context_node" | "execute_node" | "decision_node" | "evidence_node" | "output_node" | "memory_write_node" | "replay_node";
+    label?: string;
+    module?: string;
+    input_ref?: string;
+    output_ref?: string;
+    payload?: AionisObject;
+    loc?: SourceRange;
+}
+export interface ExecutionEdge {
+    from: string;
+    to: string;
+    type: "data_dependency" | "sequence_dependency" | "evidence_attachment" | "memory_writeback" | "replay_anchor";
+}

package/dist/graph/types.js

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

package/dist/handoff-store-cli.d.ts

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

package/dist/handoff-store-cli.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import process from "node:process";
+import { buildHandoffStoreRequestFromRuntimeHandoff } from "./handoff-store.js";
+class CliUsageError extends Error {
+}
+function printHelp() {
+    process.stdout.write([
+        "build-aionis-manifest-handoff-store-request",
+        "",
+        "Usage:",
+        "  build-aionis-manifest-handoff-store-request <runtime-handoff.json> [--scope <scope>] [--tenant-id <tenant>]",
+        "                                       [--actor <actor>] [--memory-lane private|shared] [--title <title>]",
+        "                                       [--tag <tag>] [--out <path>] [--compact]",
+        "",
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    let inputPath = null;
+    const flags = {
+        out: null,
+        compact: false,
+        help: false,
+        scope: null,
+        tenantId: null,
+        actor: null,
+        memoryLane: null,
+        title: null,
+        tags: [],
+    };
+    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 === "--tag") {
+            const value = argv[i + 1];
+            if (!value)
+                throw new CliUsageError("Missing value for --tag.");
+            flags.tags.push(value);
+            i += 1;
+            continue;
+        }
+        if (token === "--out" ||
+            token === "--scope" ||
+            token === "--tenant-id" ||
+            token === "--actor" ||
+            token === "--memory-lane" ||
+            token === "--title") {
+            const value = argv[i + 1];
+            if (!value)
+                throw new CliUsageError(`Missing value for ${token}.`);
+            switch (token) {
+                case "--out":
+                    flags.out = value;
+                    break;
+                case "--scope":
+                    flags.scope = value;
+                    break;
+                case "--tenant-id":
+                    flags.tenantId = value;
+                    break;
+                case "--actor":
+                    flags.actor = value;
+                    break;
+                case "--memory-lane":
+                    if (value !== "private" && value !== "shared") {
+                        throw new CliUsageError(`Unsupported memory lane '${value}'.`);
+                    }
+                    flags.memoryLane = value;
+                    break;
+                case "--title":
+                    flags.title = value;
+                    break;
+                default:
+                    break;
+            }
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            throw new CliUsageError(`Unknown flag '${token}'.`);
+        }
+        if (inputPath) {
+            throw new CliUsageError("Only one input file may be provided.");
+        }
+        inputPath = token;
+    }
+    return { inputPath, flags };
+}
+async function writeOutput(pathname, contents) {
+    await mkdir(dirname(pathname), { recursive: true });
+    await writeFile(pathname, contents, "utf8");
+}
+async function main() {
+    const { inputPath, flags } = parseArgs(process.argv.slice(2));
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    if (!inputPath) {
+        throw new CliUsageError("An input file path is required.");
+    }
+    const resolvedInput = resolve(process.cwd(), inputPath);
+    const handoff = JSON.parse(await readFile(resolvedInput, "utf8"));
+    const request = buildHandoffStoreRequestFromRuntimeHandoff({
+        handoff,
+        scope: flags.scope ?? undefined,
+        tenantId: flags.tenantId ?? undefined,
+        actor: flags.actor ?? undefined,
+        memoryLane: flags.memoryLane ?? undefined,
+        title: flags.title ?? undefined,
+        tags: flags.tags,
+    });
+    const rendered = flags.compact ? JSON.stringify(request) : `${JSON.stringify(request, null, 2)}\n`;
+    if (flags.out) {
+        await writeOutput(resolve(process.cwd(), flags.out), rendered);
+    }
+    else {
+        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/handoff-store.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const AIONIS_MANIFEST_HANDOFF_STORE_REQUEST_VERSION: "aionis_manifest_handoff_store_request_v1";
+export declare const AionisManifestHandoffStoreRequestSchema: z.ZodObject<{
+    request_version: z.ZodLiteral<"aionis_manifest_handoff_store_request_v1">;
+    tenant_id: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+    memory_lane: z.ZodDefault<z.ZodEnum<["private", "shared"]>>;
+    anchor: z.ZodString;
+    file_path: z.ZodOptional<z.ZodString>;
+    repo_root: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    handoff_kind: z.ZodLiteral<"task_handoff">;
+    title: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    handoff_text: z.ZodString;
+    risk: z.ZodOptional<z.ZodString>;
+    acceptance_checks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    target_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    next_action: z.ZodOptional<z.ZodString>;
+    must_change: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    must_remove: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    must_keep: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    execution_result_summary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    execution_artifacts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    execution_evidence: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    execution_state_v1: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    execution_packet_v1: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    control_profile_v1: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    execution_transitions_v1: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    anchor: string;
+    handoff_kind: "task_handoff";
+    handoff_text: string;
+    execution_state_v1: Record<string, unknown>;
+    execution_packet_v1: Record<string, unknown>;
+    request_version: "aionis_manifest_handoff_store_request_v1";
+    memory_lane: "private" | "shared";
+    symbol?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    acceptance_checks?: string[] | undefined;
+    file_path?: string | undefined;
+    repo_root?: string | undefined;
+    scope?: string | undefined;
+    target_files?: string[] | undefined;
+    next_action?: string | undefined;
+    execution_result_summary?: Record<string, unknown> | undefined;
+    execution_artifacts?: Record<string, unknown>[] | undefined;
+    execution_evidence?: Record<string, unknown>[] | undefined;
+    tenant_id?: string | undefined;
+    actor?: string | undefined;
+    risk?: string | undefined;
+    must_change?: string[] | undefined;
+    must_remove?: string[] | undefined;
+    must_keep?: string[] | undefined;
+    control_profile_v1?: Record<string, unknown> | undefined;
+    execution_transitions_v1?: Record<string, unknown>[] | undefined;
+}, {
+    summary: string;
+    anchor: string;
+    handoff_kind: "task_handoff";
+    handoff_text: string;
+    execution_state_v1: Record<string, unknown>;
+    execution_packet_v1: Record<string, unknown>;
+    request_version: "aionis_manifest_handoff_store_request_v1";
+    symbol?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    acceptance_checks?: string[] | undefined;
+    file_path?: string | undefined;
+    repo_root?: string | undefined;
+    scope?: string | undefined;
+    target_files?: string[] | undefined;
+    next_action?: string | undefined;
+    execution_result_summary?: Record<string, unknown> | undefined;
+    execution_artifacts?: Record<string, unknown>[] | undefined;
+    execution_evidence?: Record<string, unknown>[] | undefined;
+    tenant_id?: string | undefined;
+    actor?: string | undefined;
+    memory_lane?: "private" | "shared" | undefined;
+    risk?: string | undefined;
+    must_change?: string[] | undefined;
+    must_remove?: string[] | undefined;
+    must_keep?: string[] | undefined;
+    control_profile_v1?: Record<string, unknown> | undefined;
+    execution_transitions_v1?: Record<string, unknown>[] | undefined;
+}>;
+export type AionisManifestHandoffStoreRequest = z.infer<typeof AionisManifestHandoffStoreRequestSchema>;
+type BuildHandoffStoreRequestOptions = {
+    tenantId?: string;
+    scope?: string;
+    actor?: string;
+    memoryLane?: "private" | "shared";
+    title?: string;
+    tags?: string[];
+};
+export declare function buildHandoffStoreRequestFromRuntimeHandoff(args: {
+    handoff: unknown;
+} & BuildHandoffStoreRequestOptions): AionisManifestHandoffStoreRequest;
+export {};

package/dist/handoff-store.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { AionisManifestRuntimeHandoffSchema, } from "./runtime-handoff.js";
+export const AIONIS_MANIFEST_HANDOFF_STORE_REQUEST_VERSION = "aionis_manifest_handoff_store_request_v1";
+export const AionisManifestHandoffStoreRequestSchema = z.object({
+    request_version: z.literal(AIONIS_MANIFEST_HANDOFF_STORE_REQUEST_VERSION),
+    tenant_id: z.string().min(1).optional(),
+    scope: z.string().min(1).optional(),
+    actor: z.string().min(1).optional(),
+    memory_lane: z.enum(["private", "shared"]).default("shared"),
+    anchor: z.string().min(1),
+    file_path: z.string().min(1).optional(),
+    repo_root: z.string().min(1).optional(),
+    symbol: z.string().min(1).optional(),
+    handoff_kind: z.literal("task_handoff"),
+    title: z.string().min(1).optional(),
+    summary: z.string().min(1),
+    handoff_text: z.string().min(1),
+    risk: z.string().min(1).optional(),
+    acceptance_checks: z.array(z.string().min(1)).optional(),
+    tags: z.array(z.string().min(1)).optional(),
+    target_files: z.array(z.string().min(1)).optional(),
+    next_action: z.string().min(1).optional(),
+    must_change: z.array(z.string().min(1)).optional(),
+    must_remove: z.array(z.string().min(1)).optional(),
+    must_keep: z.array(z.string().min(1)).optional(),
+    execution_result_summary: z.record(z.unknown()).optional(),
+    execution_artifacts: z.array(z.record(z.unknown())).optional(),
+    execution_evidence: z.array(z.record(z.unknown())).optional(),
+    execution_state_v1: z.record(z.unknown()),
+    execution_packet_v1: z.record(z.unknown()),
+    control_profile_v1: z.record(z.unknown()).optional(),
+    execution_transitions_v1: z.array(z.record(z.unknown())).optional(),
+});
+export function buildHandoffStoreRequestFromRuntimeHandoff(args) {
+    const handoff = AionisManifestRuntimeHandoffSchema.parse(args.handoff);
+    return buildHandoffStoreRequestFromParsedRuntimeHandoff(handoff, args);
+}
+function buildHandoffStoreRequestFromParsedRuntimeHandoff(handoff, options) {
+    const tags = [
+        "aionis-manifest",
+        "runtime-handoff",
+        `doc:${handoff.source_doc_id}`,
+        ...(options.tags ?? []),
+    ];
+    const risk = handoff.execution_state_v1.unresolved_blockers.length > 0
+        ? handoff.execution_state_v1.unresolved_blockers.join(" | ")
+        : undefined;
+    return AionisManifestHandoffStoreRequestSchema.parse({
+        request_version: AIONIS_MANIFEST_HANDOFF_STORE_REQUEST_VERSION,
+        tenant_id: options.tenantId,
+        scope: options.scope ?? handoff.scope,
+        actor: options.actor,
+        memory_lane: options.memoryLane ?? "shared",
+        anchor: handoff.execution_ready_handoff.anchor,
+        file_path: handoff.execution_state_v1.resume_anchor?.file_path ?? undefined,
+        repo_root: handoff.execution_state_v1.resume_anchor?.repo_root ?? undefined,
+        symbol: handoff.execution_state_v1.resume_anchor?.symbol ?? undefined,
+        handoff_kind: "task_handoff",
+        title: options.title ?? `AionisManifest ${handoff.source_doc_id}`,
+        summary: handoff.execution_ready_handoff.summary ?? handoff.task_brief,
+        handoff_text: handoff.execution_ready_handoff.handoff_text,
+        risk,
+        acceptance_checks: handoff.execution_ready_handoff.acceptance_checks,
+        tags,
+        target_files: handoff.execution_ready_handoff.target_files,
+        next_action: handoff.execution_ready_handoff.next_action ?? undefined,
+        must_change: handoff.execution_packet_v1.hard_constraints,
+        must_remove: handoff.execution_state_v1.rejected_paths,
+        must_keep: handoff.execution_state_v1.rollback_notes,
+        execution_result_summary: handoff.execution_result_summary ?? undefined,
+        execution_artifacts: handoff.execution_artifacts,
+        execution_evidence: handoff.execution_evidence,
+        execution_state_v1: handoff.execution_state_v1,
+        execution_packet_v1: handoff.execution_packet_v1,
+        control_profile_v1: undefined,
+        execution_transitions_v1: undefined,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./ast/types.js";
+export * from "./compile.js";
+export * from "./contracts.js";
+export * from "./diagnostics/types.js";
+export * from "./execute.js";
+export * from "./execute/localRuntime.js";
+export * from "./execute/moduleRuntime.js";
+export * from "./registry/loadModuleRegistry.js";
+export * from "./registry/types.js";
+export type { AionisManifestRunInputKind, AionisManifestRunRequest, ExecuteAionisManifestOptions, ExecutionArtifactRecord, ExecutionModuleContext, ExecutionModuleDefinition, ExecutionModuleHandler, ExecutionModuleManifest, ExecutionModuleOutcome, ExecutionModuleRegistry, ExecutionModuleValueContract, ExecutionModuleValueContractKind, ExecutionEvidenceRecord, ExecutionNodeResult, ExecutionResultV1, ExecutionRuntime, ExecutionRuntimeCapabilities, ExecutionRuntimeCapability, } from "./execute/types.js";
+export * from "./graph/types.js";
+export * from "./handoff-store.js";
+export * from "./ir/types.js";
+export * from "./plan/buildExecutionPlan.js";
+export * from "./plan/types.js";
+export * from "./publish.js";
+export * from "./recover.js";
+export * from "./refs/resolveRefs.js";
+export * from "./run.js";
+export * from "./resume.js";
+export * from "./runtime-handoff.js";
+export * from "./validate.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from "./ast/types.js";
+export * from "./compile.js";
+export * from "./contracts.js";
+export * from "./diagnostics/types.js";
+export * from "./execute.js";
+export * from "./execute/localRuntime.js";
+export * from "./execute/moduleRuntime.js";
+export * from "./registry/loadModuleRegistry.js";
+export * from "./registry/types.js";
+export * from "./graph/types.js";
+export * from "./handoff-store.js";
+export * from "./ir/types.js";
+export * from "./plan/buildExecutionPlan.js";
+export * from "./plan/types.js";
+export * from "./publish.js";
+export * from "./recover.js";
+export * from "./refs/resolveRefs.js";
+export * from "./run.js";
+export * from "./resume.js";
+export * from "./runtime-handoff.js";
+export * from "./validate.js";

package/dist/ir/types.d.ts

@@ -0,0 +1,92 @@
+import type { Diagnostic, SourceRange } from "../diagnostics/types.js";
+export type AionisPrimitive = string | number | boolean | null;
+export type AionisValue = AionisPrimitive | AionisObject | AionisValue[];
+export interface AionisObject {
+    [key: string]: AionisValue;
+}
+export interface DocMetaIR {
+    id: string;
+    version: string;
+    kind?: string;
+    title?: string;
+    status?: string;
+    tags?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface ContextIR {
+    objective?: string;
+    audience?: string[];
+    constraints?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface PlanIR {
+    steps?: string[];
+    success_criteria?: string[];
+    checkpoints?: string[];
+    fallbacks?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface ExecuteIR {
+    module?: string;
+    tool?: string;
+    agent?: string;
+    input?: AionisObject;
+    input_ref?: string;
+    output_ref?: string;
+    deterministic?: boolean;
+    depends_on?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface DecisionIR {
+    decision?: string;
+    rationale?: string;
+    confidence?: number;
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface EvidenceIR {
+    sources?: AionisValue[];
+    confidence?: number;
+    claims_supported?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface ReplayIR {
+    executable?: boolean;
+    mode?: "deterministic" | "assisted" | "advisory";
+    workflow_id?: string;
+    expected_outputs?: string[];
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface MemoryIR {
+    topics?: string[];
+    entities?: string[];
+    writeback?: boolean;
+    summary_layer?: string;
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface StateIR {
+    phase?: string;
+    run_id?: string;
+    owner?: string;
+    data: AionisObject;
+    loc?: SourceRange;
+}
+export interface AionisManifestIR {
+    doc: DocMetaIR | null;
+    context: ContextIR[];
+    plans: PlanIR[];
+    executions: ExecuteIR[];
+    decisions: DecisionIR[];
+    evidence: EvidenceIR[];
+    replay: ReplayIR[];
+    memory: MemoryIR[];
+    state: StateIR[];
+    diagnostics: Diagnostic[];
+}

package/dist/ir/types.js

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

package/dist/parser/parseAst.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentNode } from "../ast/types.js";
+import type { ScanResult } from "../scanner/scanSource.js";
+export declare function parseAst(scan: ScanResult): DocumentNode;