@atolis-hq/corum 0.1.0

package/dist/src/writer/graph-writer.js

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { getOwnedSections } from '../loader/pack-loader.js';
+import { isPackRef } from '../loader/fs-utils.js';
+import { FileGraphSource } from '../source/file-source.js';
+const STRUCTURAL_EDGE_TYPES = new Set(['has-field', 'has-value']);
+const YAML_STRINGIFY_OPTIONS = { singleQuote: true };
+export function serializeGraph(graph, options = {}) {
+    const map = new Map();
+    map.set('graph.yaml', buildGraphYaml(graph, options));
+    for (const root of getRootNodes(graph)) {
+        map.set(clusterPath(root), stringifyGraphYaml(toClusterDocument(graph, root)));
+    }
+    const explicitEdges = getAllEdges(graph)
+        .filter(edge => !STRUCTURAL_EDGE_TYPES.has(edge.type))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    if (explicitEdges.length > 0) {
+        map.set('edges/corum.edges.yaml', stringifyGraphYaml({ edges: explicitEdges.map(toEdgeDocument) }));
+    }
+    return map;
+}
+function clusterPath(node) {
+    const parts = node.id.split('.');
+    if (parts.length !== 3)
+        throw new Error(`clusterPath: expected 3-segment root node ID, got: ${node.id}`);
+    const [component, template, name] = parts;
+    return `components/${component}/${template}s/${name}.yaml`;
+}
+export async function saveGraph(graph, options) {
+    const { sourceGraphPath, outputGraphPath, replace = true } = options;
+    if (fs.existsSync(outputGraphPath)) {
+        if (!replace) {
+            throw new Error(`output graph folder already exists: ${outputGraphPath}`);
+        }
+    }
+    const source = new FileGraphSource({ graphDir: outputGraphPath, defaultBranch: 'local' });
+    await source.commit('local', serializeGraph(graph, { sourceGraphPath, outputGraphPath }), 'save graph', { replaceGraphContent: replace });
+}
+function buildGraphYaml(graph, options) {
+    const content = graph.sourceContent?.get('graph.yaml');
+    if (!content)
+        return stringifyGraphYaml({ templatePacks: [] });
+    if (!options.sourceGraphPath || !options.outputGraphPath)
+        return content;
+    const doc = parseYaml(content);
+    const packs = Array.isArray(doc.templatePacks) ? doc.templatePacks : [];
+    doc.templatePacks = packs.map(pack => {
+        if (!isPackRef(pack))
+            return pack;
+        const absolutePackPath = path.resolve(options.sourceGraphPath, pack.path);
+        return {
+            ...pack,
+            path: normalizeContentKey(path.relative(options.outputGraphPath, absolutePackPath)),
+        };
+    });
+    return stringifyGraphYaml(doc);
+}
+function normalizeContentKey(value) {
+    return value.split(path.sep).join('/');
+}
+function toClusterDocument(graph, root) {
+    const metadata = {
+        component: root.component,
+        state: root.state,
+        stability: root.stability,
+        lastModifiedAt: root.lastModifiedAt,
+    };
+    if (root.extractedFrom !== undefined)
+        metadata.extractedFrom = root.extractedFrom;
+    if (root.derivation !== undefined)
+        metadata.derivation = root.derivation;
+    if (root.derivedBy !== undefined)
+        metadata.derivedBy = root.derivedBy;
+    const doc = {
+        id: root.id,
+        template: root.template,
+        schemaVersion: root.schemaVersion,
+        metadata,
+    };
+    if (Object.keys(root.properties).length > 0) {
+        doc.properties = root.properties;
+    }
+    appendOwnedSections(graph, root, doc);
+    return doc;
+}
+function appendOwnedSections(graph, parent, target) {
+    const template = graph.templates.get(parent.template);
+    if (!template)
+        return;
+    for (const [sectionName] of Object.entries(getOwnedSections(template))) {
+        const children = getDirectOwnedChildren(graph, parent.id, sectionName);
+        if (children.length === 0)
+            continue;
+        const section = {};
+        for (const child of children) {
+            const childDoc = { ...child.properties };
+            if (child.state !== parent.state)
+                childDoc.state = child.state;
+            if (child.stability !== parent.stability)
+                childDoc.stability = child.stability;
+            appendOwnedSections(graph, child, childDoc);
+            section[getLocalName(child.id, parent.id, sectionName)] = childDoc;
+        }
+        target[sectionName] = section;
+    }
+}
+function getDirectOwnedChildren(graph, parentId, sectionName) {
+    const prefix = `${parentId}.${sectionName}.`;
+    return [...graph.nodesById.values()]
+        .filter(node => {
+        if (!node.id.startsWith(prefix))
+            return false;
+        const remaining = node.id.slice(prefix.length);
+        return !remaining.includes('.');
+    })
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+function getLocalName(childId, parentId, sectionName) {
+    return childId.slice(`${parentId}.${sectionName}.`.length);
+}
+function stringifyGraphYaml(value) {
+    return stringifyYaml(value, YAML_STRINGIFY_OPTIONS);
+}
+function toEdgeDocument(edge) {
+    const doc = {
+        from: edge.from,
+        to: edge.to,
+        type: edge.type,
+    };
+    if (edge.state !== 'proposed')
+        doc.state = edge.state;
+    if (edge.stability !== 'unstable')
+        doc.stability = edge.stability;
+    if (edge.notes !== undefined)
+        doc.notes = edge.notes;
+    return doc;
+}
+function getAllEdges(graph) {
+    const edges = new Map();
+    for (const edgeList of graph.edgesByFrom.values()) {
+        for (const edge of edgeList) {
+            edges.set(edge.id, edge);
+        }
+    }
+    return [...edges.values()];
+}
+function getRootNodes(graph) {
+    const nodes = [...graph.nodesById.values()];
+    return nodes
+        .filter(node => !nodes.some(other => other.id !== node.id && node.id.startsWith(`${other.id}.`)))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@atolis-hq/corum",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist/src/",
+    "web/"
+  ],
+  "bin": {
+    "corum": "./dist/src/bin/corum.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && node --test dist/test",
+    "wireframes": "node design/wireframes/server.mjs",
+    "mcp": "node dist/src/mcp/index.js",
+    "mcp:smoke": "npm run build && node scripts/mcp-smoke.mjs",
+    "web": "node dist/src/web/server.js"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^12.1.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@toon-format/toon": "^2.1.0",
+    "commander": "^14.0.3",
+    "express": "^4.22.1",
+    "isomorphic-git": "^1.37.6",
+    "openapi-types": "^12.1.3",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.25",
+    "@types/node": "^20.0.0",
+    "@types/swagger-parser": "^4.0.3",
+    "typescript": "^5.0.0"
+  }
+}