spawnfile 0.1.2 → 0.1.4

package/dist/compiler/moltnetRoomMemberships.js

@@ -0,0 +1,140 @@
+import { SpawnfileError } from "../shared/index.js";
+import { resolveTeamRepresentatives } from "./moltnetRepresentativeResolution.js";
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const findAgentBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "agent" && entry.value.source === source);
+    if (!node || node.value.kind !== "agent") {
+        throw new SpawnfileError("compile_error", `Unable to find agent node at ${source}`);
+    }
+    return node.value;
+};
+const findTeamBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "team" && entry.value.source === source);
+    if (!node || node.value.kind !== "team") {
+        throw new SpawnfileError("compile_error", `Unable to find team node at ${source}`);
+    }
+    return node.value;
+};
+const clonePolicy = (policy) => ({
+    ...(policy.read ? { read: policy.read } : {}),
+    ...(policy.reply ? { reply: policy.reply } : {})
+});
+const findDirectRoomPolicy = (plan, teamNode, agentSource, memberId, networkId, roomId) => {
+    const agentNode = findAgentBySource(plan, agentSource);
+    for (const attachment of agentNode.surfaces?.moltnet ?? []) {
+        if (attachment.network !== networkId) {
+            continue;
+        }
+        if (attachment.teamSource && attachment.teamSource !== teamNode.source) {
+            continue;
+        }
+        if (attachment.memberId && attachment.memberId !== memberId) {
+            continue;
+        }
+        if (!attachment.rooms || !hasOwn(attachment.rooms, roomId)) {
+            continue;
+        }
+        return clonePolicy(attachment.rooms[roomId] ?? {});
+    }
+    return undefined;
+};
+const compareRoomMemberships = (left, right) => [
+    left.declaringTeamSource.localeCompare(right.declaringTeamSource),
+    left.networkId.localeCompare(right.networkId),
+    left.roomId.localeCompare(right.roomId),
+    left.declaredSlot.localeCompare(right.declaredSlot),
+    (left.representativePath ?? []).join("/").localeCompare((right.representativePath ?? []).join("/")),
+    left.concreteMemberId.localeCompare(right.concreteMemberId),
+    left.agentSource.localeCompare(right.agentSource)
+].find((result) => result !== 0) ?? 0;
+export const listConcreteMoltnetRoomMemberIds = (plan, teamNode, networkId, room, memberships = plan.moltnetRoomMemberships) => {
+    if (memberships) {
+        return [
+            ...new Set(memberships
+                .filter((membership) => membership.declaringTeamSource === teamNode.source
+                && membership.networkId === networkId
+                && membership.roomId === room.id)
+                .map((membership) => membership.concreteMemberId))
+        ].sort();
+    }
+    const concreteMembers = [];
+    for (const declaredSlot of room.members) {
+        const member = teamNode.members.find((entry) => entry.id === declaredSlot);
+        if (!member) {
+            throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${declaredSlot}`);
+        }
+        if (member.kind === "agent") {
+            concreteMembers.push(member.id);
+            continue;
+        }
+        const childTeam = findTeamBySource(plan, member.nodeSource);
+        const representatives = resolveTeamRepresentatives(plan, childTeam);
+        if (representatives.length === 0) {
+            throw new SpawnfileError("validation_error", `Team ${childTeam.name} has no concrete representative for Moltnet room ${room.id} on ${teamNode.name}`);
+        }
+        concreteMembers.push(...representatives.map((representative) => representative.memberId));
+    }
+    return [...new Set(concreteMembers)].sort();
+};
+export const resolveMoltnetRoomMemberships = (plan) => {
+    const memberships = [];
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "team") {
+            continue;
+        }
+        const teamNode = node.value;
+        for (const network of teamNode.networks ?? []) {
+            for (const room of network.rooms) {
+                for (const declaredSlot of room.members) {
+                    const declaredMember = teamNode.members.find((member) => member.id === declaredSlot);
+                    if (!declaredMember) {
+                        throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${declaredSlot}`);
+                    }
+                    if (declaredMember.kind === "agent") {
+                        const agentNode = findAgentBySource(plan, declaredMember.nodeSource);
+                        const policy = findDirectRoomPolicy(plan, teamNode, agentNode.source, declaredSlot, network.id, room.id);
+                        memberships.push({
+                            agentName: agentNode.name,
+                            agentSource: agentNode.source,
+                            concreteMemberId: declaredSlot,
+                            declaredSlot,
+                            declaringTeamName: teamNode.name,
+                            declaringTeamSource: teamNode.source,
+                            directTeamName: teamNode.name,
+                            directTeamSource: teamNode.source,
+                            networkId: network.id,
+                            ...(policy ? { policy } : {}),
+                            roomId: room.id
+                        });
+                        continue;
+                    }
+                    const childTeam = findTeamBySource(plan, declaredMember.nodeSource);
+                    const representatives = resolveTeamRepresentatives(plan, childTeam);
+                    if (representatives.length === 0) {
+                        throw new SpawnfileError("validation_error", `Team ${childTeam.name} has no concrete representative for Moltnet room ${room.id} on ${teamNode.name}`);
+                    }
+                    for (const representative of representatives) {
+                        const agentNode = findAgentBySource(plan, representative.agentSource);
+                        memberships.push({
+                            agentName: agentNode.name,
+                            agentSource: agentNode.source,
+                            concreteMemberId: representative.memberId,
+                            declaredSlot,
+                            declaringTeamName: teamNode.name,
+                            declaringTeamSource: teamNode.source,
+                            directTeamName: representative.sourceTeamName,
+                            directTeamSource: representative.sourceTeamSource,
+                            networkId: network.id,
+                            representedSlot: declaredSlot,
+                            representedTeamName: childTeam.name,
+                            representedTeamSource: childTeam.source,
+                            representativePath: [declaredSlot, ...representative.path],
+                            roomId: room.id
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return memberships.sort(compareRoomMemberships);
+};

package/dist/compiler/runProject.d.ts

@@ -16,6 +16,7 @@ export interface RunProjectOptions extends CompileProjectOptions {
     containerName?: string;
     detach?: boolean;
     dockerCommand?: string;
+    envFilePath?: string;
     imageTag?: string;
     runRunner?: DockerRunRunner;
 }
@@ -29,6 +30,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
     containerName?: string;
     detach?: boolean;
     dockerCommand?: string;
+    envFilePath?: string;
 }) => Promise<DockerRunInvocation>;
 export declare const runDockerContainer: DockerRunRunner;
 export declare const runProject: (inputPath: string, options?: RunProjectOptions) => Promise<RunProjectResult>;

package/dist/compiler/runProject.js

@@ -3,8 +3,8 @@ import path from "node:path";
 import { mkdtemp } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
-import { requireAuthProfile } from "../auth/index.js";
-import { ensureDirectory, fileExists, removeDirectory, writeUtf8File } from "../filesystem/index.js";
+import { parseEnvFile, requireAuthProfile } from "../auth/index.js";
+import { ensureDirectory, fileExists, readUtf8File, removeDirectory, writeUtf8File } from "../filesystem/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { compileProject } from "./compileProject.js";
 import { createDefaultImageTag } from "./buildProject.js";
@@ -47,9 +47,10 @@ const collectMissingRequiredSecrets = (containerReport, env, coveredModelSecrets
     }
     return [...missing].sort();
 };
-const resolveRunEnvironment = (containerReport, authProfile) => {
+const resolveRunEnvironment = (containerReport, authProfile, envFileEnv = {}) => {
     const env = {
-        ...(authProfile?.env ?? {})
+        ...(authProfile?.env ?? {}),
+        ...envFileEnv
     };
     for (const name of new Set([...Object.keys(env), ...containerReport.secrets_required])) {
         const processValue = process.env[name];
@@ -83,6 +84,18 @@ const renderDockerEnvFile = (env) => `${Object.entries(env)
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, value]) => `${name}=${value}`)
     .join("\n")}\n`;
+const readRunEnvFile = async (envFilePath) => {
+    if (!envFilePath) {
+        return {};
+    }
+    try {
+        return parseEnvFile(await readUtf8File(envFilePath));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("validation_error", `Unable to read env file ${envFilePath}: ${reason}`);
+    }
+};
 const resolveAuthMountArgs = async (containerReport, authProfile) => {
     if (!authProfile || containerReport.runtime_homes.length === 0) {
         return [];
@@ -110,7 +123,7 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
     const envFilePath = path.join(supportDirectory, "run.env");
     try {
         assertDeclaredModelAuthSatisfied(containerReport, options.authProfile ?? null);
-        const env = resolveRunEnvironment(containerReport, options.authProfile ?? null);
+        const env = resolveRunEnvironment(containerReport, options.authProfile ?? null, await readRunEnvFile(options.envFilePath));
         const preparedRuntimeAuth = await prepareRuntimeAuthMounts(compileResult.outputDirectory, containerReport, options.authProfile ?? null, env, supportDirectory);
         assertRunEnvironmentSatisfied(containerReport, env, preparedRuntimeAuth.coveredModelSecrets);
         await ensureDirectory(supportDirectory);
@@ -178,7 +191,8 @@ export const runProject = async (inputPath, options = {}) => {
         authProfile,
         containerName: options.containerName,
         detach: options.detach,
-        dockerCommand: options.dockerCommand
+        dockerCommand: options.dockerCommand,
+        envFilePath: options.envFilePath
     });
     try {
         await (options.runRunner ?? runDockerContainer)(invocation);

package/dist/compiler/syncProjectAuth.js

@@ -7,39 +7,64 @@ import { listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from
 const resolveAuthRequirements = async (inputPath) => {
     const plan = await buildCompilePlan(inputPath);
     const methods = new Set();
-    const envNames = new Set();
+    const optionalEnvNames = new Set();
+    const requiredEnvNames = new Set();
+    const addProjectSecret = (secret) => {
+        if (secret.required) {
+            requiredEnvNames.add(secret.name);
+            optionalEnvNames.delete(secret.name);
+        }
+        else if (!requiredEnvNames.has(secret.name)) {
+            optionalEnvNames.add(secret.name);
+        }
+    };
     for (const node of plan.nodes) {
         if (node.value.kind !== "agent") {
+            for (const secret of node.value.shared.secrets) {
+                addProjectSecret(secret);
+            }
             continue;
         }
+        for (const secret of node.value.secrets) {
+            addProjectSecret(secret);
+        }
         for (const method of Object.values(resolveExecutionModelAuthMethods(node.value.execution))) {
             methods.add(method);
         }
         for (const envName of listExecutionModelSecretNames(node.value.execution)) {
-            envNames.add(envName);
+            requiredEnvNames.add(envName);
+            optionalEnvNames.delete(envName);
         }
         for (const envName of listAgentSurfaceSecretNames(node.value.surfaces)) {
-            envNames.add(envName);
+            requiredEnvNames.add(envName);
+            optionalEnvNames.delete(envName);
         }
     }
-    return { envNames, methods };
+    return { methods, optionalEnvNames, requiredEnvNames };
+};
+const readEnvFile = async (envFilePath) => envFilePath ? parseEnvFile(await readUtf8File(envFilePath)) : {};
+const resolveEnvValue = (envName, fileEnv) => {
+    const processValue = process.env[envName];
+    if (typeof processValue === "string" && processValue.length > 0) {
+        return processValue;
+    }
+    const fileValue = fileEnv[envName];
+    if (typeof fileValue === "string" && fileValue.length > 0) {
+        return fileValue;
+    }
+    return null;
 };
-const resolveRequiredEnv = async (envNames, envFilePath) => {
-    if (envNames.size === 0) {
+const resolveRequiredEnv = async (requiredEnvNames, optionalEnvNames, envFilePath) => {
+    if (requiredEnvNames.size === 0 && optionalEnvNames.size === 0) {
         return {};
     }
-    const fileEnv = envFilePath ? parseEnvFile(await readUtf8File(envFilePath)) : {};
+    const fileEnv = await readEnvFile(envFilePath);
     const resolvedEnv = {};
     const missingEnv = [];
-    for (const envName of [...envNames].sort()) {
-        const processValue = process.env[envName];
-        if (typeof processValue === "string" && processValue.length > 0) {
-            resolvedEnv[envName] = processValue;
-            continue;
-        }
-        const fileValue = fileEnv[envName];
-        if (typeof fileValue === "string" && fileValue.length > 0) {
-            resolvedEnv[envName] = fileValue;
+    for (const envName of [...requiredEnvNames].sort()) {
+        const value = resolveEnvValue(envName, fileEnv);
+        if (value !== null) {
+            resolvedEnv[envName] = value;
             continue;
         }
         missingEnv.push(envName);
@@ -47,10 +72,19 @@ const resolveRequiredEnv = async (envNames, envFilePath) => {
     if (missingEnv.length > 0) {
         throw new SpawnfileError("validation_error", `Missing required auth env: ${missingEnv.join(", ")}`);
     }
+    for (const envName of [...optionalEnvNames].sort()) {
+        if (requiredEnvNames.has(envName)) {
+            continue;
+        }
+        const value = resolveEnvValue(envName, fileEnv);
+        if (value !== null) {
+            resolvedEnv[envName] = value;
+        }
+    }
     return resolvedEnv;
 };
 export const syncProjectAuth = async (inputPath, options) => {
-    const { envNames, methods } = await resolveAuthRequirements(inputPath);
+    const { methods, optionalEnvNames, requiredEnvNames } = await resolveAuthRequirements(inputPath);
     await ensureAuthProfile(options.profileName);
     if (methods.has("codex")) {
         await importCodexAuth(options.profileName, options.codexDirectory);
@@ -58,8 +92,8 @@ export const syncProjectAuth = async (inputPath, options) => {
     if (methods.has("claude-code")) {
         await importClaudeCodeAuth(options.profileName, options.claudeCodeDirectory);
     }
-    if (envNames.size > 0) {
-        await setAuthProfileEnv(options.profileName, await resolveRequiredEnv(envNames, options.envFilePath));
+    if (requiredEnvNames.size > 0 || optionalEnvNames.size > 0) {
+        await setAuthProfileEnv(options.profileName, await resolveRequiredEnv(requiredEnvNames, optionalEnvNames, options.envFilePath));
     }
     return requireAuthProfile(options.profileName);
 };

package/dist/compiler/types.d.ts

@@ -189,9 +189,27 @@ export interface ResolvedTeamMembershipContext {
     teamName: string;
     teamSource: string;
 }
+export interface ResolvedMoltnetRoomMembership {
+    agentName: string;
+    agentSource: string;
+    concreteMemberId: string;
+    declaredSlot: string;
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    directTeamName: string;
+    directTeamSource: string;
+    networkId: string;
+    policy?: ResolvedMoltnetRoomPolicy;
+    representedSlot?: string;
+    representedTeamName?: string;
+    representedTeamSource?: string;
+    representativePath?: string[];
+    roomId: string;
+}
 export interface CompilePlan {
     edges: CompilePlanEdge[];
     memberships?: ResolvedTeamMembershipContext[];
+    moltnetRoomMemberships?: ResolvedMoltnetRoomMembership[];
     nodes: CompilePlanNode[];
     root: string;
     runtimes: Record<string, {

package/dist/compiler/view/buildOrganizationView.d.ts

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

package/dist/compiler/view/buildOrganizationView.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { SpawnfileError } from "../../shared/index.js";
+import { buildCompilePlan } from "../buildCompilePlan.js";
+import { resolveMoltnetRoomMemberships } from "../moltnetRoomMemberships.js";
+const createNameCounts = (plan) => {
+    const counts = new Map();
+    for (const node of plan.nodes) {
+        const key = `${node.kind}:${node.value.name}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+};
+const formatDisplayName = (node, nameCounts) => {
+    const key = `${node.kind}:${node.value.name}`;
+    return (nameCounts.get(key) ?? 0) > 1
+        ? `${node.value.name} [${node.id}]`
+        : node.value.name;
+};
+const groupEdgesBySource = (edges) => {
+    const groups = new Map();
+    for (const edge of edges) {
+        const group = groups.get(edge.from) ?? [];
+        group.push(edge);
+        groups.set(edge.from, group);
+    }
+    return groups;
+};
+const buildTreeNetworkSummaries = (node) => {
+    if (node.value.kind !== "team") {
+        return [];
+    }
+    return (node.value.networks ?? []).map((network) => ({
+        expose: network.expose ?? false,
+        id: network.id,
+        name: network.name,
+        provider: network.provider,
+        rooms: network.rooms.map((room) => ({
+            declaredMembers: [...room.members],
+            id: room.id
+        }))
+    }));
+};
+const buildTreeNode = (node, nodeById, edgesBySource, nameCounts, ancestors = []) => {
+    if (ancestors.includes(node.id)) {
+        throw new SpawnfileError("compile_error", `Cycle detected while building view tree for ${node.id}`);
+    }
+    const children = (edgesBySource.get(node.id) ?? []).map((edge) => {
+        const child = nodeById.get(edge.to);
+        if (!child) {
+            throw new SpawnfileError("compile_error", `Unable to find view node ${edge.to}`);
+        }
+        return {
+            label: edge.label,
+            node: buildTreeNode(child, nodeById, edgesBySource, nameCounts, [...ancestors, node.id]),
+            relation: edge.kind
+        };
+    });
+    return {
+        children,
+        displayName: formatDisplayName(node, nameCounts),
+        ...(node.value.kind === "team"
+            ? {
+                external: [...node.value.external],
+                lead: node.value.lead,
+                mode: node.value.mode
+            }
+            : {}),
+        id: node.id,
+        kind: node.kind,
+        name: node.value.name,
+        networks: buildTreeNetworkSummaries(node),
+        runtimeName: node.runtimeName,
+        source: node.value.source
+    };
+};
+const sortNetworkMembers = (declaredMembers, members) => {
+    const declaredOrder = new Map(declaredMembers.map((member, index) => [member, index]));
+    return [...members].sort((left, right) => (declaredOrder.get(left.declaredSlot) ?? Number.MAX_SAFE_INTEGER)
+        - (declaredOrder.get(right.declaredSlot) ?? Number.MAX_SAFE_INTEGER)
+        || (left.representativePath ?? []).join("/").localeCompare((right.representativePath ?? []).join("/"))
+        || left.concreteMemberId.localeCompare(right.concreteMemberId));
+};
+const toNetworkMemberView = (membership) => ({
+    agentName: membership.agentName,
+    agentSource: membership.agentSource,
+    concreteMemberId: membership.concreteMemberId,
+    declaredSlot: membership.declaredSlot,
+    directTeamName: membership.directTeamName,
+    directTeamSource: membership.directTeamSource,
+    ...(membership.policy ? { policy: { ...membership.policy } } : {}),
+    ...(membership.representedSlot ? { representedSlot: membership.representedSlot } : {}),
+    ...(membership.representedTeamName
+        ? { representedTeamName: membership.representedTeamName }
+        : {}),
+    ...(membership.representedTeamSource
+        ? { representedTeamSource: membership.representedTeamSource }
+        : {}),
+    ...(membership.representativePath
+        ? { representativePath: [...membership.representativePath] }
+        : {})
+});
+const createNetworkKey = (provider, networkId) => `${provider}::${networkId}`;
+const buildNetworkDeclaration = (teamNode, network, roomMemberships) => ({
+    declaringTeamName: teamNode.name,
+    declaringTeamSource: teamNode.source,
+    expose: network.expose ?? false,
+    name: network.name,
+    rooms: network.rooms.map((room) => {
+        const members = roomMemberships
+            .filter((membership) => membership.declaringTeamSource === teamNode.source
+            && membership.networkId === network.id
+            && membership.roomId === room.id)
+            .map(toNetworkMemberView);
+        return {
+            declaredMembers: [...room.members],
+            id: room.id,
+            members: sortNetworkMembers(room.members, members)
+        };
+    })
+});
+const buildNetworks = (plan) => {
+    const roomMemberships = plan.moltnetRoomMemberships
+        ?? resolveMoltnetRoomMemberships(plan);
+    const groups = new Map();
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "team") {
+            continue;
+        }
+        const teamNode = node.value;
+        for (const network of teamNode.networks ?? []) {
+            const key = createNetworkKey(network.provider, network.id);
+            const declaration = buildNetworkDeclaration(teamNode, network, roomMemberships);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.declarations = [...(existing.declarations ?? []), declaration];
+                continue;
+            }
+            groups.set(key, {
+                declaringTeamName: declaration.declaringTeamName,
+                declaringTeamSource: declaration.declaringTeamSource,
+                declarations: [declaration],
+                expose: declaration.expose,
+                id: network.id,
+                name: declaration.name,
+                provider: network.provider,
+                rooms: declaration.rooms
+            });
+        }
+    }
+    const networks = [...groups.values()];
+    for (const network of networks) {
+        const firstDeclaration = network.declarations?.[0];
+        if (firstDeclaration) {
+            network.declaringTeamName = firstDeclaration.declaringTeamName;
+            network.declaringTeamSource = firstDeclaration.declaringTeamSource;
+            network.expose = firstDeclaration.expose;
+            network.name = firstDeclaration.name;
+            network.rooms = firstDeclaration.rooms;
+        }
+    }
+    return networks;
+};
+export const buildOrganizationView = async (inputPath) => {
+    const plan = await buildCompilePlan(inputPath);
+    const rootNode = plan.nodes.find((node) => node.value.source === plan.root);
+    if (!rootNode) {
+        throw new SpawnfileError("compile_error", `Unable to find root view node for ${plan.root}`);
+    }
+    const nodeById = new Map(plan.nodes.map((node) => [node.id, node]));
+    const root = buildTreeNode(rootNode, nodeById, groupEdgesBySource(plan.edges), createNameCounts(plan));
+    return {
+        contexts: [],
+        diagnostics: [],
+        inputPath,
+        networks: buildNetworks(plan),
+        projectRoot: path.dirname(plan.root),
+        root,
+        runtimes: []
+    };
+};

package/dist/compiler/view/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./buildOrganizationView.js";
+export * from "./renderNetworks.js";
+export * from "./renderTree.js";
+export * from "./types.js";

package/dist/compiler/view/index.js

@@ -0,0 +1,4 @@
+export * from "./buildOrganizationView.js";
+export * from "./renderNetworks.js";
+export * from "./renderTree.js";
+export * from "./types.js";

package/dist/compiler/view/renderNetworks.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView, RenderOrganizationViewOptions } from "./types.js";
+export declare const renderOrganizationNetworks: (view: OrganizationView, options?: RenderOrganizationViewOptions) => string;

package/dist/compiler/view/renderNetworks.js

@@ -0,0 +1,93 @@
+import { formatSourceMeta } from "./sourcePaths.js";
+const color = (value, code, options) => options.color ? `\u001b[${code}m${value}\u001b[0m` : value;
+const glyphsFor = (options) => options.ascii
+    ? { branch: "|-- ", last: "`-- ", pipe: "|   ", space: "    " }
+    : { branch: "├── ", last: "└── ", pipe: "│   ", space: "    " };
+const formatPolicy = (member) => {
+    if (!member.policy) {
+        return [];
+    }
+    return [
+        member.policy.read ? `read=${member.policy.read}` : undefined,
+        member.policy.reply ? `reply=${member.policy.reply}` : undefined
+    ].filter((entry) => entry !== undefined);
+};
+const formatMember = (member, options, projectRoot) => {
+    const metadata = member.representedSlot
+        ? [
+            `represents=${member.representedSlot}`,
+            member.representedTeamName && member.representedTeamName !== member.representedSlot
+                ? `team=${member.representedTeamName}`
+                : undefined,
+            `member=${member.concreteMemberId}`
+        ]
+        : [
+            `team=${member.directTeamName}`,
+            `member=${member.concreteMemberId}`
+        ];
+    const source = options.paths
+        ? formatSourceMeta("source", member.agentSource, projectRoot)
+        : "";
+    const details = [
+        ...metadata,
+        ...formatPolicy(member)
+    ].filter((entry) => entry !== undefined);
+    return `${member.agentName}  ${details.join(" ")}${source}`;
+};
+const formatNetwork = (network, options) => {
+    const id = color(network.id, "36", options);
+    return `${network.provider} ${id}`;
+};
+const getDeclarations = (network) => network.declarations ?? [
+    {
+        declaringTeamName: network.declaringTeamName,
+        declaringTeamSource: network.declaringTeamSource,
+        expose: network.expose,
+        name: network.name,
+        rooms: network.rooms
+    }
+];
+const formatDeclaration = (network, declaration, options, projectRoot) => {
+    const exposed = declaration.expose ? " exposed" : "";
+    const source = options.paths
+        ? formatSourceMeta("declared_source", declaration.declaringTeamSource, projectRoot)
+        : "";
+    return `${network.id} "${declaration.name}" on ${declaration.declaringTeamName}${exposed}${source}`;
+};
+export const renderOrganizationNetworks = (view, options = {}) => {
+    if (view.networks.length === 0) {
+        return "No Moltnet networks.";
+    }
+    const glyphs = glyphsFor(options);
+    const lines = ["Moltnet networks"];
+    view.networks.forEach((network, networkIndex) => {
+        const networkLast = networkIndex === view.networks.length - 1;
+        const networkPrefix = networkLast ? glyphs.space : glyphs.pipe;
+        lines.push(`${networkLast ? glyphs.last : glyphs.branch}${formatNetwork(network, options)}`);
+        const declarations = getDeclarations(network);
+        declarations.forEach((declaration, declarationIndex) => {
+            const declarationLast = declarationIndex === declarations.length - 1;
+            const declarationPrefix = `${networkPrefix}${declarationLast ? glyphs.space : glyphs.pipe}`;
+            lines.push(`${networkPrefix}${declarationLast ? glyphs.last : glyphs.branch}${formatDeclaration(network, declaration, options, view.projectRoot)}`);
+            declaration.rooms.forEach((room, roomIndex) => {
+                const roomLast = roomIndex === declaration.rooms.length - 1;
+                const roomPrefix = `${declarationPrefix}${roomLast ? glyphs.space : glyphs.pipe}`;
+                const legacyDeclared = options.declared && !view.projectRoot
+                    ? ` room ${room.id} declared [${room.declaredMembers.join(", ")}]`
+                    : "";
+                lines.push(`${declarationPrefix}${roomLast ? glyphs.last : glyphs.branch}#${room.id}${legacyDeclared}`);
+                if (options.declared) {
+                    const declaredMembers = room.declaredMembers.length > 0
+                        ? room.declaredMembers.join(", ")
+                        : "(none)";
+                    lines.push(`${roomPrefix}${glyphs.branch}declared members: ${declaredMembers}`);
+                }
+                room.members.forEach((member, memberIndex) => {
+                    const memberLast = memberIndex === room.members.length - 1;
+                    lines.push(`${roomPrefix}${memberLast ? glyphs.last : glyphs.branch}${formatMember(member, options, view.projectRoot)}`);
+                });
+            });
+        });
+    });
+    return lines.join("\n");
+};

package/dist/compiler/view/renderTree.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView, RenderOrganizationViewOptions } from "./types.js";
+export declare const renderOrganizationTree: (view: OrganizationView, options?: RenderOrganizationViewOptions) => string;