@interf/compiler 0.13.0 → 0.18.0

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

@@ -1,116 +0,0 @@
-import { rmSync } from "node:fs";
-import { createMethodAuthoringShell } from "../agents/lib/shells.js";
-import { createScratchLocalMethodPackage } from "../method-package/interf-method-package.js";
-import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
-import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../method-package/local-methods.js";
-import { runMethodEditSession } from "./method-edit-session.js";
-function buildMethodAuthoringPrompt() {
-    return [
-        "This is an automated Interf Method-authoring run, not an open-ended chat session.",
-        "Execute it now.",
-        "Create one standalone Method package for the source data, desired portable-context outputs, and proof requirements in this source folder.",
-        "Read `runtime/authoring-context.json` first.",
-        "Treat `task_prompt` as the user's preparation-and-evidence brief: source data, output shape, and evidence that should show the data is ready.",
-        `Then read \`method/README.md\`, \`method/method.json\`, and \`method/${CONTEXT_INTERFACE_FILE}\`.`,
-        "The `method/` directory starts as a neutral Method package scaffold, not as a suggested Method.",
-        "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this agent work actually needs.",
-        "Read `runtime/source-files.json` and inspect the listed source locators before editing the package.",
-        "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
-        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
-        "Edit only files under `method/`.",
-        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
-        "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
-        "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
-        "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
-        "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
-        "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
-        "For file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`.",
-        "Before stopping, verify every zone-count acceptance key is declared in `method.schema.json`.",
-        "For every stage in `method.json`, create `method/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's kebab-case `skill_dir`.",
-        "Every zone path in `method.schema.json` must be unique and non-overlapping. Do not declare both `knowledge/indexes` and `knowledge/indexes/some-file.md` as separate zones.",
-        "Make the package materially specific to this Preparation task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
-        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
-        "Keep the portable-context entrypoint canonical: if the Method writes an agent entrypoint, declare zone id `home` with path `home.md` and make the final shaping stage own it.",
-        "Do not move the main entrypoint to `knowledge/home.md` or any other nested path.",
-        "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
-        "Do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path.",
-        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
-        "Do not make one stage point at files or notes that are only created later by another stage.",
-        "Prefer conservative retrieval routing over speculative note sprawl.",
-        "Do not narrate plans or ask follow-up questions.",
-        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "As soon as the Method edits are complete, stop.",
-    ].join("\n");
-}
-function validateAuthoredMethodPackage(methodPath) {
-    const validation = validateMethodPackage(methodPath);
-    if (!validation.ok)
-        return validation;
-    const definition = loadMethodDefinitionFromDir(methodPath);
-    if (!definition)
-        return validation;
-    const errors = [...validation.errors];
-    const placeholderStage = definition.stages?.find((stage) => stage.id === "prepare" &&
-        stage.contract_type === "method-draft-stage" &&
-        stage.writes.includes("draft-context"));
-    const placeholderZone = definition.method_schema.zones.find((zone) => zone.id === "draft-context");
-    const placeholderPurpose = definition.purpose?.label === "From-scratch Method draft" ||
-        definition.purpose?.task_hint?.includes("Replace this neutral scaffold");
-    if (placeholderStage) {
-        errors.push("Authored Method still contains the neutral scaffold stage `prepare`.");
-    }
-    if (placeholderZone) {
-        errors.push("Authored Method still contains the neutral scaffold zone `draft-context`.");
-    }
-    if (placeholderPurpose) {
-        errors.push("Authored Method still contains the neutral scaffold purpose.");
-    }
-    return {
-        ok: validation.ok && errors.length === 0,
-        summary: errors.length === 0
-            ? validation.summary
-            : `Method package has ${errors.length} issue(s).`,
-        errors,
-        counts: validation.counts,
-    };
-}
-export async function runMethodAuthoringDraft(options) {
-    const methodPath = createScratchLocalMethodPackage({
-        prepDataDir: options.prepDataDir,
-        methodId: options.methodId,
-        label: options.label,
-        hint: options.hint,
-    });
-    const shell = createMethodAuthoringShell({
-        methodPath,
-        methodId: options.methodId,
-        label: options.label,
-        referenceMethodId: options.baseMethodId ?? null,
-        sourceFolderPath: options.sourceFolderPath,
-        taskPrompt: options.taskPrompt,
-        checks: options.checks ?? [],
-    });
-    const session = await runMethodEditSession({
-        executor: options.executor,
-        methodPath,
-        shell,
-        prompt: buildMethodAuthoringPrompt(),
-        validate: validateAuthoredMethodPackage,
-        maxValidationRepairAttempts: 1,
-        onStatus: options.onStatus,
-    });
-    if (session.status !== "updated") {
-        rmSync(methodPath, { recursive: true, force: true });
-    }
-    return {
-        status: session.status,
-        changed: session.changed,
-        summary: session.summary,
-        validation: session.validation,
-        methodPath,
-        shellPath: shell.rootPath,
-    };
-}
-export function resolveMethodDraftPath(sourcePath, methodId) {
-    return methodDefinitionPath(sourcePath, methodId);
-}

package/dist/packages/method-package/context-interface.d.ts

@@ -1,60 +0,0 @@
-import { z } from "zod";
-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<"method-schema">;
-    version: z.ZodLiteral<1>;
-    target_type: z.ZodLiteral<"compiled">;
-    label: z.ZodString;
-    zones: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        role: z.ZodEnum<{
-            runtime: "runtime";
-            output: "output";
-            input: "input";
-            working: "working";
-        }>;
-        path: z.ZodString;
-        kind: z.ZodEnum<{
-            runtime: "runtime";
-            file: "file";
-            directory: "directory";
-        }>;
-        required: z.ZodBoolean;
-        owned_by: z.ZodArray<z.ZodString>;
-        description: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-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 type ContextInterface = MethodCompiledSchema;
-export type ContextInterfaceZone = MethodCompiledZone;
-export type ContextInterfaceZoneId = MethodZoneId;
-export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
-interface ContextInterfaceStageLike {
-    id: string;
-    writes: readonly string[];
-}
-interface ContextInterfaceSummary {
-    inputZones: ContextInterfaceZone[];
-    workingZones: ContextInterfaceZone[];
-    outputZones: ContextInterfaceZone[];
-    runtimeZones: ContextInterfaceZone[];
-}
-export declare function contextInterfaceFilePath(rootPath: string): string;
-export declare function resolveContextInterfacePath(rootPath: string): string | null;
-export declare function contextInterfaceExists(rootPath: string): boolean;
-export declare function contextInterfaceZoneAbsolutePath(compiledPath: string, zone: Pick<ContextInterfaceZone, "path">): string;
-export declare function contextInterfaceArtifactPath(zone: Pick<ContextInterfaceZone, "path" | "kind">): string;
-export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
-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;
-export declare function readContextInterface(rootPath: string): ContextInterface | null;
-export {};

package/dist/packages/testing/index.d.ts

@@ -1,13 +0,0 @@
-export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
-export * as readinessCheckRun from "./readiness-check-run.js";
-export * as sandbox from "./test-sandbox.js";
-export * as specs from "./test-specs.js";
-export * as targets from "./test-targets.js";
-export * as types from "./test-types.js";
-export type { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, ReadinessCheckRun, TestTargetType, } from "./lib/schema.js";
-export type { LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
-export type { TestSandboxRetentionMode, } from "./test-sandbox.js";

package/dist/packages/testing/index.js

@@ -1,10 +0,0 @@
-export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
-export * as readinessCheckRun from "./readiness-check-run.js";
-export * as sandbox from "./test-sandbox.js";
-export * as specs from "./test-specs.js";
-export * as targets from "./test-targets.js";
-export * as types from "./test-types.js";