@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/verify/verify-specs.js

@@ -0,0 +1,126 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { TestSpecSchema } from "./lib/schema.js";
+import { TEST_SPEC_EXTENSIONS, assertTestId, assertSafeRelativeTestFile, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./verify-paths.js";
+function readTestSpecFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    if (!TEST_SPEC_EXTENSIONS.has(extension))
+        return null;
+    const parsed = readJsonFileWithSchema(filePath, "test spec", TestSpecSchema);
+    if (!parsed)
+        return null;
+    return {
+        ...parsed,
+        id: basename(filePath, extension),
+        filePath,
+    };
+}
+function serializeTestSpec(spec) {
+    return {
+        type: spec.type,
+        name: spec.name,
+        ...(spec.description ? { description: spec.description } : {}),
+        cases: spec.cases.map((testCase) => ({
+            id: testCase.id,
+            question: testCase.question,
+            ...(testCase.file ? { file: testCase.file } : {}),
+            ...(testCase.answer ? { answer: testCase.answer } : {}),
+            ...(testCase.strictness ? { strictness: testCase.strictness } : {}),
+            ...(testCase.expect ? { expect: testCase.expect } : {}),
+        })),
+    };
+}
+export function listTestSpecs(sourcePath, type) {
+    const dirPath = testSpecTypePath(sourcePath, type);
+    if (!existsSync(dirPath))
+        return [];
+    return readdirSync(dirPath)
+        .map((entry) => join(dirPath, entry))
+        .filter((filePath) => TEST_SPEC_EXTENSIONS.has(extname(filePath).toLowerCase()))
+        .map((filePath) => readTestSpecFile(filePath))
+        .filter((value) => value !== null)
+        .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+export function loadTestSpec(sourcePath, type, id) {
+    const normalizedId = normalizeTestId(id);
+    const filePath = join(testSpecTypePath(sourcePath, type), `${normalizedId}.json`);
+    if (!existsSync(filePath))
+        return null;
+    return readTestSpecFile(filePath);
+}
+export function loadTestSpecFromFile(filePath) {
+    return readTestSpecFile(filePath);
+}
+export function writeTestSpec(sourcePath, spec, options = {}) {
+    const id = normalizeTestId(spec.id ?? spec.name);
+    assertTestId(id);
+    const dirPath = testSpecTypePath(sourcePath, spec.type);
+    mkdirSync(dirPath, { recursive: true });
+    const existingPath = join(dirPath, `${id}.json`);
+    if (existsSync(existingPath) && !options.overwrite) {
+        throw new Error(`Test spec already exists: ${existingPath}`);
+    }
+    const filePath = testSpecFilePath(sourcePath, spec.type, id);
+    if (!options.overwrite) {
+        assertWritableTestSpecPath(filePath);
+    }
+    const normalizedSpec = {
+        type: spec.type,
+        name: spec.name.trim(),
+        ...(spec.description && spec.description.trim().length > 0
+            ? { description: spec.description.trim() }
+            : {}),
+        cases: spec.cases.map((testCase) => {
+            // H3: trim then safelist the relative path before persisting. A malicious
+            // `../../../etc/passwd` spec must be rejected here, not stored verbatim and
+            // later fed to path.join. This is the same guard the schema enforces (H2),
+            // applied at the write boundary so the spec is never written with an
+            // escaping file value.
+            const file = testCase.file?.trim();
+            if (file)
+                assertSafeRelativeTestFile(file);
+            return {
+                id: normalizeTestId(testCase.id),
+                question: testCase.question.trim(),
+                ...(file && file.length > 0
+                    ? { file }
+                    : {}),
+                ...(testCase.answer && testCase.answer.trim().length > 0
+                    ? { answer: testCase.answer.trim() }
+                    : {}),
+                ...(testCase.strictness && testCase.strictness.trim().length > 0
+                    ? { strictness: testCase.strictness.trim() }
+                    : {}),
+                ...(testCase.expect
+                    ? {
+                        expect: {
+                            ...(testCase.expect.must_include && testCase.expect.must_include.length > 0
+                                ? { must_include: testCase.expect.must_include.map((value) => value.trim()).filter(Boolean) }
+                                : {}),
+                            ...(testCase.expect.must_include_one_of && testCase.expect.must_include_one_of.length > 0
+                                ? {
+                                    must_include_one_of: testCase.expect.must_include_one_of
+                                        .map((group) => group.map((value) => value.trim()).filter(Boolean))
+                                        .filter((group) => group.length > 0),
+                                }
+                                : {}),
+                            ...(testCase.expect.must_not_include && testCase.expect.must_not_include.length > 0
+                                ? { must_not_include: testCase.expect.must_not_include.map((value) => value.trim()).filter(Boolean) }
+                                : {}),
+                            ...(typeof testCase.expect.min_words === "number"
+                                ? { min_words: testCase.expect.min_words }
+                                : {}),
+                            ...(typeof testCase.expect.max_words === "number"
+                                ? { max_words: testCase.expect.max_words }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            };
+        }),
+    };
+    const parsed = TestSpecSchema.parse(normalizedSpec);
+    writeFileSync(filePath, `${JSON.stringify(serializeTestSpec(parsed), null, 2)}\n`);
+    return filePath;
+}

package/dist/packages/runtime/verify/verify-targets.d.ts

@@ -0,0 +1,5 @@
+import type { TestTargetCandidate } from "./verify-types.js";
+export declare function listContextGraphTestTargets(sourcePath: string): TestTargetCandidate[];
+export declare function createContextGraphTestTarget(contextGraphPath: string, contextGraphName: string, buildPlanId?: string): TestTargetCandidate;
+export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;
+export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/packages/{engine → runtime}/verify/verify-targets.js

@@ -1,20 +1,20 @@
-import { listVerifiableContextsForSourceFolder } from "../../project/interf-detect.js";
-import { computeVerifiableContextHealth } from "../build/state.js";
+import { listContextGraphsForSourceFolder } from "../../projects/interf-detect.js";
+import { computeContextGraphHealth } from "../build/state.js";
 import { DEFAULT_BUILD_PLAN_ID, resolveBuildPlanId } from "../../build-plans/build-plan-resolution.js";
 function summarizeTargetSortKey(target) {
     return `${target.name}\u0000${target.build_plan}`;
 }
-export function listVerifiableContextTestTargets(sourcePath) {
-    return listVerifiableContextsForSourceFolder(sourcePath)
-        .map(({ path, config }) => createVerifiableContextTestTarget(path, config.name, resolveBuildPlanId(config)))
+export function listContextGraphTestTargets(sourcePath) {
+    return listContextGraphsForSourceFolder(sourcePath)
+        .map(({ path, config }) => createContextGraphTestTarget(path, config.name, resolveBuildPlanId(config)))
         .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
 }
-export function createVerifiableContextTestTarget(verifiableContextPath, verifiableContextName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
-    const health = computeVerifiableContextHealth(verifiableContextPath);
+export function createContextGraphTestTarget(contextGraphPath, contextGraphName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
+    const health = computeContextGraphHealth(contextGraphPath);
     return {
-        type: "verifiable-context",
-        name: verifiableContextName,
-        path: verifiableContextPath,
+        type: "context-graph",
+        name: contextGraphName,
+        path: contextGraphPath,
         build_plan: buildPlanId,
         status: health.status,
         stage: health.stage,
@@ -30,10 +30,10 @@ export function createSourceFilesTestTarget(sourcePath) {
         build_plan: "source-files",
         status: "built",
         stage: "source-files",
-        summary: "Run the checks against source file references in an isolated test shell.",
+        summary: "Run the checks against source file references in an isolated benchmark shell.",
         eligible: true,
     };
 }
 export function listTestTargets(sourcePath) {
-    return listVerifiableContextTestTargets(sourcePath);
+    return listContextGraphTestTargets(sourcePath);
 }

package/dist/packages/runtime/verify/verify-types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/{engine → runtime}/verify/verify.d.ts

@@ -1,4 +1,4 @@
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./verify-types.js";
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
-export { createSourceFilesTestTarget, createVerifiableContextTestTarget, listVerifiableContextTestTargets, listTestTargets, } from "./verify-targets.js";
+export { createSourceFilesTestTarget, createContextGraphTestTarget, listContextGraphTestTargets, listTestTargets, } from "./verify-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";

package/dist/packages/{engine → runtime}/verify/verify.js

@@ -1,3 +1,3 @@
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
-export { createSourceFilesTestTarget, createVerifiableContextTestTarget, listVerifiableContextTestTargets, listTestTargets, } from "./verify-targets.js";
+export { createSourceFilesTestTarget, createContextGraphTestTarget, listContextGraphTestTargets, listTestTargets, } from "./verify-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";

package/dist/packages/runtime/wire-schemas.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Thrown when `getJson` parses a response that fails the registered
+ * schema. Surfaces the request path and the zod issue list so the UI
+ * can render an actionable error rather than a stack trace.
+ *
+ * `issues` is typed as `unknown[]` so the class works across both
+ * `zod` dependency trees in the monorepo.
+ * Callers cast or render structurally as needed.
+ */
+export declare class WireShapeError extends Error {
+    readonly name = "WireShapeError";
+    readonly path: string;
+    readonly issues: readonly unknown[];
+    constructor(options: {
+        path: string;
+        issues: readonly unknown[];
+    });
+}

package/dist/packages/runtime/wire-schemas.js

@@ -0,0 +1,27 @@
+/**
+ * Thrown when `getJson` parses a response that fails the registered
+ * schema. Surfaces the request path and the zod issue list so the UI
+ * can render an actionable error rather than a stack trace.
+ *
+ * `issues` is typed as `unknown[]` so the class works across both
+ * `zod` dependency trees in the monorepo.
+ * Callers cast or render structurally as needed.
+ */
+export class WireShapeError extends Error {
+    name = "WireShapeError";
+    path;
+    issues;
+    constructor(options) {
+        super(`Wire-shape validation failed for ${options.path}: ${options.issues.map((issue) => describeIssue(issue)).join("; ")}`);
+        this.path = options.path;
+        this.issues = options.issues;
+    }
+}
+function describeIssue(issue) {
+    if (typeof issue === "object" && issue !== null && "message" in issue) {
+        const message = issue.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return JSON.stringify(issue);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.22.2",
-  "description": "Interf builds verifiable context for agents from your files.",
+  "version": "0.50.0",
+  "description": "Interf prepares data for agents by building Context Graphs from files.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -14,30 +14,33 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./actions": {
+      "types": "./dist/packages/runtime/actions/index.d.ts",
+      "import": "./dist/packages/runtime/actions/index.js"
+    },
+    "./agent-handoff": {
+      "types": "./dist/packages/runtime/agent-handoff.d.ts",
+      "import": "./dist/packages/runtime/agent-handoff.js"
+    },
+    "./schemas": {
+      "types": "./dist/packages/runtime/schemas/index.d.ts",
+      "import": "./dist/packages/runtime/schemas/index.js"
+    },
+    "./service/routes": {
+      "types": "./dist/packages/runtime/service/routes.d.ts",
+      "import": "./dist/packages/runtime/service/routes.js"
+    },
+    "./service/operations": {
+      "types": "./dist/packages/runtime/service/operations.d.ts",
+      "import": "./dist/packages/runtime/service/operations.js"
+    },
+    "./openapi": {
+      "types": "./dist/packages/runtime/service/openapi.d.ts",
+      "import": "./dist/packages/runtime/service/openapi.js"
+    },
     "./package.json": "./package.json"
   },
   "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 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",
-    "test:e2e": "npm run test:acceptance",
-    "test:e2e:claude": "npm run test:acceptance-live -- --agent claude-code --with-test",
-    "test:e2e:codex": "npm run test:acceptance-live -- --agent codex --with-test",
-    "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-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",
-    "prepack": "node scripts/release/package-readme.mjs --write",
     "postpack": "node scripts/release/package-readme.mjs --clean"
   },
   "files": [
@@ -59,10 +62,10 @@
   "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": {
@@ -71,13 +74,12 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@workos-inc/node": "^9.2.0",
     "chalk": "^5.4.1",
+    "jose": "^6.2.3",
+    "keytar": "^7.9.0",
+    "open": "^11.0.0",
     "yargs": "^17.7.2",
     "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@types/node": "^22.15.3",
-    "@types/yargs": "^17.0.33",
-    "typescript": "^5.8.3"
   }
 }

package/public-repo/CONTRIBUTING.md

@@ -1,43 +1,41 @@
 # 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 README, license and security docs, bundled Skills, and public Build Plans.
 
-The Interf engine source is private. Do not add private source paths,
-maintainer docs, or internal repo instructions here.
+Only files under `public-repo` are intended for this public surface. Do not add
+source paths outside `public-repo`, maintainer docs, or repo-specific operating
+instructions here.
+
+The marketing website is maintained separately in `interf-labs/interf-website`.
+Do not add landing-page code, website assets, or website operating notes to this
+public SDK/package surface.
 
 ## 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-plan.json` is the current technical filename for Build Plan stages,
+  requested outputs, coverage requirements, and graph entrypoints.
+- `build-plan.schema.json` is the current technical filename for the Build Plan
+  package 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.
+- `use/query/SKILL.md` tells agents how to read the Context Graph.
+- `improve/SKILL.md` tells Interf how to revise the Build Plan when coverage,
+  Stage Manifest validation, or graph output requirements fail.
 
 For the shipped default Build Plan, edit `build-plans/interf-default/`.
 
-## Agent Skills And Plugins
+## Agent Skills
 
 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