@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{method-package → methods/package}/method-review-paths.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../compiler/compiled-paths.js";
+import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../../engine/compile/compiled-paths.js";
 export function resolveMethodImprovementReviewSourcePaths(compiledPath) {
     const compiledRuntime = compiledRuntimeRoot(compiledPath);
     const readinessRuns = testRootForCompiled(compiledPath);

package/dist/packages/{method-package → methods/package}/method-stage-runner.d.ts

@@ -1,7 +1,7 @@
-import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type RuntimeStageInstructions } from "../compiler/lib/schema.js";
-import type { RuntimeContractType } from "../contracts/lib/schema.js";
-import { type RuntimeStageContractDraft } from "../compiler/runtime.js";
+import { type MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
+import type { RuntimeContractType } from "../../contracts/lib/schema.js";
+import { type RuntimeStageContractDraft } from "../../engine/compile/runtime.js";
 import { type MethodReporter, type MethodStageResult } from "./method-helpers.js";
 interface MethodStageShape<TContractType extends RuntimeContractType> {
     id: string;
@@ -31,13 +31,8 @@ interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType
         summary: string;
     };
 }
-interface ExecuteValidatedSummarizeStageOptions<TContractType extends RuntimeContractType> extends ExecuteValidatedStageOptions<TContractType> {
-    startingSummaryCount: number;
-    targetCount: number;
-}
 export declare function findStageByContractType<TStage extends {
     contractType: string;
 }>(stages: TStage[], contractType: TStage["contractType"]): TStage;
 export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<MethodStageResult>;
-export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<MethodStageResult>;
 export {};

package/dist/packages/{method-package → methods/package}/method-stage-runner.js

@@ -1,4 +1,4 @@
-import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, runExecutorSummarizeStage, } from "../compiler/runtime.js";
+import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, } from "../../engine/compile/runtime.js";
 import { reportValidationFailure, } from "./method-helpers.js";
 export function findStageByContractType(stages, contractType) {
     const stage = stages.find((candidate) => candidate.contractType === contractType);
@@ -33,34 +33,6 @@ export async function executeValidatedStage(options) {
     });
     return finalizeValidatedStage(options, code);
 }
-export async function executeValidatedSummarizeStage(options) {
-    const completionCheck = options.completionCheck
-        ? () => {
-            options.syncWrites?.();
-            options.reconcile?.();
-            return options.completionCheck?.() === true;
-        }
-        : undefined;
-    const code = await runExecutorSummarizeStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        executionPath: options.executionPath,
-        compiledName: options.targetName,
-        method: options.method,
-        methodSourcePath: options.methodSourcePath,
-        stage: options.stageDefinition.id,
-        stageLabel: options.stageDefinition.label,
-        contractType: options.stageDefinition.contractType,
-        summary: options.summary,
-        contract: options.contract,
-        buildPrompt: (contractPath) => buildStagePrompt(options.instructions, contractPath, options.statusLines),
-        completionCheck,
-        onStatus: options.onStatus,
-        startingSummaryCount: options.startingSummaryCount,
-        targetCount: options.targetCount,
-    });
-    return finalizeValidatedStage(options, code);
-}
 function finalizeValidatedStage(options, code) {
     const refreshAndValidate = () => {
         options.syncWrites?.();

package/dist/packages/{method-package → methods/package}/user-methods.js

@@ -1,7 +1,7 @@
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { userMethodPackagePath, userMethodsRoot, } from "../contracts/lib/preparation-paths.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { userMethodPackagePath, userMethodsRoot, } from "../../contracts/lib/preparation-paths.js";
 import { loadMethodDefinitionFromDir, } from "./local-methods.js";
 export function userMethodPath(id) {
     return userMethodPackagePath(id);

package/dist/packages/{project-model → project}/interf-bootstrap.d.ts

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";

package/dist/packages/{project-model → project}/interf-bootstrap.js

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";

package/dist/packages/{project-model → project}/interf-detect.js

@@ -1,11 +1,11 @@
 import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
+import { warnInterf } from "../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../contracts/utils/parse.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../engine/compile/compiled-paths.js";
 import { InterfConfigSchema, } from "./lib/schema.js";
-import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { assertPathWithinRoot } from "../contracts/utils/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
 export const METHOD_CONTAINER_NAME = "methods";
 export const TEST_CONTAINER_NAME = "tests";

package/dist/packages/{project-model → project}/interf-scaffold.js

@@ -1,15 +1,15 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
-import { getCompiledMethod } from "../method-package/method-definitions.js";
-import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../method-package/local-methods.js";
-import { initializeCompiledRuntimeState, } from "../compiler/state.js";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { getCompiledMethod } from "../methods/package/method-definitions.js";
+import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../methods/package/local-methods.js";
+import { initializeCompiledRuntimeState, } from "../engine/compile/state.js";
+import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
 import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
-import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
+import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../compiler/compiled-schema.js";
-import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { ensureCompiledArtifactTargets, listCompiledSchemaArtifacts, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
+import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../engine/compile/compiled-paths.js";
 import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
@@ -33,11 +33,11 @@ function renderUncompiledCompiledFile(compiledName, relativePath, about) {
 }
 function compiledGitignoreEntries(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zoneEntries = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
+    const artifactEntries = (schema ? listCompiledSchemaArtifacts(schema) : [])
+        .filter((artifact) => artifact.kind !== "runtime")
+        .map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`);
     return [
-        ...zoneEntries,
+        ...artifactEntries,
         ".claude/",
         ".codex/",
         ".agents/",
@@ -52,14 +52,14 @@ function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
     if (!schema) {
         throw new Error(`Missing Method schema at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
-    ensureCompiledZoneTargets(compiledPath, schema);
-    for (const zone of schema.zones) {
-        if (!zone.required || zone.kind !== "file" || zone.role !== "output")
+    ensureCompiledArtifactTargets(compiledPath, schema);
+    for (const artifact of listCompiledSchemaArtifacts(schema)) {
+        if (!artifact.required || artifact.kind !== "file" || artifact.role !== "output")
             continue;
-        const targetPath = join(compiledPath, zone.path);
+        const targetPath = join(compiledPath, artifact.path);
         if (existsSync(targetPath))
             continue;
-        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
+        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, artifact.path, about));
     }
 }
 function localMethodMatches(compiledPath, methodId) {
@@ -99,7 +99,7 @@ export function createCompiled(name, prepDataDir, methodId = DEFAULT_METHOD_ID,
     const compiledPath = ensurePortableContextScaffold(prepDataDir, name, selectedMethod.id);
     const resolvedAbout = about ?? savedCompiled?.about;
     const resolvedSourceFolderPath = savedCompiled
-        ? resolveSourcePreparationPath(prepDataDir, savedCompiled)
+        ? resolveConfiguredSourceFolderPath(prepDataDir) ?? resolveSourcePreparationPath(prepDataDir, savedCompiled)
         : sourceFolderPath;
     const sourceRelativePath = relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
     saveCompiledInterfConfig(compiledPath, {

package/dist/packages/{project-model → project}/lib/schema.d.ts

@@ -38,7 +38,7 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$loose>;
 export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
@@ -102,7 +102,7 @@ export declare const InterfConfigSchema: z.ZodObject<{
 export declare const SourceFolderConfigSchema: z.ZodObject<{
     source_folder: z.ZodOptional<z.ZodObject<{
         path: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$loose>>;
     preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;

package/dist/packages/{project-model → project}/lib/schema.js

@@ -65,7 +65,7 @@ export const SourcePreparationConfigSchema = z.object({
 }).strict();
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),
-}).strict();
+}).passthrough();
 export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
     name: PreparationNameSchema,

package/dist/packages/{project-model → project}/source-config.d.ts

@@ -1,5 +1,5 @@
 import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourcePreparationConfig, type SourceFolderConfig } from "./lib/schema.js";
-import type { TestSpec, TestTargetType } from "../testing/lib/schema.js";
+import type { TestSpec, TestTargetType } from "../engine/verify/lib/schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
 export declare const SOURCE_FOLDER_CONFIG_PATH = "interf.json";
 export interface LoadedSourceTestSpec extends TestSpec {

package/dist/packages/{project-model → project}/source-config.js

@@ -1,16 +1,16 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
-import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { getCompiledMethod } from "../method-package/method-definitions.js";
+import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
+import { readJsonFileWithSchema } from "../contracts/utils/parse.js";
+import { getCompiledMethod } from "../methods/package/method-definitions.js";
 import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.js";
-import { slugify } from "../shared/naming.js";
-import { assertPathWithinRoot, isPathWithinRoot } from "../shared/path-guards.js";
-import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
+import { slugify } from "../contracts/utils/naming.js";
+import { assertPathWithinRoot, isPathWithinRoot } from "../contracts/utils/path-guards.js";
+import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../engine/compile/compiled-paths.js";
 import { asPreparationDataDir, preparationConfigPath, PREPARATION_CONFIG_FILENAME, } from "../contracts/lib/preparation-paths.js";
 export const SOURCE_FOLDER_CONFIG_FILE = PREPARATION_CONFIG_FILENAME;
 export const SOURCE_FOLDER_CONFIG_PATH = SOURCE_FOLDER_CONFIG_FILE;
@@ -241,7 +241,8 @@ export function saveCompiledInterfConfig(compiledPath, config) {
 export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
     const current = readInterfConfig(compiledPath);
     const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
-    const preparationAbsolutePath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
+    const preparationAbsolutePath = resolveConfiguredSourceFolderPath(prepDataDir) ??
+        resolveSourcePreparationPath(prepDataDir, preparationConfig);
     const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
     const methodId = methodIdForSourcePreparationConfig(preparationConfig)
         ?? methodIdForSourcePreparationConfig(current)

package/dist/packages/{project-model → project}/source-folders.js

@@ -1,8 +1,8 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, sep } from "node:path";
-import { slugify } from "../shared/naming.js";
+import { slugify } from "../contracts/utils/naming.js";
 import { resolveSourcePreparationPath } from "./source-config.js";
-import { isPathWithinRoot } from "../shared/path-guards.js";
+import { isPathWithinRoot } from "../contracts/utils/path-guards.js";
 const DEFAULT_PREPARATION_NAME = "default";
 const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     ".DS_Store",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.13.0",
+  "version": "0.18.0",
   "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
@@ -14,18 +14,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./contracts": {
-      "types": "./dist/packages/contracts/index.d.ts",
-      "import": "./dist/packages/contracts/index.js"
-    },
-    "./execution": {
-      "types": "./dist/packages/execution/index.d.ts",
-      "import": "./dist/packages/execution/index.js"
-    },
-    "./local-service": {
-      "types": "./dist/packages/local-service/index.d.ts",
-      "import": "./dist/packages/local-service/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -54,6 +42,7 @@
     "dist",
     "builtin-methods",
     "agent-skills",
+    "LICENSE.md",
     "TRADEMARKS.md"
   ],
   "publishConfig": {
@@ -67,13 +56,14 @@
     "claude",
     "codex"
   ],
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "Interf Inc.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/interf-labs/interf.git"
+    "url": "git+https://github.com/interf-labs/compiler.git"
   },
   "bugs": {
-    "url": "https://github.com/interf-labs/interf/issues"
+    "url": "https://github.com/interf-labs/compiler/issues"
   },
   "homepage": "https://interf.com",
   "engines": {
@@ -81,6 +71,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "chalk": "^5.4.1",
     "yargs": "^17.7.2",
     "zod": "^4.3.6"

package/dist/cli/commands/test.d.ts

@@ -1,9 +0,0 @@
-import type { CommandModule } from "yargs";
-interface TestArgs {
-    prepId: string;
-    target?: "source-files" | "portable-context" | "both";
-    url?: string;
-    token?: string;
-}
-export declare const testCommand: CommandModule<unknown, TestArgs>;
-export {};