@donartcha/openlag 0.1.0

package/dist/cli/openlag.js

@@ -0,0 +1,1793 @@
+#!/usr/bin/env node
+
+// scripts/cli/openlag.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk6 from "chalk";
+import { Command } from "commander";
+
+// scripts/cli/build.ts
+import { execFileSync } from "child_process";
+import path4 from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+
+// scripts/cli/generate.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// scripts/core/parser/scanner.ts
+import fs from "fs";
+import path from "path";
+function scanDocs(docsDir) {
+  const documents = [];
+  const traverse = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    const items = fs.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory()) {
+        traverse(fullPath);
+      } else if (item.endsWith(".md")) {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        documents.push({
+          file: fullPath,
+          content
+        });
+      }
+    }
+  };
+  traverse(docsDir);
+  return documents;
+}
+
+// scripts/core/parser/schemas.ts
+import { z } from "zod";
+var ArtifactSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  subType: z.string().optional(),
+  title: z.string(),
+  version: z.string(),
+  description: z.string(),
+  systemVersionId: z.string().optional(),
+  status: z.enum(["draft", "in_progress", "ready", "closed", "deprecated"]).optional(),
+  layer: z.string().optional(),
+  ownership: z.object({
+    owner: z.string().optional(),
+    team: z.string().optional(),
+    domain: z.string().optional(),
+    maintainers: z.array(z.string()).optional(),
+    reviewers: z.array(z.string()).optional(),
+    steward: z.string().optional()
+  }).optional(),
+  file: z.string(),
+  schemaVersion: z.string().optional()
+});
+
+// src/core/semantic/artifact-layers.ts
+var LayerInferenceRules = {
+  PROJECT: "BUSINESS",
+  EPIC: "BUSINESS",
+  FEATURE: "BUSINESS",
+  REQUIREMENT: "BUSINESS",
+  BUSINESS_RULE: "BUSINESS",
+  USE_CASE: "BUSINESS",
+  DESIGN: "ARCHITECTURE",
+  DECISION: "ARCHITECTURE",
+  COMPONENT: "ARCHITECTURE",
+  API: "ARCHITECTURE",
+  CODE_ENTITY: "IMPLEMENTATION",
+  DATABASE_ENTITY: "IMPLEMENTATION",
+  TEST_CASE: "IMPLEMENTATION",
+  TEST: "IMPLEMENTATION",
+  CHANGE: "IMPLEMENTATION",
+  BUG: "IMPLEMENTATION",
+  RISK: "IMPLEMENTATION",
+  INCIDENT: "OPERATIONS",
+  INFRASTRUCTURE: "OPERATIONS",
+  DEPLOYMENT: "OPERATIONS",
+  MONITORING: "OPERATIONS",
+  MAINTENANCE: "OPERATIONS",
+  SYSTEM_VERSION: "OPERATIONS",
+  GLOSSARY_TERM: "DOCUMENTATION",
+  DOCUMENTATION: "DOCUMENTATION",
+  VERSION: "DOCUMENTATION",
+  LIBRARY: "IMPLEMENTATION",
+  ENVIRONMENT: "OPERATIONS",
+  CHECK: "OPERATIONS",
+  PROCESS: "OPERATIONS",
+  PIPELINE: "OPERATIONS"
+};
+function inferLayer(artifactType) {
+  return LayerInferenceRules[artifactType];
+}
+
+// scripts/core/parser/normalizer.ts
+function normalizeArtifact(parsed, fullPath, body) {
+  const p = { ...parsed };
+  if (!p.schemaVersion) {
+    p.schemaVersion = "1.0.0";
+  }
+  const typeValue = p.type || p.Type;
+  return {
+    id: String(p.id || p.ID || ""),
+    type: typeValue,
+    subType: p.subType || p.subtype || p.SubType,
+    title: String(p.title || p.Title || (p.id || p.ID || "")),
+    version: String(p.version || p.Version || "v-1"),
+    description: body,
+    systemVersionId: p.systemVersionId || p.systemversionid,
+    component: p.component,
+    releaseDate: p.releaseDate || p.timestamp,
+    status: p.status,
+    layer: inferLayer(typeValue),
+    ownership: p.ownership || p.owner ? { owner: p.owner, ...p.ownership } : void 0,
+    file: fullPath,
+    schemaVersion: p.schemaVersion
+  };
+}
+
+// scripts/core/parser/diagnostic.ts
+var DiagnosticEngine = class {
+  constructor() {
+    this.diagnostics = [];
+  }
+  add(file, message, severity) {
+    this.diagnostics.push({ file, message, severity });
+  }
+  getDiagnostics() {
+    return this.diagnostics;
+  }
+  getErrors() {
+    return this.diagnostics.map((d) => ({ file: d.file, message: `[${d.severity}] ${d.message}` }));
+  }
+  hasCritical() {
+    return this.diagnostics.some((d) => d.severity === "CRITICAL" /* CRITICAL */);
+  }
+};
+
+// src/core/generated/relation-definitions.ts
+var GENERATED_RELATIONS = [
+  {
+    "type": "BLOCKS",
+    "description": "Descripci\xF3n de impedimentos directos.",
+    "category": "DEPENDENCY",
+    "allowedFrom": [
+      "BUG",
+      "RISK",
+      "INCIDENT",
+      "CHANGE",
+      "DECISION",
+      "REQUIREMENT",
+      "FEATURE",
+      "EPIC"
+    ],
+    "allowedTo": [
+      "PROJECT",
+      "EPIC",
+      "FEATURE",
+      "REQUIREMENT",
+      "BUG",
+      "CHANGE",
+      "DEPLOYMENT",
+      "DEPLOYMENT"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "BREAKS",
+    "description": "Aver\xEDas o rupturas confirmadas.",
+    "category": "OPERATIONAL",
+    "allowedFrom": [
+      "CHANGE",
+      "CODE_ENTITY",
+      "COMPONENT",
+      "SYSTEM_VERSION"
+    ],
+    "allowedTo": [
+      "TEST_CASE",
+      "TEST",
+      "API",
+      "COMPONENT",
+      "REQUIREMENT",
+      "FEATURE"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "CALLS",
+    "description": "Trazabilidad de invocaci\xF3n a nivel c\xF3digo.",
+    "category": "STRUCTURAL",
+    "allowedFrom": [
+      "CODE_ENTITY"
+    ],
+    "allowedTo": [
+      "CODE_ENTITY",
+      "API"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "DEFINES",
+    "description": "Entidades que instauran glosarios o normas.",
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "BUSINESS_RULE",
+      "DECISION",
+      "DOCUMENTATION",
+      "GLOSSARY_TERM"
+    ],
+    "allowedTo": [
+      "REQUIREMENT",
+      "FEATURE",
+      "DESIGN",
+      "PROJECT",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  },
+  {
+    "type": "DEPENDS_ON",
+    "description": "Acoplamiento est\xE1tico arquitect\xF3nico o de empaquetado.",
+    "category": "STRUCTURAL",
+    "allowedFrom": [
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "LIBRARY",
+      "VERSION",
+      "SYSTEM_VERSION"
+    ],
+    "allowedTo": [
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "LIBRARY",
+      "VERSION",
+      "SYSTEM_VERSION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "DEPLOYS",
+    "description": "Instanciaci\xF3n de componentes o release en infraestructura.",
+    "category": "OPERATIONAL",
+    "allowedFrom": [
+      "DEPLOYMENT",
+      "PIPELINE",
+      "SYSTEM_VERSION"
+    ],
+    "allowedTo": [
+      "COMPONENT",
+      "INFRASTRUCTURE",
+      "ENVIRONMENT",
+      "DATABASE_ENTITY"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "DERIVES_FROM",
+    "description": "Evoluci\xF3n conceptual gen\xE9rica.",
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "REQUIREMENT",
+      "FEATURE",
+      "DESIGN",
+      "BUSINESS_RULE",
+      "DECISION",
+      "USE_CASE"
+    ],
+    "allowedTo": [
+      "REQUIREMENT",
+      "FEATURE",
+      "DESIGN",
+      "BUSINESS_RULE",
+      "DECISION",
+      "USE_CASE"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  },
+  {
+    "type": "DOCUMENTS",
+    "description": "Conecta documentaci\xF3n con el artefacto descrito.",
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "DOCUMENTATION",
+      "GLOSSARY_TERM"
+    ],
+    "allowedTo": [
+      "PROJECT",
+      "EPIC",
+      "FEATURE",
+      "REQUIREMENT",
+      "BUSINESS_RULE",
+      "USE_CASE",
+      "DESIGN",
+      "DECISION",
+      "CODE_ENTITY",
+      "TEST_CASE",
+      "CHANGE",
+      "BUG",
+      "RISK",
+      "GLOSSARY_TERM",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "TEST",
+      "DOCUMENTATION",
+      "INCIDENT",
+      "INFRASTRUCTURE",
+      "DEPLOYMENT",
+      "MONITORING",
+      "MAINTENANCE",
+      "SYSTEM_VERSION",
+      "VERSION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  },
+  {
+    "type": "FIXES",
+    "description": "Conecta correcciones con bugs o incidentes.",
+    "category": "TRACEABILITY",
+    "allowedFrom": [
+      "CHANGE",
+      "CODE_ENTITY",
+      "COMPONENT",
+      "SYSTEM_VERSION"
+    ],
+    "allowedTo": [
+      "BUG",
+      "INCIDENT",
+      "RISK"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "IMPACTS",
+    "description": "Descripci\xF3n de posibles efectos colaterales.",
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "CHANGE",
+      "RISK",
+      "BUG",
+      "INCIDENT",
+      "DECISION"
+    ],
+    "allowedTo": [
+      "PROJECT",
+      "EPIC",
+      "FEATURE",
+      "REQUIREMENT",
+      "DESIGN",
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "SYSTEM_VERSION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "IMPLEMENTS",
+    "description": "Conecta implementaci\xF3n con necesidad funcional/t\xE9cnica.",
+    "category": "TRACEABILITY",
+    "allowedFrom": [
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "SYSTEM_VERSION"
+    ],
+    "allowedTo": [
+      "REQUIREMENT",
+      "FEATURE",
+      "EPIC",
+      "DESIGN",
+      "USE_CASE",
+      "BUSINESS_RULE"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "IMPORTS",
+    "description": "Trazabilidad de importaci\xF3n est\xE1tica a nivel de c\xF3digo.",
+    "category": "STRUCTURAL",
+    "allowedFrom": [
+      "CODE_ENTITY"
+    ],
+    "allowedTo": [
+      "CODE_ENTITY",
+      "LIBRARY"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "JUSTIFIES",
+    "description": "Conecta decisiones con aquello que justifican.",
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "DECISION",
+      "BUSINESS_RULE",
+      "DOCUMENTATION",
+      "RISK"
+    ],
+    "allowedTo": [
+      "DESIGN",
+      "REQUIREMENT",
+      "FEATURE",
+      "EPIC",
+      "PROJECT",
+      "CODE_ENTITY",
+      "COMPONENT",
+      "INFRASTRUCTURE",
+      "DEPLOYMENT",
+      "MAINTENANCE"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "MONITORS",
+    "description": "Relaci\xF3n de observabilidad.",
+    "category": "OPERATIONAL",
+    "allowedFrom": [
+      "MONITORING",
+      "CHECK"
+    ],
+    "allowedTo": [
+      "COMPONENT",
+      "INFRASTRUCTURE",
+      "DEPLOYMENT",
+      "DATABASE_ENTITY",
+      "API"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  },
+  {
+    "type": "REFINES",
+    "description": "Descompone artefactos en otros m\xE1s concretos.",
+    "category": "TRACEABILITY",
+    "allowedFrom": [
+      "FEATURE",
+      "REQUIREMENT",
+      "BUG",
+      "RISK",
+      "DESIGN"
+    ],
+    "allowedTo": [
+      "EPIC",
+      "FEATURE",
+      "PROJECT",
+      "BUSINESS_RULE",
+      "REQUIREMENT",
+      "DESIGN"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "RELATES_TO",
+    "description": 'Uso gen\xE9rico propenso a poluci\xF3n sem\xE1ntica. (DISCOURAGED)\nPara mantener un grafo limpio, solo \xFAsala aportando rationale expl\xEDcito:\n\nrelations:\n  - to: mi-otro-artefacto\n    type: RELATES_TO\n    rationale: "No encaja con USES o DEPENDS_ON debido al contexto X."\n',
+    "category": "SEMANTIC",
+    "allowedFrom": [
+      "PROJECT",
+      "EPIC",
+      "FEATURE",
+      "REQUIREMENT",
+      "BUSINESS_RULE",
+      "USE_CASE",
+      "DESIGN",
+      "DECISION",
+      "CODE_ENTITY",
+      "TEST_CASE",
+      "CHANGE",
+      "BUG",
+      "RISK",
+      "GLOSSARY_TERM",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "TEST",
+      "DOCUMENTATION",
+      "INCIDENT",
+      "INFRASTRUCTURE",
+      "DEPLOYMENT",
+      "MONITORING",
+      "MAINTENANCE",
+      "SYSTEM_VERSION",
+      "VERSION"
+    ],
+    "allowedTo": [
+      "PROJECT",
+      "EPIC",
+      "FEATURE",
+      "REQUIREMENT",
+      "BUSINESS_RULE",
+      "USE_CASE",
+      "DESIGN",
+      "DECISION",
+      "CODE_ENTITY",
+      "TEST_CASE",
+      "CHANGE",
+      "BUG",
+      "RISK",
+      "GLOSSARY_TERM",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "TEST",
+      "DOCUMENTATION",
+      "INCIDENT",
+      "INFRASTRUCTURE",
+      "DEPLOYMENT",
+      "MONITORING",
+      "MAINTENANCE",
+      "SYSTEM_VERSION",
+      "VERSION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "REPLACES",
+    "description": "Evoluci\xF3n e hist\xF3rico, deprecando versiones anteriores.",
+    "category": "EVOLUTIONARY",
+    "allowedFrom": [
+      "COMPONENT",
+      "API",
+      "SYSTEM_VERSION",
+      "VERSION",
+      "REQUIREMENT",
+      "FEATURE",
+      "DESIGN",
+      "DECISION"
+    ],
+    "allowedTo": [
+      "COMPONENT",
+      "API",
+      "SYSTEM_VERSION",
+      "VERSION",
+      "REQUIREMENT",
+      "FEATURE",
+      "DESIGN",
+      "DECISION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "one"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  },
+  {
+    "type": "TESTS",
+    "description": "Conecta tests con comportamiento validado.",
+    "category": "TRACEABILITY",
+    "allowedFrom": [
+      "TEST_CASE",
+      "TEST"
+    ],
+    "allowedTo": [
+      "REQUIREMENT",
+      "FEATURE",
+      "EPIC",
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "DATABASE_ENTITY",
+      "BUG",
+      "INCIDENT"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "error"
+    },
+    "strength": "STRONG"
+  },
+  {
+    "type": "USES",
+    "description": "Llamada funcional, invocaci\xF3n o flujo en tiempo de ejecuci\xF3n.",
+    "category": "OPERATIONAL",
+    "allowedFrom": [
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "FEATURE",
+      "USE_CASE"
+    ],
+    "allowedTo": [
+      "CODE_ENTITY",
+      "COMPONENT",
+      "API",
+      "SYSTEM_VERSION"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "warn"
+    },
+    "strength": "MEDIUM"
+  },
+  {
+    "type": "VALIDATES",
+    "description": "Validaci\xF3n emp\xEDrica/humana (QA Manual).",
+    "category": "TRACEABILITY",
+    "allowedFrom": [
+      "PROCESS",
+      "CHECK",
+      "DOCUMENTATION"
+    ],
+    "allowedTo": [
+      "REQUIREMENT",
+      "FEATURE",
+      "USE_CASE",
+      "DEPLOYMENT"
+    ],
+    "multiplicity": {
+      "from": "many",
+      "to": "many"
+    },
+    "validation": {
+      "severity": "info"
+    },
+    "strength": "WEAK"
+  }
+];
+
+// src/core/registry/RelationRegistry.ts
+var RelationRegistry = class {
+  static {
+    this.relationsMap = new Map(
+      GENERATED_RELATIONS.map((rel) => [rel.type, rel])
+    );
+  }
+  static getValidTypes() {
+    return Array.from(this.relationsMap.keys());
+  }
+  static getContract(type) {
+    return this.relationsMap.get(type);
+  }
+  static isValid(type) {
+    return this.relationsMap.has(type);
+  }
+  static getRelationsByCategory(category) {
+    return GENERATED_RELATIONS.filter((rel) => rel.category === category);
+  }
+  static getAllContracts() {
+    return GENERATED_RELATIONS;
+  }
+};
+
+// scripts/core/parser.ts
+import yaml from "js-yaml";
+function parseOpenLagDocs(docsDir) {
+  const diag = new DiagnosticEngine();
+  const state = {
+    versions: [],
+    systemVersions: [],
+    changes: [],
+    artifacts: [],
+    relations: [],
+    errors: []
+  };
+  const documents = scanDocs(docsDir);
+  for (const doc of documents) {
+    const { content, file: fullPath } = doc;
+    const sections = content.split(/---+\r?\n/);
+    let i = 0;
+    if (content.trim().startsWith("---")) i = 1;
+    for (; i < sections.length; i += 1) {
+      const section = sections[i].trim();
+      if (section.length < 5) continue;
+      let parsed;
+      try {
+        const yamlCandidate = sections[i].split("\n").map((l) => l.replace(/^##\s?/, "")).join("\n").replace(/---$/, "").trim();
+        parsed = yaml.load(yamlCandidate);
+      } catch (e) {
+        throw new Error(`CRITICAL: Invalid YAML block in ${fullPath}: ${e.message}`, { cause: e });
+      }
+      if (parsed && typeof parsed === "object" && (parsed.id || parsed.ID) && (parsed.type || parsed.Type)) {
+        const body = i + 1 < sections.length ? sections[i + 1].trim() : "";
+        if (i + 1 < sections.length) i++;
+        const normalized = normalizeArtifact(parsed, fullPath, body);
+        try {
+          ArtifactSchema.parse(normalized);
+          const artifact = normalized;
+          state.artifacts.push(artifact);
+          const typeValue = artifact.type;
+          if (typeValue === "VERSION") {
+            state.versions.push({
+              id: artifact.id,
+              name: String(parsed.name || ""),
+              timestamp: String(parsed.timestamp || ""),
+              parentVersion: parsed.parentVersion || null
+            });
+          } else if (typeValue === "SYSTEM_VERSION") {
+            state.systemVersions.push({
+              id: artifact.id,
+              component: String(parsed.component || ""),
+              version: String(parsed.version || ""),
+              releaseDate: String(parsed.releaseDate || "")
+            });
+          } else if (typeValue === "CHANGE") {
+            state.changes.push({
+              id: artifact.id,
+              type: parsed.changeType || "FEATURE",
+              title: artifact.title,
+              description: artifact.description,
+              affects: Array.isArray(parsed.affects) ? parsed.affects : [],
+              versionFrom: String(parsed.versionFrom || ""),
+              versionTo: String(parsed.versionTo || "")
+            });
+          }
+          const rels = parsed.relations || parsed.Relations;
+          if (rels) {
+            const relArray = Array.isArray(rels) ? rels : [rels];
+            relArray.forEach((rel, idx) => {
+              const to = typeof rel === "string" ? rel : rel.to || rel.id || rel.ID;
+              if (to) {
+                const relType = rel.type;
+                if (!relType) {
+                  diag.add(fullPath, `Relation targeting ${to} missing 'type' in artifact ${artifact.id}`, "WARNING" /* WARNING */);
+                  return;
+                }
+                const contract = RelationRegistry.getContract(relType);
+                state.relations.push({
+                  id: `rel-${artifact.id}-${idx}`,
+                  from: artifact.id,
+                  to: String(to),
+                  type: relType,
+                  category: contract?.category,
+                  strength: contract?.strength,
+                  file: fullPath
+                });
+              }
+            });
+          }
+        } catch (e) {
+          diag.add(fullPath, `Schema validation error: ${e.message}`, "INVALID" /* INVALID */);
+        }
+      } else if (parsed && typeof parsed === "object") {
+        if (!(parsed.id || parsed.ID)) {
+          diag.add(fullPath, `Missing ID in artifact`, "INVALID" /* INVALID */);
+        } else if (!(parsed.type || parsed.Type)) {
+          diag.add(fullPath, `Missing Type in artifact`, "INVALID" /* INVALID */);
+        }
+      }
+    }
+  }
+  state.errors = diag.getErrors();
+  return state;
+}
+
+// scripts/cli/generate.ts
+import chokidar from "chokidar";
+import chalk from "chalk";
+function isDescendant(currentVersionId, artifactVersionId, versions) {
+  const artifactVersion = versions.find((v) => v.id === artifactVersionId);
+  if (!artifactVersion) return false;
+  let temp = versions.find((v) => v.id === currentVersionId);
+  let depth = 0;
+  while (temp && temp.parentVersion) {
+    depth++;
+    if (depth > 50) return false;
+    if (temp.parentVersion === artifactVersionId) return true;
+    temp = versions.find((v) => v.id === temp.parentVersion);
+  }
+  return false;
+}
+function generateData(docsDir, outputDir, silent = false) {
+  if (!silent) console.log(chalk.blue("\u{1F680} Generating OpenLAG Static Data..."));
+  const parsedData = parseOpenLagDocs(docsDir);
+  const state = {
+    versions: parsedData.versions,
+    systemVersions: parsedData.systemVersions,
+    graphs: {},
+    changes: parsedData.changes
+  };
+  const allArtifacts = parsedData.artifacts;
+  const allRelations = parsedData.relations;
+  state.versions.forEach((v) => {
+    state.graphs[v.id] = {
+      artifacts: allArtifacts.filter((a) => a.type === "SYSTEM_VERSION" || a.type === "VERSION" || a.version === v.id || isDescendant(v.id, a.version, state.versions)),
+      relations: allRelations.filter((r) => {
+        const fromArt = allArtifacts.find((a) => a.id === r.from);
+        return fromArt && (fromArt.type === "SYSTEM_VERSION" || fromArt.type === "VERSION" || fromArt.version === v.id || isDescendant(v.id, fromArt.version, state.versions));
+      })
+    };
+  });
+  if (!fs2.existsSync(outputDir)) fs2.mkdirSync(outputDir, { recursive: true });
+  fs2.writeFileSync(
+    path2.join(outputDir, "graph-data.json"),
+    JSON.stringify(state, null, 2)
+  );
+  if (!silent) console.log(chalk.green("\u2705 Data generated at"), chalk.cyan(path2.join(outputDir, "graph-data.json")));
+}
+function watchData(docsDir, outputDir) {
+  console.log(chalk.yellow("\u{1F440} Watching for changes in"), chalk.cyan(docsDir));
+  const watcher = chokidar.watch(docsDir, {
+    ignoreInitial: true,
+    persistent: true
+  });
+  const runCleanly = () => {
+    try {
+      generateData(docsDir, outputDir, true);
+      console.log(chalk.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk.green("Regenerated graph-data.json"));
+    } catch (e) {
+      console.error(chalk.red("\u274C Error during regeneration:"), e);
+    }
+  };
+  let timeout;
+  const debouncedRun = () => {
+    clearTimeout(timeout);
+    timeout = setTimeout(runCleanly, 300);
+  };
+  watcher.on("all", (event, path9) => {
+    debouncedRun();
+  });
+}
+
+// scripts/cli/vite-bin.ts
+import path3 from "path";
+import { createRequire } from "module";
+function resolveViteBin(importMetaUrl) {
+  const require2 = createRequire(importMetaUrl);
+  const viteEntry = require2.resolve("vite");
+  return path3.resolve(path3.dirname(viteEntry), "../../bin/vite.js");
+}
+
+// scripts/cli/build.ts
+function buildPortal() {
+  const packageRoot2 = path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "../..");
+  const viteBin = resolveViteBin(import.meta.url);
+  const viteConfig = path4.join(packageRoot2, "vite.config.ts");
+  const docsDir = path4.join(process.cwd(), "docs");
+  const outputDir = path4.join(process.cwd(), "public");
+  generateData(docsDir, outputDir);
+  console.log(chalk2.blue("Building OpenLAG portal..."));
+  try {
+    execFileSync(process.execPath, [viteBin, "build", "--config", viteConfig], {
+      cwd: packageRoot2,
+      env: {
+        ...process.env,
+        OPENLAG_PROJECT_ROOT: process.cwd()
+      },
+      stdio: "inherit"
+    });
+    console.log(chalk2.green("Portal build complete."));
+  } catch {
+    console.error(chalk2.red("Build failed."));
+    process.exit(1);
+  }
+}
+
+// scripts/cli/dev.ts
+import { spawn } from "child_process";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk3 from "chalk";
+function runDevServer() {
+  const packageRoot2 = path5.resolve(path5.dirname(fileURLToPath2(import.meta.url)), "../..");
+  const viteBin = resolveViteBin(import.meta.url);
+  const viteConfig = path5.join(packageRoot2, "vite.config.ts");
+  const projectRoot = process.cwd();
+  const docsDir = path5.join(projectRoot, "docs");
+  const outputDir = path5.join(projectRoot, "public");
+  generateData(docsDir, outputDir);
+  watchData(docsDir, outputDir);
+  console.log(chalk3.blue("Starting OpenLAG portal dev server..."));
+  const vite = spawn(process.execPath, [viteBin, "--config", viteConfig], {
+    cwd: packageRoot2,
+    env: {
+      ...process.env,
+      OPENLAG_PROJECT_ROOT: projectRoot
+    },
+    stdio: "inherit"
+  });
+  vite.on("close", (code) => {
+    process.exit(code || 0);
+  });
+}
+
+// scripts/cli/init.ts
+import fs3 from "fs";
+import path6 from "path";
+import chalk4 from "chalk";
+async function initProject(projectName, projectDesc, includeAllRelations) {
+  const name = projectName || process.env.PROJECT_NAME || "My OpenLAG Project";
+  const desc = projectDesc || process.env.PROJECT_DESCRIPTION || "Living Architecture documentation for my system.";
+  const ROOT_DIR = process.cwd();
+  console.log(chalk4.blue(`\u{1F6E0}\uFE0F  Initializing OpenLAG for: `) + chalk4.bold(name));
+  const metadataPath = path6.join(ROOT_DIR, "metadata.json");
+  if (fs3.existsSync(metadataPath)) {
+    const metadata = JSON.parse(fs3.readFileSync(metadataPath, "utf-8"));
+    metadata.name = name;
+    metadata.description = desc;
+    fs3.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    console.log(chalk4.green("\u2705 Updated metadata.json"));
+  }
+  const htmlPath = path6.join(ROOT_DIR, "index.html");
+  if (fs3.existsSync(htmlPath)) {
+    let html = fs3.readFileSync(htmlPath, "utf-8");
+    html = html.replace(/<title>.*?<\/title>/, `<title>${name} | OpenLAG</title>`);
+    fs3.writeFileSync(htmlPath, html);
+    console.log(chalk4.green("\u2705 Updated index.html title"));
+  }
+  const docsDir = path6.join(ROOT_DIR, "docs");
+  if (!fs3.existsSync(docsDir)) {
+    fs3.mkdirSync(docsDir);
+    console.log(chalk4.green("\u2705 Created /docs directory"));
+  }
+  const relationsDir = path6.join(docsDir, "relations");
+  if (!fs3.existsSync(relationsDir)) {
+    fs3.mkdirSync(relationsDir);
+    console.log(chalk4.green("\u2705 Created /docs/relations directory"));
+  } else {
+    const files = fs3.readdirSync(relationsDir);
+    for (const file of files) {
+      if (file.endsWith(".yaml")) {
+        fs3.unlinkSync(path6.join(relationsDir, file));
+      }
+    }
+  }
+  const mandatoryRelations = [
+    {
+      name: "IMPLEMENTS.yaml",
+      content: `relation: IMPLEMENTS
+description: "Conecta implementaci\xF3n con necesidad funcional/t\xE9cnica."
+category: TRACEABILITY
+allowedFrom: [CODE_ENTITY, COMPONENT, API, DATABASE_ENTITY, SYSTEM_VERSION]
+allowedTo: [REQUIREMENT, FEATURE, EPIC, DESIGN, USE_CASE, BUSINESS_RULE]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+    },
+    {
+      name: "TESTS.yaml",
+      content: `relation: TESTS
+description: "Conecta tests con comportamiento validado."
+category: TRACEABILITY
+allowedFrom: [TEST_CASE, TEST]
+allowedTo: [REQUIREMENT, FEATURE, EPIC, CODE_ENTITY, COMPONENT, API, DATABASE_ENTITY, BUG, INCIDENT]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+    },
+    {
+      name: "REFINES.yaml",
+      content: `relation: REFINES
+description: "Descompone artefactos en otros m\xE1s concretos."
+category: TRACEABILITY
+allowedFrom: [FEATURE, REQUIREMENT, BUG, RISK, DESIGN]
+allowedTo: [EPIC, FEATURE, PROJECT, BUSINESS_RULE, REQUIREMENT, DESIGN]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+    },
+    {
+      name: "FIXES.yaml",
+      content: `relation: FIXES
+description: "Conecta correcciones con bugs o incidentes."
+category: TRACEABILITY
+allowedFrom: [CHANGE, CODE_ENTITY, COMPONENT, SYSTEM_VERSION]
+allowedTo: [BUG, INCIDENT, RISK]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+    },
+    {
+      name: "DOCUMENTS.yaml",
+      content: `relation: DOCUMENTS
+description: "Conecta documentaci\xF3n con el artefacto descrito."
+category: SEMANTIC
+allowedFrom: [DOCUMENTATION, GLOSSARY_TERM]
+allowedTo: [PROJECT, EPIC, FEATURE, REQUIREMENT, BUSINESS_RULE, USE_CASE, DESIGN, DECISION, CODE_ENTITY, TEST_CASE, CHANGE, BUG, RISK, GLOSSARY_TERM, COMPONENT, API, DATABASE_ENTITY, TEST, DOCUMENTATION, INCIDENT, INFRASTRUCTURE, DEPLOYMENT, MONITORING, MAINTENANCE, SYSTEM_VERSION, VERSION]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: info`
+    },
+    {
+      name: "JUSTIFIES.yaml",
+      content: `relation: JUSTIFIES
+description: "Conecta decisiones con aquello que justifican."
+category: SEMANTIC
+allowedFrom: [DECISION, BUSINESS_RULE, DOCUMENTATION, RISK]
+allowedTo: [DESIGN, REQUIREMENT, FEATURE, EPIC, PROJECT, CODE_ENTITY, COMPONENT, INFRASTRUCTURE, DEPLOYMENT, MAINTENANCE]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+    }
+  ];
+  mandatoryRelations.forEach((rel) => {
+    fs3.writeFileSync(path6.join(relationsDir, rel.name), rel.content);
+  });
+  console.log(chalk4.green("\u2705 Created Mandatory Core Relations (IMPLEMENTS, TESTS, REFINES, FIXES, DOCUMENTS, JUSTIFIES)"));
+  if (includeAllRelations) {
+    const optionalRelations = [
+      {
+        name: "DEPENDS_ON.yaml",
+        content: `relation: DEPENDS_ON
+description: "Acoplamiento est\xE1tico arquitect\xF3nico o de empaquetado."
+category: STRUCTURAL
+allowedFrom: [CODE_ENTITY, COMPONENT, API, DATABASE_ENTITY, LIBRARY, VERSION, SYSTEM_VERSION]
+allowedTo: [CODE_ENTITY, COMPONENT, API, DATABASE_ENTITY, LIBRARY, VERSION, SYSTEM_VERSION]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      },
+      {
+        name: "USES.yaml",
+        content: `relation: USES
+description: "Llamada funcional, invocaci\xF3n o flujo en tiempo de ejecuci\xF3n."
+category: OPERATIONAL
+allowedFrom: [CODE_ENTITY, COMPONENT, API, FEATURE, USE_CASE]
+allowedTo: [CODE_ENTITY, COMPONENT, API, SYSTEM_VERSION]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      },
+      {
+        name: "DEPLOYS.yaml",
+        content: `relation: DEPLOYS
+description: "Instanciaci\xF3n de componentes o release en infraestructura."
+category: OPERATIONAL
+allowedFrom: [DEPLOYMENT, PIPELINE, SYSTEM_VERSION]
+allowedTo: [COMPONENT, INFRASTRUCTURE, ENVIRONMENT, DATABASE_ENTITY]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+      },
+      {
+        name: "MONITORS.yaml",
+        content: `relation: MONITORS
+description: "Relaci\xF3n de observabilidad."
+category: OPERATIONAL
+allowedFrom: [MONITORING, CHECK]
+allowedTo: [COMPONENT, INFRASTRUCTURE, DEPLOYMENT, DATABASE_ENTITY, API]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: info`
+      },
+      {
+        name: "IMPACTS.yaml",
+        content: `relation: IMPACTS
+description: "Descripci\xF3n de posibles efectos colaterales."
+category: SEMANTIC
+allowedFrom: [CHANGE, RISK, BUG, INCIDENT, DECISION]
+allowedTo: [PROJECT, EPIC, FEATURE, REQUIREMENT, DESIGN, CODE_ENTITY, COMPONENT, API, DATABASE_ENTITY, SYSTEM_VERSION]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      },
+      {
+        name: "BLOCKS.yaml",
+        content: `relation: BLOCKS
+description: "Descripci\xF3n de impedimentos directos."
+category: DEPENDENCY
+allowedFrom: [BUG, RISK, INCIDENT, CHANGE, DECISION, REQUIREMENT, FEATURE, EPIC]
+allowedTo: [PROJECT, EPIC, FEATURE, REQUIREMENT, BUG, CHANGE, DEPLOYMENT, DEPLOYMENT]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+      },
+      {
+        name: "BREAKS.yaml",
+        content: `relation: BREAKS
+description: "Aver\xEDas o rupturas confirmadas."
+category: OPERATIONAL
+allowedFrom: [CHANGE, CODE_ENTITY, COMPONENT, SYSTEM_VERSION]
+allowedTo: [TEST_CASE, TEST, API, COMPONENT, REQUIREMENT, FEATURE]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: error`
+      },
+      {
+        name: "REPLACES.yaml",
+        content: `relation: REPLACES
+description: "Evoluci\xF3n e hist\xF3rico, deprecando versiones anteriores."
+category: EVOLUTIONARY
+allowedFrom: [COMPONENT, API, SYSTEM_VERSION, VERSION, REQUIREMENT, FEATURE, DESIGN, DECISION]
+allowedTo: [COMPONENT, API, SYSTEM_VERSION, VERSION, REQUIREMENT, FEATURE, DESIGN, DECISION]
+multiplicity:
+  from: many
+  to: one
+validation:
+  severity: info`
+      },
+      {
+        name: "DERIVES_FROM.yaml",
+        content: `relation: DERIVES_FROM
+description: "Evoluci\xF3n conceptual gen\xE9rica."
+category: SEMANTIC
+allowedFrom: [REQUIREMENT, FEATURE, DESIGN, BUSINESS_RULE, DECISION, USE_CASE]
+allowedTo: [REQUIREMENT, FEATURE, DESIGN, BUSINESS_RULE, DECISION, USE_CASE]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: info`
+      },
+      {
+        name: "VALIDATES.yaml",
+        content: `relation: VALIDATES
+description: "Validaci\xF3n emp\xEDrica/humana (QA Manual)."
+category: TRACEABILITY
+allowedFrom: [PROCESS, CHECK, DOCUMENTATION]
+allowedTo: [REQUIREMENT, FEATURE, USE_CASE, DEPLOYMENT]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: info`
+      },
+      {
+        name: "DEFINES.yaml",
+        content: `relation: DEFINES
+description: "Entidades que instauran glosarios o normas."
+category: SEMANTIC
+allowedFrom: [BUSINESS_RULE, DECISION, DOCUMENTATION, GLOSSARY_TERM]
+allowedTo: [REQUIREMENT, FEATURE, DESIGN, PROJECT, COMPONENT, API, DATABASE_ENTITY]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: info`
+      },
+      {
+        name: "CALLS.yaml",
+        content: `relation: CALLS
+description: "Trazabilidad de invocaci\xF3n a nivel c\xF3digo."
+category: STRUCTURAL
+allowedFrom: [CODE_ENTITY]
+allowedTo: [CODE_ENTITY, API]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      },
+      {
+        name: "IMPORTS.yaml",
+        content: `relation: IMPORTS
+description: "Trazabilidad de importaci\xF3n est\xE1tica a nivel de c\xF3digo."
+category: STRUCTURAL
+allowedFrom: [CODE_ENTITY]
+allowedTo: [CODE_ENTITY, LIBRARY]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      },
+      {
+        name: "RELATES_TO.yaml",
+        content: `relation: RELATES_TO
+description: |
+  Uso gen\xE9rico propenso a poluci\xF3n sem\xE1ntica. (DISCOURAGED)
+  Para mantener un grafo limpio, solo \xFAsala aportando rationale expl\xEDcito:
+  
+  relations:
+    - to: mi-otro-artefacto
+      type: RELATES_TO
+      rationale: "No encaja con USES o DEPENDS_ON debido al contexto X."
+category: SEMANTIC
+allowedFrom: [PROJECT, EPIC, FEATURE, REQUIREMENT, BUSINESS_RULE, USE_CASE, DESIGN, DECISION, CODE_ENTITY, TEST_CASE, CHANGE, BUG, RISK, GLOSSARY_TERM, COMPONENT, API, DATABASE_ENTITY, TEST, DOCUMENTATION, INCIDENT, INFRASTRUCTURE, DEPLOYMENT, MONITORING, MAINTENANCE, SYSTEM_VERSION, VERSION]
+allowedTo: [PROJECT, EPIC, FEATURE, REQUIREMENT, BUSINESS_RULE, USE_CASE, DESIGN, DECISION, CODE_ENTITY, TEST_CASE, CHANGE, BUG, RISK, GLOSSARY_TERM, COMPONENT, API, DATABASE_ENTITY, TEST, DOCUMENTATION, INCIDENT, INFRASTRUCTURE, DEPLOYMENT, MONITORING, MAINTENANCE, SYSTEM_VERSION, VERSION]
+multiplicity:
+  from: many
+  to: many
+validation:
+  severity: warn`
+      }
+    ];
+    optionalRelations.forEach((rel) => {
+      fs3.writeFileSync(path6.join(relationsDir, rel.name), rel.content);
+    });
+    console.log(chalk4.green("\u2705 Created Official Optional Relations"));
+  }
+  const versionsDir = path6.join(docsDir, "versions");
+  if (!fs3.existsSync(versionsDir)) {
+    fs3.mkdirSync(versionsDir);
+    console.log(chalk4.green("\u2705 Created /docs/versions directory"));
+  }
+  const versionPath = path6.join(versionsDir, "v-1.0.0.md");
+  if (!fs3.existsSync(versionPath)) {
+    const versionsContent = `---
+id: v-1.0.0
+type: VERSION
+name: "Baseline"
+timestamp: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"
+parentVersion: null
+layer: DOCUMENTATION
+title: "Project Release v1.0.0"
+description: "Initial release"
+ownership:
+  owner: architecture
+  team: architecture
+relations: []
+---
+`;
+    fs3.writeFileSync(versionPath, versionsContent);
+    console.log(chalk4.green("\u2705 Created initial docs/versions/v-1.0.0.md"));
+  }
+  const componentsVersionsPath = path6.join(versionsDir, "sys-core-1.0.md");
+  if (!fs3.existsSync(componentsVersionsPath)) {
+    const cvContent = `---
+id: sys-core-1.0
+type: SYSTEM_VERSION
+component: "Core System"
+version: "1.0.0"
+releaseDate: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"
+layer: OPERATIONS
+title: "Core System v1.0"
+description: "Base framework."
+ownership:
+  owner: architecture
+  team: architecture
+relations: []
+---
+`;
+    fs3.writeFileSync(componentsVersionsPath, cvContent);
+    console.log(chalk4.green("\u2705 Created initial docs/versions/sys-core-1.0.md"));
+  }
+  const architectureDir = path6.join(docsDir, "architecture");
+  if (!fs3.existsSync(architectureDir)) {
+    fs3.mkdirSync(architectureDir);
+    console.log(chalk4.green("\u2705 Created /docs/architecture directory"));
+  }
+  const sampleDocPath = path6.join(architectureDir, "architecture-overview.md");
+  if (!fs3.existsSync(sampleDocPath)) {
+    const sampleContent = `---
+id: arch-overview
+type: DOCUMENT
+status: draft
+title: "Architecture Overview"
+description: "High-level description of the system architecture."
+---
+
+# Architecture Overview
+
+This document describes the high-level architecture of ${name}.
+
+## Key Principles
+- Traceability first.
+- Documentation as Code.
+- Graph-based relationships.
+`;
+    fs3.writeFileSync(sampleDocPath, sampleContent);
+    console.log(chalk4.green("\u2705 Created initial docs/architecture/architecture-overview.md"));
+  }
+  console.log("\n" + chalk4.cyan("\u{1F680} Project initialized successfully!"));
+  console.log("Next steps:");
+  console.log("1. Edit " + chalk4.cyan("docs/") + " to reflect your architecture.");
+  console.log("2. Run " + chalk4.cyan("openlag dev") + " to see your portal.");
+}
+
+// scripts/cli/lint.ts
+import path7 from "path";
+
+// scripts/lint/lint-engine.ts
+import fs4 from "fs";
+import yaml2 from "js-yaml";
+import chalk5 from "chalk";
+
+// src/core/registry/ArtifactRegistry.ts
+var CORE_ARTIFACT_TYPES = [
+  "PROJECT",
+  "EPIC",
+  "FEATURE",
+  "REQUIREMENT",
+  "BUSINESS_RULE",
+  "USE_CASE",
+  "DESIGN",
+  "DECISION",
+  "CODE_ENTITY",
+  "TEST_CASE",
+  "CHANGE",
+  "BUG",
+  "RISK",
+  "GLOSSARY_TERM",
+  "COMPONENT",
+  "API",
+  "DATABASE_ENTITY",
+  "TEST",
+  "DOCUMENTATION",
+  "INCIDENT",
+  "INFRASTRUCTURE",
+  "DEPLOYMENT",
+  "MONITORING",
+  "MAINTENANCE",
+  "SYSTEM_VERSION",
+  "VERSION",
+  "LIBRARY",
+  "ENVIRONMENT",
+  "CHECK",
+  "PROCESS",
+  "PIPELINE"
+];
+var ArtifactRegistry = class {
+  static getValidTypes() {
+    return CORE_ARTIFACT_TYPES;
+  }
+  static isValid(type) {
+    return CORE_ARTIFACT_TYPES.includes(type);
+  }
+};
+
+// scripts/lint/lint-rules.ts
+function runLintRules(data, profile) {
+  const issues = [];
+  const getSeverity = (rule, artifactStatus) => {
+    let severity = profile[rule];
+    if (!severity || severity === "off") return "off";
+    if (artifactStatus === "draft") {
+      if (rule !== "brokenRelation" && rule !== "invalidYaml" && rule !== "duplicateId") {
+        severity = "info";
+      }
+    } else if (artifactStatus === "in_progress") {
+      if (rule !== "brokenRelation" && rule !== "invalidYaml" && rule !== "duplicateId") {
+        if (severity === "error") severity = "warning";
+      }
+    }
+    return severity;
+  };
+  const addIssue = (rule, message, file, artifactId, artifactStatus) => {
+    const severity = getSeverity(rule, artifactStatus);
+    if (severity && severity !== "off") {
+      issues.push({ severity, rule, message, file, artifactId });
+    }
+  };
+  for (const error of data.errors) {
+    addIssue("invalidYaml", error.message, error.file);
+  }
+  const artifactMap = /* @__PURE__ */ new Map();
+  for (const artifact of data.artifacts) {
+    const list = artifactMap.get(artifact.id) || [];
+    list.push(artifact);
+    artifactMap.set(artifact.id, list);
+  }
+  for (const [id, artifacts] of artifactMap.entries()) {
+    if (artifacts.length > 1) {
+      addIssue("duplicateId", `${id} appears in ${artifacts.length} files`, artifacts[0].file, id);
+    }
+  }
+  for (const artifact of data.artifacts) {
+    if (!ArtifactRegistry.isValid(artifact.type)) {
+      addIssue("invalidArtifactType", `Invalid artifact type: ${artifact.type}`, artifact.file, artifact.id, artifact.status);
+    }
+    if (!artifact.type || !artifact.title) {
+      addIssue("missingRequiredFields", `Artifact missing type or title`, artifact.file, artifact.id, artifact.status);
+    }
+  }
+  const targets = new Set(data.artifacts.map((a) => a.id));
+  const implementationsByReq = /* @__PURE__ */ new Map();
+  const testsByReq = /* @__PURE__ */ new Map();
+  const reqsByCode = /* @__PURE__ */ new Map();
+  const reqsByTest = /* @__PURE__ */ new Map();
+  for (const relation of data.relations) {
+    if (!RelationRegistry.isValid(relation.type)) {
+      addIssue("invalidRelationType", `Invalid relation type: ${relation.type}`, relation.file, relation.from);
+    }
+    if (!targets.has(relation.to)) {
+      addIssue("brokenRelation", `${relation.from} -> ${relation.to} target does not exist`, relation.file, relation.from);
+    }
+    if (relation.type === "IMPLEMENTS") {
+      const list = implementationsByReq.get(relation.to) || [];
+      list.push(relation);
+      implementationsByReq.set(relation.to, list);
+      const listCode = reqsByCode.get(relation.from) || [];
+      listCode.push(relation);
+      reqsByCode.set(relation.from, listCode);
+    }
+    if (relation.type === "TESTS" || relation.type === "VALIDATES") {
+      const list = testsByReq.get(relation.to) || [];
+      list.push(relation);
+      testsByReq.set(relation.to, list);
+      const listTest = reqsByTest.get(relation.from) || [];
+      listTest.push(relation);
+      reqsByTest.set(relation.from, listTest);
+    }
+  }
+  for (const artifact of data.artifacts) {
+    const isDraft = artifact.status === "draft";
+    const isClosed = artifact.status === "closed";
+    const isDeprecated = artifact.status === "deprecated";
+    if (isDeprecated) continue;
+    if (artifact.type === "REQUIREMENT") {
+      const hasImplementation = implementationsByReq.has(artifact.id);
+      const hasTest = testsByReq.has(artifact.id);
+      if (!hasImplementation) {
+        addIssue("requirementWithoutImplementation", `${artifact.id} lacks implementation`, artifact.file, artifact.id, artifact.status);
+      }
+      if (!hasTest) {
+        addIssue("requirementWithoutTest", `${artifact.id} has no tests linked`, artifact.file, artifact.id, artifact.status);
+      }
+    }
+    if (artifact.type === "CODE_ENTITY") {
+      const hasReq = reqsByCode.has(artifact.id);
+      if (!hasReq) {
+        addIssue("codeWithoutRequirement", `${artifact.id} has no requirement associated`, artifact.file, artifact.id, artifact.status);
+      }
+    }
+    if (artifact.type === "TEST") {
+      const hasReq = reqsByTest.has(artifact.id);
+      if (!hasReq) {
+        addIssue("orphanArtifact", `${artifact.id} is a test without associated requirement`, artifact.file, artifact.id, artifact.status);
+      }
+    }
+    if (isClosed) {
+      const outgoing = data.relations.filter((r) => r.from === artifact.id);
+      for (const rel of outgoing) {
+        const targetArts = artifactMap.get(rel.to);
+        if (targetArts && targetArts[0]) {
+          const targetStatus = targetArts[0].status;
+          if (targetStatus === "draft" || targetStatus === "in_progress") {
+            if (rel.type !== "RELATES_TO" && rel.type !== "DOCUMENTS" && rel.type !== "JUSTIFIES") {
+              addIssue("closedArtifactWithPendingRelations", `${artifact.id} is closed but links to ${targetStatus} artifact ${rel.to} via ${rel.type}`, artifact.file, artifact.id, artifact.status);
+            }
+          }
+        }
+      }
+      if (!artifact.ownership || Object.keys(artifact.ownership).length === 0) {
+        addIssue("missingOwnership", `${artifact.id} is closed but has no ownership defined`, artifact.file, artifact.id, artifact.status);
+      }
+    }
+    if (artifact.type === "API" && (!artifact.ownership || Object.keys(artifact.ownership).length === 0)) {
+      addIssue("missingOwnership", `API ${artifact.id} should have ownership defined`, artifact.file, artifact.id, artifact.status);
+    }
+    if (artifact.layer === "BUSINESS") {
+      const outgoing = data.relations.filter((r) => r.from === artifact.id);
+      for (const rel of outgoing) {
+        const relSemantics = rel.category;
+        if (relSemantics === "OPERATIONAL") {
+          addIssue("invalidLayerRelation", `Business layer artifact ${artifact.id} should not have OPERATIONAL relations (${rel.type})`, artifact.file, artifact.id, artifact.status);
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// scripts/lint/lint-profiles.ts
+var defaultProfiles = {
+  feature: {
+    duplicateId: "error",
+    invalidYaml: "error",
+    brokenRelation: "error",
+    missingRequiredFields: "warning",
+    requirementWithoutImplementation: "info",
+    requirementWithoutTest: "info",
+    codeWithoutRequirement: "info",
+    closedArtifactWithPendingRelations: "warning",
+    orphanArtifact: "info",
+    invalidRelationType: "error",
+    invalidArtifactType: "error",
+    invalidLayerRelation: "info",
+    missingOwnership: "info"
+  },
+  develop: {
+    duplicateId: "error",
+    invalidYaml: "error",
+    brokenRelation: "error",
+    missingRequiredFields: "error",
+    requirementWithoutImplementation: "warning",
+    requirementWithoutTest: "warning",
+    codeWithoutRequirement: "warning",
+    closedArtifactWithPendingRelations: "warning",
+    orphanArtifact: "warning",
+    invalidRelationType: "error",
+    invalidArtifactType: "error",
+    invalidLayerRelation: "warning",
+    missingOwnership: "warning"
+  },
+  release: {
+    duplicateId: "error",
+    invalidYaml: "error",
+    brokenRelation: "error",
+    missingRequiredFields: "error",
+    requirementWithoutImplementation: "error",
+    requirementWithoutTest: "error",
+    codeWithoutRequirement: "error",
+    closedArtifactWithPendingRelations: "error",
+    orphanArtifact: "error",
+    invalidRelationType: "error",
+    invalidArtifactType: "error",
+    invalidLayerRelation: "error",
+    missingOwnership: "error"
+  }
+};
+
+// scripts/lint/lint-engine.ts
+function loadConfig(configPath) {
+  const defaultConfig = {
+    defaultProfile: "develop",
+    failOnWarnings: false,
+    profiles: {}
+  };
+  if (fs4.existsSync(configPath)) {
+    try {
+      const fileContent = fs4.readFileSync(configPath, "utf8");
+      const parsed = yaml2.load(fileContent);
+      if (parsed && parsed.lint) {
+        return {
+          ...defaultConfig,
+          ...parsed.lint
+        };
+      }
+    } catch (e) {
+      console.warn("\u26A0\uFE0F  Could not parse openlag.config.yml, using defaults.");
+    }
+  }
+  return defaultConfig;
+}
+function runLint(docsDir, configPath, profileName) {
+  const config = loadConfig(configPath);
+  const selectedProfileName = profileName || config.defaultProfile;
+  const baseProfile = defaultProfiles[selectedProfileName] || defaultProfiles["develop"];
+  const customProfileOverrides = config.profiles[selectedProfileName] || {};
+  const activeProfile = { ...baseProfile, ...customProfileOverrides };
+  const parsedData = parseOpenLagDocs(docsDir);
+  const issues = runLintRules(parsedData, activeProfile);
+  const summary = {
+    errors: 0,
+    warnings: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    if (issue.severity === "error") summary.errors++;
+    if (issue.severity === "warning") summary.warnings++;
+    if (issue.severity === "info") summary.info++;
+  }
+  return {
+    profile: selectedProfileName,
+    summary,
+    issues
+  };
+}
+function printHumanReport(report) {
+  console.log(`
+` + chalk5.bold(`OpenLAG Lint Report`));
+  console.log(chalk5.dim(`Profile: ${report.profile}
+`));
+  if (report.issues.length === 0) {
+    console.log(chalk5.green(`\u2705 No issues found!
+`));
+  } else {
+    for (const issue of report.issues) {
+      const sevColor = issue.severity === "error" ? chalk5.red : issue.severity === "warning" ? chalk5.yellow : chalk5.cyan;
+      const severityLabel = issue.severity.toUpperCase().padEnd(7);
+      const ruleLabel = issue.rule.padEnd(30);
+      console.log(`${sevColor(severityLabel)} ${chalk5.dim(ruleLabel)} ${issue.message}`);
+    }
+  }
+  console.log(`
+` + chalk5.bold(`Summary:`));
+  console.log(chalk5.red(`Errors:   ${report.summary.errors}`));
+  console.log(chalk5.yellow(`Warnings: ${report.summary.warnings}`));
+  console.log(chalk5.cyan(`Info:     ${report.summary.info}
+`));
+}
+
+// scripts/cli/lint.ts
+function lintDocs(profile, jsonOutput = false, strictWarnings = false) {
+  const docsDir = path7.join(process.cwd(), "docs");
+  const configPath = path7.join(process.cwd(), "openlag.config.yml");
+  const config = loadConfig(configPath);
+  const report = runLint(docsDir, configPath, profile);
+  if (jsonOutput) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    printHumanReport(report);
+  }
+  const failOnWarnings = strictWarnings || config.failOnWarnings;
+  let hasErrors = report.summary.errors > 0;
+  if (failOnWarnings && report.summary.warnings > 0) {
+    hasErrors = true;
+  }
+  if (hasErrors) {
+    process.exit(1);
+  }
+}
+
+// scripts/cli/openlag.ts
+var program = new Command();
+var packageRoot = path8.resolve(path8.dirname(fileURLToPath3(import.meta.url)), "../..");
+function runVitePreview() {
+  const viteBin = resolveViteBin(import.meta.url);
+  execFileSync2(process.execPath, [viteBin, "preview", "--outDir", path8.join(process.cwd(), "dist")], {
+    cwd: packageRoot,
+    env: {
+      ...process.env,
+      OPENLAG_PROJECT_ROOT: process.cwd()
+    },
+    stdio: "inherit"
+  });
+}
+program.name("openlag").description("Architecture as Code traceability graph generator").version("0.1.0");
+program.command("init").description("Initialize a new OpenLAG project").option("-n, --name <name>", "Project name").option("-d, --desc <description>", "Project description").option("--all", "Include optional synthetic relations").action((options) => {
+  initProject(options.name, options.desc, options.all);
+});
+program.command("generate").description("Generate static graph data from markdown docs").option("-w, --watch", "Watch mode").action((options) => {
+  const docsDir = path8.join(process.cwd(), "docs");
+  const outputDir = path8.join(process.cwd(), "public");
+  if (options.watch) {
+    watchData(docsDir, outputDir);
+  } else {
+    generateData(docsDir, outputDir);
+  }
+});
+program.command("dev").description("Start development server with live data refresh").action(() => {
+  runDevServer();
+});
+program.command("build").description("Build the OpenLAG portal for production").action(() => {
+  buildPortal();
+});
+program.command("lint").description("Validate architecture documentation").option("-p, --profile <profile>", "Lint profile (develop, feature, release)", "develop").option("--json", "Output report in JSON format").option("--strict", "Fail on warnings").action((options) => {
+  lintDocs(options.profile, options.json, options.strict);
+});
+program.command("preview").description("Preview the production build").action(() => {
+  runVitePreview();
+});
+program.command("check").description("Generate graph data and validate architecture documentation").option("-p, --profile <profile>", "Lint profile (develop, feature, release)", "develop").option("--strict", "Fail on warnings").action((options) => {
+  console.log(chalk6.blue("Running OpenLAG checks..."));
+  const docsDir = path8.join(process.cwd(), "docs");
+  const outputDir = path8.join(process.cwd(), "public");
+  try {
+    generateData(docsDir, outputDir);
+    lintDocs(options.profile, false, options.strict);
+    console.log(chalk6.green("\nOpenLAG checks passed."));
+  } catch {
+    console.error(chalk6.red("\nOpenLAG checks failed."));
+    process.exit(1);
+  }
+});
+program.parse();