@interf/compiler 0.22.2 → 0.33.0

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

@@ -2,10 +2,10 @@ import type { TestTargetType } from "./verify-types.js";
 export declare const TEST_SPEC_EXTENSIONS: Set<string>;
 export declare function testSpecRootPath(sourcePath: string): string;
 export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;
-export declare function targetTestRunsPath(verifiableContextPath: string, type: TestTargetType): string;
-export declare function targetTestRunGitignorePath(verifiableContextPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxesPath(verifiableContextPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxGitignorePath(verifiableContextPath: string, type: TestTargetType): string;
+export declare function targetTestRunsPath(contextGraphPath: string, type: TestTargetType): string;
+export declare function targetTestRunGitignorePath(contextGraphPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxesPath(contextGraphPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxGitignorePath(contextGraphPath: string, type: TestTargetType): string;
 export declare function testSpecFilePath(sourcePath: string, type: TestTargetType, id: string): string;
 export declare function normalizeTestId(input: string): string;
 export declare function assertTestId(id: string): void;

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

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { targetTestRunsRootForContextGraph, targetTestSandboxesRootForContextGraph, contextGraphInterfConfigPath, } from "../build/context-graph-paths.js";
+import { asProjectDataDir, projectTestsSpecsRoot, } from "../../contracts/lib/project-paths.js";
+const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
+export function testSpecRootPath(sourcePath) {
+    return projectTestsSpecsRoot(asProjectDataDir(sourcePath));
+}
+export function testSpecTypePath(sourcePath, type) {
+    return join(testSpecRootPath(sourcePath), type);
+}
+function isProjectTestsRootPath(artifactRootPath) {
+    return basename(artifactRootPath) === "tests" &&
+        basename(dirname(artifactRootPath)) === ".interf";
+}
+export function targetTestRunsPath(contextGraphPath, type) {
+    if (existsSync(contextGraphInterfConfigPath(contextGraphPath))) {
+        return join(targetTestRunsRootForContextGraph(contextGraphPath), type);
+    }
+    if (isProjectTestsRootPath(contextGraphPath)) {
+        return join(contextGraphPath, type === "source-files" ? "source-files" : "context-graph", "runs");
+    }
+    throw new Error(`Unsupported test artifact root: ${contextGraphPath}. Expected context graph or interf/<project>/.interf/tests root.`);
+}
+export function targetTestRunGitignorePath(contextGraphPath, type) {
+    return join(targetTestRunsPath(contextGraphPath, type), ".gitignore");
+}
+export function targetTestSandboxesPath(contextGraphPath, type) {
+    if (existsSync(contextGraphInterfConfigPath(contextGraphPath))) {
+        return join(targetTestSandboxesRootForContextGraph(contextGraphPath), type);
+    }
+    if (isProjectTestsRootPath(contextGraphPath)) {
+        return join(contextGraphPath, type === "source-files" ? "source-files" : "context-graph", "sandboxes");
+    }
+    throw new Error(`Unsupported test artifact root: ${contextGraphPath}. Expected context graph or interf/<project>/.interf/tests root.`);
+}
+export function targetTestSandboxGitignorePath(contextGraphPath, type) {
+    return join(targetTestSandboxesPath(contextGraphPath, type), ".gitignore");
+}
+export function testSpecFilePath(sourcePath, type, id) {
+    return join(testSpecTypePath(sourcePath, type), `${id}.json`);
+}
+export function normalizeTestId(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+export function assertTestId(id) {
+    if (!TEST_ID_PATTERN.test(id)) {
+        throw new Error(`Invalid test id: ${id}`);
+    }
+}
+export function assertWritableTestSpecPath(filePath) {
+    if (existsSync(filePath)) {
+        throw new Error(`Test spec already exists: ${filePath}`);
+    }
+}

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

@@ -3,7 +3,7 @@ export type TestSandboxRetentionMode = "on-failure" | "always";
 export interface TestSandbox {
     rootPath: string;
     targetPath: string;
-    verifiableContextPath: string | null;
+    contextGraphPath: string | null;
     preserve(destinationPath: string): string;
     cleanup(): void;
 }

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

@@ -0,0 +1,88 @@
+import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { refreshContextGraphBootstrapGuidance } from "../agents/lib/context-graph-bootstrap.js";
+import { readInterfConfig } from "../../projects/interf.js";
+import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
+import { asProjectDataDir, projectContextGraphPath, } from "../../contracts/lib/project-paths.js";
+import { saveContextGraphInterfConfig } from "../../projects/source-config.js";
+import { loadContextGraphSourceManifest, sourceManifestToSourceFiles, } from "../build/source-manifest.js";
+import { refreshContextGraphArtifacts } from "../build/state.js";
+import { testRootForContextGraph, stageExecutionShellsRoot, targetTestSandboxesRootForContextGraph, buildPlanImprovementLoopsRoot, contextGraphQueryAcceptanceRoot, contextGraphRuntimeLogsRoot, } from "../build/context-graph-paths.js";
+function sanitizeContextGraphArtifacts(contextGraphPath) {
+    for (const absolutePath of [
+        testRootForContextGraph(contextGraphPath),
+        targetTestSandboxesRootForContextGraph(contextGraphPath),
+        stageExecutionShellsRoot(contextGraphPath),
+        buildPlanImprovementLoopsRoot(contextGraphPath),
+        contextGraphRuntimeLogsRoot(contextGraphPath),
+        contextGraphQueryAcceptanceRoot(contextGraphPath),
+    ]) {
+        rmSync(absolutePath, { recursive: true, force: true });
+    }
+}
+export function createTestSandbox(target) {
+    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
+    let preserved = false;
+    const sandboxContextGraphPath = () => (target.type === "context-graph"
+        ? projectContextGraphPath(asProjectDataDir(sandboxRoot), target.name)
+        : null);
+    const sandboxTargetPath = () => (target.type === "context-graph"
+        ? projectContextGraphPath(asProjectDataDir(sandboxRoot), target.name)
+        : sandboxRoot);
+    try {
+        if (target.type === "context-graph") {
+            mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
+            cpSync(target.path, sandboxTargetPath(), { recursive: true });
+            sanitizeContextGraphArtifacts(sandboxTargetPath());
+            const sandboxConfig = readInterfConfig(sandboxTargetPath());
+            if (!sandboxConfig) {
+                throw new Error(`Sandbox Context Graph is missing interf.json: ${sandboxTargetPath()}`);
+            }
+            saveContextGraphInterfConfig(sandboxTargetPath(), {
+                ...sandboxConfig,
+                source: sandboxConfig.source,
+            });
+            refreshContextGraphBootstrapGuidance(sandboxTargetPath());
+            refreshContextGraphArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
+        }
+        else {
+            mkdirSync(join(sandboxTargetPath(), "runtime"), { recursive: true });
+            const manifest = loadContextGraphSourceManifest(target.path);
+            if (!manifest) {
+                throw new Error(`Source-files benchmark target has no Source Manifest: ${target.path}`);
+            }
+            writeFileSync(join(sandboxTargetPath(), "runtime", "source-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(sourceManifestToSourceFiles(manifest), null, 2)}\n`);
+            projectSourceFilesTestQueryShell(sandboxTargetPath());
+        }
+    }
+    catch (error) {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        get rootPath() {
+            return sandboxRoot;
+        },
+        get targetPath() {
+            return sandboxTargetPath();
+        },
+        get contextGraphPath() {
+            return sandboxContextGraphPath();
+        },
+        preserve(destinationPath) {
+            mkdirSync(dirname(destinationPath), { recursive: true });
+            rmSync(destinationPath, { recursive: true, force: true });
+            renameSync(sandboxRoot, destinationPath);
+            sandboxRoot = destinationPath;
+            preserved = true;
+            return sandboxRoot;
+        },
+        cleanup() {
+            if (preserved)
+                return;
+            rmSync(sandboxRoot, { recursive: true, force: true });
+        },
+    };
+}

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

@@ -4,4 +4,6 @@ export declare function loadTestSpec(sourcePath: string, type: TestTargetType, i
 export declare function loadTestSpecFromFile(filePath: string): LoadedTestSpec | null;
 export declare function writeTestSpec(sourcePath: string, spec: TestSpec & {
     id?: string;
+}, options?: {
+    overwrite?: boolean;
 }): string;

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

@@ -52,17 +52,19 @@ export function loadTestSpec(sourcePath, type, id) {
 export function loadTestSpecFromFile(filePath) {
     return readTestSpecFile(filePath);
 }
-export function writeTestSpec(sourcePath, spec) {
+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)) {
+    if (existsSync(existingPath) && !options.overwrite) {
         throw new Error(`Test spec already exists: ${existingPath}`);
     }
     const filePath = testSpecFilePath(sourcePath, spec.type, id);
-    assertWritableTestSpecPath(filePath);
+    if (!options.overwrite) {
+        assertWritableTestSpecPath(filePath);
+    }
     const normalizedSpec = {
         type: spec.type,
         name: spec.name.trim(),

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 (root + `src/apps/interf-desktop/renderer`).
+ * 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 (root + `src/apps/interf-desktop/renderer`).
+ * 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.33.0",
+  "description": "Interf prepares data for agents by building Context Graphs from files.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -14,35 +14,44 @@
       "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": [
     "dist",
-    "public-repo"
+    "public-repo",
+    "!dist/cli/commands/desktop.d.ts",
+    "!dist/cli/commands/desktop.js",
+    "!dist/desktop",
+    "!dist/desktop/**",
+    "!dist/desktop-renderer",
+    "!dist/desktop-renderer/**"
   ],
   "publishConfig": {
     "access": "public"
@@ -59,10 +68,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 +80,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,17 +1,16 @@
 # 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.
 
 ## 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
@@ -21,23 +20,15 @@ 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.
+- `use/query/SKILL.md` tells agents how to read the Context Graph.
+- `improve/SKILL.md` tells Interf how to revise the Build Plan when checks 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