@aionis/manifest 0.1.1

package/dist/publish-cli.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import process from "node:process";
+import { publishAionisManifestSource, publishHandoffStoreRequest, publishRuntimeHandoff, } from "./publish.js";
+class CliUsageError extends Error {
+}
+function printHelp() {
+    process.stdout.write([
+        "publish-aionis-manifest-handoff",
+        "",
+        "Usage:",
+        "  publish-aionis-manifest-handoff <input-file> [--input-kind source|runtime-handoff|handoff-store-request]",
+        "                             [--base-url http://127.0.0.1:3001] [--scope <scope>] [--tenant-id <tenant>]",
+        "                             [--actor <actor>] [--memory-lane private|shared] [--title <title>] [--tag <tag>]",
+        "                             [--repo-root <path>] [--file-path <path>] [--symbol <name>]",
+        "                             [--current-stage triage|patch|review|resume] [--active-role orchestrator|triage|patch|review|resume]",
+        "                             [--allow-compile-errors] [--timeout-ms <ms>] [--api-key <key>] [--auth-bearer <token>]",
+        "                             [--admin-token <token>] [--request-id <id>] [--compact]",
+        "",
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    let inputPath = null;
+    const flags = {
+        inputKind: "source",
+        baseUrl: process.env.AIONIS_BASE_URL?.trim() || "http://127.0.0.1:3001",
+        scope: process.env.AIONIS_SCOPE?.trim() || null,
+        tenantId: null,
+        actor: null,
+        memoryLane: null,
+        title: null,
+        tags: [],
+        repoRoot: null,
+        filePath: null,
+        symbol: null,
+        currentStage: null,
+        activeRole: null,
+        allowCompileErrors: false,
+        timeoutMs: Number(process.env.AIONIS_TIMEOUT_MS || 10_000),
+        apiKey: process.env.API_KEY?.trim() || process.env.PERF_API_KEY?.trim() || null,
+        authBearer: process.env.AUTH_BEARER?.trim() || process.env.PERF_AUTH_BEARER?.trim() || null,
+        adminToken: process.env.ADMIN_TOKEN?.trim() || null,
+        requestId: 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 === "--allow-compile-errors") {
+            flags.allowCompileErrors = 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 === "--input-kind" ||
+            token === "--base-url" ||
+            token === "--scope" ||
+            token === "--tenant-id" ||
+            token === "--actor" ||
+            token === "--memory-lane" ||
+            token === "--title" ||
+            token === "--repo-root" ||
+            token === "--file-path" ||
+            token === "--symbol" ||
+            token === "--current-stage" ||
+            token === "--active-role" ||
+            token === "--timeout-ms" ||
+            token === "--api-key" ||
+            token === "--auth-bearer" ||
+            token === "--admin-token" ||
+            token === "--request-id") {
+            const value = argv[i + 1];
+            if (!value)
+                throw new CliUsageError(`Missing value for ${token}.`);
+            switch (token) {
+                case "--input-kind":
+                    if (value !== "source" && value !== "runtime-handoff" && value !== "handoff-store-request") {
+                        throw new CliUsageError(`Unsupported input kind '${value}'.`);
+                    }
+                    flags.inputKind = value;
+                    break;
+                case "--base-url":
+                    flags.baseUrl = 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;
+                case "--repo-root":
+                    flags.repoRoot = value;
+                    break;
+                case "--file-path":
+                    flags.filePath = value;
+                    break;
+                case "--symbol":
+                    flags.symbol = value;
+                    break;
+                case "--current-stage":
+                    if (!["triage", "patch", "review", "resume"].includes(value)) {
+                        throw new CliUsageError(`Unsupported current stage '${value}'.`);
+                    }
+                    flags.currentStage = value;
+                    break;
+                case "--active-role":
+                    if (!["orchestrator", "triage", "patch", "review", "resume"].includes(value)) {
+                        throw new CliUsageError(`Unsupported active role '${value}'.`);
+                    }
+                    flags.activeRole = value;
+                    break;
+                case "--timeout-ms":
+                    flags.timeoutMs = Number(value);
+                    break;
+                case "--api-key":
+                    flags.apiKey = value;
+                    break;
+                case "--auth-bearer":
+                    flags.authBearer = value;
+                    break;
+                case "--admin-token":
+                    flags.adminToken = value;
+                    break;
+                case "--request-id":
+                    flags.requestId = 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 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 inputText = await readFile(resolvedInput, "utf8");
+    const result = flags.inputKind === "source"
+        ? await publishAionisManifestSource({
+            source: inputText,
+            inputPath: resolvedInput,
+            baseUrl: flags.baseUrl,
+            scope: flags.scope ?? undefined,
+            tenantId: flags.tenantId ?? undefined,
+            actor: flags.actor ?? undefined,
+            memoryLane: flags.memoryLane ?? undefined,
+            title: flags.title ?? undefined,
+            tags: flags.tags,
+            repoRoot: flags.repoRoot,
+            filePath: flags.filePath,
+            symbol: flags.symbol,
+            currentStage: flags.currentStage ?? undefined,
+            activeRole: flags.activeRole ?? undefined,
+            allowCompileErrors: flags.allowCompileErrors,
+            timeoutMs: flags.timeoutMs,
+            apiKey: flags.apiKey ?? undefined,
+            authBearer: flags.authBearer ?? undefined,
+            adminToken: flags.adminToken ?? undefined,
+            requestId: flags.requestId ?? undefined,
+        })
+        : flags.inputKind === "runtime-handoff"
+            ? await publishRuntimeHandoff({
+                runtimeHandoff: JSON.parse(inputText),
+                baseUrl: flags.baseUrl,
+                scope: flags.scope ?? undefined,
+                tenantId: flags.tenantId ?? undefined,
+                actor: flags.actor ?? undefined,
+                memoryLane: flags.memoryLane ?? undefined,
+                title: flags.title ?? undefined,
+                tags: flags.tags,
+                repoRoot: flags.repoRoot,
+                filePath: flags.filePath,
+                symbol: flags.symbol,
+                currentStage: flags.currentStage ?? undefined,
+                activeRole: flags.activeRole ?? undefined,
+                allowCompileErrors: flags.allowCompileErrors,
+                timeoutMs: flags.timeoutMs,
+                apiKey: flags.apiKey ?? undefined,
+                authBearer: flags.authBearer ?? undefined,
+                adminToken: flags.adminToken ?? undefined,
+                requestId: flags.requestId ?? undefined,
+            })
+            : await publishHandoffStoreRequest({
+                baseUrl: flags.baseUrl,
+                handoffStoreRequest: JSON.parse(inputText),
+                inputKind: "handoff-store-request",
+                timeoutMs: flags.timeoutMs,
+                apiKey: flags.apiKey ?? undefined,
+                authBearer: flags.authBearer ?? undefined,
+                adminToken: flags.adminToken ?? undefined,
+                requestId: flags.requestId ?? undefined,
+            });
+    const rendered = flags.compact ? JSON.stringify(result) : `${JSON.stringify(result, null, 2)}\n`;
+    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/publish.d.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+export declare const AIONIS_MANIFEST_PUBLISH_RESULT_VERSION: "aionis_manifest_publish_result_v1";
+export declare const PublishInputKindSchema: z.ZodEnum<["source", "runtime-handoff", "handoff-store-request"]>;
+export type PublishInputKind = z.infer<typeof PublishInputKindSchema>;
+export declare const PublishResultSchema: z.ZodObject<{
+    publish_result_version: z.ZodLiteral<"aionis_manifest_publish_result_v1">;
+    published_at: z.ZodString;
+    base_url: z.ZodString;
+    input_kind: z.ZodEnum<["source", "runtime-handoff", "handoff-store-request"]>;
+    source_doc_id: z.ZodNullable<z.ZodString>;
+    source_doc_version: z.ZodNullable<z.ZodString>;
+    request: z.ZodObject<{
+        anchor: z.ZodString;
+        handoff_kind: z.ZodString;
+        scope: z.ZodOptional<z.ZodString>;
+        memory_lane: z.ZodOptional<z.ZodEnum<["private", "shared"]>>;
+    }, "strip", z.ZodTypeAny, {
+        anchor: string;
+        handoff_kind: string;
+        scope?: string | undefined;
+        memory_lane?: "private" | "shared" | undefined;
+    }, {
+        anchor: string;
+        handoff_kind: string;
+        scope?: string | undefined;
+        memory_lane?: "private" | "shared" | undefined;
+    }>;
+    response: z.ZodObject<{
+        status: z.ZodNumber;
+        request_id: z.ZodNullable<z.ZodString>;
+        tenant_id: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodString>;
+        commit_id: z.ZodString;
+        commit_uri: z.ZodOptional<z.ZodString>;
+        handoff_anchor: z.ZodNullable<z.ZodString>;
+        handoff_kind: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: number;
+        handoff_kind: string | null;
+        request_id: string | null;
+        commit_id: string;
+        handoff_anchor: string | null;
+        scope?: string | undefined;
+        tenant_id?: string | undefined;
+        commit_uri?: string | undefined;
+    }, {
+        status: number;
+        handoff_kind: string | null;
+        request_id: string | null;
+        commit_id: string;
+        handoff_anchor: string | null;
+        scope?: string | undefined;
+        tenant_id?: string | undefined;
+        commit_uri?: string | undefined;
+    }>;
+    handoff_store_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    source_doc_id: string | null;
+    source_doc_version: string | null;
+    publish_result_version: "aionis_manifest_publish_result_v1";
+    published_at: string;
+    base_url: string;
+    input_kind: "source" | "runtime-handoff" | "handoff-store-request";
+    request: {
+        anchor: string;
+        handoff_kind: string;
+        scope?: string | undefined;
+        memory_lane?: "private" | "shared" | undefined;
+    };
+    response: {
+        status: number;
+        handoff_kind: string | null;
+        request_id: string | null;
+        commit_id: string;
+        handoff_anchor: string | null;
+        scope?: string | undefined;
+        tenant_id?: string | undefined;
+        commit_uri?: string | undefined;
+    };
+    handoff_store_request: Record<string, unknown>;
+}, {
+    source_doc_id: string | null;
+    source_doc_version: string | null;
+    publish_result_version: "aionis_manifest_publish_result_v1";
+    published_at: string;
+    base_url: string;
+    input_kind: "source" | "runtime-handoff" | "handoff-store-request";
+    request: {
+        anchor: string;
+        handoff_kind: string;
+        scope?: string | undefined;
+        memory_lane?: "private" | "shared" | undefined;
+    };
+    response: {
+        status: number;
+        handoff_kind: string | null;
+        request_id: string | null;
+        commit_id: string;
+        handoff_anchor: string | null;
+        scope?: string | undefined;
+        tenant_id?: string | undefined;
+        commit_uri?: string | undefined;
+    };
+    handoff_store_request: Record<string, unknown>;
+}>;
+export type AionisManifestPublishResult = z.infer<typeof PublishResultSchema>;
+type PublishFromSourceOptions = {
+    source: string;
+    inputPath: string;
+    baseUrl: string;
+    scope?: string;
+    tenantId?: string;
+    actor?: string;
+    memoryLane?: "private" | "shared";
+    title?: string;
+    tags?: string[];
+    repoRoot?: string | null;
+    filePath?: string | null;
+    symbol?: string | null;
+    currentStage?: "triage" | "patch" | "review" | "resume";
+    activeRole?: "orchestrator" | "triage" | "patch" | "review" | "resume";
+    allowCompileErrors?: boolean;
+    timeoutMs?: number;
+    apiKey?: string;
+    authBearer?: string;
+    adminToken?: string;
+    requestId?: string;
+    publishedAt?: string;
+};
+type PublishRequestOptions = {
+    baseUrl: string;
+    handoffStoreRequest: unknown;
+    inputKind: PublishInputKind;
+    sourceDocId?: string | null;
+    sourceDocVersion?: string | null;
+    timeoutMs?: number;
+    apiKey?: string;
+    authBearer?: string;
+    adminToken?: string;
+    requestId?: string;
+    publishedAt?: string;
+};
+export declare function publishHandoffStoreRequest(args: PublishRequestOptions): Promise<AionisManifestPublishResult>;
+export declare function publishAionisManifestSource(args: PublishFromSourceOptions): Promise<AionisManifestPublishResult>;
+export declare function publishRuntimeHandoff(args: {
+    runtimeHandoff: unknown;
+} & Omit<PublishFromSourceOptions, "source" | "inputPath">): Promise<AionisManifestPublishResult>;
+export {};

package/dist/publish.js

@@ -0,0 +1,190 @@
+import { z } from "zod";
+import { compileAionisManifest } from "./compile.js";
+import { buildHandoffStoreRequestFromRuntimeHandoff, AionisManifestHandoffStoreRequestSchema, } from "./handoff-store.js";
+import { buildRuntimeHandoffV1, AionisManifestRuntimeHandoffSchema, } from "./runtime-handoff.js";
+export const AIONIS_MANIFEST_PUBLISH_RESULT_VERSION = "aionis_manifest_publish_result_v1";
+export const PublishInputKindSchema = z.enum(["source", "runtime-handoff", "handoff-store-request"]);
+export const PublishResultSchema = z.object({
+    publish_result_version: z.literal(AIONIS_MANIFEST_PUBLISH_RESULT_VERSION),
+    published_at: z.string().min(1),
+    base_url: z.string().min(1),
+    input_kind: PublishInputKindSchema,
+    source_doc_id: z.string().min(1).nullable(),
+    source_doc_version: z.string().min(1).nullable(),
+    request: z.object({
+        anchor: z.string().min(1),
+        handoff_kind: z.string().min(1),
+        scope: z.string().min(1).optional(),
+        memory_lane: z.enum(["private", "shared"]).optional(),
+    }),
+    response: z.object({
+        status: z.number().int().nonnegative(),
+        request_id: z.string().nullable(),
+        tenant_id: z.string().optional(),
+        scope: z.string().optional(),
+        commit_id: z.string().min(1),
+        commit_uri: z.string().optional(),
+        handoff_anchor: z.string().nullable(),
+        handoff_kind: z.string().nullable(),
+    }),
+    handoff_store_request: z.record(z.unknown()),
+});
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function withTimeout(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        cancel: () => clearTimeout(timer),
+    };
+}
+async function parseResponseBody(res) {
+    const contentType = (res.headers.get("content-type") ?? "").toLowerCase();
+    if (contentType.includes("application/json")) {
+        return res.json();
+    }
+    const text = await res.text();
+    return text.length > 0 ? text : null;
+}
+function buildHeaders(args) {
+    const headers = {
+        "content-type": "application/json",
+    };
+    if (args.apiKey)
+        headers["x-api-key"] = args.apiKey;
+    if (args.adminToken)
+        headers["x-admin-token"] = args.adminToken;
+    if (args.authBearer) {
+        headers.authorization = args.authBearer.toLowerCase().startsWith("bearer ")
+            ? args.authBearer
+            : `Bearer ${args.authBearer}`;
+    }
+    if (args.requestId)
+        headers["x-request-id"] = args.requestId;
+    return headers;
+}
+function extractRequestId(headers) {
+    return headers.get("x-request-id") ?? headers.get("request-id") ?? null;
+}
+export async function publishHandoffStoreRequest(args) {
+    const handoffStoreRequest = AionisManifestHandoffStoreRequestSchema.parse(args.handoffStoreRequest);
+    const timeoutMs = args.timeoutMs ?? 10_000;
+    const url = joinUrl(args.baseUrl, "/v1/handoff/store");
+    const timeout = withTimeout(timeoutMs);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: buildHeaders({
+                apiKey: args.apiKey,
+                authBearer: args.authBearer,
+                adminToken: args.adminToken,
+                requestId: args.requestId,
+            }),
+            body: JSON.stringify(handoffStoreRequest),
+            signal: timeout.signal,
+        });
+        const body = await parseResponseBody(res);
+        if (!res.ok) {
+            const message = body && typeof body === "object" && "message" in body && typeof body.message === "string"
+                ? String(body.message)
+                : `handoff publish failed with status ${res.status}`;
+            throw new Error(message);
+        }
+        const payload = body && typeof body === "object" ? body : {};
+        return PublishResultSchema.parse({
+            publish_result_version: AIONIS_MANIFEST_PUBLISH_RESULT_VERSION,
+            published_at: args.publishedAt ?? new Date().toISOString(),
+            base_url: args.baseUrl,
+            input_kind: args.inputKind,
+            source_doc_id: args.sourceDocId ?? null,
+            source_doc_version: args.sourceDocVersion ?? null,
+            request: {
+                anchor: handoffStoreRequest.anchor,
+                handoff_kind: handoffStoreRequest.handoff_kind,
+                scope: handoffStoreRequest.scope,
+                memory_lane: handoffStoreRequest.memory_lane,
+            },
+            response: {
+                status: res.status,
+                request_id: extractRequestId(res.headers),
+                tenant_id: typeof payload.tenant_id === "string" ? payload.tenant_id : undefined,
+                scope: typeof payload.scope === "string" ? payload.scope : undefined,
+                commit_id: String(payload.commit_id ?? ""),
+                commit_uri: typeof payload.commit_uri === "string" ? payload.commit_uri : undefined,
+                handoff_anchor: payload.handoff && typeof payload.handoff === "object" && typeof payload.handoff.anchor === "string"
+                    ? String(payload.handoff.anchor)
+                    : null,
+                handoff_kind: payload.handoff && typeof payload.handoff === "object" && typeof payload.handoff.handoff_kind === "string"
+                    ? String(payload.handoff.handoff_kind)
+                    : null,
+            },
+            handoff_store_request: handoffStoreRequest,
+        });
+    }
+    finally {
+        timeout.cancel();
+    }
+}
+export async function publishAionisManifestSource(args) {
+    const compile = compileAionisManifest(args.source);
+    const runtimeHandoff = buildRuntimeHandoffV1({
+        inputPath: args.inputPath,
+        result: compile,
+        scope: args.scope,
+        repoRoot: args.repoRoot,
+        filePath: args.filePath,
+        symbol: args.symbol,
+        currentStage: args.currentStage,
+        activeRole: args.activeRole,
+        requireErrorFree: !(args.allowCompileErrors ?? false),
+    });
+    const storeRequest = buildHandoffStoreRequestFromRuntimeHandoff({
+        handoff: runtimeHandoff,
+        tenantId: args.tenantId,
+        scope: args.scope,
+        actor: args.actor,
+        memoryLane: args.memoryLane,
+        title: args.title,
+        tags: args.tags,
+    });
+    return publishHandoffStoreRequest({
+        baseUrl: args.baseUrl,
+        handoffStoreRequest: storeRequest,
+        inputKind: "source",
+        sourceDocId: runtimeHandoff.source_doc_id,
+        sourceDocVersion: runtimeHandoff.source_doc_version,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        publishedAt: args.publishedAt,
+    });
+}
+export async function publishRuntimeHandoff(args) {
+    const runtimeHandoff = AionisManifestRuntimeHandoffSchema.parse(args.runtimeHandoff);
+    const storeRequest = buildHandoffStoreRequestFromRuntimeHandoff({
+        handoff: runtimeHandoff,
+        tenantId: args.tenantId,
+        scope: args.scope,
+        actor: args.actor,
+        memoryLane: args.memoryLane,
+        title: args.title,
+        tags: args.tags,
+    });
+    return publishHandoffStoreRequest({
+        baseUrl: args.baseUrl,
+        handoffStoreRequest: storeRequest,
+        inputKind: "runtime-handoff",
+        sourceDocId: runtimeHandoff.source_doc_id,
+        sourceDocVersion: runtimeHandoff.source_doc_version,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        publishedAt: args.publishedAt,
+    });
+}

package/dist/recover-cli.d.ts

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