@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/agents/lib/shell-projection.js

@@ -0,0 +1,314 @@
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, join, sep } from "node:path";
+import { buildPlanPackagePathForContextGraph, contextGraphRuntimeRoot, } from "../../build/context-graph-paths.js";
+import { ensureBuildPlanArtifactTargets } from "../../build/context-graph-schema.js";
+import { listFilesRecursive } from "../../../contracts/utils/filesystem.js";
+import { CONTEXT_INTERFACE_FILE as BUILD_PLAN_SCHEMA_FILE, contextInterfaceArtifactAbsolutePath as contextGraphArtifactAbsolutePath, listContextInterfaceArtifacts, readContextInterface as readBuildPlanContextFile, resolveContextInterfacePath as resolveBuildPlanSchemaPath, } from "../../../build-plans/package/context-interface.js";
+import { copyResolvedTree, linkPath, linkRelativePath, } from "./shell-fs.js";
+import { describeShellArtifactAliasMountPath, normalizeArtifactRelativePath, relativePathEqualsOrWithin, shellArtifactAliasMountPath, shellRuntimePath, stageShellBuildPlanRoot, } from "./shell-paths.js";
+export function loadContextGraphSchema(contextGraphPath) {
+    const buildPlanRoot = buildPlanPackagePathForContextGraph(contextGraphPath);
+    const schema = readBuildPlanContextFile(buildPlanRoot);
+    if (!schema) {
+        throw new Error(`Missing Build Plan schema at ${join(buildPlanRoot, BUILD_PLAN_SCHEMA_FILE)}`);
+    }
+    return schema;
+}
+export function artifactMap(schema) {
+    return new Map(listContextInterfaceArtifacts(schema).map((artifact) => [artifact.id, artifact]));
+}
+export function artifactOrThrow(artifacts, artifactId) {
+    const artifact = artifacts.get(artifactId);
+    if (!artifact) {
+        throw new Error(`Missing Build Plan schema Artifact "${artifactId}" for stage shell projection.`);
+    }
+    return artifact;
+}
+export function stageWriteArtifactSet(schema, stage) {
+    const artifacts = listContextInterfaceArtifacts(schema);
+    return new Set(stage.writes.filter((artifactId) => artifacts.some((artifact) => artifact.id === artifactId)));
+}
+export function stageMaterializedArtifactSet(schema, stage, writeArtifacts = []) {
+    const materialized = stageWriteArtifactSet(schema, stage);
+    for (const artifact of listContextInterfaceArtifacts(schema)) {
+        if (stage.reads.includes(artifact.id)) {
+            materialized.add(artifact.id);
+        }
+    }
+    for (const artifactPath of writeArtifacts) {
+        const normalizedArtifactPath = normalizeArtifactRelativePath(artifactPath);
+        if (normalizedArtifactPath.length === 0)
+            continue;
+        const owner = listContextInterfaceArtifacts(schema).find((artifact) => relativePathEqualsOrWithin(artifact.path, normalizedArtifactPath));
+        if (owner) {
+            materialized.add(owner.id);
+        }
+    }
+    return materialized;
+}
+function ensureShellLocalProjection(sourcePath, targetPath, artifact) {
+    if (existsSync(sourcePath)) {
+        copyResolvedTree({
+            sourcePath,
+            targetPath,
+            shellType: "stage-execution",
+        });
+        return;
+    }
+    if (artifact.kind === "file") {
+        mkdirSync(dirname(targetPath), { recursive: true });
+        return;
+    }
+    mkdirSync(targetPath, { recursive: true });
+}
+export function ensureBuildExecutionSurface(contextGraphPath) {
+    mkdirSync(contextGraphRuntimeRoot(contextGraphPath), { recursive: true });
+    mkdirSync(buildPlanPackagePathForContextGraph(contextGraphPath), { recursive: true });
+    const schema = loadContextGraphSchema(contextGraphPath);
+    ensureBuildPlanArtifactTargets(contextGraphPath, schema);
+    return schema;
+}
+export function readStageBuildPlanDoc(contextGraphPath, stage) {
+    const buildPlanRoot = buildPlanPackagePathForContextGraph(contextGraphPath);
+    const path = join(buildPlanRoot, "build", "stages", stage.skillDir, "SKILL.md");
+    if (!isRegularBuildPlanFile(buildPlanRoot, path))
+        return null;
+    return readFileSync(path, "utf8").trim();
+}
+export function stageBuildPlanDocsPath(contextGraphPath, stage) {
+    return join(buildPlanPackagePathForContextGraph(contextGraphPath), "build", "stages", stage.skillDir);
+}
+function isInsideRealRoot(realRoot, path) {
+    try {
+        const realPath = realpathSync(path);
+        return realPath === realRoot || realPath.startsWith(`${realRoot}${sep}`);
+    }
+    catch {
+        return false;
+    }
+}
+function isRegularBuildPlanFile(buildPlanRoot, path) {
+    if (!existsSync(path))
+        return false;
+    try {
+        return lstatSync(path).isFile() && isInsideRealRoot(realpathSync(buildPlanRoot), path);
+    }
+    catch {
+        return false;
+    }
+}
+function copyBuildPlanPath(buildPlanRoot, sourcePath, targetPath) {
+    if (!existsSync(sourcePath))
+        return;
+    const realRoot = realpathSync(buildPlanRoot);
+    if (!isInsideRealRoot(realRoot, sourcePath))
+        return;
+    const stat = lstatSync(sourcePath);
+    if (stat.isSymbolicLink())
+        return;
+    if (stat.isDirectory()) {
+        mkdirSync(targetPath, { recursive: true });
+        for (const entry of readdirSync(sourcePath)) {
+            copyBuildPlanPath(buildPlanRoot, join(sourcePath, entry), join(targetPath, entry));
+        }
+        return;
+    }
+    if (!stat.isFile())
+        return;
+    mkdirSync(dirname(targetPath), { recursive: true });
+    copyFileSync(sourcePath, targetPath);
+}
+export function projectBuildPlanMetadata(contextGraphPath, shellRoot, stage) {
+    const shellBuildPlanRoot = stageShellBuildPlanRoot(shellRoot);
+    mkdirSync(join(shellBuildPlanRoot, "build", "stages"), { recursive: true });
+    const contextGraphBuildPlanRoot = buildPlanPackagePathForContextGraph(contextGraphPath);
+    const buildPlanJsonPath = join(contextGraphBuildPlanRoot, "build-plan.json");
+    copyBuildPlanPath(contextGraphBuildPlanRoot, buildPlanJsonPath, join(shellBuildPlanRoot, "build-plan.json"));
+    const buildPlanSchemaPath = resolveBuildPlanSchemaPath(contextGraphBuildPlanRoot);
+    if (buildPlanSchemaPath) {
+        copyBuildPlanPath(contextGraphBuildPlanRoot, buildPlanSchemaPath, join(shellBuildPlanRoot, BUILD_PLAN_SCHEMA_FILE));
+    }
+    const readmePath = join(contextGraphBuildPlanRoot, "README.md");
+    copyBuildPlanPath(contextGraphBuildPlanRoot, readmePath, join(shellBuildPlanRoot, "README.md"));
+    const stageDocsPath = stageBuildPlanDocsPath(contextGraphPath, stage);
+    copyBuildPlanPath(contextGraphBuildPlanRoot, stageDocsPath, join(shellBuildPlanRoot, "build", "stages", stage.skillDir));
+}
+export function projectContextGraphSchemaArtifacts(contextGraphPath, shellRoot, schema, artifactIds, materializedArtifactIds, cleanMaterializedArtifactIds) {
+    const allowedArtifactIds = artifactIds ? new Set(artifactIds) : null;
+    for (const artifact of listContextInterfaceArtifacts(schema)) {
+        if (allowedArtifactIds && !allowedArtifactIds.has(artifact.id))
+            continue;
+        const sourcePath = contextGraphArtifactAbsolutePath(contextGraphPath, artifact);
+        const targetPath = join(shellRoot, artifact.path);
+        if (cleanMaterializedArtifactIds?.has(artifact.id)) {
+            rmSync(targetPath, { recursive: true, force: true });
+            if (artifact.kind === "file") {
+                mkdirSync(dirname(targetPath), { recursive: true });
+            }
+            else {
+                mkdirSync(targetPath, { recursive: true });
+            }
+            continue;
+        }
+        if (materializedArtifactIds?.has(artifact.id)) {
+            ensureShellLocalProjection(sourcePath, targetPath, artifact);
+            continue;
+        }
+        linkPath(sourcePath, targetPath);
+    }
+}
+export function buildStageArtifactMounts(_contextGraphPath, _shellRoot, stage, schema) {
+    const artifacts = artifactMap(schema);
+    const mountFor = (artifactId) => {
+        const artifact = artifactOrThrow(artifacts, artifactId);
+        return {
+            artifact_id: artifact.id,
+            artifact_path: artifact.path,
+            shell_root_path: artifact.path,
+            input_mount_path: stage.reads.includes(artifactId)
+                ? describeShellArtifactAliasMountPath(artifact, "inputs")
+                : null,
+            output_mount_path: stage.writes.includes(artifactId)
+                ? describeShellArtifactAliasMountPath(artifact, "outputs")
+                : null,
+        };
+    };
+    return {
+        reads: stage.reads.map(mountFor),
+        writes: stage.writes.map(mountFor),
+    };
+}
+export function projectStageArtifactMountAliases(shellRoot, stage, schema) {
+    const artifacts = artifactMap(schema);
+    for (const artifactId of new Set([...stage.reads, ...stage.writes])) {
+        const artifact = artifactOrThrow(artifacts, artifactId);
+        const targetPath = join(shellRoot, artifact.path);
+        if (stage.reads.includes(artifactId)) {
+            linkRelativePath(targetPath, shellArtifactAliasMountPath(shellRoot, artifact, "inputs"));
+        }
+        if (stage.writes.includes(artifactId)) {
+            linkRelativePath(targetPath, shellArtifactAliasMountPath(shellRoot, artifact, "outputs"));
+        }
+    }
+}
+export function writeExecutionShellPathsFile(shellRoot, buildPlanId, stage, mounts) {
+    const paths = {
+        kind: "interf-execution-shell",
+        version: 1,
+        build_plan: buildPlanId,
+        stage: stage.id,
+        reads: mounts.reads,
+        writes: mounts.writes,
+    };
+    writeFileSync(shellRuntimePath(shellRoot, "paths.json"), `${JSON.stringify(paths, null, 2)}\n`);
+}
+export function syncStageExecutionShellWrites(contextGraphPath, shellRoot, stage, writeArtifacts = []) {
+    const schema = ensureBuildExecutionSurface(contextGraphPath);
+    const artifacts = artifactMap(schema);
+    const stageWriteArtifacts = Array.from(stageWriteArtifactSet(schema, stage))
+        .map((artifactId) => artifactOrThrow(artifacts, artifactId));
+    for (const artifact of stageWriteArtifacts) {
+        const canonicalShellArtifactPath = join(shellRoot, artifact.path);
+        const outputAliasPath = shellArtifactAliasMountPath(shellRoot, artifact, "outputs");
+        const shellArtifactPath = artifact.kind === "file" &&
+            existsSync(outputAliasPath) &&
+            !lstatSync(outputAliasPath).isSymbolicLink()
+            ? outputAliasPath
+            : canonicalShellArtifactPath;
+        if (!existsSync(shellArtifactPath))
+            continue;
+        const shellArtifactStat = lstatSync(shellArtifactPath);
+        if (shellArtifactStat.isSymbolicLink())
+            continue;
+        const contextGraphArtifactPath = contextGraphArtifactAbsolutePath(contextGraphPath, artifact);
+        if (shellArtifactStat.isDirectory()) {
+            const shellArtifactFiles = listFilesRecursive(shellArtifactPath);
+            const contextGraphArtifactFiles = existsSync(contextGraphArtifactPath)
+                ? listFilesRecursive(contextGraphArtifactPath)
+                : [];
+            if (shellArtifactFiles.length === 0 && contextGraphArtifactFiles.length > 0) {
+                continue;
+            }
+            rmSync(contextGraphArtifactPath, { recursive: true, force: true });
+            mkdirSync(dirname(contextGraphArtifactPath), { recursive: true });
+            cpSync(shellArtifactPath, contextGraphArtifactPath, {
+                recursive: true,
+                force: true,
+            });
+            continue;
+        }
+        mkdirSync(dirname(contextGraphArtifactPath), { recursive: true });
+        copyFileSync(shellArtifactPath, contextGraphArtifactPath);
+    }
+    for (const artifactPath of writeArtifacts) {
+        const normalizedArtifactPath = normalizeArtifactRelativePath(artifactPath);
+        if (normalizedArtifactPath.length === 0 ||
+            stageWriteArtifacts.some((artifact) => relativePathEqualsOrWithin(artifact.path, normalizedArtifactPath))) {
+            continue;
+        }
+        const shellArtifactPath = join(shellRoot, normalizedArtifactPath);
+        if (!existsSync(shellArtifactPath))
+            continue;
+        const contextGraphArtifactPath = join(contextGraphPath, normalizedArtifactPath);
+        const shellArtifactStat = lstatSync(shellArtifactPath);
+        if (shellArtifactStat.isSymbolicLink())
+            continue;
+        if (shellArtifactStat.isDirectory()) {
+            rmSync(contextGraphArtifactPath, { recursive: true, force: true });
+            mkdirSync(dirname(contextGraphArtifactPath), { recursive: true });
+            cpSync(shellArtifactPath, contextGraphArtifactPath, {
+                recursive: true,
+                force: true,
+            });
+            continue;
+        }
+        mkdirSync(dirname(contextGraphArtifactPath), { recursive: true });
+        copyFileSync(shellArtifactPath, contextGraphArtifactPath);
+    }
+}
+export function projectContextGraphReviewArtifactsState(contextGraphPath, shellRoot, schema) {
+    const contextGraphViewRoot = join(shellRoot, "artifacts", "context-graph-view");
+    mkdirSync(contextGraphViewRoot, { recursive: true });
+    for (const artifact of listContextInterfaceArtifacts(schema)) {
+        if (artifact.path === "source-files")
+            continue;
+        const sourcePath = contextGraphArtifactAbsolutePath(contextGraphPath, artifact);
+        if (!existsSync(sourcePath))
+            continue;
+        copyResolvedTree({
+            sourcePath,
+            targetPath: join(contextGraphViewRoot, artifact.path),
+            shellType: "build-plan-improvement",
+        });
+    }
+}
+export function projectContextGraphRuntimeArtifacts(contextGraphPath, shellRoot) {
+    const runtimeTarget = join(shellRoot, "artifacts", "context-graph-runtime");
+    mkdirSync(runtimeTarget, { recursive: true });
+    const runtimeRoot = contextGraphRuntimeRoot(contextGraphPath);
+    const artifactNames = [
+        "run.json",
+        "run-history.jsonl",
+        "state.json",
+        "health.json",
+        "view-spec.json",
+        "source-manifest.json",
+        "source-manifest.audit.json",
+        "source-files.json",
+        "source-state.json",
+        "stages",
+        "logs",
+    ];
+    for (const artifactName of artifactNames) {
+        copyIfExistsLocal(join(runtimeRoot, artifactName), join(runtimeTarget, artifactName));
+    }
+}
+function copyIfExistsLocal(sourcePath, targetPath) {
+    if (!existsSync(sourcePath))
+        return;
+    copyResolvedTree({
+        sourcePath,
+        targetPath,
+        shellType: "build-plan-improvement",
+    });
+}

package/dist/packages/runtime/agents/lib/shell-templates.d.ts

@@ -0,0 +1,30 @@
+export interface NativeStageDefinition {
+    id: string;
+    label: string;
+    description: string;
+    contractType: import("../../../contracts/lib/schema.js").RuntimeContractType;
+    skillDir: string;
+    reads: import("../../../build-plans/package/context-interface.js").ContextInterfaceArtifactId[];
+    writes: import("../../../build-plans/package/context-interface.js").ContextInterfaceArtifactId[];
+}
+export declare function renderContextGraphAgents(contextGraphPath: string, name: string, buildPlanId: string, options?: {
+    buildPlanOriginSelected?: string | null;
+    buildPlanLocalDraft?: boolean;
+}): string;
+export declare function renderContextGraphQuerySkill(): string;
+export declare function renderSourceFilesTestAgents(): string;
+export declare function renderSourceFilesTestQuerySkill(): string;
+export declare function readContextGraphQuerySkillSource(contextGraphPath: string): string;
+export declare function renderStageExecutionAgents(contextGraphName: string, buildPlanId: string, stage: NativeStageDefinition): string;
+export declare function renderStageExecutionSkill(stage: NativeStageDefinition, stageBuildPlanDoc: string | null): string;
+export declare function renderContextGraphQueryNativeSkill(querySkillContent: string): string;
+export declare function renderClaudeBootstrap(content: string): string;
+export declare function renderBuildPlanAuthoringAgents(options: {
+    buildPlanId: string;
+    label: string;
+    referenceBuildPlanId?: string | null;
+}): string;
+export declare function renderBuildPlanAuthoringSkill(): string;
+export declare function renderBuildPlanImprovementAgents(contextGraphName: string, buildPlanId: string, loopIndex: number): string;
+export declare function readBuildPlanImprovementDoc(contextGraphPath: string): string | null;
+export declare function renderBuildPlanImprovementSkill(buildPlanId: string, loopIndex: number, improvementDoc: string | null): string;