@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/methods/authoring/method-edit-session.d.ts

@@ -1,18 +0,0 @@
-import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
-import type { MethodValidationResult } from "../package/local-methods.js";
-import { type MethodEditShellArtifacts } from "./lib/method-edit-utils.js";
-export interface MethodEditSessionResult {
-    status: "updated" | "no-change" | "invalid" | "executor-failed";
-    changed: boolean;
-    validation: MethodValidationResult | null;
-    summary: string;
-}
-export declare function runMethodEditSession(options: {
-    executor: MethodExecutor;
-    methodPath: string;
-    shell: MethodEditShellArtifacts;
-    prompt: string;
-    validate: (methodPath: string) => MethodValidationResult;
-    maxValidationRepairAttempts?: number;
-    onStatus?: (line: string) => void;
-}): Promise<MethodEditSessionResult>;

package/dist/packages/methods/authoring/method-improvement.d.ts

@@ -1,23 +0,0 @@
-import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
-import { type MethodValidationResult } from "../package/local-methods.js";
-import type { SourcePreparationConfig } from "../../project/lib/schema.js";
-import type { MethodImprovementLoopSummary } from "../../engine/compile/lib/schema.js";
-export interface MethodImprovementRunResult {
-    status: "updated" | "no-change" | "invalid" | "executor-failed";
-    changed: boolean;
-    validation: MethodValidationResult | null;
-    summary: string;
-    shellPath: string;
-    loopRootPath: string;
-}
-export declare function runMethodImprovementLoop(options: {
-    executor: MethodExecutor;
-    compiledPath: string;
-    methodId: string;
-    compiledConfig: Pick<SourcePreparationConfig, "checks">;
-    runId: string;
-    loopIndex: number;
-    maxLoops: number;
-    maxAttempts: number;
-    previousVariations: MethodImprovementLoopSummary[];
-}): Promise<MethodImprovementRunResult>;

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

@@ -1,217 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
-import { join, relative } from "node:path";
-import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../../engine/agents/lib/shells.js";
-import { validateMethodPackage } from "../package/local-methods.js";
-import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { resolveMethodImprovementReviewPaths } from "../package/method-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../../engine/compile/compiled-paths.js";
-import { readInterfConfig } from "../../project/interf.js";
-import { saveCompiledInterfConfig } from "../../project/source-config.js";
-import { MethodImprovementRunLedgerSchema, } from "../../engine/compile/lib/schema.js";
-import { runMethodEditSession } from "./method-edit-session.js";
-import { ensureStageRoles } from "./method-authoring.js";
-function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
-    if (!absolutePath)
-        return null;
-    const normalizedSourceRoot = `${sourceRoot}/`;
-    if (absolutePath !== sourceRoot && !absolutePath.startsWith(normalizedSourceRoot)) {
-        return null;
-    }
-    const relativePath = relative(sourceRoot, absolutePath);
-    return join(shellRoot, relativePath);
-}
-function mapLoopSummaryForShell(summary, compiledPath) {
-    const shellTestRunsRoot = "artifacts/test-runs";
-    const shellTestSandboxesRoot = "artifacts/test-sandboxes";
-    return {
-        ...summary,
-        test_run_path: toShellArtifactPath(summary.test_run_path, targetTestRunsRootForCompiled(compiledPath), shellTestRunsRoot) ?? summary.test_run_path ?? null,
-        test_sandbox_path: toShellArtifactPath(summary.test_sandbox_path, targetTestSandboxesRootForCompiled(compiledPath), shellTestSandboxesRoot) ?? summary.test_sandbox_path ?? null,
-    };
-}
-function buildLoopContext(options) {
-    const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.compiledPath));
-    const latestFailure = previousVariations.at(-1) ?? null;
-    return {
-        kind: "interf-method-improvement-loop",
-        version: 1,
-        generated_at: new Date().toISOString(),
-        target_name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-        method_id: options.methodId,
-        loop_index: options.loopIndex,
-        max_loops: options.maxLoops,
-        max_attempts: options.maxAttempts,
-        review_paths: resolveMethodImprovementReviewPaths(options.compiledPath),
-        readiness_checks: {
-            count: options.compiledConfig.checks.length,
-            questions: options.compiledConfig.checks.map((check, index) => ({
-                id: check.id ?? `check-${index + 1}`,
-                question: check.question,
-            })),
-        },
-        previous_variations: previousVariations,
-        latest_failure: latestFailure,
-    };
-}
-function buildMethodImprovementPrompt() {
-    return [
-        "This is an automated Interf Method-improvement run, not an open-ended chat session.",
-        "The user already invoked this through `interf compile` with self-improving loops enabled. Execute it now.",
-        "Read `runtime/loop-context.json` first.",
-        `Then read \`method/README.md\`, \`method/method.json\`, \`method/${CONTEXT_INTERFACE_FILE}\`, and \`method/improve/SKILL.md\` if it exists.`,
-        "Review preserved evidence from earlier failures under `artifacts/` before you edit the Method.",
-        "Treat `method/improve/SKILL.md` as guidance for how to improve the Method, not as the default file to edit.",
-        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
-        "Prefer editing the stage docs, Method contract, input contract, or schema ownership that actually change portable-context outputs.",
-        "Edit only files under `method/`.",
-        "Do not edit checks, test specs, source files, or generated portable-context outputs.",
-        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
-        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read Artifacts.",
-        "Do not make one stage point at files or notes that are only created later by another stage.",
-        "Prefer small, defensible changes to Method docs, stage docs, stage policies, or schema ownership over random churn.",
-        "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 updateCompiledMethodOrigin(options) {
-    const current = readInterfConfig(options.compiledPath);
-    if (!current)
-        return;
-    const nextConfig = {
-        ...current,
-        method: current.method ?? options.selectedMethodId,
-        method_origin: {
-            selected: options.selectedMethodId,
-            ...(options.localDraft ? { local_draft: true } : {}),
-        },
-    };
-    saveCompiledInterfConfig(options.compiledPath, nextConfig);
-}
-function methodImprovementRunLedgerPath(compiledPath, runId) {
-    return join(methodImprovementRunRoot(compiledPath, runId), "run.json");
-}
-function methodImprovementLoopHistoryPath(compiledPath, runId) {
-    return join(methodImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
-}
-function methodImprovementLoopRecordPath(loopRootPath) {
-    return join(loopRootPath, "loop.json");
-}
-function readMethodImprovementRunLedger(compiledPath, runId) {
-    const ledgerPath = methodImprovementRunLedgerPath(compiledPath, runId);
-    if (!existsSync(ledgerPath))
-        return null;
-    return readJsonFileWithSchema(ledgerPath, "Method improvement run ledger", MethodImprovementRunLedgerSchema);
-}
-function writeMethodImprovementRunLedger(compiledPath, runId, record, options) {
-    const runRoot = methodImprovementRunRoot(compiledPath, runId);
-    mkdirSync(runRoot, { recursive: true });
-    const existing = readMethodImprovementRunLedger(compiledPath, runId);
-    const generatedAt = existing?.generated_at ?? new Date().toISOString();
-    const ledger = {
-        kind: "interf-method-improvement-run",
-        version: 1,
-        generated_at: generatedAt,
-        updated_at: new Date().toISOString(),
-        run_id: runId,
-        target_name: options.targetName,
-        method_id: options.methodId,
-        max_loops: options.maxLoops,
-        max_attempts: options.maxAttempts,
-        loops: [...(existing?.loops ?? []), record],
-    };
-    writeFileSync(methodImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
-    writeFileSync(methodImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
-    appendFileSync(methodImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
-}
-function buildMethodImprovementLoopRecord(options) {
-    return {
-        kind: "interf-method-improvement-loop-record",
-        version: 1,
-        recorded_at: new Date().toISOString(),
-        run_id: options.runId,
-        loop_index: options.loopIndex,
-        target_name: options.targetName,
-        method_id: options.methodId,
-        result: options.result,
-        changed: options.changed,
-        applied: options.result === "updated",
-        summary: options.summary,
-        shell_path: options.shellPath,
-        loop_root_path: options.loopRootPath,
-        context_path: join(options.shellPath, "runtime", "loop-context.json"),
-        method_before_path: options.methodBeforePath,
-        method_after_path: options.methodAfterPath,
-        prompt_log_path: options.promptLogPath,
-        event_log_path: options.eventLogPath,
-        status_log_path: options.statusLogPath,
-        preserved_shell_manifest_path: options.preservedShellManifestPath,
-        validation: options.validation,
-    };
-}
-export async function runMethodImprovementLoop(options) {
-    const compiledName = readInterfConfig(options.compiledPath)?.name ?? "compiled";
-    const context = buildLoopContext(options);
-    const shell = createMethodImprovementShell({
-        compiledPath: options.compiledPath,
-        compiledName,
-        methodId: options.methodId,
-        runId: options.runId,
-        loopIndex: options.loopIndex,
-        context,
-    });
-    const methodRoot = methodPackagePathForCompiled(options.compiledPath);
-    const session = await runMethodEditSession({
-        executor: options.executor,
-        methodPath: methodRoot,
-        shell,
-        prompt: buildMethodImprovementPrompt(),
-        validate: validateMethodPackage,
-        maxValidationRepairAttempts: 1,
-    });
-    if (session.status === "updated") {
-        // 0.15 — fill role=general on any stage the improvement run
-        // dropped a role from. Idempotent and silent when complete.
-        ensureStageRoles(methodRoot);
-    }
-    const preservedShellManifestPath = freezeMethodImprovementShell(shell.rootPath);
-    writeMethodImprovementRunLedger(options.compiledPath, options.runId, buildMethodImprovementLoopRecord({
-        targetName: compiledName,
-        methodId: options.methodId,
-        runId: options.runId,
-        loopIndex: options.loopIndex,
-        shellPath: shell.rootPath,
-        loopRootPath: shell.loopRootPath,
-        methodBeforePath: shell.methodBeforePath,
-        methodAfterPath: shell.methodAfterPath,
-        promptLogPath: shell.promptLogPath,
-        eventLogPath: shell.eventLogPath,
-        statusLogPath: shell.statusLogPath,
-        preservedShellManifestPath,
-        changed: session.changed,
-        validation: session.validation,
-        result: session.status,
-        summary: session.summary,
-    }), {
-        targetName: compiledName,
-        methodId: options.methodId,
-        maxLoops: options.maxLoops,
-        maxAttempts: options.maxAttempts,
-    });
-    if (session.status === "updated") {
-        updateCompiledMethodOrigin({
-            compiledPath: options.compiledPath,
-            selectedMethodId: options.methodId,
-            localDraft: true,
-        });
-    }
-    return {
-        status: session.status,
-        changed: session.changed,
-        validation: session.validation,
-        summary: session.summary,
-        shellPath: shell.rootPath,
-        loopRootPath: shell.loopRootPath,
-    };
-}

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

@@ -1,2 +0,0 @@
-export * as methodResolution from "./method-resolution.js";
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveMethodId, } from "./method-resolution.js";

package/dist/packages/methods/index.js

@@ -1,2 +0,0 @@
-export * as methodResolution from "./method-resolution.js";
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveMethodId, } from "./method-resolution.js";

package/dist/packages/methods/method-resolution.d.ts

@@ -1,6 +0,0 @@
-export declare const DEFAULT_METHOD_ID = "interf-default";
-export interface MethodSelectionLike {
-    method?: string | null;
-}
-export declare function methodIdForSourcePreparationConfig(preparationConfig: MethodSelectionLike | null | undefined): string | null;
-export declare function resolveMethodId(selection: MethodSelectionLike | null | undefined, fallback?: string): string;

package/dist/packages/methods/method-resolution.js

@@ -1,7 +0,0 @@
-export const DEFAULT_METHOD_ID = "interf-default";
-export function methodIdForSourcePreparationConfig(preparationConfig) {
-    return preparationConfig?.method ?? null;
-}
-export function resolveMethodId(selection, fallback = DEFAULT_METHOD_ID) {
-    return methodIdForSourcePreparationConfig(selection) ?? fallback;
-}

package/dist/packages/methods/package/builtin-compiled-method.d.ts

@@ -1,37 +0,0 @@
-import { type CompiledArtifactKind } from "../../engine/compile/method-primitives.js";
-declare const BUILTIN_COMPILED_STAGE_IDS: {
-    readonly SUMMARIZE: "summarize";
-    readonly STRUCTURE: "structure";
-    readonly SHAPE: "shape";
-};
-type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
-export declare const BUILTIN_COMPILED_ARTIFACT_IDS: {
-    readonly SUMMARIES: "summaries";
-    readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
-    readonly KNOWLEDGE_CLAIMS: "knowledge-claims";
-    readonly KNOWLEDGE_INDEXES: "knowledge-indexes";
-    readonly HOME: "atlas";
-    readonly RUNTIME: "runtime";
-};
-export type BuiltinCompiledArtifactId = typeof BUILTIN_COMPILED_ARTIFACT_IDS[keyof typeof BUILTIN_COMPILED_ARTIFACT_IDS];
-export interface BuiltinCompiledArtifactSpec {
-    id: BuiltinCompiledArtifactId;
-    role: "input" | "working" | "output" | "runtime";
-    path: string;
-    kind: CompiledArtifactKind;
-    required: boolean;
-    description: string;
-}
-export interface BuiltinCompiledStageAccessPattern {
-    id: BuiltinCompiledStageId;
-    contract_type: string;
-    reads: BuiltinCompiledArtifactId[];
-    writes: BuiltinCompiledArtifactId[];
-}
-export declare function listBuiltinCompiledArtifactSpecs(): BuiltinCompiledArtifactSpec[];
-export declare function listBuiltinCompiledFallbackStages(): BuiltinCompiledStageAccessPattern[];
-export declare function requiredCompiledArtifactOwners<TStage extends {
-    id: string;
-    writes: readonly string[];
-}>(stages: readonly TStage[], artifactId: BuiltinCompiledArtifactId): string[];
-export {};

package/dist/packages/methods/package/builtin-compiled-method.js

@@ -1,91 +0,0 @@
-import { join } from "node:path";
-import { z } from "zod";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { MethodCompiledSchemaSchema } from "../../engine/compile/lib/schema.js";
-import { PACKAGE_ROOT } from "./lib/package-root.js";
-const BUILTIN_COMPILED_STAGE_IDS = {
-    SUMMARIZE: "summarize",
-    STRUCTURE: "structure",
-    SHAPE: "shape",
-};
-export const BUILTIN_COMPILED_ARTIFACT_IDS = {
-    SUMMARIES: "summaries",
-    KNOWLEDGE_ENTITIES: "knowledge-entities",
-    KNOWLEDGE_CLAIMS: "knowledge-claims",
-    KNOWLEDGE_INDEXES: "knowledge-indexes",
-    HOME: "atlas",
-    RUNTIME: "runtime",
-};
-const BUILTIN_ARTIFACT_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ARTIFACT_IDS));
-const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
-const BuiltinMethodStageSchema = z.object({
-    id: z.string(),
-    contract_type: z.string(),
-    reads: z.array(z.string()),
-    writes: z.array(z.string()).min(1),
-});
-const BuiltinMethodPackageSchema = z.object({
-    stages: z.array(BuiltinMethodStageSchema).min(1),
-});
-let builtinCompiledContractCache = null;
-const BUILTIN_DEFAULT_METHOD_ROOT = join(PACKAGE_ROOT, "public-repo", "methods", "interf-default");
-function assertBuiltinArtifactId(value) {
-    if (!BUILTIN_ARTIFACT_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf Method schema declares unsupported Artifact id "${value}".`);
-    }
-    return value;
-}
-function assertBuiltinStageId(value) {
-    if (!BUILTIN_STAGE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf Method package declares unsupported stage id "${value}".`);
-    }
-    return value;
-}
-function loadBuiltinCompiledContract() {
-    if (builtinCompiledContractCache)
-        return builtinCompiledContractCache;
-    const schemaPath = join(BUILTIN_DEFAULT_METHOD_ROOT, "method.schema.json");
-    const methodPath = join(BUILTIN_DEFAULT_METHOD_ROOT, "method.json");
-    const schema = readJsonFileWithSchema(schemaPath, "built-in Interf Method schema", MethodCompiledSchemaSchema);
-    if (!schema) {
-        throw new Error(`Missing or invalid built-in Method schema at ${schemaPath}.`);
-    }
-    const method = readJsonFileWithSchema(methodPath, "built-in Interf Method package", BuiltinMethodPackageSchema);
-    if (!method) {
-        throw new Error(`Missing or invalid built-in Method package at ${methodPath}.`);
-    }
-    const artifacts = schema.artifacts.map((artifact) => {
-        const path = artifact.shape.path;
-        return {
-            id: assertBuiltinArtifactId(artifact.id),
-            role: "output",
-            path,
-            kind: artifact.shape.artifact_kind,
-            required: true,
-            description: artifact.description,
-        };
-    });
-    const stages = method.stages.map((stage) => ({
-        id: assertBuiltinStageId(stage.id),
-        contract_type: stage.contract_type,
-        reads: stage.reads.map(assertBuiltinArtifactId),
-        writes: stage.writes.map(assertBuiltinArtifactId),
-    }));
-    builtinCompiledContractCache = { artifacts, stages };
-    return builtinCompiledContractCache;
-}
-export function listBuiltinCompiledArtifactSpecs() {
-    return loadBuiltinCompiledContract().artifacts.map((artifact) => ({ ...artifact }));
-}
-export function listBuiltinCompiledFallbackStages() {
-    return loadBuiltinCompiledContract().stages.map((stage) => ({
-        ...stage,
-        reads: [...stage.reads],
-        writes: [...stage.writes],
-    }));
-}
-export function requiredCompiledArtifactOwners(stages, artifactId) {
-    return Array.from(new Set(stages
-        .filter((stage) => stage.writes.includes(artifactId))
-        .map((stage) => stage.id)));
-}

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

@@ -1,31 +0,0 @@
-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;
-    prepDataDir: string;
-    methodId: string;
-}): void;
-export declare function createLocalMethodPackageFromTemplate(options: {
-    prepDataDir: string;
-    baseMethodId: string;
-    methodId: string;
-    label: string;
-    hint: string;
-    stagePolicyNotes: Record<string, string[]>;
-}): string;
-export declare function seedLocalMethodPackageFromBase(options: {
-    prepDataDir: string;
-    baseMethodId: string;
-    methodId: string;
-    label: string;
-    hint: string;
-}): string;
-export declare function createScratchLocalMethodPackage(options: {
-    prepDataDir: string;
-    methodId: string;
-    label: string;
-    hint: string;
-}): string;