@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/engine/compile/compiled-schema.js

@@ -1,126 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { warnInterf } from "../../contracts/utils/logger.js";
-import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
-import { listBuiltinCompiledArtifactSpecs, requiredCompiledArtifactOwners, } from "../../methods/package/builtin-compiled-method.js";
-import { MethodCompiledSchemaSchema, } from "./lib/schema.js";
-export const METHOD_SCHEMA_FILE = "method.schema.json";
-export function methodSchemaFilePath(rootPath) {
-    return join(rootPath, METHOD_SCHEMA_FILE);
-}
-export function resolveMethodSchemaPath(rootPath) {
-    const path = methodSchemaFilePath(rootPath);
-    return existsSync(path) ? path : null;
-}
-export function methodSchemaExists(rootPath) {
-    return existsSync(methodSchemaFilePath(rootPath));
-}
-export function methodSchemaRelativePath() {
-    return `method/${METHOD_SCHEMA_FILE}`;
-}
-export function listCompiledSchemaArtifacts(schema) {
-    return schema.artifacts.map(artifactToMethodArtifact);
-}
-export function findCompiledSchemaArtifact(schema, artifactId) {
-    return listCompiledSchemaArtifacts(schema).find((artifact) => artifact.id === artifactId) ?? null;
-}
-export function compiledArtifactAbsolutePath(compiledPath, artifact) {
-    return join(compiledPath, artifact.path);
-}
-export function compiledContractArtifactPath(artifact) {
-    if (artifact.kind === "file")
-        return artifact.path;
-    return artifact.path.endsWith("/") ? artifact.path : `${artifact.path}/`;
-}
-export function compiledContractArtifactPathsForArtifactIds(schema, artifactIds) {
-    return artifactIds.map((artifactId) => {
-        const artifact = findCompiledSchemaArtifact(schema, artifactId);
-        if (!artifact) {
-            throw new Error(`Compiled schema is missing declared Artifact "${artifactId}".`);
-        }
-        return compiledContractArtifactPath(artifact);
-    });
-}
-export function ensureCompiledArtifactTargets(compiledPath, schema) {
-    for (const artifact of listCompiledSchemaArtifacts(schema)) {
-        if (artifact.kind === "directory" || artifact.kind === "runtime") {
-            mkdirSync(compiledArtifactAbsolutePath(compiledPath, artifact), { recursive: true });
-            continue;
-        }
-        mkdirSync(dirname(compiledArtifactAbsolutePath(compiledPath, artifact)), { recursive: true });
-    }
-}
-function normalizeMethodSchema(schema) {
-    return {
-        ...schema,
-        kind: "method-schema",
-    };
-}
-function artifactToMethodArtifact(artifact) {
-    if (artifact.shape.kind !== "path") {
-        return {
-            id: artifact.id,
-            role: "output",
-            path: artifact.id,
-            kind: "directory",
-            required: true,
-            owned_by: [...artifact.built_by_stages],
-            description: artifact.description,
-        };
-    }
-    return {
-        id: artifact.id,
-        role: "output",
-        path: artifact.shape.path,
-        kind: artifact.shape.artifact_kind,
-        required: true,
-        owned_by: [...artifact.built_by_stages],
-        description: artifact.description,
-    };
-}
-export function buildMethodSchema(stages, label = "Method schema") {
-    return {
-        kind: "method-schema",
-        version: 1,
-        target_type: "compiled",
-        label,
-        artifacts: listBuiltinCompiledArtifactSpecs().map((artifact) => ({
-            id: artifact.id,
-            description: artifact.description,
-            shape: {
-                kind: "path",
-                path: artifact.path,
-                artifact_kind: artifact.kind === "file" ? "file" : "directory",
-            },
-            checks: [],
-            built_by_stages: requiredCompiledArtifactOwners(stages, artifact.id),
-        })),
-    };
-}
-export function writeMethodSchemaFile(rootPath, stages, label) {
-    const schema = buildMethodSchema(stages, label);
-    writeMethodSchemaDocument(rootPath, schema);
-    return schema;
-}
-export function writeMethodSchemaDocument(rootPath, schema) {
-    const normalized = normalizeMethodSchema(schema);
-    writeFileSync(methodSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
-    return normalized;
-}
-export function readMethodSchemaFile(rootPath) {
-    const path = methodSchemaFilePath(rootPath);
-    if (!existsSync(path))
-        return null;
-    const raw = readJsonFileUnchecked(path, "Method schema");
-    if (raw === null)
-        return null;
-    const parsed = MethodCompiledSchemaSchema.safeParse(raw);
-    if (!parsed.success) {
-        warnInterf(`Warning: failed to validate Method schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    return normalizeMethodSchema(parsed.data);
-}
-export function readCompiledSchemaFile(rootPath) {
-    return readMethodSchemaFile(rootPath);
-}

package/dist/packages/engine/compile/compiled-stage-plan.d.ts

@@ -1,16 +0,0 @@
-import { type RuntimeStageContractDraft } from "./runtime.js";
-import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
-import { resolveCompiledContext, type CompiledStageExecutionDefinition } from "./compiled-target.js";
-import type { RuntimeStageInstructions } from "./lib/schema.js";
-export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<MethodStageDefinition, "id" | "reads" | "writes">): {
-    reads: string[];
-    writes: string[];
-    writeContracts: RuntimeStageContractDraft["artifacts"]["write_contracts"];
-};
-export declare function buildStageCounts(compiledPath: string, stageDefinition: MethodStageDefinition): Record<string, number>;
-export declare function buildStageContract(compiledPath: string, stageDefinition: MethodStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;
-export declare function buildCompiledStageExecutionPlan(compiledPath: string, stageDefinition: CompiledStageExecutionDefinition): {
-    context: ReturnType<typeof resolveCompiledContext>;
-    contract: RuntimeStageContractDraft;
-    instructions: RuntimeStageInstructions;
-};

package/dist/packages/engine/compile/compiled-stage-plan.js

@@ -1,100 +0,0 @@
-import { join } from "node:path";
-import { buildRuntimeStageContract, } from "./runtime.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { compiledContractArtifactPath, compiledContractArtifactPathsForArtifactIds, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../../methods/package/method-helpers.js";
-import { getActiveCompiledStagePolicyNotes, } from "../../methods/package/method-definitions.js";
-import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { readInterfConfig } from "../../project/interf-detect.js";
-import { resolveCompiledContext, } from "./compiled-target.js";
-function artifactCount(compiledPath, artifactPath, kind) {
-    const absolutePath = join(compiledPath, artifactPath);
-    try {
-        if (kind === "file") {
-            return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
-        }
-    }
-    catch {
-        if (kind === "file")
-            return 0;
-    }
-    return listFilesRecursive(absolutePath).length;
-}
-export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    if (!schema) {
-        throw new Error(`Missing Method schema for stage "${stageDefinition.id}" at ${methodPackagePathForCompiled(compiledPath)}.`);
-    }
-    return {
-        reads: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.reads),
-        writes: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.writes),
-        writeContracts: stageDefinition.writes.map((artifactId) => {
-            const artifact = schema.artifacts.find((candidate) => candidate.id === artifactId);
-            if (!artifact) {
-                throw new Error(`Compiled schema is missing declared Artifact "${artifactId}".`);
-            }
-            const path = artifact.shape.kind === "path"
-                ? compiledContractArtifactPath({
-                    path: artifact.shape.path,
-                    kind: artifact.shape.artifact_kind,
-                })
-                : artifact.id;
-            return {
-                artifact_id: artifact.id,
-                path,
-                checks: artifact.checks ?? [],
-            };
-        }),
-    };
-}
-export function buildStageCounts(compiledPath, stageDefinition) {
-    const context = resolveCompiledContext(compiledPath);
-    const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const artifactCounts = {};
-    if (schema) {
-        for (const artifactId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
-            const artifact = findCompiledSchemaArtifact(schema, artifactId);
-            if (!artifact)
-                continue;
-            artifactCounts[artifactId] = artifactCount(compiledPath, artifact.path, artifact.kind);
-        }
-    }
-    return {
-        source_total: sourceTotal,
-        read_artifact_total: stageDefinition.reads.length,
-        write_artifact_total: stageDefinition.writes.length,
-        ...artifactCounts,
-    };
-}
-export function buildStageContract(compiledPath, stageDefinition, instructions) {
-    const config = readInterfConfig(compiledPath);
-    const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
-    return buildRuntimeStageContract({
-        compiledName: config?.name ?? "compiled",
-        stageId: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        counts: buildStageCounts(compiledPath, stageDefinition),
-        extraReadArtifacts: [
-            ".interf/runtime/source-snapshot.json",
-            `.interf/runtime/stages/${stageDefinition.id}/inputs.json`,
-        ],
-        stageReadArtifacts: stageArtifacts.reads,
-        stageWriteArtifacts: stageArtifacts.writes,
-        stageWriteContracts: stageArtifacts.writeContracts,
-        methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
-        localSkillDocs: instructions.local_docs,
-        instructions,
-    });
-}
-export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {
-    const context = resolveCompiledContext(compiledPath);
-    const localSkills = buildLocalSkillContractExtension(compiledPath, [methodCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this Method stage while still honoring the declared reads, writes, and proof rules.");
-    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
-    return {
-        context,
-        instructions,
-        contract: buildStageContract(compiledPath, stageDefinition, instructions),
-    };
-}

package/dist/packages/engine/compile/compiled-stage-runner.d.ts

@@ -1,15 +0,0 @@
-import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type MethodReporter, type MethodStageResult } from "../../methods/package/method-helpers.js";
-import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
-import { type RunEventSink } from "../execution/events.js";
-export declare function runCompiledStage(options: {
-    executor: MethodExecutor;
-    compiledPath: string;
-    reporter?: MethodReporter;
-    reportStep?: boolean;
-    stageDefinition: CompiledStageExecutionDefinition;
-    runId?: string;
-    events?: RunEventSink;
-    stageIndex?: number;
-    stageTotal?: number;
-}): Promise<MethodStageResult>;

package/dist/packages/engine/compile/compiled-target.d.ts

@@ -1,11 +0,0 @@
-import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
-import { type CompiledMethodId } from "../../methods/package/method-definitions.js";
-export interface CompiledStageExecutionDefinition extends MethodStageDefinition {
-}
-export declare function resolveCompiledContext(compiledPath: string): {
-    compiledName: string;
-    sourcePath: string;
-    prepDataDir: string;
-    methodId: CompiledMethodId;
-};
-export declare function compiledExecutionStages(_methodId: CompiledMethodId, compiledPath: string): CompiledStageExecutionDefinition[];

package/dist/packages/engine/compile/compiled-target.js

@@ -1,16 +0,0 @@
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
-import { readInterfConfig, resolveSourceFolderPath, resolveSourceControlPath, } from "../../project/interf-detect.js";
-export function resolveCompiledContext(compiledPath) {
-    const config = readInterfConfig(compiledPath);
-    const methodId = resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${compiledPath}`);
-    return {
-        compiledName: config?.name ?? "compiled",
-        sourcePath: resolveSourceFolderPath(compiledPath, config),
-        prepDataDir: resolveSourceControlPath(compiledPath),
-        methodId,
-    };
-}
-export function compiledExecutionStages(_methodId, compiledPath) {
-    return getActiveCompiledMethod(compiledPath)
-        .stages;
-}

package/dist/packages/engine/compile/method-primitives.d.ts

@@ -1,2 +0,0 @@
-export declare const COMPILED_ARTIFACT_KINDS: readonly ["directory", "file", "runtime"];
-export type CompiledArtifactKind = typeof COMPILED_ARTIFACT_KINDS[number];

package/dist/packages/engine/compile/method-runs.d.ts

@@ -1,14 +0,0 @@
-import { type InterfConfig } from "../../project/interf-detect.js";
-export type { MethodReporter } from "../../methods/package/method-helpers.js";
-export type CompiledCheck = "compiled" | "stage";
-export interface DetectedInterfTarget {
-    path: string;
-    kind: "compiled";
-    engineType: "compiled";
-    config: InterfConfig;
-}
-export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
-export declare function createCompiled(name: string, sourcePath: string, methodId: string | undefined, about: string | undefined, sourceFolderPath: string): string;
-export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledMethodValidation;
-export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
-export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, ResolveStageExecutor, } from "./compiled-compile.js";

package/dist/packages/engine/compile/method-runs.js

@@ -1,31 +0,0 @@
-import { createCompiled as createCompiledScaffold, } from "../../project/interf-scaffold.js";
-import { detectInterf } from "../../project/interf-detect.js";
-import { validateCompiledCompile, } from "./validate.js";
-import { DEFAULT_METHOD_ID } from "../../methods/method-resolution.js";
-export function detectCompiled(cwd) {
-    const detected = detectInterf(cwd);
-    if (!detected)
-        return null;
-    return {
-        path: detected.path,
-        kind: "compiled",
-        engineType: "compiled",
-        config: detected.config,
-    };
-}
-export function createCompiled(name, sourcePath, methodId, about, sourceFolderPath) {
-    return createCompiledScaffold(name, sourcePath, methodId ?? DEFAULT_METHOD_ID, about, sourceFolderPath);
-}
-export function verifyCompiledCheck(check, compiledPath) {
-    switch (check) {
-        case "compiled":
-            return validateCompiledCompile(compiledPath);
-        case "stage":
-            return validateCompiledCompile(compiledPath);
-        default: {
-            const exhaustiveCheck = check;
-            throw new Error(`Unknown compiled check: ${exhaustiveCheck}`);
-        }
-    }
-}
-export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";

package/dist/packages/engine/compile/reset.d.ts

@@ -1,2 +0,0 @@
-export declare function clearCompiledRuntimeDerivedArtifacts(compiledPath: string): void;
-export declare function resetCompiledGeneratedState(compiledPath: string, scope?: "compile" | "all"): void;

package/dist/packages/engine/compile/reset.js

@@ -1,74 +0,0 @@
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
-import { initializeCompiledRuntimeState } from "./state.js";
-import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, methodPackagePathForCompiled, } from "./compiled-paths.js";
-function removeIfExists(path) {
-    if (existsSync(path)) {
-        rmSync(path, { recursive: true, force: true });
-    }
-}
-const COMPILE_RUNTIME_RESET_ENTRIES = [
-    "state.json",
-    "health.json",
-    "view-spec.json",
-    "inventory.json",
-    "run.json",
-    "source-files.json",
-    "source-snapshot.json",
-    "stage-contract.json",
-    "stages",
-];
-const PRESERVED_COMPILED_ROOTS = new Set([
-    ".agents",
-    ".claude",
-    ".codex",
-    ".cursor",
-    ".gitignore",
-    ".interf",
-    ".interfignore",
-    "AGENTS.md",
-    "CLAUDE.md",
-]);
-export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
-    const runtimeRoot = compiledRuntimeRoot(compiledPath);
-    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
-        removeIfExists(join(runtimeRoot, entry));
-    }
-    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
-}
-function activeCompiledInputRoots(compiledPath) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const roots = new Set();
-    for (const artifact of schema ? listCompiledSchemaArtifacts(schema) : []) {
-        if (artifact.role !== "input")
-            continue;
-        const root = artifact.path.split("/")[0]?.trim();
-        if (root)
-            roots.add(root);
-    }
-    return roots;
-}
-function resetCompiledGeneratedOutputs(compiledPath) {
-    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
-    for (const entry of readdirSync(compiledPath)) {
-        if (PRESERVED_COMPILED_ROOTS.has(entry))
-            continue;
-        if (preservedInputRoots.has(entry))
-            continue;
-        removeIfExists(join(compiledPath, entry));
-    }
-}
-export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
-    resetCompiledGeneratedOutputs(compiledPath);
-    clearCompiledRuntimeDerivedArtifacts(compiledPath);
-    initializeCompiledRuntimeState(compiledPath);
-    if (scope === "all") {
-        removeIfExists(stageExecutionShellsRoot(compiledPath));
-        removeIfExists(methodImprovementLoopsRoot(compiledPath));
-        removeIfExists(compiledRuntimeLogsRoot(compiledPath));
-        removeIfExists(join(compiledRuntimeRoot(compiledPath), "run-history.jsonl"));
-        removeIfExists(testRootForCompiled(compiledPath));
-        removeIfExists(testTargetsRootForCompiled(compiledPath));
-    }
-}

package/dist/packages/engine/compile/runtime-inventory.d.ts

@@ -1,7 +0,0 @@
-import { type CompiledInventory, type CompiledInventoryEntry } from "./lib/schema.js";
-export declare function emptyCompiledInventory(): CompiledInventory;
-export declare function compiledInventoryFromEntries(entries: CompiledInventoryEntry[], stage?: string): CompiledInventory;
-export declare function compiledInventoryEntryCount(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryTotal(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryFrontmatterScannedCount(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryAbstractCoverageCount(inventory: CompiledInventory | null): number;

package/dist/packages/engine/compile/runtime-reconcile.d.ts

@@ -1,2 +0,0 @@
-import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
-export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<MethodStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;

package/dist/packages/engine/compile/source-files.d.ts

@@ -1,46 +0,0 @@
-import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
-export declare function buildCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function writeCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function buildCompiledSourceSnapshot(options: {
-    compiledPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function writeCompiledSourceSnapshot(options: {
-    compiledPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function buildCompiledStageInputs(options: {
-    methodId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeCompiledStageInputs(options: {
-    compiledPath: string;
-    methodId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeCompiledSourceRuntime(options: {
-    compiledPath: string;
-    methodId: string;
-    stageIds: string[];
-    sourcePath?: string;
-    runId?: string | null;
-}): {
-    sourceFiles: SourceFiles;
-    snapshot: SourceSnapshot;
-    stageInputs: StageInputs[];
-};
-export declare function loadCompiledSourceFiles(compiledPath: string): SourceFiles | null;
-export declare function loadCompiledSourceSnapshot(compiledPath: string): SourceSnapshot | null;
-export declare function loadCompiledStageInputs(compiledPath: string, stageId: string): StageInputs | null;

package/dist/packages/engine/compile/state-artifacts.d.ts

@@ -1,9 +0,0 @@
-import { type CompiledHealth, type CompiledViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function refreshCompiledArtifacts(dirPath: string, options?: {
-    ensureViewSpec?: boolean;
-}): {
-    health: CompiledHealth;
-    viewSpec?: CompiledViewSpec;
-    sourceFiles: SourceFiles;
-    sourceSnapshot: SourceSnapshot;
-};

package/dist/packages/engine/compile/state-artifacts.js

@@ -1,14 +0,0 @@
-import { saveCompiledHealth, } from "./state-io.js";
-import { computeCompiledHealth, } from "./state-health.js";
-import { ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, ensureCompiledViewSpec, } from "./state-view.js";
-export function refreshCompiledArtifacts(dirPath, options) {
-    const health = computeCompiledHealth(dirPath);
-    saveCompiledHealth(dirPath, health);
-    const sourceFiles = ensureCompiledSourceFiles(dirPath);
-    const sourceSnapshot = ensureCompiledSourceSnapshot(dirPath, sourceFiles);
-    let viewSpec;
-    if (options?.ensureViewSpec) {
-        viewSpec = ensureCompiledViewSpec(dirPath);
-    }
-    return { health, viewSpec, sourceFiles, sourceSnapshot };
-}

package/dist/packages/engine/compile/state-health.d.ts

@@ -1,4 +0,0 @@
-import { type CompiledHealth, type CompiledStage, type RuntimeStatus } from "./lib/schema.js";
-export declare function computeCompiledHealth(dirPath: string): CompiledHealth;
-export declare function resolveCompiledStatus(..._args: unknown[]): RuntimeStatus;
-export declare function resolveCompiledStage(...args: unknown[]): CompiledStage;

package/dist/packages/engine/compile/state-io.d.ts

@@ -1,11 +0,0 @@
-import { type CompiledHealth, type CompiledState, type CompiledViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function loadState<T>(dirPath: string): T | null;
-export declare function saveState<T>(dirPath: string, state: T): void;
-export declare function loadCompiledHealth(dirPath: string): CompiledHealth | null;
-export declare function saveCompiledHealth(dirPath: string, health: CompiledHealth): void;
-export declare function loadCompiledViewSpec(dirPath: string): CompiledViewSpec | null;
-export declare function saveCompiledViewSpec(dirPath: string, viewSpec: CompiledViewSpec): void;
-export declare function loadCompiledSourceFiles(dirPath: string): SourceFiles | null;
-export declare function loadCompiledSourceSnapshot(dirPath: string): SourceSnapshot | null;
-export declare function saveEmptyCompiledInventory(dirPath: string): void;
-export declare function initCompiledState(): CompiledState;

package/dist/packages/engine/compile/state-paths.js

@@ -1,16 +0,0 @@
-import { compiledRuntimeHealthPath, compiledRuntimeSourceFilesPath, compiledRuntimeSourceSnapshotPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "./compiled-paths.js";
-export function statePath(dirPath) {
-    return compiledRuntimeStatePath(dirPath);
-}
-export function healthPath(dirPath) {
-    return compiledRuntimeHealthPath(dirPath);
-}
-export function viewSpecPath(dirPath) {
-    return compiledRuntimeViewSpecPath(dirPath);
-}
-export function sourceFilesPath(dirPath) {
-    return compiledRuntimeSourceFilesPath(dirPath);
-}
-export function sourceSnapshotPath(dirPath) {
-    return compiledRuntimeSourceSnapshotPath(dirPath);
-}

package/dist/packages/engine/compile/state-view.d.ts

@@ -1,5 +0,0 @@
-import { type CompiledViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function ensureCompiledViewSpec(dirPath: string): CompiledViewSpec;
-export declare function ensureCompiledSourceFiles(dirPath: string): SourceFiles;
-export declare function ensureCompiledSourceSnapshot(dirPath: string, sourceFiles?: SourceFiles): SourceSnapshot;
-export declare function normalizeCompiledViewSpec(existing: CompiledViewSpec, defaults?: CompiledViewSpec): CompiledViewSpec;

package/dist/packages/engine/compile/state.d.ts

@@ -1,7 +0,0 @@
-export type { RuntimeStatus, CompiledStage, CompiledState, CompiledHealth, ViewSection, ViewCard, CompiledViewSpec, SourceFiles, SourceSnapshot, StageInputs, } from "./lib/schema.js";
-export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledSourceFiles, loadCompiledSourceSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
-export { refreshCompiledArtifacts, } from "./state-artifacts.js";
-export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
-export { ensureCompiledViewSpec, ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
-export declare function initializeCompiledRuntimeState(dirPath: string): void;

package/dist/packages/engine/compile/state.js

@@ -1,12 +0,0 @@
-export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledSourceFiles, loadCompiledSourceSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
-export { refreshCompiledArtifacts, } from "./state-artifacts.js";
-export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
-export { ensureCompiledViewSpec, ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
-import { saveEmptyCompiledInventory, initCompiledState, saveState } from "./state-io.js";
-import { refreshCompiledArtifacts } from "./state-artifacts.js";
-export function initializeCompiledRuntimeState(dirPath) {
-    saveState(dirPath, initCompiledState());
-    saveEmptyCompiledInventory(dirPath);
-    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
-}

package/dist/packages/engine/compile/validate-compiled.d.ts

@@ -1,27 +0,0 @@
-export interface CompiledValidationSummary {
-    config_present: boolean;
-    config_valid: boolean;
-    config_type_match: boolean;
-    method_present: boolean;
-    method_valid: boolean;
-    schema_present: boolean;
-    schema_valid: boolean;
-}
-export interface CompiledStageValidation {
-    ok: boolean;
-    required: boolean;
-    stage: string;
-    summary: string;
-    counts: Record<string, number>;
-    checks: Record<string, boolean>;
-    errors: string[];
-}
-export interface CompiledMethodValidation extends CompiledStageValidation {
-    stage_results: Record<string, boolean>;
-}
-export declare function validateCompiled(dirPath: string): CompiledValidationSummary;
-export declare function validateCompiledStage(dirPath: string, stageId: string): CompiledStageValidation;
-export declare function validateCompiledMethod(dirPath: string): CompiledMethodValidation;
-export declare function validateCompiledSummarize(dirPath: string): CompiledStageValidation;
-export declare function validateCompiledStructure(dirPath: string): CompiledStageValidation;
-export declare function validateCompiledCompile(dirPath: string): CompiledMethodValidation;

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

@@ -1,4 +0,0 @@
-export * as authoring from "./method-authoring.js";
-export * as editSession from "./method-edit-session.js";
-export * as editUtils from "./lib/method-edit-utils.js";
-export * as improvement from "./method-improvement.js";

package/dist/packages/methods/authoring/index.js

@@ -1,4 +0,0 @@
-export * as authoring from "./method-authoring.js";
-export * as editSession from "./method-edit-session.js";
-export * as editUtils from "./lib/method-edit-utils.js";
-export * as improvement from "./method-improvement.js";

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

@@ -1,36 +0,0 @@
-import { type MethodAuthoringArtifactRequirement } from "../../engine/agents/lib/shells.js";
-import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
-import { validateMethodPackage } from "../package/local-methods.js";
-import type { RequestedArtifact, SourceProfile, SourceReadinessCheck } from "../../project/lib/schema.js";
-/**
- * Walk method.json after a successful authoring run and fill in
- * `role: "general"` for any stage missing a role field. Custom role
- * names are kept as-is. Idempotent — does nothing when every stage
- * already declares a role. Returns the list of stage ids that were
- * touched so the runtime can surface that to the user.
- */
-export declare function ensureStageRoles(methodPath: string): string[];
-export interface MethodAuthoringRunResult {
-    status: "updated" | "no-change" | "invalid" | "executor-failed";
-    changed: boolean;
-    summary: string;
-    validation: ReturnType<typeof validateMethodPackage> | null;
-    methodPath: string;
-    shellPath: string;
-}
-export declare function runMethodAuthoringDraft(options: {
-    prepDataDir: string;
-    sourceFolderPath: string;
-    baseMethodId?: string;
-    methodId: string;
-    label: string;
-    hint: string;
-    taskPrompt: string;
-    checks?: SourceReadinessCheck[];
-    requestedArtifacts?: RequestedArtifact[];
-    sourceProfile?: SourceProfile | null;
-    artifactRequirements?: MethodAuthoringArtifactRequirement[];
-    executor: MethodExecutor;
-    onStatus?: (line: string) => void;
-}): Promise<MethodAuthoringRunResult>;
-export declare function resolveMethodDraftPath(sourcePath: string, methodId: string): string;