@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/plan-artifact-contract.d.ts

@@ -0,0 +1,17 @@
+import type { Artifact } from "../contracts/lib/schema.js";
+import type { RequestedArtifact } from "../build-plans/authoring/brief.js";
+import type { ProjectConfig } from "../projects/lib/schema.js";
+import type { BuildPlanAuthoringArtifactRequirement } from "./schemas/index.js";
+export declare function artifactsForBuildPlan(projectDataDir: string, buildPlanId: string | null | undefined): Artifact[];
+export declare function artifactsForSelectedBuildPlan(projectDataDir: string, projectConfig: ProjectConfig): Artifact[];
+export declare function requestedArtifactsForPlanAuthoring(options: {
+    projectDataDir: string;
+    projectConfig: ProjectConfig | null;
+    explicitRequestedArtifacts?: RequestedArtifact[];
+}): RequestedArtifact[];
+export declare function artifactRequirementsForPlanAuthoring(options: {
+    projectDataDir: string;
+    projectConfig: ProjectConfig | null;
+    requestedArtifacts: RequestedArtifact[];
+    explicitArtifactRequirements?: BuildPlanAuthoringArtifactRequirement[];
+}): BuildPlanAuthoringArtifactRequirement[];

package/dist/packages/runtime/plan-artifact-contract.js

@@ -0,0 +1,42 @@
+import { getBuildPlan, } from "../build-plans/package/build-plan-definitions.js";
+import { buildPlanIdForProjectConfig, } from "../projects/source-config.js";
+import { artifactRequirementsFromRequestedArtifacts, requestedArtifactsFromPlanArtifacts, } from "./requested-artifacts.js";
+export function artifactsForBuildPlan(projectDataDir, buildPlanId) {
+    if (!buildPlanId)
+        return [];
+    try {
+        const buildPlan = getBuildPlan(buildPlanId, { projectDataDir });
+        return [...(buildPlan.contextInterface?.artifacts ?? [])];
+    }
+    catch {
+        return [];
+    }
+}
+export function artifactsForSelectedBuildPlan(projectDataDir, projectConfig) {
+    return artifactsForBuildPlan(projectDataDir, buildPlanIdForProjectConfig(projectConfig));
+}
+export function requestedArtifactsForPlanAuthoring(options) {
+    if (options.explicitRequestedArtifacts) {
+        return options.explicitRequestedArtifacts;
+    }
+    if (!options.projectConfig)
+        return [];
+    return requestedArtifactsFromPlanArtifacts(artifactsForSelectedBuildPlan(options.projectDataDir, options.projectConfig));
+}
+export function artifactRequirementsForPlanAuthoring(options) {
+    if (options.explicitArtifactRequirements) {
+        return options.explicitArtifactRequirements;
+    }
+    const fromRequestedArtifacts = artifactRequirementsFromRequestedArtifacts(options.requestedArtifacts);
+    if (fromRequestedArtifacts.length > 0)
+        return fromRequestedArtifacts;
+    if (!options.projectConfig)
+        return [];
+    const buildPlanArtifacts = artifactsForSelectedBuildPlan(options.projectDataDir, options.projectConfig);
+    return buildPlanArtifacts.map((artifact) => ({
+        id: artifact.id,
+        description: artifact.description,
+        shape: artifact.shape,
+        checks: artifact.checks,
+    }));
+}

package/dist/packages/runtime/project-entries.d.ts

@@ -0,0 +1,11 @@
+import type { ProjectConfig } from "../projects/lib/schema.js";
+export interface SavedProjectEntry {
+    config: ProjectConfig;
+    path: string | null;
+    localDraft: boolean;
+}
+export declare function listSavedProjectEntries(projectDataDir: string): SavedProjectEntry[];
+export declare function findBuiltContextGraphPath(projectDataDir: string, projectName: string): string | null;
+export declare function findSavedProjectConfig(projectDataDir: string, projectName: string): ProjectConfig | null;
+export declare function createContextGraphFromConfig(projectDataDir: string, projectConfig: ProjectConfig): string;
+export declare function ensureContextGraphFromConfig(projectDataDir: string, projectConfig: ProjectConfig): string;

package/dist/packages/runtime/project-entries.js

@@ -0,0 +1,49 @@
+import { listContextGraphsForSourceFolder, } from "../projects/interf-detect.js";
+import { createContextGraph, ensureContextGraphScaffold, } from "./context-graph-scaffold.js";
+import { listProjectConfigs, loadContextGraphProjectConfig, loadSourceFolderConfig, resolveProjectSourceBindingPath, projectConfigFromInterfConfig, syncContextGraphInterfConfigFromProjectConfig, } from "../projects/source-config.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForProjectConfig, } from "../build-plans/build-plan-resolution.js";
+export function listSavedProjectEntries(projectDataDir) {
+    const builtEntries = new Map();
+    for (const builtContext of listContextGraphsForSourceFolder(projectDataDir)) {
+        const projectConfig = loadContextGraphProjectConfig(builtContext.path)
+            ?? projectConfigFromInterfConfig(builtContext.config);
+        builtEntries.set(builtContext.config.name, {
+            config: projectConfig,
+            path: builtContext.path,
+            localDraft: builtContext.config.build_plan_origin?.local_draft === true,
+        });
+    }
+    const entries = new Map();
+    for (const config of listProjectConfigs(loadSourceFolderConfig(projectDataDir))) {
+        const built = builtEntries.get(config.name);
+        entries.set(config.name, {
+            config,
+            path: built?.path ?? null,
+            localDraft: built?.localDraft ?? false,
+        });
+    }
+    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
+}
+export function findBuiltContextGraphPath(projectDataDir, projectName) {
+    return listSavedProjectEntries(projectDataDir).find((entry) => entry.config.name === projectName)?.path ?? null;
+}
+export function findSavedProjectConfig(projectDataDir, projectName) {
+    return listSavedProjectEntries(projectDataDir).find((entry) => entry.config.name === projectName)?.config ?? null;
+}
+export function createContextGraphFromConfig(projectDataDir, projectConfig) {
+    const buildPlanId = buildPlanIdForProjectConfig(projectConfig) ?? DEFAULT_BUILD_PLAN_ID;
+    const sourceFolderPath = resolveProjectSourceBindingPath(projectDataDir, projectConfig);
+    const contextGraphPath = createContextGraph(projectConfig.name, projectDataDir, buildPlanId, sourceFolderPath);
+    syncContextGraphInterfConfigFromProjectConfig(contextGraphPath, projectConfig);
+    return contextGraphPath;
+}
+export function ensureContextGraphFromConfig(projectDataDir, projectConfig) {
+    const buildPlanId = buildPlanIdForProjectConfig(projectConfig) ?? DEFAULT_BUILD_PLAN_ID;
+    const existingPath = findBuiltContextGraphPath(projectDataDir, projectConfig.name);
+    if (existingPath) {
+        ensureContextGraphScaffold(projectDataDir, projectConfig.name, buildPlanId);
+        syncContextGraphInterfConfigFromProjectConfig(existingPath, projectConfig);
+        return existingPath;
+    }
+    return createContextGraphFromConfig(projectDataDir, projectConfig);
+}

package/dist/packages/runtime/project-source-state.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Project source-state computation.
+ *
+ * Interf does not inspect Source bytes directly. The latest Source Manifest
+ * is the scan state for a Project; before a manifest exists the Source state
+ * is unknown, not missing.
+ */
+import type { ProjectSourceState } from "../contracts/lib/project-schema.js";
+export interface ProjectSourceStateInput {
+    projectId: string;
+    contextGraphPath: string;
+    /**
+     * Hash from the last successful Build (typically the latest Context
+     * Graph's file index hash). Omit when computing state for the latest
+     * Context Graph itself; pass null only when no Build has produced a
+     * manifest yet.
+     */
+    lastGraphIndexHash?: string | null;
+}
+/**
+ * Compute the current `ProjectSourceState`.
+ *
+ * The Project Source state is manifest-backed. Interf does not stat or hash
+ * the bound Source locator while answering this API.
+ */
+export declare function computeProjectSourceState(input: ProjectSourceStateInput): ProjectSourceState;

package/dist/packages/runtime/project-source-state.js

@@ -0,0 +1,56 @@
+/**
+ * Project source-state computation.
+ *
+ * Interf does not inspect Source bytes directly. The latest Source Manifest
+ * is the scan state for a Project; before a manifest exists the Source state
+ * is unknown, not missing.
+ */
+import { computeFileIndexHash, loadContextGraphSourceManifest, sourceManifestToSourceFiles } from "./build/source-manifest.js";
+/**
+ * Compute the current `ProjectSourceState`.
+ *
+ * The Project Source state is manifest-backed. Interf does not stat or hash
+ * the bound Source locator while answering this API.
+ */
+export function computeProjectSourceState(input) {
+    const generatedAt = new Date().toISOString();
+    const manifest = loadContextGraphSourceManifest(input.contextGraphPath);
+    if (!manifest) {
+        return {
+            kind: "interf-project-source-state",
+            version: 1,
+            project_id: input.projectId,
+            file_index_hash: null,
+            file_count: 0,
+            last_observed_at: generatedAt,
+            drift_kind: "unknown",
+            drift_summary: "No Source Manifest has been recorded for this Project yet.",
+        };
+    }
+    const sourceFiles = sourceManifestToSourceFiles(manifest);
+    const fileIndexHash = computeFileIndexHash(sourceFiles);
+    const baselineIndexHash = input.lastGraphIndexHash === undefined
+        ? fileIndexHash
+        : input.lastGraphIndexHash;
+    const driftKind = (() => {
+        if (baselineIndexHash === null)
+            return "unknown";
+        if (baselineIndexHash === fileIndexHash)
+            return "fresh";
+        return "drifted";
+    })();
+    return {
+        kind: "interf-project-source-state",
+        version: 1,
+        project_id: input.projectId,
+        file_index_hash: fileIndexHash,
+        file_count: sourceFiles.files.length,
+        last_observed_at: generatedAt,
+        drift_kind: driftKind,
+        drift_summary: driftKind === "drifted"
+            ? "A newer Source Manifest differs from the last Build. Build again to reflect changes."
+            : driftKind === "fresh"
+                ? "Latest Source Manifest matches the Context Graph."
+                : "Latest Source Manifest has been recorded; run a rescan to check for Source drift.",
+    };
+}

package/dist/packages/runtime/project-store.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Project store.
+ *
+ * Each Project lives at `~/.interf/projects/<id>/` and is registered
+ * with the runtime so the build / benchmark / readiness machinery can find its
+ * Project data dir.
+ *
+ *   ~/.interf/projects/<id>/
+ *     interf.json          <- Project config, single Project entry name=<id>
+ *     graphs/<run-id>/     <- per-Build Run Context Graph outputs
+ *
+ * NOTE: `projectDataDir` remains the storage helper type name until the P7.3
+ * path-helper cleanup. The runtime and HTTP resource are Project-keyed.
+ */
+import type { ProjectConfig } from "../projects/lib/schema.js";
+import type { LocalServiceRuntime } from "./runtime.js";
+export interface ProjectCreateInput {
+    id: string;
+    source: {
+        kind: "local-folder";
+        locator: string;
+    };
+    intent: string;
+    /** Build Plan binding. Null/undefined means "not bound yet" — bind later via update. */
+    build_plan_id?: string | null;
+}
+export interface ProjectUpdateInput {
+    intent?: string;
+    build_plan_id?: string | null;
+}
+export interface StoredProject {
+    id: string;
+    projectDataDir: string;
+    source: {
+        kind: "local-folder";
+        locator: string;
+    };
+    intent: string;
+    /** Null when no Build Plan has been bound to this Project yet. */
+    buildPlanId: string | null;
+    config: ProjectConfig;
+    contextGraphPath: string;
+    configPath: string;
+}
+/** List every Project registered under `~/.interf/projects/`. */
+export declare function listStoredProjects(): StoredProject[];
+/** Read one Project by id. Returns null when missing. */
+export declare function getStoredProject(projectId: string): StoredProject | null;
+/**
+ * Create a Project: scaffold its data dir, write the local
+ * Project config, and register it with the runtime so subsequent
+ * build / benchmark / readiness calls find it.
+ *
+ * Throws on validation errors (bad id, bad Build Plan id, source missing).
+ */
+export declare function createStoredProject(runtime: LocalServiceRuntime, input: ProjectCreateInput): StoredProject;
+/**
+ * Delete a Project: deregister its runtime context and remove
+ * `~/.interf/projects/<id>/` from disk. Returns true when something
+ * was actually removed.
+ */
+export declare function deleteStoredProject(runtime: LocalServiceRuntime, projectId: string): boolean;
+/**
+ * Update mutable fields on an existing Project. Returns the freshly-loaded
+ * record. Throws if the Project does not exist.
+ */
+export declare function updateStoredProject(projectId: string, patch: ProjectUpdateInput): StoredProject;
+/**
+ * Re-register every Project directory with the runtime on startup so
+ * Projects survive an `interf runtime` restart.
+ */
+export declare function rehydrateProjects(runtime: LocalServiceRuntime): void;
+/** Build the wire shape for `GET /v1/projects/<id>` given a stored Project. */
+export declare function projectWireShape(stored: StoredProject): {
+    id: string;
+    project_id: string;
+    source: {
+        kind: string;
+        locator: string;
+    };
+    intent: string;
+    build_plan_id: string | null;
+    config_path: string;
+    updated_at: string | null;
+    context_graph: {
+        kind: "local-path";
+        value: string;
+    };
+    context_graph_path: string;
+};

package/dist/packages/runtime/project-store.js

@@ -0,0 +1,195 @@
+/**
+ * Project store.
+ *
+ * Each Project lives at `~/.interf/projects/<id>/` and is registered
+ * with the runtime so the build / benchmark / readiness machinery can find its
+ * Project data dir.
+ *
+ *   ~/.interf/projects/<id>/
+ *     interf.json          <- Project config, single Project entry name=<id>
+ *     graphs/<run-id>/     <- per-Build Run Context Graph outputs
+ *
+ * NOTE: `projectDataDir` remains the storage helper type name until the P7.3
+ * path-helper cleanup. The runtime and HTTP resource are Project-keyed.
+ */
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, } from "node:fs";
+import { resolve } from "node:path";
+import { ProjectIdSchema, BuildPlanIdSchema, ProjectIntentSchema, } from "../contracts/lib/schema.js";
+import { projectDataDir as resolveProjectDataDir, projectConfigPath, projectContextGraphPath, projectRunContextGraphPath, projectsRoot, } from "../contracts/lib/project-paths.js";
+import { saveSourceFolderConfig, loadSourceFolderConfig, } from "../projects/source-config.js";
+import { assertCanCreateProject } from "./entitlement-guard.js";
+function ensureProjectsRoot() {
+    mkdirSync(projectsRoot(), { recursive: true });
+}
+function loadStoredProject(projectId) {
+    const projectDataDir = resolveProjectDataDir(projectId);
+    if (!existsSync(projectDataDir) || !statSync(projectDataDir).isDirectory())
+        return null;
+    const config = loadSourceFolderConfig(projectDataDir);
+    if (!config)
+        return null;
+    const loadedProject = config.projects?.find((p) => p.name === projectId);
+    if (!loadedProject)
+        return null;
+    const intent = ProjectIntentSchema.safeParse(loadedProject.intent);
+    if (!intent.success)
+        return null;
+    const project = { ...loadedProject, intent: intent.data };
+    const sourceFolderPath = config.source_folder?.path;
+    if (!sourceFolderPath)
+        return null;
+    return {
+        id: projectId,
+        projectDataDir,
+        source: { kind: "local-folder", locator: sourceFolderPath },
+        intent: project.intent,
+        buildPlanId: project.build_plan ?? null,
+        config: project,
+        contextGraphPath: project.latest_context_graph_run_id
+            ? projectRunContextGraphPath(projectDataDir, project.latest_context_graph_run_id)
+            : projectContextGraphPath(projectDataDir, projectId),
+        configPath: projectConfigPath(projectDataDir),
+    };
+}
+/** List every Project registered under `~/.interf/projects/`. */
+export function listStoredProjects() {
+    const root = projectsRoot();
+    if (!existsSync(root))
+        return [];
+    const entries = readdirSync(root, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const stored = loadStoredProject(entry.name);
+        if (stored)
+            out.push(stored);
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Read one Project by id. Returns null when missing. */
+export function getStoredProject(projectId) {
+    return loadStoredProject(projectId);
+}
+/**
+ * Create a Project: scaffold its data dir, write the local
+ * Project config, and register it with the runtime so subsequent
+ * build / benchmark / readiness calls find it.
+ *
+ * Throws on validation errors (bad id, bad Build Plan id, source missing).
+ */
+export function createStoredProject(runtime, input) {
+    ProjectIdSchema.parse(input.id);
+    if (input.build_plan_id != null) {
+        BuildPlanIdSchema.parse(input.build_plan_id);
+    }
+    const intent = ProjectIntentSchema.parse(input.intent);
+    const sourceLocator = resolve(input.source.locator);
+    ensureProjectsRoot();
+    const projectDataDir = resolveProjectDataDir(input.id);
+    if (existsSync(projectDataDir) && loadStoredProject(input.id)) {
+        throw new Error(`Project already exists: ${input.id}`);
+    }
+    // Free-tier 10-Project cap. Cloud accounts on Pro bypass this.
+    assertCanCreateProject(runtime.currentAccount, listStoredProjects().length);
+    mkdirSync(projectDataDir, { recursive: true });
+    const project = {
+        name: input.id,
+        intent,
+        path: input.id,
+        ...(input.build_plan_id ? { build_plan: input.build_plan_id } : {}),
+    };
+    saveSourceFolderConfig(projectDataDir, {
+        source_folder: { path: sourceLocator },
+        projects: [project],
+    });
+    // Hand the Project data dir to the runtime so the existing
+    // build/benchmark/readiness paths see it.
+    runtime.registerProject(projectDataDir);
+    const stored = loadStoredProject(input.id);
+    if (!stored)
+        throw new Error(`Failed to load freshly-created Project ${input.id}`);
+    return stored;
+}
+/**
+ * Delete a Project: deregister its runtime context and remove
+ * `~/.interf/projects/<id>/` from disk. Returns true when something
+ * was actually removed.
+ */
+export function deleteStoredProject(runtime, projectId) {
+    const projectDataDir = resolveProjectDataDir(projectId);
+    if (!existsSync(projectDataDir))
+        return false;
+    runtime.deregisterProject(projectDataDir);
+    rmSync(projectDataDir, { recursive: true, force: true });
+    return true;
+}
+/**
+ * Update mutable fields on an existing Project. Returns the freshly-loaded
+ * record. Throws if the Project does not exist.
+ */
+export function updateStoredProject(projectId, patch) {
+    const stored = loadStoredProject(projectId);
+    if (!stored)
+        throw new Error(`Project not found: ${projectId}`);
+    if (patch.build_plan_id !== undefined && patch.build_plan_id !== null) {
+        BuildPlanIdSchema.parse(patch.build_plan_id);
+    }
+    if (patch.intent !== undefined) {
+        ProjectIntentSchema.parse(patch.intent);
+    }
+    const nextProject = {
+        ...stored.config,
+        ...(patch.intent !== undefined ? { intent: ProjectIntentSchema.parse(patch.intent) } : {}),
+        ...(patch.build_plan_id === null
+            ? { build_plan: undefined }
+            : patch.build_plan_id !== undefined
+                ? { build_plan: patch.build_plan_id }
+                : {}),
+    };
+    saveSourceFolderConfig(stored.projectDataDir, {
+        source_folder: { path: stored.source.locator },
+        projects: [nextProject],
+    });
+    const next = loadStoredProject(projectId);
+    if (!next)
+        throw new Error(`Failed to reload updated Project ${projectId}`);
+    return next;
+}
+/**
+ * Re-register every Project directory with the runtime on startup so
+ * Projects survive an `interf runtime` restart.
+ */
+export function rehydrateProjects(runtime) {
+    for (const stored of listStoredProjects()) {
+        runtime.registerProject(stored.projectDataDir);
+    }
+}
+/**
+ * Last-modified time of the Project's `interf.json`, ISO 8601. This is the
+ * Projects list recency signal: it advances on create, edit (intent / Build
+ * Plan change), and a successful Build (which writes `latest_context_graph_run_id`
+ * back into the config). Null when the mtime can't be read.
+ */
+function projectConfigUpdatedAt(configPath) {
+    try {
+        return statSync(configPath).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+/** Build the wire shape for `GET /v1/projects/<id>` given a stored Project. */
+export function projectWireShape(stored) {
+    return {
+        id: stored.id,
+        project_id: stored.id,
+        source: stored.source,
+        intent: stored.intent,
+        build_plan_id: stored.buildPlanId,
+        config_path: stored.configPath,
+        updated_at: projectConfigUpdatedAt(stored.configPath),
+        context_graph: { kind: "local-path", value: stored.contextGraphPath },
+        context_graph_path: stored.contextGraphPath,
+    };
+}

package/dist/packages/runtime/requested-artifacts.d.ts

@@ -0,0 +1,7 @@
+import type { RequestedArtifact } from "../build-plans/authoring/brief.js";
+import { type Artifact } from "../contracts/lib/schema.js";
+import type { BuildPlanAuthoringArtifactRequirement } from "../build-plans/authoring/brief.js";
+export declare function requestedArtifactCheckLabel(check: RequestedArtifact["checks"][number]): string;
+export declare function formatRequestedArtifactsForPrompt(artifacts: RequestedArtifact[]): string;
+export declare function artifactRequirementsFromRequestedArtifacts(artifacts: RequestedArtifact[]): BuildPlanAuthoringArtifactRequirement[];
+export declare function requestedArtifactsFromPlanArtifacts(artifacts: readonly Artifact[]): RequestedArtifact[];

package/dist/packages/{engine → runtime}/requested-artifacts.js

@@ -7,7 +7,7 @@ export function formatRequestedArtifactsForPrompt(artifacts) {
         return "";
     return artifacts.map((artifact, index) => {
         const lines = [
-            `${index + 1}. ${artifact.title}`,
+            `${index + 1}. ${artifact.title}${artifact.id ? ` (id: ${artifact.id})` : ""}`,
             artifact.purpose ?? artifact.description ?? null,
             artifact.checks.length > 0
                 ? `Checks:\n${artifact.checks.map((check) => `- ${requestedArtifactCheckLabel(check)}`).join("\n")}`
@@ -34,3 +34,25 @@ export function artifactRequirementsFromRequestedArtifacts(artifacts) {
             }];
     });
 }
+function titleFromArtifactId(value) {
+    return value
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join(" ");
+}
+function labelForArtifactCheck(check) {
+    return check.description ?? titleFromArtifactId(check.id) ?? "Output diagnostic";
+}
+export function requestedArtifactsFromPlanArtifacts(artifacts) {
+    return artifacts.map((artifact) => ({
+        id: artifact.id,
+        title: titleFromArtifactId(artifact.id),
+        description: artifact.description,
+        checks: artifact.checks.map(labelForArtifactCheck),
+        output: {
+            shape: artifact.shape,
+            checks: artifact.checks,
+        },
+    }));
+}

package/dist/packages/{engine → runtime}/run-observability.d.ts

@@ -1,6 +1,7 @@
 import { type ArtifactRef, type BuildRun } from "./execution/lib/schema.js";
-import { type BuildRunResource, type LocalJobRunResource, type RunObservabilityResource, type VerifyRunResource } from "./lib/schema.js";
+import { type BuildRunResource, type LocalJobRunResource, type RunObservabilityResource, type RunStatusResource, type VerifyRunResource } from "./schemas/index.js";
 export declare function uniqueArtifacts(artifacts: ArtifactRef[]): ArtifactRef[];
+export declare function runObservabilityToStatus(run: RunObservabilityResource): RunStatusResource;
 type BuildRunForObservability = BuildRun | BuildRunResource["run"];
 export declare function buildRunToObservability(run: BuildRunForObservability): RunObservabilityResource;
 export declare function verifyRunToObservability(run: VerifyRunResource): RunObservabilityResource;