@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/runtime-build-plans.js

@@ -0,0 +1,175 @@
+import { existsSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { installUserBuildPlan, userBuildPlanExists, } from "../build-plans/package/user-build-plans.js";
+import { asProjectDataDir, projectBuildPlansRoot, userBuildPlansRoot, } from "../contracts/lib/project-paths.js";
+import { buildPlanIdForProjectConfig, DEFAULT_BUILD_PLAN_ID, listProjectConfigs, loadSourceFolderConfig, saveSourceFolderConfig, } from "../projects/source-config.js";
+import { listBuildPlanChoices, } from "../build-plans/package/build-plan-definitions.js";
+import { buildPlanDefinitionPath, resolveBuildPlanPackageSourcePath, } from "../build-plans/package/local-build-plans.js";
+import { seedLocalBuildPlanPackageFromBase, } from "../build-plans/package/interf-build-plan-package.js";
+import { PACKAGE_ROOT } from "../build-plans/package/lib/package-root.js";
+import { buildBuildPlanResource, } from "./runtime-resource-builders.js";
+import { buildPlanLabelFromId, } from "./runtime-proposal-helpers.js";
+function detachBuildPlanFromProject(project, buildPlanId) {
+    if (buildPlanIdForProjectConfig(project) !== buildPlanId)
+        return project;
+    const { build_plan: _removedBuildPlan, ...detachedProject } = project;
+    return detachedProject;
+}
+import { BuildPlanChangeCreateRequestSchema, BuildPlanChangeResultSchema, } from "./schemas/index.js";
+export function listBuildPlans(runtime, projectDataDir) {
+    // The Build Plan choices list is dominated by repeated reads of
+    // build-plan.json + build-plan.schema.json across bundled, user-library, and
+    // Project-local Build Plan package roots. Key the cache off mtimes; if
+    // any of them changes (a new local Build Plan, an edit to the user
+    // library, etc.) the cache misses and we re-resolve.
+    const builtinRoot = join(PACKAGE_ROOT, "public-repo", "build-plans");
+    const localRoot = projectBuildPlansRoot(asProjectDataDir(projectDataDir));
+    const userRoot = userBuildPlansRoot();
+    return runtime.buildPlanListingCache.get(projectDataDir, [builtinRoot, localRoot, userRoot], () => {
+        const projects = listProjectConfigs(loadSourceFolderConfig(projectDataDir));
+        const choices = listBuildPlanChoices(projectDataDir);
+        return choices.map((buildPlan) => {
+            const activeForProjects = projects
+                .filter((project) => buildPlanIdForProjectConfig(project) === buildPlan.id)
+                .map((project) => project.name);
+            // Package file mtime/birthtime give migration-free "last updated"/"created"
+            // signals so clients can sort Build Plans newest-first like Projects.
+            const sourcePath = resolveBuildPlanPackageSourcePath(projectDataDir, buildPlan.id);
+            let createdAt = null;
+            let updatedAt = null;
+            if (sourcePath) {
+                try {
+                    const stat = statSync(sourcePath);
+                    updatedAt = stat.mtime.toISOString();
+                    createdAt = (stat.birthtimeMs > 0 ? stat.birthtime : stat.mtime).toISOString();
+                }
+                catch {
+                    // Package file vanished between listing and stat — leave timestamps null.
+                }
+            }
+            return buildBuildPlanResource({
+                id: buildPlan.id,
+                path: sourcePath ?? buildPlan.id,
+                created_at: createdAt,
+                updated_at: updatedAt,
+                label: buildPlan.label,
+                hint: buildPlan.hint,
+                purpose: buildPlan.purpose,
+                brief: buildPlan.brief,
+                inputs: buildPlan.inputs,
+                source_kind: buildPlan.scope === "builtin" ? "builtin" : "local",
+                built_in: buildPlan.scope === "builtin",
+                scope: buildPlan.scope ?? "local",
+                active_for_projects: activeForProjects,
+                artifacts: buildPlan.contextInterface?.artifacts ?? [],
+                stages: buildPlan.stages.map((stage) => ({
+                    id: stage.id,
+                    label: stage.label,
+                    description: stage.description,
+                    contract_type: stage.contractType,
+                    skill_dir: stage.skillDir,
+                    role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
+                    reads: stage.reads,
+                    writes: stage.writes,
+                })),
+            });
+        });
+    });
+}
+export function getBuildPlanResource(runtime, projectDataDir, buildPlanId) {
+    return listBuildPlans(runtime, projectDataDir).find((buildPlan) => buildPlan.id === buildPlanId) ?? null;
+}
+export function applyBuildPlanChange(runtime, projectDataDir, requestValue) {
+    const request = BuildPlanChangeCreateRequestSchema.parse(requestValue);
+    const buildPlanId = request.build_plan;
+    const outputPath = request.operation === "duplicate"
+        ? buildPlanDefinitionPath(projectDataDir, request.new_build_plan_id)
+        : buildPlanDefinitionPath(projectDataDir, buildPlanId);
+    if (request.operation === "duplicate") {
+        if (resolveBuildPlanPackageSourcePath(projectDataDir, request.new_build_plan_id)) {
+            throw new Error(`Build Plan "${request.new_build_plan_id}" already exists.`);
+        }
+        if (!resolveBuildPlanPackageSourcePath(projectDataDir, buildPlanId)) {
+            throw new Error(`Build Plan "${buildPlanId}" does not exist.`);
+        }
+        const label = request.label ?? buildPlanLabelFromId(request.new_build_plan_id);
+        const hint = request.hint ?? `Duplicate of ${buildPlanId}`;
+        const buildPlanPath = seedLocalBuildPlanPackageFromBase({
+            projectDataDir,
+            baseBuildPlanId: buildPlanId,
+            buildPlanId: request.new_build_plan_id,
+            label,
+            hint,
+        });
+        runtime.buildPlanListingCache.invalidate(projectDataDir);
+        return BuildPlanChangeResultSchema.parse({
+            kind: "interf-build-plan-change-result",
+            version: 1,
+            operation: "duplicate",
+            build_plan: buildPlanId,
+            new_build_plan_id: request.new_build_plan_id,
+            updated_projects: [],
+            build_plan_path: buildPlanPath,
+            changed: true,
+            message: `Duplicated Build Plan ${buildPlanId} as ${request.new_build_plan_id}.`,
+        });
+    }
+    if (request.operation === "save") {
+        const localPath = buildPlanDefinitionPath(projectDataDir, buildPlanId);
+        if (buildPlanId === DEFAULT_BUILD_PLAN_ID || !existsSync(localPath)) {
+            throw new Error(`Build Plan "${buildPlanId}" is not a project Build Plan that can be saved to the library.`);
+        }
+        if (userBuildPlanExists(buildPlanId)) {
+            throw new Error(`Build Plan "${buildPlanId}" is already in your reusable library.`);
+        }
+        const installed = installUserBuildPlan({ sourceDir: dirname(localPath), id: buildPlanId, overwrite: false });
+        // Move (not copy): drop the project-local package so the id lives only in
+        // the user library — same plan, now reusable, still bound to the Project.
+        rmSync(dirname(localPath), { recursive: true, force: true });
+        runtime.buildPlanListingCache.invalidate(projectDataDir);
+        return BuildPlanChangeResultSchema.parse({
+            kind: "interf-build-plan-change-result",
+            version: 1,
+            operation: "save",
+            build_plan: buildPlanId,
+            updated_projects: [],
+            build_plan_path: installed.path,
+            changed: true,
+            message: `Saved Build Plan ${buildPlanId} to your reusable library.`,
+        });
+    }
+    if (request.confirmation !== buildPlanId) {
+        throw new Error(`Type ${buildPlanId} to confirm Build Plan removal.`);
+    }
+    const localBuildPlanPath = buildPlanDefinitionPath(projectDataDir, buildPlanId);
+    if (buildPlanId === DEFAULT_BUILD_PLAN_ID || !existsSync(localBuildPlanPath)) {
+        throw new Error(`Build Plan "${buildPlanId}" is not a removable local Build Plan.`);
+    }
+    const projects = listProjectConfigs(loadSourceFolderConfig(projectDataDir));
+    const updatedProjects = projects
+        .filter((project) => buildPlanIdForProjectConfig(project) === buildPlanId);
+    if (updatedProjects.length > 0) {
+        saveSourceFolderConfig(projectDataDir, {
+            projects: projects.map((project) => detachBuildPlanFromProject(project, buildPlanId)),
+        });
+        // Detaching a Build Plan changes readiness shape for those Projects.
+        for (const project of updatedProjects) {
+            runtime.readinessCache.invalidateProject(projectDataDir, project.name);
+        }
+        runtime.contextGraphResourceCache.invalidateProject(projectDataDir);
+    }
+    rmSync(outputPath, { recursive: true, force: true });
+    runtime.buildPlanListingCache.invalidate(projectDataDir);
+    return BuildPlanChangeResultSchema.parse({
+        kind: "interf-build-plan-change-result",
+        version: 1,
+        operation: "remove",
+        build_plan: buildPlanId,
+        updated_projects: updatedProjects.map((project) => project.name),
+        build_plan_path: outputPath,
+        changed: true,
+        message: updatedProjects.length > 0
+            ? `Removed Build Plan ${buildPlanId} and cleared it from ${updatedProjects.length} Project(s).`
+            : `Removed Build Plan ${buildPlanId}.`,
+    });
+}

package/dist/packages/runtime/runtime-build-runs.d.ts

@@ -0,0 +1,47 @@
+import { type ArtifactRef, type BuildRun, type InterfRunEvent, type EvidenceRecord } from "./execution/lib/schema.js";
+import { type BuildRunResource } from "./schemas/index.js";
+import type { LocalServiceRuntime } from "./runtime.js";
+export declare function listBuildRuns(runtime: LocalServiceRuntime, projectDataDir: string): BuildRunResource[];
+export declare function listBuildRunsForProject(runtime: LocalServiceRuntime, projectDataDir: string, projectName: string): BuildRun[];
+export declare function getBuildRun(runtime: LocalServiceRuntime, projectDataDir: string, runId: string): BuildRunResource | null;
+export declare function getBuildRunEvents(runtime: LocalServiceRuntime, projectDataDir: string, runId: string): InterfRunEvent[] | null;
+export declare function getBuildRunEvidence(runtime: LocalServiceRuntime, projectDataDir: string, runId: string): EvidenceRecord[] | null;
+export declare function getBuildRunArtifacts(runtime: LocalServiceRuntime, projectDataDir: string, runId: string): ArtifactRef[] | null;
+export declare function createBuildRun(runtime: LocalServiceRuntime, projectDataDir: string, requestValue: unknown): Promise<BuildRunResource>;
+/**
+ * Cancel an in-flight Build run. Marks the persisted record as
+ * `cancelled`, emits a `run.cancelled` event to capture the cancellation in
+ * the run timeline, and clears the active handle so retries may start a
+ * fresh run. If the run already finished, returns
+ * `{ cancelled: false, reason: "already finished" }` and persists nothing.
+ */
+export declare function cancelBuildRun(runtime: LocalServiceRuntime, runId: string): {
+    cancelled: boolean;
+    reason?: string;
+};
+/**
+ * Look up the run id previously associated with this idempotency key in
+ * `projectDataDir`. Returns null when the key is unknown or its TTL has
+ * elapsed. The project argument is required so that the same key in
+ * two different projects always returns two different runs.
+ */
+export declare function findIdempotentBuildRun(runtime: LocalServiceRuntime, projectDataDir: string, key: string): string | null;
+/**
+ * Cache the run id created (or returned) for this idempotency key in
+ * `projectDataDir`. Entries expire after `IDEMPOTENCY_TTL_MS`. Pruning
+ * is opportunistic: the previous implementation walked every entry on
+ * every read AND write, which was O(N) per request. Now we only sweep
+ * when the cache grows past {@link IDEMPOTENCY_PRUNE_THRESHOLD}.
+ */
+export declare function recordIdempotentBuildRun(runtime: LocalServiceRuntime, projectDataDir: string, key: string, runId: string): void;
+/**
+ * Test seam: force the cached entry for `key` in `projectDataDir` to be
+ * expired so the next lookup returns null. Returns true when an entry was
+ * found and expired. Tests use this in place of fake timers because the
+ * idempotency TTL is one hour and faking `Date.now()` would destabilize
+ * unrelated runtime state.
+ */
+export declare function expireIdempotencyKeyForTesting(runtime: LocalServiceRuntime, projectDataDir: string, key: string): boolean;
+export declare function readBuildRun(projectDataDir: string, runId: string): BuildRun | null;
+export declare function finalizeInterruptedBuildRuns(runtime: LocalServiceRuntime, projectDataDir: string): void;
+export declare function writeBuildRun(runtime: LocalServiceRuntime, projectDataDir: string, run: BuildRun): void;