@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/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 "../engine/agents/lib/compiled-bootstrap.js";
+import { refreshVerifiableContextBootstrapGuidance } from "../engine/agents/lib/verifiable-context-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
-import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
+import { seedVerifiableContextBuildPlanPackage } from "../build-plans/package/interf-build-plan-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 { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.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 { defaultControlPathForVerifiableContext, resolveSourceControlPathForVerifiableContext, verifiableContextInterfConfigPath, verifiableContextInterfRoot, } from "../engine/build/verifiable-context-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;
@@ -61,18 +61,18 @@ export function loadSourceFolderConfig(prepDataDir) {
         return null;
     return readSourceFolderConfigFile(filePath);
 }
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
 function normalizeSourcePreparationConfig(preparationConfig) {
-    const method = methodIdForSourcePreparationConfig(preparationConfig);
+    const buildPlan = buildPlanIdForSourcePreparationConfig(preparationConfig);
     return {
         ...preparationConfig,
-        ...(method ? { method } : {}),
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
     };
 }
 export function listSourcePreparationConfigs(config) {
     return (config?.preparations ?? []).map((preparation) => normalizeSourcePreparationConfig(preparation));
 }
-export function resolvePreparationCompileMaxAttempts(preparationConfig, override = null) {
+export function resolvePreparationBuildMaxAttempts(preparationConfig, override = null) {
     const configured = override ?? preparationConfig.max_attempts ?? null;
     if (configured == null)
         return null;
@@ -81,7 +81,7 @@ export function resolvePreparationCompileMaxAttempts(preparationConfig, override
         return 1;
     return Math.min(5, normalized);
 }
-export function resolvePreparationCompileMaxLoops(preparationConfig, override = null) {
+export function resolvePreparationBuildMaxLoops(preparationConfig, override = null) {
     const configured = override ?? preparationConfig.max_loops ?? null;
     if (configured == null)
         return null;
@@ -119,15 +119,19 @@ function toWritableSourceProjectConfig(config) {
     };
 }
 function toWritableSourcePreparationConfig(preparation) {
-    const method = methodIdForSourcePreparationConfig(preparation);
+    const buildPlan = buildPlanIdForSourcePreparationConfig(preparation);
     return {
         name: preparation.name,
         path: preparation.path,
         ...(preparation.about ? { about: preparation.about } : {}),
-        ...(method ? { method } : {}),
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
+        ...(preparation.requested_artifacts?.length
+            ? { requested_artifacts: preparation.requested_artifacts }
+            : {}),
+        ...(preparation.source_profile ? { source_profile: preparation.source_profile } : {}),
     };
 }
 export function saveSourceFolderConfig(prepDataDir, config) {
@@ -185,22 +189,22 @@ export function removeSourcePreparationConfig(prepDataDir, preparationName) {
     });
     return true;
 }
-export function compiledMaxAttempts(maxAttempts) {
+export function buildMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
-    return resolvePreparationCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+    return resolvePreparationBuildMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
 }
-export function compiledMaxLoops(maxLoops) {
+export function buildMaxLoops(maxLoops) {
     if (maxLoops == null)
         return undefined;
-    return resolvePreparationCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+    return resolvePreparationBuildMaxLoops({ max_loops: maxLoops }, null) ?? 1;
 }
 export function sourcePreparationConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
     return {
         name: config.name,
         path: preparationPath,
         ...(config.about ? { about: config.about } : {}),
-        method: config.method,
+        build_plan: config.build_plan,
         ...(typeof config.max_attempts === "number"
             ? { max_attempts: config.max_attempts }
             : {}),
@@ -210,11 +214,11 @@ export function sourcePreparationConfigFromInterfConfig(config, preparationPath
         checks: config.checks ?? [],
     };
 }
-export function loadCompiledPreparationConfig(compiledPath) {
-    const config = readInterfConfig(compiledPath);
+export function loadVerifiableContextPreparationConfig(verifiableContextPath) {
+    const config = readInterfConfig(verifiableContextPath);
     if (!config)
         return null;
-    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
     const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
     const defaultPreparationPath = configuredPreparations.length === 1
         ? configuredPreparations[0].path
@@ -224,7 +228,7 @@ export function loadCompiledPreparationConfig(compiledPath) {
         : null;
     const preparationPath = sourceBinding
         ? (() => {
-            const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
+            const sourceAbsolutePath = resolve(verifiableContextPath, sourceBinding);
             if (!isPathWithinRoot(prepDataDir, sourceAbsolutePath)) {
                 return sourceAbsolutePath;
             }
@@ -233,40 +237,40 @@ export function loadCompiledPreparationConfig(compiledPath) {
         : defaultPreparationPath;
     return sourcePreparationConfigFromInterfConfig(config, preparationPath);
 }
-export function saveCompiledInterfConfig(compiledPath, config) {
-    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
-    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
+export function saveVerifiableContextInterfConfig(verifiableContextPath, config) {
+    mkdirSync(verifiableContextInterfRoot(verifiableContextPath), { recursive: true });
+    writeFileSync(verifiableContextInterfConfigPath(verifiableContextPath), JSON.stringify(config, null, 2) + "\n");
     return config;
 }
-export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
-    const current = readInterfConfig(compiledPath);
-    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+export function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig) {
+    const current = readInterfConfig(verifiableContextPath);
+    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
     const preparationAbsolutePath = resolveConfiguredSourceFolderPath(prepDataDir) ??
         resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig)
-        ?? methodIdForSourcePreparationConfig(current)
-        ?? DEFAULT_METHOD_ID;
-    const methodChanged = current?.method !== undefined && current.method !== methodId;
-    const methodOrigin = methodChanged || !current?.method_origin
+    const preparationRelativePath = relative(verifiableContextPath, preparationAbsolutePath).split(sep).join("/") || ".";
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig)
+        ?? buildPlanIdForSourcePreparationConfig(current)
+        ?? DEFAULT_BUILD_PLAN_ID;
+    const buildPlanChanged = current?.build_plan !== undefined && current.build_plan !== buildPlanId;
+    const buildPlanOrigin = buildPlanChanged || !current?.build_plan_origin
         ? {
-            selected: methodId,
+            selected: buildPlanId,
             local_draft: false,
         }
-        : current.method_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, method: _ignoredMethod, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, method_origin: _ignoredMethodOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+        : current.build_plan_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, build_plan: _ignoredBuildPlan, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, build_plan_origin: _ignoredBuildPlanOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
     const nextConfig = {
         ...passthrough,
         ...(!current ? {
-            type: "compiled",
+            type: "verifiable-context",
             source: {
                 path: preparationRelativePath,
             },
         } : {}),
-        type: "compiled",
+        type: "verifiable-context",
         name: preparationConfig.name,
         ...(preparationConfig.about ? { about: preparationConfig.about } : {}),
-        method: methodId,
+        build_plan: buildPlanId,
         ...(typeof preparationConfig.max_attempts === "number"
             ? { max_attempts: preparationConfig.max_attempts }
             : {}),
@@ -274,23 +278,23 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
             ? { max_loops: preparationConfig.max_loops }
             : {}),
         checks: preparationConfig.checks,
-        method_origin: methodOrigin,
+        build_plan_origin: buildPlanOrigin,
         source: {
             path: preparationRelativePath,
-            control_path: defaultControlPathForCompiled(compiledPath),
+            control_path: defaultControlPathForVerifiableContext(verifiableContextPath),
             preparation_path: preparationRelativePath,
         },
     };
-    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
-    if (methodChanged) {
-        const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
-        seedCompiledMethodPackage({
-            compiledPath,
+    const saved = saveVerifiableContextInterfConfig(verifiableContextPath, nextConfig);
+    if (buildPlanChanged) {
+        const selectedBuildPlan = getBuildPlan(buildPlanId, { prepDataDir });
+        seedVerifiableContextBuildPlanPackage({
+            verifiableContextPath,
             prepDataDir,
-            methodId: selectedMethod.id,
+            buildPlanId: selectedBuildPlan.id,
         });
     }
-    refreshCompiledBootstrapGuidance(compiledPath);
+    refreshVerifiableContextBootstrapGuidance(verifiableContextPath);
     return saved;
 }
 function buildLoadedTestSpec(options) {
@@ -298,7 +302,7 @@ function buildLoadedTestSpec(options) {
         return null;
     const testId = options.id ?? slugify(options.name);
     return {
-        id: options.targetType === "source-files" ? `${testId}-source-files` : testId,
+        id: options.targetType === "source-files" ? `${testId}-source-files` : `${testId}-verifiable-context`,
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
@@ -307,7 +311,7 @@ function buildLoadedTestSpec(options) {
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
-    const { prepDataDir, targetName, targetType = "compiled" } = options;
+    const { prepDataDir, targetName, targetType = "verifiable-context" } = options;
     const config = loadSourceFolderConfig(prepDataDir);
     if (!config)
         return null;
@@ -330,14 +334,14 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         targetType,
         filePath: targetType === "source-files"
             ? `${configPath}#preparations/${match.name}:source-files`
-            : `${configPath}#preparations/${match.name}:portable-context`,
+            : `${configPath}#preparations/${match.name}:verifiable-context`,
         defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
     });
 }
-export function buildTestSpecFromCompiledPreparationConfig(options) {
-    const { compiledPath, targetType = "compiled" } = options;
-    const config = readInterfConfig(compiledPath);
-    const configPath = compiledInterfConfigPath(compiledPath);
+export function buildTestSpecFromPreparationConfig(options) {
+    const { verifiableContextPath, targetType = "verifiable-context" } = options;
+    const config = readInterfConfig(verifiableContextPath);
+    const configPath = verifiableContextInterfConfigPath(verifiableContextPath);
     if (!config)
         return null;
     return buildLoadedTestSpec({
@@ -347,8 +351,8 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
         targetType,
         filePath: targetType === "source-files"
             ? `${configPath}#checks:source-files`
-            : `${configPath}#checks:compiled`,
-        defaultDescription: "Derived from checks in the portable context config.",
+            : `${configPath}#checks:verifiable-context`,
+        defaultDescription: "Derived from checks in the verifiable-context config.",
     });
 }
 /**
@@ -356,7 +360,7 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
  * absolute `preparation.path` was authored by hand. The schema-level
  * refinement in `SourcePreparationConfigSchema` is the primary line of
  * defense; this is the in-process backstop for callers that hand-craft a
- * SourcePreparationConfig at runtime (e.g. method authoring helpers that
+ * SourcePreparationConfig at runtime (e.g. Build Plan authoring helpers that
  * construct a config from an InterfConfig).
  */
 const FORBIDDEN_PREPARATION_PATH_PREFIXES = [

package/dist/packages/project/source-folders.js

@@ -47,7 +47,7 @@ export function normalizeSourcePreparationPathForConfig(prepDataDir, value) {
     const resolvedPath = resolveSourcePreparationPath(prepDataDir, { path: trimmedValue });
     const relativePath = relative(prepDataDir, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
-        throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
+        throw new Error("Pick a Source Folder, not the Interf preparation data folder itself.");
     }
     if (isAbsolute(trimmedValue) && !isPathWithinRoot(prepDataDir, resolvedPath)) {
         if (!existsSync(resolvedPath)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "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.",
+  "version": "0.22.0",
+  "description": "Interf builds verifiable context for agents from your files.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -19,11 +19,11 @@
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('.tsbuildinfo',{force:true})\" && tsc && chmod 755 dist/bin.js",
     "dev": "tsc --watch",
-    "web:dev": "npm --prefix apps/compiler-ui run dev",
-    "web:typecheck": "npm --prefix apps/compiler-ui run typecheck",
-    "web:build": "node scripts/web/build-compiler-ui.mjs",
-    "docs:sync-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs",
-    "docs:check-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs --check",
+    "web:dev": "npm --prefix src/apps/interf-ui run dev",
+    "web:typecheck": "npm --prefix src/apps/interf-ui run typecheck",
+    "web:build": "node scripts/web/build-interf-ui.mjs",
+    "docs:sync-public": "node scripts/docs/sync-public-repo.mjs",
+    "docs:check-public": "node scripts/docs/sync-public-repo.mjs --check",
     "test:smoke": "npm run build && node --test test/**/*.test.mjs",
     "test": "npm run test:smoke",
     "test:full": "npm test && npm run web:build",
@@ -33,17 +33,14 @@
     "test:acceptance": "npm run build && node scripts/acceptance/release.mjs",
     "test:release": "npm run web:typecheck && npm test && node scripts/acceptance/release.mjs && npm run web:build",
     "test:acceptance-live": "npm run build && node scripts/acceptance/live.mjs",
-    "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance/targeted.mjs create-compiled",
-    "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance/targeted.mjs compiled-query",
-    "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance/targeted.mjs self-improving-compile",
+    "test:acceptance-quick:create-build": "npm run build && node scripts/acceptance/targeted.mjs create-build",
+    "test:acceptance-quick:context-query": "npm run build && node scripts/acceptance/targeted.mjs context-query",
+    "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance/targeted.mjs self-improving-build",
     "prepublishOnly": "node scripts/release/prepublish-gate.mjs"
   },
   "files": [
     "dist",
-    "builtin-methods",
-    "agent-skills",
-    "LICENSE.md",
-    "TRADEMARKS.md"
+    "public-repo"
   ],
   "publishConfig": {
     "access": "public"
@@ -56,14 +53,14 @@
     "claude",
     "codex"
   ],
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "SEE LICENSE IN public-repo/LICENSE.md",
   "author": "Interf Inc.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/interf-labs/compiler.git"
+    "url": "git+https://github.com/interf-labs/interf.git"
   },
   "bugs": {
-    "url": "https://github.com/interf-labs/compiler/issues"
+    "url": "https://github.com/interf-labs/interf/issues"
   },
   "homepage": "https://interf.com",
   "engines": {

package/public-repo/CONTRIBUTING.md

@@ -0,0 +1,47 @@
+# Contributing
+
+This public surface contains the files users and agent hosts need to inspect:
+the README, license and security docs, bundled Skills, plugin manifests, and
+public Build Plans.
+
+The Interf engine source is private. Do not add private source paths,
+maintainer docs, or internal repo instructions here.
+
+## What To Change Here
+
+- Public product docs: the public README, `SECURITY.md`, and `TRADEMARKS.md`.
+- Agent Skills: `skills/interf/`.
+- Host plugin bundles: `plugins/`.
+- Public Build Plans: `build-plans/`.
+
+## Public Build Plans
+
+Build Plans are inspectable folders. Keep them standalone:
+
+- `build-plan.json` is the current technical filename for the Build Plan stages and Artifact outputs.
+- `build-plan.schema.json` is the current technical filename for the output contract.
+- `build/stages/<stage>/SKILL.md` contains stage instructions.
+- `use/query/SKILL.md` tells agents how to read the verifiable context.
+- `improve/SKILL.md` tells Interf how to revise the plan when checks fail.
+
+For the shipped default Build Plan, edit `build-plans/interf-default/`.
+
+## Agent Skills And Plugins
+
+Keep `skills/interf/SKILL.md` as the canonical Skill.
+
+Plugin bundles should stay thin:
+
+- host manifest
+- copied Interf Skill when the host requires a local copy
+- MCP configuration that launches `interf mcp`
+
+The MCP server implementation ships inside `interf`.
+
+## Before Opening A PR
+
+Check that public docs do not reference private paths such as internal source
+trees, maintainer-only docs, or local machine paths.
+
+If you changed a Build Plan, test it with an installed `interf`
+runtime before submitting the change.