@interf/compiler 0.22.2 → 0.33.0

package/dist/packages/runtime/schemas/runs.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { ArtifactRefSchema, BuildRunSchema, BuildRunStatusSchema, InterfRunEventSchema, EvidenceRecordSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, RunObservabilitySchema, } from "../execution/lib/schema.js";
+import { ProjectIdSchema, ReadinessSchema, RuntimeExecutorInfoSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, BuildPlanIdSchema, } from "../../contracts/lib/schema.js";
+import { BenchmarkRunSchema, TestRunModeSchema, } from "../verify/lib/schema.js";
+export const BuildRunCreateRequestSchema = z.object({
+    project: ProjectIdSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
+    max_loops: SourceBuildMaxLoopsSchema.optional(),
+    preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
+}).strict();
+export const BuildRunSummarySchema = z.object({
+    run_id: z.string().min(1),
+    status: BuildRunStatusSchema,
+    project: ProjectIdSchema,
+    build_plan: BuildPlanIdSchema,
+    context_graph_path: z.string().min(1),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    latest_event: InterfRunEventSchema.nullable().optional(),
+    latest_evidence: EvidenceRecordSchema.nullable().optional(),
+}).strict();
+export const BuildRunResourceSchema = z.object({
+    run: BuildRunSchema,
+}).strict();
+export const BuildRunListResponseSchema = z.object({
+    runs: z.array(BuildRunSchema),
+}).strict();
+/**
+ * Verify runs share the run-status enum with build runs.
+ */
+export const VerifyRunStatusSchema = BuildRunStatusSchema;
+/**
+ * Verify runs choose their judge target. `both` is the product default:
+ * one visible benchmark/evaluation run compares the Source files baseline
+ * with the prepared Context Graph using the same saved checks.
+ */
+export const VerifyRunCreateRequestSchema = z.object({
+    project: ProjectIdSchema,
+    target: TestRunModeSchema.default("both"),
+    agent_name: z.string().min(1).optional(),
+}).strict();
+export const VerifyRunBatchSummarySchema = z.object({
+    child_run_ids: z.array(z.string().min(1)).default([]),
+    total_agents: z.number().int().nonnegative(),
+    completed_agents: z.number().int().nonnegative(),
+    succeeded_agents: z.number().int().nonnegative(),
+    failed_agents: z.number().int().nonnegative(),
+}).strict();
+export const VerifyRunResourceSchema = z.object({
+    run_id: z.string().min(1),
+    status: VerifyRunStatusSchema,
+    project: ProjectIdSchema,
+    target: TestRunModeSchema.optional(),
+    source_path: z.string().min(1),
+    context_graph_path: z.string().min(1).nullable(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    executor: RuntimeExecutorInfoSchema.nullable().optional(),
+    agent_label: z.string().min(1).nullable().optional(),
+    parent_run_id: z.string().min(1).nullable().optional(),
+    batch: VerifyRunBatchSummarySchema.nullable().optional(),
+    benchmark_run: BenchmarkRunSchema.nullable(),
+    readiness: ReadinessSchema.nullable().optional(),
+    events: z.array(InterfRunEventSchema).default([]),
+    error: z.string().min(1).nullable().optional(),
+}).strict();
+/** `/v1/runs` projection — the unified observable run view across all run kinds. */
+export const RunObservabilityResourceSchema = RunObservabilitySchema;
+export const RunObservabilityListResponseSchema = z.object({
+    runs: z.array(RunObservabilityResourceSchema),
+}).strict();
+export const RunStatusResourceSchema = z.object({
+    kind: z.literal("interf-run-status"),
+    version: z.literal(1),
+    run_id: z.string().min(1),
+    run_type: ObservableRunTypeSchema,
+    title: z.string().min(1),
+    status: ObservableRunStatusSchema,
+    project: ProjectIdSchema.nullable().optional(),
+    build_plan: BuildPlanIdSchema.nullable().optional(),
+    created_at: z.string().min(1),
+    started_at: z.string().min(1).nullable().optional(),
+    finished_at: z.string().min(1).nullable().optional(),
+    metrics: z.array(ObservableRunMetricSchema).default([]),
+    artifact_count: z.number().int().nonnegative(),
+    check_count: z.number().int().nonnegative(),
+    context_check_count: z.number().int().nonnegative(),
+    readiness: ReadinessSchema.nullable().optional(),
+    latest_event: z.record(z.string(), z.unknown()).nullable(),
+    latest_log: z.record(z.string(), z.unknown()).nullable(),
+    detail_hint: z.string().min(1),
+}).strict();
+export const RunStatusListResponseSchema = z.object({
+    runs: z.array(RunStatusResourceSchema),
+}).strict();
+export const RunArtifactsResponseSchema = z.object({
+    artifacts: z.array(ArtifactRefSchema),
+}).strict();

package/dist/packages/runtime/service/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./routes.js";
+export * from "./server.js";
+export * from "./service-registry.js";

package/dist/packages/runtime/service/index.js

@@ -0,0 +1,3 @@
+export * from "./routes.js";
+export * from "./server.js";
+export * from "./service-registry.js";

package/dist/packages/runtime/service/openapi.d.ts

@@ -0,0 +1,7 @@
+type JsonObject = Record<string, unknown>;
+export declare function buildOpenApiDocument(options?: {
+    title?: string;
+    version?: string;
+    includeInternal?: boolean;
+}): JsonObject;
+export {};

package/dist/packages/runtime/service/openapi.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { LocalServiceErrorSchema } from "../schemas/index.js";
+import { SERVICE_OPERATIONS, } from "./operations.js";
+function withoutSchemaKeyword(value) {
+    if (Array.isArray(value))
+        return value.map(withoutSchemaKeyword);
+    if (!value || typeof value !== "object")
+        return value;
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "$schema")
+            continue;
+        next[key] = withoutSchemaKeyword(child);
+    }
+    return next;
+}
+function schemaObject(schema) {
+    return withoutSchemaKeyword(z.toJSONSchema(schema));
+}
+function parameterObject(parameter) {
+    return {
+        name: parameter.name,
+        in: parameter.in,
+        required: parameter.required,
+        description: parameter.description,
+        schema: schemaObject(parameter.schema),
+    };
+}
+function operationObject(operation) {
+    const contentType = operation.response_content_type ?? "application/json";
+    const responseSchema = operation.response_schema
+        ? schemaObject(operation.response_schema)
+        : {};
+    const requestBody = operation.request_schema
+        ? {
+            required: operation.method !== "GET",
+            content: {
+                "application/json": {
+                    schema: schemaObject(operation.request_schema),
+                },
+            },
+        }
+        : undefined;
+    return {
+        operationId: operation.id,
+        tags: operation.tags,
+        summary: operation.summary,
+        description: operation.description,
+        ...(operation.parameters?.length ? { parameters: operation.parameters.map(parameterObject) } : {}),
+        ...(requestBody ? { requestBody } : {}),
+        responses: {
+            [String(operation.success_status)]: {
+                description: "Success",
+                content: {
+                    [contentType]: {
+                        schema: responseSchema,
+                    },
+                },
+            },
+            default: {
+                description: "Error",
+                content: {
+                    "application/json": {
+                        schema: schemaObject(LocalServiceErrorSchema),
+                    },
+                },
+            },
+        },
+        ...(operation.visibility === "public" ? { security: [] } : {}),
+        "x-interf-visibility": operation.visibility,
+        ...(operation.workflow_step ? { "x-interf-workflow-step": operation.workflow_step } : {}),
+    };
+}
+export function buildOpenApiDocument(options = {}) {
+    const paths = {};
+    const serviceOperations = SERVICE_OPERATIONS;
+    const operations = serviceOperations.filter((operation) => options.includeInternal || operation.visibility !== "internal");
+    for (const operation of operations) {
+        const pathItem = paths[operation.path] ?? {};
+        pathItem[operation.method.toLowerCase()] = operationObject(operation);
+        paths[operation.path] = pathItem;
+    }
+    return {
+        openapi: "3.1.0",
+        info: {
+            title: options.title ?? "Interf Local Service API",
+            version: options.version ?? "0.1.0",
+            summary: "Human-readable contract for the Interf local service.",
+            description: "Interf prepares data for agents. This OpenAPI document describes the local service API that the CLI, MCP, and authorized clients use.",
+        },
+        servers: [
+            {
+                url: "http://127.0.0.1:4873",
+                description: "Default local Interf service.",
+            },
+        ],
+        security: [{ bearerAuth: [] }],
+        tags: [
+            { name: "Instance" },
+            { name: "Projects" },
+            { name: "Build Plans" },
+            { name: "Build Runs" },
+            { name: "Runs" },
+            { name: "Context Graphs" },
+        ],
+        paths,
+        components: {
+            securitySchemes: {
+                bearerAuth: {
+                    type: "http",
+                    scheme: "bearer",
+                    description: "Per-instance bearer token for local service clients.",
+                },
+            },
+        },
+    };
+}