@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/{workflow-package → method-package}/context-interface.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "../compiler/lib/schema.js";
-export declare const CONTEXT_INTERFACE_FILE = "workflow.schema.json";
+import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../compiler/lib/schema.js";
+export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"workflow-schema">;
+    kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
@@ -17,8 +17,8 @@ export declare const ContextInterfaceSchema: z.ZodObject<{
         path: z.ZodString;
         kind: z.ZodEnum<{
             runtime: "runtime";
-            directory: "directory";
             file: "file";
+            directory: "directory";
         }>;
         required: z.ZodBoolean;
         owned_by: z.ZodArray<z.ZodString>;
@@ -36,8 +36,8 @@ export declare const ContextInterfaceZoneSchema: z.ZodObject<{
     path: z.ZodString;
     kind: z.ZodEnum<{
         runtime: "runtime";
-        directory: "directory";
         file: "file";
+        directory: "directory";
     }>;
     required: z.ZodBoolean;
     owned_by: z.ZodArray<z.ZodString>;
@@ -50,25 +50,25 @@ export declare const ContextInterfaceZoneRoleSchema: z.ZodEnum<{
     input: "input";
     working: "working";
 }>;
-export declare const WorkflowInputSpecSchema: z.ZodObject<{
+export declare const MethodInputSpecSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export declare const WorkflowInputContractSchema: z.ZodArray<z.ZodObject<{
+export declare const MethodInputContractSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
-export type ContextInterface = WorkflowCompiledSchema;
-export type ContextInterfaceZone = WorkflowCompiledZone;
-export type ContextInterfaceZoneId = WorkflowZoneId;
+export type ContextInterface = MethodCompiledSchema;
+export type ContextInterfaceZone = MethodCompiledZone;
+export type ContextInterfaceZoneId = MethodZoneId;
 export type ContextInterfaceZoneRole = z.infer<typeof ContextInterfaceZoneRoleSchema>;
-export type WorkflowInputSpec = z.infer<typeof WorkflowInputSpecSchema>;
+export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
 export interface ContextInterfaceStageLike {
     id: string;
     writes: readonly string[];
@@ -89,7 +89,7 @@ export declare function contextInterfaceZoneAbsolutePath(compiledPath: string, z
 export declare function contextInterfaceArtifactPath(zone: Pick<ContextInterfaceZone, "path" | "kind">): string;
 export declare function contextInterfaceArtifactPathsForZoneIds(contextInterface: ContextInterface, zoneIds: readonly ContextInterfaceZoneId[]): string[];
 export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
-export declare function deriveWorkflowInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): WorkflowInputSpec[];
+export declare function deriveMethodInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): MethodInputSpec[];
 export declare function buildContextInterface(stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterfaceFile(rootPath: string, stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterface(rootPath: string, contextInterface: ContextInterface): ContextInterface;

package/dist/packages/{workflow-package → method-package}/context-interface.js

@@ -3,32 +3,32 @@ import { join } from "node:path";
 import { z } from "zod";
 import { warnInterf } from "../shared/logger.js";
 import { readJsonFileUnchecked } from "../shared/parse.js";
-import { WorkflowCompiledSchemaSchema, WorkflowCompiledZoneSchema, WorkflowZoneIdSchema, WorkflowZoneRoleSchema, } from "../compiler/lib/schema.js";
-import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-workflow.js";
-// Workflow packages define the context interface. The compiler persists the
+import { MethodCompiledSchemaSchema, MethodCompiledZoneSchema, MethodZoneIdSchema, MethodZoneRoleSchema, } from "../compiler/lib/schema.js";
+import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-method.js";
+// Method packages define the context interface. The compiler persists the
 // same schema on disk, but higher layers should prefer this boundary when they
-// mean "the workflow-declared shape a compiled context must implement."
-export const CONTEXT_INTERFACE_FILE = "workflow.schema.json";
-export const ContextInterfaceSchema = WorkflowCompiledSchemaSchema;
-export const ContextInterfaceZoneSchema = WorkflowCompiledZoneSchema;
-export const ContextInterfaceZoneIdSchema = WorkflowZoneIdSchema;
-export const ContextInterfaceZoneRoleSchema = WorkflowZoneRoleSchema;
+// mean "the Method-declared shape a portable context must implement."
+export const CONTEXT_INTERFACE_FILE = "method.schema.json";
+export const ContextInterfaceSchema = MethodCompiledSchemaSchema;
+export const ContextInterfaceZoneSchema = MethodCompiledZoneSchema;
+export const ContextInterfaceZoneIdSchema = MethodZoneIdSchema;
+export const ContextInterfaceZoneRoleSchema = MethodZoneRoleSchema;
 // Package-owned input contract for authoring, review, and future authoring flows.
 // This does not change compiler execution semantics; it describes what data a
-// workflow expects to organize before the compiler materializes the context
+// Method expects to organize before the compiler materializes the context
 // interface on disk.
-export const WorkflowInputSpecSchema = z.object({
-    id: WorkflowZoneIdSchema,
+export const MethodInputSpecSchema = z.object({
+    id: MethodZoneIdSchema,
     label: z.string().min(1),
     description: z.string().min(1),
     required: z.boolean().default(false),
     examples: z.array(z.string().min(1)).optional(),
 }).strict();
-export const WorkflowInputContractSchema = z.array(WorkflowInputSpecSchema);
+export const MethodInputContractSchema = z.array(MethodInputSpecSchema);
 function normalizeContextInterface(contextInterface) {
     return {
         ...contextInterface,
-        kind: "workflow-schema",
+        kind: "method-schema",
     };
 }
 function pushContextInterfaceZone(zones, zone) {
@@ -54,7 +54,7 @@ export function contextInterfaceExists(rootPath) {
     return existsSync(contextInterfaceFilePath(rootPath));
 }
 export function contextInterfaceRelativePath() {
-    return `workflow/${CONTEXT_INTERFACE_FILE}`;
+    return `method/${CONTEXT_INTERFACE_FILE}`;
 }
 export function listContextInterfaceZones(contextInterface) {
     return [...contextInterface.zones];
@@ -87,7 +87,7 @@ export function summarizeContextInterface(contextInterface) {
         runtimeZones: contextInterface.zones.filter((zone) => zone.role === "runtime"),
     };
 }
-export function deriveWorkflowInputsFromContextInterface(contextInterface) {
+export function deriveMethodInputsFromContextInterface(contextInterface) {
     if (!contextInterface)
         return [];
     return contextInterface.zones
@@ -99,7 +99,7 @@ export function deriveWorkflowInputsFromContextInterface(contextInterface) {
         required: zone.required,
     }));
 }
-export function buildContextInterface(stages, label = "Workflow context interface") {
+export function buildContextInterface(stages, label = "Method context interface") {
     const zones = [];
     for (const zone of listBuiltinCompiledZoneSpecs()) {
         pushContextInterfaceZone(zones, {
@@ -113,7 +113,7 @@ export function buildContextInterface(stages, label = "Workflow context interfac
         });
     }
     return {
-        kind: "workflow-schema",
+        kind: "method-schema",
         version: 1,
         target_type: "compiled",
         label,
@@ -134,12 +134,12 @@ export function readContextInterface(rootPath) {
     const path = contextInterfaceFilePath(rootPath);
     if (!existsSync(path))
         return null;
-    const raw = readJsonFileUnchecked(path, "workflow context interface");
+    const raw = readJsonFileUnchecked(path, "Method context interface");
     if (raw === null)
         return null;
     const parsed = ContextInterfaceSchema.safeParse(raw);
     if (!parsed.success) {
-        warnInterf(`Warning: failed to validate workflow context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        warnInterf(`Warning: failed to validate Method context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
         return null;
     }
     return normalizeContextInterface(parsed.data);

package/dist/packages/method-package/index.d.ts

@@ -0,0 +1,11 @@
+export * as builtinMethod from "./builtin-compiled-method.js";
+export * as contextInterface from "./context-interface.js";
+export * as localMethods from "./local-methods.js";
+export * as packageWriters from "./interf-method-package.js";
+export * as methodDefinitions from "./method-definitions.js";
+export * as methodHelpers from "./method-helpers.js";
+export * as methodStagePolicy from "./method-stage-policy.js";
+export * as methodStageRunner from "./method-stage-runner.js";
+export * as methodReviewPaths from "./method-review-paths.js";
+export * as packageRoot from "./lib/package-root.js";
+export { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, ContextInterfaceZoneSchema, ContextInterfaceZoneIdSchema, ContextInterfaceZoneRoleSchema, MethodInputSpecSchema, MethodInputContractSchema, contextInterfaceFilePath, resolveContextInterfacePath, contextInterfaceExists, contextInterfaceRelativePath, listContextInterfaceZones, findContextInterfaceZone, contextInterfaceZoneAbsolutePath, contextInterfaceArtifactPath, contextInterfaceArtifactPathsForZoneIds, buildContextInterface, writeContextInterfaceFile, writeContextInterface, readContextInterface, type ContextInterface, type ContextInterfaceZone, type ContextInterfaceZoneId, type ContextInterfaceZoneRole, type ContextInterfaceStageLike, type MethodInputSpec, type ContextInterfaceSummary, summarizeContextInterface, deriveMethodInputsFromContextInterface, } from "./context-interface.js";

package/dist/packages/method-package/index.js

@@ -0,0 +1,11 @@
+export * as builtinMethod from "./builtin-compiled-method.js";
+export * as contextInterface from "./context-interface.js";
+export * as localMethods from "./local-methods.js";
+export * as packageWriters from "./interf-method-package.js";
+export * as methodDefinitions from "./method-definitions.js";
+export * as methodHelpers from "./method-helpers.js";
+export * as methodStagePolicy from "./method-stage-policy.js";
+export * as methodStageRunner from "./method-stage-runner.js";
+export * as methodReviewPaths from "./method-review-paths.js";
+export * as packageRoot from "./lib/package-root.js";
+export { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, ContextInterfaceZoneSchema, ContextInterfaceZoneIdSchema, ContextInterfaceZoneRoleSchema, MethodInputSpecSchema, MethodInputContractSchema, contextInterfaceFilePath, resolveContextInterfacePath, contextInterfaceExists, contextInterfaceRelativePath, listContextInterfaceZones, findContextInterfaceZone, contextInterfaceZoneAbsolutePath, contextInterfaceArtifactPath, contextInterfaceArtifactPathsForZoneIds, buildContextInterface, writeContextInterfaceFile, writeContextInterface, readContextInterface, summarizeContextInterface, deriveMethodInputsFromContextInterface, } from "./context-interface.js";

package/dist/packages/method-package/interf-method-package.d.ts

@@ -0,0 +1,31 @@
+import { type MethodDefinition } from "./method-definitions.js";
+export declare function writeCompiledMethodPackage(compiledPath: string, method: MethodDefinition<string>): void;
+export declare function writeMethodPackageToDir(methodDir: string, method: MethodDefinition<string>, options?: {
+    overwrite?: boolean;
+}): void;
+export declare function seedCompiledMethodPackage(options: {
+    compiledPath: string;
+    sourcePath: string;
+    methodId: string;
+}): void;
+export declare function createLocalMethodPackageFromTemplate(options: {
+    sourcePath: string;
+    baseMethodId: string;
+    methodId: string;
+    label: string;
+    hint: string;
+    stagePolicyNotes: Record<string, string[]>;
+}): string;
+export declare function seedLocalMethodPackageFromBase(options: {
+    sourcePath: string;
+    baseMethodId: string;
+    methodId: string;
+    label: string;
+    hint: string;
+}): string;
+export declare function createScratchLocalMethodPackage(options: {
+    sourcePath: string;
+    methodId: string;
+    label: string;
+    hint: string;
+}): string;