spawnfile 0.1.0

package/dist/compiler/addProjectNode.js

@@ -0,0 +1,126 @@
+import path from "node:path";
+import { fileExists, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
+import { isAgentManifest, isTeamManifest, loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { initProject } from "./initProject.js";
+const assertAddableId = (id) => {
+    if (id.trim().length === 0) {
+        throw new SpawnfileError("validation_error", "Child id must not be empty");
+    }
+    if (/\s/.test(id)) {
+        throw new SpawnfileError("validation_error", `Child id must not contain whitespace: ${id}`);
+    }
+    if (/[\\/]/.test(id)) {
+        throw new SpawnfileError("validation_error", `Child id must not contain path separators: ${id}`);
+    }
+};
+const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
+const assertChildDirectoryAvailable = async (childDirectory) => {
+    if (await fileExists(childDirectory)) {
+        throw new SpawnfileError("io_error", `Refusing to overwrite existing child directory at ${childDirectory}`);
+    }
+};
+const assertUniqueRef = (refs, id, label) => {
+    if (refs.some((entry) => entry.id === id)) {
+        throw new SpawnfileError("validation_error", `Duplicate ${label} id: ${id}`);
+    }
+};
+const updateParentManifest = async (manifestPath, manifest) => {
+    await writeUtf8File(manifestPath, renderSpawnfile(manifest));
+};
+const getRuntimeName = (runtime) => typeof runtime === "string" ? runtime : runtime?.name;
+const createTeamMember = (id, relativeRef) => ({
+    id,
+    ref: relativeRef
+});
+export const addAgentProject = async (options) => {
+    assertAddableId(options.id);
+    const manifestPath = resolveTargetManifestPath(options.path);
+    const loadedManifest = await loadManifest(manifestPath);
+    if (!isTeamManifest(loadedManifest.manifest)) {
+        throw new SpawnfileError("validation_error", "spawnfile add agent only works on team projects");
+    }
+    assertUniqueRef(loadedManifest.manifest.members, options.id, "member");
+    const targetDirectory = getProjectRoot(manifestPath);
+    const childDirectory = path.join(targetDirectory, "agents", options.id);
+    await assertChildDirectoryAvailable(childDirectory);
+    const child = await initProject({
+        directory: childDirectory,
+        runtime: options.runtime
+    });
+    await updateParentManifest(manifestPath, {
+        ...loadedManifest.manifest,
+        members: [
+            ...loadedManifest.manifest.members,
+            createTeamMember(options.id, `./agents/${options.id}`)
+        ]
+    });
+    return {
+        createdFiles: child.createdFiles,
+        targetDirectory,
+        updatedFiles: [manifestPath]
+    };
+};
+export const addSubagentProject = async (options) => {
+    assertAddableId(options.id);
+    const manifestPath = resolveTargetManifestPath(options.path);
+    const loadedManifest = await loadManifest(manifestPath);
+    if (!isAgentManifest(loadedManifest.manifest)) {
+        throw new SpawnfileError("validation_error", "spawnfile add subagent only works on agent projects");
+    }
+    assertUniqueRef(loadedManifest.manifest.subagents ?? [], options.id, "subagent");
+    const runtimeName = getRuntimeName(loadedManifest.manifest.runtime);
+    if (!runtimeName) {
+        throw new SpawnfileError("validation_error", "Agent must declare a runtime before adding subagents");
+    }
+    const targetDirectory = getProjectRoot(manifestPath);
+    const childDirectory = path.join(targetDirectory, "subagents", options.id);
+    await assertChildDirectoryAvailable(childDirectory);
+    const child = await initProject({
+        directory: childDirectory,
+        runtime: runtimeName
+    });
+    await updateParentManifest(manifestPath, {
+        ...loadedManifest.manifest,
+        subagents: [
+            ...(loadedManifest.manifest.subagents ?? []),
+            {
+                id: options.id,
+                ref: `./subagents/${options.id}`
+            }
+        ]
+    });
+    return {
+        createdFiles: child.createdFiles,
+        targetDirectory,
+        updatedFiles: [manifestPath]
+    };
+};
+export const addTeamProject = async (options) => {
+    assertAddableId(options.id);
+    const manifestPath = resolveTargetManifestPath(options.path);
+    const loadedManifest = await loadManifest(manifestPath);
+    if (!isTeamManifest(loadedManifest.manifest)) {
+        throw new SpawnfileError("validation_error", "spawnfile add team only works on team projects");
+    }
+    assertUniqueRef(loadedManifest.manifest.members, options.id, "member");
+    const targetDirectory = getProjectRoot(manifestPath);
+    const childDirectory = path.join(targetDirectory, "teams", options.id);
+    await assertChildDirectoryAvailable(childDirectory);
+    const child = await initProject({
+        directory: childDirectory,
+        team: true
+    });
+    await updateParentManifest(manifestPath, {
+        ...loadedManifest.manifest,
+        members: [
+            ...loadedManifest.manifest.members,
+            createTeamMember(options.id, `./teams/${options.id}`)
+        ]
+    });
+    return {
+        createdFiles: child.createdFiles,
+        targetDirectory,
+        updatedFiles: [manifestPath]
+    };
+};

package/dist/compiler/agentSurfaces.d.ts

@@ -0,0 +1,4 @@
+import { SurfacesBlock } from "../manifest/index.js";
+import type { ResolvedAgentSurfaces } from "./types.js";
+export declare const resolveAgentSurfaces: (surfaces: SurfacesBlock | undefined) => ResolvedAgentSurfaces | undefined;
+export declare const listAgentSurfaceSecretNames: (surfaces: ResolvedAgentSurfaces | undefined) => string[];

package/dist/compiler/agentSurfaces.js

@@ -0,0 +1,70 @@
+import { DEFAULT_DISCORD_BOT_TOKEN_SECRET, DEFAULT_SLACK_APP_TOKEN_SECRET, DEFAULT_SLACK_BOT_TOKEN_SECRET, DEFAULT_TELEGRAM_BOT_TOKEN_SECRET } from "../shared/index.js";
+export const resolveAgentSurfaces = (surfaces) => {
+    if (!surfaces) {
+        return undefined;
+    }
+    const resolved = {};
+    if (surfaces.discord) {
+        resolved.discord = {
+            ...(surfaces.discord.access
+                ? {
+                    access: {
+                        channels: [...(surfaces.discord.access.channels ?? [])],
+                        guilds: [...(surfaces.discord.access.guilds ?? [])],
+                        mode: surfaces.discord.access.mode ?? "allowlist",
+                        users: [...(surfaces.discord.access.users ?? [])]
+                    }
+                }
+                : {}),
+            botTokenSecret: surfaces.discord.bot_token_secret ?? DEFAULT_DISCORD_BOT_TOKEN_SECRET
+        };
+    }
+    if (surfaces.telegram) {
+        resolved.telegram = {
+            ...(surfaces.telegram.access
+                ? {
+                    access: {
+                        chats: [...(surfaces.telegram.access.chats ?? [])],
+                        mode: surfaces.telegram.access.mode ?? "allowlist",
+                        users: [...(surfaces.telegram.access.users ?? [])]
+                    }
+                }
+                : {}),
+            botTokenSecret: surfaces.telegram.bot_token_secret ?? DEFAULT_TELEGRAM_BOT_TOKEN_SECRET
+        };
+    }
+    if (surfaces.whatsapp) {
+        resolved.whatsapp = surfaces.whatsapp.access
+            ? {
+                access: {
+                    groups: [...(surfaces.whatsapp.access.groups ?? [])],
+                    mode: surfaces.whatsapp.access.mode ?? "allowlist",
+                    users: [...(surfaces.whatsapp.access.users ?? [])]
+                }
+            }
+            : {};
+    }
+    if (surfaces.slack) {
+        resolved.slack = {
+            ...(surfaces.slack.access
+                ? {
+                    access: {
+                        channels: [...(surfaces.slack.access.channels ?? [])],
+                        mode: surfaces.slack.access.mode ?? "allowlist",
+                        users: [...(surfaces.slack.access.users ?? [])]
+                    }
+                }
+                : {}),
+            appTokenSecret: surfaces.slack.app_token_secret ?? DEFAULT_SLACK_APP_TOKEN_SECRET,
+            botTokenSecret: surfaces.slack.bot_token_secret ?? DEFAULT_SLACK_BOT_TOKEN_SECRET
+        };
+    }
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+};
+export const listAgentSurfaceSecretNames = (surfaces) => [
+    ...(surfaces?.discord ? [surfaces.discord.botTokenSecret] : []),
+    ...(surfaces?.slack
+        ? [surfaces.slack.appTokenSecret, surfaces.slack.botTokenSecret]
+        : []),
+    ...(surfaces?.telegram ? [surfaces.telegram.botTokenSecret] : [])
+].sort();

package/dist/compiler/buildCompilePlan.d.ts

@@ -0,0 +1,2 @@
+import { CompilePlan } from "./types.js";
+export declare const buildCompilePlan: (inputPath: string) => Promise<CompilePlan>;

package/dist/compiler/buildCompilePlan.js

@@ -0,0 +1,258 @@
+import { getCanonicalManifestPath, getManifestPath, resolveProjectPath } from "../filesystem/index.js";
+import { isAgentManifest, isTeamManifest, loadManifest, mergeExecution, normalizeRuntimeBinding } from "../manifest/index.js";
+import { assertRuntimeCanCompile } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { getAgentFingerprint, getMcpNames, getTeamFingerprint, validateEffectiveSkillRequirements } from "./compilePlanHelpers.js";
+import { resolveAgentSurfaces } from "./agentSurfaces.js";
+import { assignStableNodeIds } from "./helpers.js";
+import { loadResolvedDocuments, mergeResolvedSkills, loadResolvedSkills, mergeSharedSurface } from "./surfaces.js";
+import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
+import { assertRuntimeSupportsAgentSurfaces } from "./surfaceSupport.js";
+import { applyExecutionDefaults } from "./executionDefaults.js";
+const resolveRuntime = async (manifest, context) => {
+    const localRuntime = normalizeRuntimeBinding(manifest.runtime);
+    if (context.isSubagent) {
+        if (!context.inheritedRuntime) {
+            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} is missing inherited runtime context`);
+        }
+        if (localRuntime &&
+            localRuntime.name !== context.inheritedRuntime.name) {
+            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} must match parent runtime`);
+        }
+        return context.inheritedRuntime;
+    }
+    if (!localRuntime) {
+        throw new SpawnfileError("runtime_error", `Agent ${manifest.name} does not declare a runtime`);
+    }
+    await assertRuntimeCanCompile(localRuntime.name);
+    return localRuntime;
+};
+export const buildCompilePlan = async (inputPath) => {
+    const rootManifestPath = getCanonicalManifestPath(getManifestPath(inputPath));
+    const loadCache = new Map();
+    const nodeCache = new Map();
+    const fingerprintCache = new Map();
+    const edges = [];
+    const visitStack = [];
+    const getLoadedManifest = (manifestPath) => {
+        const canonicalPath = getCanonicalManifestPath(manifestPath);
+        const cached = loadCache.get(canonicalPath);
+        if (cached) {
+            return cached;
+        }
+        const promise = loadManifest(canonicalPath);
+        loadCache.set(canonicalPath, promise);
+        return promise;
+    };
+    const visitAgent = async (manifestPath, context) => {
+        const canonicalPath = getCanonicalManifestPath(manifestPath);
+        if (visitStack.includes(canonicalPath)) {
+            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${canonicalPath}`);
+        }
+        const loadedManifest = await getLoadedManifest(canonicalPath);
+        if (!isAgentManifest(loadedManifest.manifest)) {
+            throw new SpawnfileError("compile_error", `Expected agent manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
+        }
+        const runtime = await resolveRuntime(loadedManifest.manifest, context);
+        const execution = applyExecutionDefaults(context.isSubagent
+            ? mergeExecution(context.inheritedExecution, loadedManifest.manifest.execution)
+            : loadedManifest.manifest.execution);
+        assertRuntimeSupportsExecutionModelAuth(runtime.name, execution, loadedManifest.manifest.name);
+        const sharedSurface = mergeSharedSurface(context.inheritedShared?.surface, {
+            env: loadedManifest.manifest.env,
+            mcpServers: loadedManifest.manifest.mcp_servers,
+            secrets: loadedManifest.manifest.secrets,
+            skills: loadedManifest.manifest.skills
+        });
+        const inheritedSkills = context.inheritedShared
+            ? await loadResolvedSkills(context.inheritedShared.manifestPath, context.inheritedShared.surface?.skills)
+            : [];
+        const localSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.skills);
+        const skills = mergeResolvedSkills(inheritedSkills, localSkills);
+        validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(sharedSurface.mcpServers), skills);
+        const candidate = {
+            docs: await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs),
+            env: sharedSurface.env,
+            execution,
+            kind: "agent",
+            mcpServers: sharedSurface.mcpServers,
+            name: loadedManifest.manifest.name,
+            policyMode: loadedManifest.manifest.policy?.mode ?? null,
+            policyOnDegrade: loadedManifest.manifest.policy?.on_degrade ?? null,
+            runtime,
+            secrets: sharedSurface.secrets,
+            skills,
+            source: canonicalPath,
+            surfaces: resolveAgentSurfaces(loadedManifest.manifest.surfaces),
+            subagents: []
+        };
+        assertRuntimeSupportsAgentSurfaces(runtime.name, candidate.surfaces, loadedManifest.manifest.name);
+        const fingerprint = getAgentFingerprint(candidate);
+        const existingFingerprint = fingerprintCache.get(canonicalPath);
+        if (existingFingerprint && existingFingerprint !== fingerprint) {
+            throw new SpawnfileError("compile_error", `Manifest ${canonicalPath} resolves differently across compile contexts`);
+        }
+        const cachedNode = nodeCache.get(canonicalPath);
+        if (cachedNode) {
+            return cachedNode.value;
+        }
+        fingerprintCache.set(canonicalPath, fingerprint);
+        nodeCache.set(canonicalPath, {
+            runtimeName: runtime.name,
+            source: canonicalPath,
+            value: candidate
+        });
+        visitStack.push(canonicalPath);
+        for (const subagent of loadedManifest.manifest.subagents ?? []) {
+            const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, subagent.ref));
+            const resolvedSubagent = await visitAgent(childManifestPath, {
+                inheritedExecution: execution,
+                inheritedRuntime: runtime,
+                isSubagent: true
+            });
+            candidate.subagents.push({
+                id: subagent.id,
+                nodeSource: resolvedSubagent.source
+            });
+            edges.push({
+                from: canonicalPath,
+                kind: "subagent",
+                label: subagent.id,
+                to: resolvedSubagent.source
+            });
+        }
+        visitStack.pop();
+        return candidate;
+    };
+    const visitTeam = async (manifestPath) => {
+        const canonicalPath = getCanonicalManifestPath(manifestPath);
+        if (visitStack.includes(canonicalPath)) {
+            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${canonicalPath}`);
+        }
+        const loadedManifest = await getLoadedManifest(canonicalPath);
+        if (!isTeamManifest(loadedManifest.manifest)) {
+            throw new SpawnfileError("compile_error", `Expected team manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
+        }
+        const sharedSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.shared?.skills);
+        validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(loadedManifest.manifest.shared?.mcp_servers ?? []), sharedSkills);
+        const structure = loadedManifest.manifest.structure;
+        const memberIds = loadedManifest.manifest.members.map((member) => member.id);
+        const resolvedExternal = structure.external
+            ?? (structure.mode === "hierarchical" && structure.leader
+                ? [structure.leader]
+                : memberIds);
+        const candidate = {
+            docs: await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs),
+            kind: "team",
+            members: [],
+            name: loadedManifest.manifest.name,
+            policyMode: loadedManifest.manifest.policy?.mode ?? null,
+            policyOnDegrade: loadedManifest.manifest.policy?.on_degrade ?? null,
+            shared: {
+                env: loadedManifest.manifest.shared?.env ?? {},
+                mcpServers: loadedManifest.manifest.shared?.mcp_servers ?? [],
+                secrets: loadedManifest.manifest.shared?.secrets ?? [],
+                skills: sharedSkills
+            },
+            source: canonicalPath,
+            structure: {
+                external: resolvedExternal,
+                leader: structure.leader ?? null,
+                mode: structure.mode
+            }
+        };
+        const fingerprint = getTeamFingerprint(candidate);
+        const existingFingerprint = fingerprintCache.get(canonicalPath);
+        if (existingFingerprint && existingFingerprint !== fingerprint) {
+            throw new SpawnfileError("compile_error", `Team manifest ${canonicalPath} resolves differently across compile contexts`);
+        }
+        const cachedNode = nodeCache.get(canonicalPath);
+        if (cachedNode) {
+            return cachedNode.value;
+        }
+        fingerprintCache.set(canonicalPath, fingerprint);
+        nodeCache.set(canonicalPath, {
+            runtimeName: null,
+            source: canonicalPath,
+            value: candidate
+        });
+        visitStack.push(canonicalPath);
+        for (const member of loadedManifest.manifest.members) {
+            const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, member.ref));
+            const childManifest = await getLoadedManifest(childManifestPath);
+            let resolvedMember;
+            if (isAgentManifest(childManifest.manifest)) {
+                const resolvedAgent = await visitAgent(childManifestPath, {
+                    inheritedShared: {
+                        manifestPath: canonicalPath,
+                        surface: loadedManifest.manifest.shared
+                    },
+                    isSubagent: false
+                });
+                resolvedMember = {
+                    id: member.id,
+                    kind: "agent",
+                    nodeSource: resolvedAgent.source,
+                    runtimeName: resolvedAgent.runtime.name
+                };
+            }
+            else {
+                const resolvedTeam = await visitTeam(childManifestPath);
+                resolvedMember = {
+                    id: member.id,
+                    kind: "team",
+                    nodeSource: resolvedTeam.source,
+                    runtimeName: null
+                };
+            }
+            candidate.members.push(resolvedMember);
+            edges.push({
+                from: canonicalPath,
+                kind: "team_member",
+                label: member.id,
+                to: resolvedMember.nodeSource
+            });
+        }
+        visitStack.pop();
+        return candidate;
+    };
+    const rootLoadedManifest = await getLoadedManifest(rootManifestPath);
+    if (isAgentManifest(rootLoadedManifest.manifest)) {
+        await visitAgent(rootManifestPath, { isSubagent: false });
+    }
+    else {
+        await visitTeam(rootManifestPath);
+    }
+    const nodes = assignStableNodeIds([...nodeCache.values()]
+        .sort((left, right) => left.source.localeCompare(right.source))
+        .map((node) => ({
+        id: "",
+        kind: node.value.kind,
+        runtimeName: node.runtimeName,
+        slug: "",
+        source: node.source,
+        value: node.value
+    })));
+    const idBySource = new Map(nodes.map((node) => [node.value.source, node.id]));
+    const compilePlanNodes = nodes;
+    const compilePlanEdges = edges.map((edge) => ({
+        ...edge,
+        from: idBySource.get(edge.from) ?? edge.from,
+        to: idBySource.get(edge.to) ?? edge.to
+    }));
+    const runtimes = compilePlanNodes.reduce((groups, node) => {
+        if (!node.runtimeName) {
+            return groups;
+        }
+        const group = groups[node.runtimeName] ?? { nodeIds: [] };
+        group.nodeIds.push(node.id);
+        groups[node.runtimeName] = group;
+        return groups;
+    }, {});
+    return {
+        edges: compilePlanEdges,
+        nodes: compilePlanNodes,
+        root: rootManifestPath,
+        runtimes
+    };
+};

package/dist/compiler/buildProject.d.ts

@@ -0,0 +1,20 @@
+import { type CompileProjectOptions, type CompileProjectResult } from "./compileProject.js";
+export interface DockerBuildInvocation {
+    args: string[];
+    command: string;
+    cwd: string;
+    imageTag: string;
+}
+export type DockerBuildRunner = (invocation: DockerBuildInvocation) => Promise<void>;
+export interface BuildProjectOptions extends CompileProjectOptions {
+    buildRunner?: DockerBuildRunner;
+    dockerCommand?: string;
+    imageTag?: string;
+}
+export interface BuildProjectResult extends CompileProjectResult {
+    imageTag: string;
+}
+export declare const createDefaultImageTag: (projectRoot: string) => string;
+export declare const createDockerBuildInvocation: (outputDirectory: string, imageTag: string, dockerCommand?: string) => DockerBuildInvocation;
+export declare const runDockerBuild: DockerBuildRunner;
+export declare const buildProject: (inputPath: string, options?: BuildProjectOptions) => Promise<BuildProjectResult>;

package/dist/compiler/buildProject.js

@@ -0,0 +1,52 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { SpawnfileError } from "../shared/index.js";
+import { compileProject } from "./compileProject.js";
+import { slugify } from "./helpers.js";
+export const createDefaultImageTag = (projectRoot) => {
+    const baseName = slugify(path.basename(projectRoot));
+    return `spawnfile-${baseName || "project"}`;
+};
+const resolveImageTagRoot = (inputPath) => {
+    const resolvedPath = path.resolve(inputPath);
+    return path.basename(resolvedPath).toLowerCase() === "spawnfile"
+        ? path.dirname(resolvedPath)
+        : resolvedPath;
+};
+export const createDockerBuildInvocation = (outputDirectory, imageTag, dockerCommand = "docker") => ({
+    args: ["build", "-t", imageTag, "."],
+    command: dockerCommand,
+    cwd: outputDirectory,
+    imageTag
+});
+export const runDockerBuild = async (invocation) => new Promise((resolve, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+        cwd: invocation.cwd,
+        stdio: "inherit"
+    });
+    child.once("error", (error) => {
+        reject(new SpawnfileError("compile_error", `Unable to start docker build for ${invocation.imageTag}: ${error.message}`));
+    });
+    child.once("exit", (code, signal) => {
+        if (code === 0) {
+            resolve();
+            return;
+        }
+        reject(new SpawnfileError("compile_error", signal
+            ? `Docker build for ${invocation.imageTag} exited from signal ${signal}`
+            : `Docker build for ${invocation.imageTag} failed with exit code ${code ?? "unknown"}`));
+    });
+});
+export const buildProject = async (inputPath, options = {}) => {
+    const compileResult = await compileProject(inputPath, {
+        clean: options.clean,
+        outputDirectory: options.outputDirectory
+    });
+    const imageTag = options.imageTag ?? createDefaultImageTag(resolveImageTagRoot(inputPath));
+    const invocation = createDockerBuildInvocation(compileResult.outputDirectory, imageTag, options.dockerCommand);
+    await (options.buildRunner ?? runDockerBuild)(invocation);
+    return {
+        ...compileResult,
+        imageTag
+    };
+};

package/dist/compiler/compilePlanHelpers.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedAgentNode, ResolvedSkill, ResolvedTeamNode } from "./types.js";
+export declare const getMcpNames: (servers: Array<{
+    name: string;
+}>) => Set<string>;
+export declare const validateEffectiveSkillRequirements: (nodeName: string, mcpNames: Set<string>, skills: ResolvedSkill[]) => void;
+export declare const getAgentFingerprint: (node: ResolvedAgentNode) => string;
+export declare const getTeamFingerprint: (node: ResolvedTeamNode) => string;

package/dist/compiler/compilePlanHelpers.js

@@ -0,0 +1,39 @@
+import { SpawnfileError } from "../shared/index.js";
+import { stableStringify } from "./helpers.js";
+export const getMcpNames = (servers) => new Set(servers.map((server) => server.name));
+export const validateEffectiveSkillRequirements = (nodeName, mcpNames, skills) => {
+    for (const skill of skills) {
+        for (const mcpName of skill.requiresMcp) {
+            if (!mcpNames.has(mcpName)) {
+                throw new SpawnfileError("validation_error", `Skill ${skill.name} on ${nodeName} requires undeclared MCP server: ${mcpName}`);
+            }
+        }
+    }
+};
+export const getAgentFingerprint = (node) => stableStringify({
+    env: node.env,
+    execution: node.execution,
+    mcpServers: node.mcpServers,
+    runtime: node.runtime,
+    secrets: node.secrets,
+    skills: node.skills.map((skill) => ({
+        name: skill.name,
+        ref: skill.ref,
+        requiresMcp: skill.requiresMcp
+    })),
+    surfaces: node.surfaces
+});
+export const getTeamFingerprint = (node) => stableStringify({
+    members: node.members,
+    structure: node.structure,
+    shared: {
+        env: node.shared.env,
+        mcpServers: node.shared.mcpServers,
+        secrets: node.shared.secrets,
+        skills: node.shared.skills.map((skill) => ({
+            name: skill.name,
+            ref: skill.ref,
+            requiresMcp: skill.requiresMcp
+        }))
+    }
+});

package/dist/compiler/compileProject.d.ts

@@ -0,0 +1,11 @@
+import { CompileReport } from "../report/index.js";
+export interface CompileProjectOptions {
+    clean?: boolean;
+    outputDirectory?: string;
+}
+export interface CompileProjectResult {
+    outputDirectory: string;
+    report: CompileReport;
+    reportPath: string;
+}
+export declare const compileProject: (inputPath: string, options?: CompileProjectOptions) => Promise<CompileProjectResult>;