@donartcha/openlag 0.1.0

package/src/core/graph/GraphQueryLayer.ts

@@ -0,0 +1,194 @@
+import { GraphSnapshot, Artifact, Relation } from "../../types.js";
+
+export interface GraphIndex {
+  artifactsById: Map<string, Artifact>;
+  relationsBySource: Map<string, Relation[]>;
+  relationsByTarget: Map<string, Relation[]>;
+  artifactsByType: Map<string, Artifact[]>;
+  artifactsByLayer: Map<string, Artifact[]>;
+  artifactsByStatus: Map<string, Artifact[]>;
+  artifactsByOwner: Map<string, Artifact[]>;
+  artifactsByTeam: Map<string, Artifact[]>;
+}
+
+export interface GraphQueryOptions {
+  focusId?: string;
+  depth?: number;
+  maxNodes?: number;
+  showWeakRelations?: boolean;
+  filterLayer?: string;
+  filterOwner?: string;
+  filterTeam?: string;
+}
+
+export const MAX_RENDER_NODES = 150;
+export const MAX_RENDER_EDGES = 300;
+export const DEFAULT_NEIGHBORHOOD_DEPTH = 1;
+export const MAX_EXPANSION_DEPTH = 3;
+export const HUB_COLLAPSE_THRESHOLD = 25;
+export const WEAK_RELATIONS_VISIBLE_BY_DEFAULT = false;
+
+const WEAK_CATEGORIES = ['SEMANTIC', 'TRACEABILITY', 'DEPENDENCY'];
+
+export function buildGraphIndex(graph: GraphSnapshot): GraphIndex {
+  const index: GraphIndex = {
+    artifactsById: new Map(),
+    relationsBySource: new Map(),
+    relationsByTarget: new Map(),
+    artifactsByType: new Map(),
+    artifactsByLayer: new Map(),
+    artifactsByStatus: new Map(),
+    artifactsByOwner: new Map(),
+    artifactsByTeam: new Map(),
+  };
+
+  graph.artifacts.forEach(a => {
+    index.artifactsById.set(a.id, a);
+    
+    if (a.type) {
+      if (!index.artifactsByType.has(a.type)) index.artifactsByType.set(a.type, []);
+      index.artifactsByType.get(a.type)!.push(a);
+    }
+    
+    if (a.layer) {
+      if (!index.artifactsByLayer.has(a.layer)) index.artifactsByLayer.set(a.layer, []);
+      index.artifactsByLayer.get(a.layer)!.push(a);
+    }
+    
+    if (a.status) {
+      if (!index.artifactsByStatus.has(a.status)) index.artifactsByStatus.set(a.status, []);
+      index.artifactsByStatus.get(a.status)!.push(a);
+    }
+
+    if (a.ownership?.owner) {
+      if (!index.artifactsByOwner.has(a.ownership.owner)) index.artifactsByOwner.set(a.ownership.owner, []);
+      index.artifactsByOwner.get(a.ownership.owner)!.push(a);
+    }
+
+    if (a.ownership?.team) {
+      if (!index.artifactsByTeam.has(a.ownership.team)) index.artifactsByTeam.set(a.ownership.team, []);
+      index.artifactsByTeam.get(a.ownership.team)!.push(a);
+    }
+  });
+
+  graph.relations.forEach(r => {
+    if (!index.relationsBySource.has(r.from)) index.relationsBySource.set(r.from, []);
+    index.relationsBySource.get(r.from)!.push(r);
+    
+    if (!index.relationsByTarget.has(r.to)) index.relationsByTarget.set(r.to, []);
+    index.relationsByTarget.get(r.to)!.push(r);
+  });
+
+  return index;
+}
+
+function isRelationAllowed(rel: Relation, options: GraphQueryOptions): boolean {
+  if (!options.showWeakRelations && WEAK_CATEGORIES.includes(rel.strength || (rel.category === 'SEMANTIC' ? 'WEAK' : 'STRONG'))) {
+    // we need to rely on rel config here, wait rel has only type?
+    // we should use a registry maybe, but for now let's just make it generic
+    // wait relation has type, category is not always present in data, but it might be.
+    // Assuming strength is mapped somehow or we check relation type
+    if (['RELATES_TO', 'DOCUMENTS'].includes(rel.type)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function projectSubgraph(graph: GraphSnapshot, index: GraphIndex, options: GraphQueryOptions): GraphSnapshot {
+  const { 
+    focusId, 
+    depth = DEFAULT_NEIGHBORHOOD_DEPTH, 
+    filterLayer = 'ALL', 
+    filterOwner = 'ALL', 
+    filterTeam = 'ALL' 
+  } = options;
+
+  let artifacts = new Set<Artifact>();
+  let relations = new Set<Relation>();
+
+  const isArtifactAllowed = (a: Artifact) => {
+    if (filterLayer !== 'ALL' && a.layer !== filterLayer) return false;
+    if (filterOwner !== 'ALL' && a.ownership?.owner !== filterOwner) return false;
+    if (filterTeam !== 'ALL' && a.ownership?.team !== filterTeam) return false;
+    return true;
+  };
+
+  if (focusId) {
+    // Neighborhood exploration
+    const root = index.artifactsById.get(focusId);
+    if (!root || !isArtifactAllowed(root)) return { artifacts: [], relations: [] };
+    
+    artifacts.add(root);
+    let queue: { id: string, currentDepth: number }[] = [{ id: focusId, currentDepth: 0 }];
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+      const { id, currentDepth } = queue.shift()!;
+      if (visited.has(id)) continue;
+      visited.add(id);
+
+      if (currentDepth >= depth) continue;
+
+      const outgoing = index.relationsBySource.get(id) || [];
+      const incoming = index.relationsByTarget.get(id) || [];
+
+      [...outgoing, ...incoming].forEach(rel => {
+        if (!isRelationAllowed(rel, options)) return;
+
+        const otherId = rel.from === id ? rel.to : rel.from;
+        const otherArt = index.artifactsById.get(otherId);
+        
+        if (otherArt && isArtifactAllowed(otherArt)) {
+          relations.add(rel);
+          artifacts.add(otherArt);
+          if (!visited.has(otherId)) {
+            queue.push({ id: otherId, currentDepth: currentDepth + 1 });
+          }
+        }
+      });
+    }
+
+  } else {
+    // If no focus, return all (subject to limits and filters layer)
+    // and hide weak relations if flag is off
+    graph.artifacts.forEach(a => {
+      if (isArtifactAllowed(a)) artifacts.add(a);
+    });
+    graph.relations.forEach(r => {
+      const from = index.artifactsById.get(r.from);
+      const to = index.artifactsById.get(r.to);
+      if (from && to && isArtifactAllowed(from) && isArtifactAllowed(to) && isRelationAllowed(r, options)) {
+        relations.add(r);
+      }
+    });
+
+    // If still too large, we might truncate to prevent crash, though graph limits are handled later or gracefully
+    if (artifacts.size > MAX_RENDER_NODES && !focusId) {
+      const allArtifacts = Array.from(artifacts).slice(0, MAX_RENDER_NODES);
+      const allowedIds = new Set(allArtifacts.map(a => a.id));
+      const filteredRelations = Array.from(relations).filter(r => allowedIds.has(r.from) && allowedIds.has(r.to));
+      
+      return {
+        artifacts: allArtifacts,
+        relations: filteredRelations
+      };
+    }
+  }
+
+  // Hub suppression or capping
+  if (artifacts.size > MAX_RENDER_NODES) {
+     const allArtifacts = Array.from(artifacts).slice(0, MAX_RENDER_NODES);
+     const allowedIds = new Set(allArtifacts.map(a => a.id));
+     const filteredRelations = Array.from(relations).filter(r => allowedIds.has(r.from) && allowedIds.has(r.to));
+     return {
+       artifacts: allArtifacts,
+       relations: filteredRelations
+     };
+  }
+
+  return {
+    artifacts: Array.from(artifacts),
+    relations: Array.from(relations)
+  };
+}

package/src/core/registry/ArtifactRegistry.ts

@@ -0,0 +1,19 @@
+export const 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'
+] as const;
+
+export type ArtifactType = typeof CORE_ARTIFACT_TYPES[number];
+
+export class ArtifactRegistry {
+  static getValidTypes(): readonly string[] {
+    return CORE_ARTIFACT_TYPES;
+  }
+
+  static isValid(type: string): type is ArtifactType {
+    return CORE_ARTIFACT_TYPES.includes(type as ArtifactType);
+  }
+}

package/src/core/registry/RelationRegistry.ts

@@ -0,0 +1,27 @@
+import { RelationContract, GENERATED_RELATIONS } from '../generated/relation-definitions.js';
+
+export class RelationRegistry {
+  private static relationsMap = new Map<string, RelationContract>(
+    GENERATED_RELATIONS.map(rel => [rel.type, rel])
+  );
+
+  static getValidTypes(): string[] {
+    return Array.from(this.relationsMap.keys());
+  }
+
+  static getContract(type: string): RelationContract | undefined {
+    return this.relationsMap.get(type);
+  }
+
+  static isValid(type: string): boolean {
+    return this.relationsMap.has(type);
+  }
+
+  static getRelationsByCategory(category: string): RelationContract[] {
+    return GENERATED_RELATIONS.filter(rel => rel.category === category);
+  }
+
+  static getAllContracts(): RelationContract[] {
+    return GENERATED_RELATIONS;
+  }
+}

package/src/core/semantic/artifact-layers.ts

@@ -0,0 +1,43 @@
+import { ArtifactType, ArtifactLayer } from '../../types.js';
+
+export const LayerInferenceRules: Record<ArtifactType, ArtifactLayer> = {
+  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',
+};
+
+export function inferLayer(artifactType: ArtifactType): ArtifactLayer | undefined {
+  return LayerInferenceRules[artifactType];
+}

package/src/core/semantic/ownership-rules.ts

@@ -0,0 +1,13 @@
+import { Ownership } from '../../types.js';
+
+export function resolveArtifactOwnership(localOwnership?: Ownership, parentOwnership?: Ownership): Ownership {
+  if (!localOwnership && !parentOwnership) return {};
+  
+  return {
+    owner: localOwnership?.owner || parentOwnership?.owner,
+    team: localOwnership?.team || parentOwnership?.team,
+    maintainers: localOwnership?.maintainers || parentOwnership?.maintainers || [],
+    reviewers: localOwnership?.reviewers || parentOwnership?.reviewers || [],
+    steward: localOwnership?.steward || parentOwnership?.steward,
+  };
+}

package/src/core/semantic/types.ts

@@ -0,0 +1,11 @@
+export type ArtifactLayer = 'BUSINESS' | 'ARCHITECTURE' | 'IMPLEMENTATION' | 'OPERATIONS' | 'DOCUMENTATION';
+export type RelationCategory = 'STRUCTURAL' | 'BEHAVIORAL' | 'OPERATIONAL' | 'TRACEABILITY';
+export type RelationStrength = 'STRONG' | 'MEDIUM' | 'WEAK';
+
+export interface Ownership {
+  owner?: string;
+  team?: string;
+  maintainers?: string[];
+  reviewers?: string[];
+  steward?: string;
+}

package/src/index.css

@@ -0,0 +1,121 @@
+@import "tailwindcss";
+
+@layer base {
+  ::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+  }
+
+  ::-webkit-scrollbar-track {
+    background: #0a0a0a;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: #222;
+    border-radius: 10px;
+  }
+
+  ::-webkit-scrollbar-thumb:hover {
+    background: #10b981;
+  }
+
+  * {
+    scrollbar-width: thin;
+    scrollbar-color: #222 #0a0a0a;
+  }
+}
+
+@media print {
+  @page {
+    size: auto;
+    margin: 15mm 10mm;
+  }
+  
+  /* Force light theme for printing to save ink */
+  *, *::before, *::after {
+    background: transparent !important;
+    background-color: transparent !important;
+    color: #000 !important;
+    box-shadow: none !important;
+    text-shadow: none !important;
+    backdrop-filter: none !important;
+    -webkit-backdrop-filter: none !important;
+  }
+
+  body {
+    -webkit-print-color-adjust: exact !important;
+    print-color-adjust: exact !important;
+    background-color: white !important;
+  }
+  
+  [class*="border"],
+  [class*="divide"] > * {
+    border-color: #aaa !important;
+  }
+
+  /* Hide scrollbars and allow full height for printing */
+  html, body, #root, .h-full, .h-screen, .overflow-hidden, .overflow-y-auto, .flex-1, .print-block {
+    height: auto !important;
+    min-height: auto !important;
+    overflow: visible !important;
+    position: static !important;
+  }
+  
+  /* Change specific flex containers to block to prevent print cutoff */
+  .print-block {
+    display: block !important;
+  }
+
+  /* Prevent page breaks inside sections and artifacts */
+  section, tr, .group {
+    page-break-inside: avoid;
+    break-inside: avoid;
+  }
+  
+  /* Hide UI elements */
+  .print-hidden {
+    display: none !important;
+  }
+
+  /* Fix for Mermaid diagrams printing as black blocks */
+  .mermaid-wrapper svg rect,
+  .mermaid-wrapper svg circle,
+  .mermaid-wrapper svg ellipse,
+  .mermaid-wrapper svg polygon,
+  .mermaid-wrapper svg path {
+    fill: white !important;
+    stroke: #555 !important;
+    stroke-width: 1px !important;
+  }
+  
+  .mermaid-wrapper svg .edgePath path,
+  .mermaid-wrapper svg .flowchart-link {
+    fill: none !important;
+  }
+
+  /* Keep arrows filled */
+  .mermaid-wrapper svg [id*="arrow"] path,
+  .mermaid-wrapper svg marker path,
+  .mermaid-wrapper svg marker polygon {
+    fill: #555 !important;
+    stroke: none !important;
+  }
+
+  .mermaid-wrapper svg text,
+  .mermaid-wrapper svg tspan {
+    fill: black !important;
+    stroke: none !important;
+    color: black !important;
+  }
+  
+  .mermaid-wrapper svg .cluster rect {
+    fill: transparent !important;
+    stroke: #999 !important;
+    stroke-dasharray: 4 !important;
+  }
+  
+  .mermaid-wrapper svg .edgeLabel rect {
+    fill: white !important;
+    stroke: none !important;
+  }
+}

package/src/lib/reportUtils.ts

@@ -0,0 +1,59 @@
+export interface GapIssue {
+    artifact: any;
+    type: string;
+    message: string;
+    severity: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+
+export function generateGapsReport(gaps: GapIssue[], isFiltered: boolean): string {
+    const total = gaps.length;
+    const critical = gaps.filter(g => g.severity === 'HIGH').length;
+    const warning = gaps.filter(g => g.severity === 'MEDIUM').length;
+    const info = gaps.filter(g => g.severity === 'LOW').length;
+
+    let content = `# OpenLAG GAPs Report
+
+Generated at: ${new Date().toISOString()}
+
+Scope: ${isFiltered ? 'filtered' : 'all'}
+
+## Summary
+
+- Total issues: ${total}
+- Critical: ${critical}
+- Warning: ${warning}
+- Info: ${info}
+
+## Issues
+
+`;
+
+    if (total === 0) {
+        content += `*No GAPs found for the current exact filters. Great job!*\n`;
+        return content;
+    }
+
+    gaps.forEach((gap, index) => {
+        const art = gap.artifact;
+        content += `### ${index + 1}. ${art.id} — ${gap.severity}\n\n`;
+        content += `- Artifact: ${art.title || 'Untitled'}\n`;
+        content += `- Type: ${art.type}\n`;
+        if (art.status) content += `- Status: ${art.status}\n`;
+        content += `- Relation: N/A\n`;
+        content += `- Reason: ${gap.message}\n\n`;
+    });
+
+    return content;
+}
+
+export function downloadTextFile(filename: string, content: string) {
+    const blob = new Blob([content], { type: 'text/markdown;charset=utf-8;' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.setAttribute('download', filename);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}

package/src/main.tsx

@@ -0,0 +1,10 @@
+import {StrictMode} from 'react';
+import {createRoot} from 'react-dom/client';
+import App from './App.tsx';
+import './index.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/src/store.ts

@@ -0,0 +1,146 @@
+import { create } from 'zustand';
+import { Version, Change, GraphSnapshot, Artifact, Relation, SystemVersion } from './types';
+import { GraphIndex, buildGraphIndex, projectSubgraph, GraphQueryOptions, DEFAULT_NEIGHBORHOOD_DEPTH } from './core/graph/GraphQueryLayer';
+
+interface Settings {
+  graphFocusDepth: number;
+  docsFocusDepth: number;
+  defaultDocsFocusMode: boolean;
+  showWeakRelations: boolean;
+  language: 'EN' | 'ES';
+}
+
+interface StoreState {
+  versions: Version[];
+  systemVersions: SystemVersion[];
+  changes: Change[];
+  currentVersionId: string | null;
+  fullGraph: GraphSnapshot | null;
+  graphIndex: GraphIndex | null;
+  currentSubgraph: GraphSnapshot | null;
+  activeView: 'graph' | 'docs' | 'impact' | 'orphans' | 'guide' | 'settings';
+  selectedArtifactId: string | null;
+  isLoading: boolean;
+  settings: Settings;
+  globalFilters: {
+    layer: string;
+    owner: string;
+    team: string;
+  };
+  
+  initializeStore: () => Promise<void>;
+  setVersion: (versionId: string) => void;
+  setView: (view: 'graph' | 'docs' | 'impact' | 'orphans' | 'guide' | 'settings') => void;
+  setSelectedArtifact: (id: string | null) => void;
+  updateSettings: (newSettings: Partial<Settings>) => void;
+  setGlobalFilter: (filterType: 'layer' | 'owner' | 'team', value: string) => void;
+  refreshSubgraph: () => void;
+}
+
+// Global variable to store fetched data
+let cachedData: {
+  versions: Version[];
+  systemVersions: SystemVersion[];
+  changes: Change[];
+  graphs: Record<string, GraphSnapshot>;
+} | null = null;
+
+export const useStore = create<StoreState>((set, get) => ({
+  versions: [],
+  systemVersions: [],
+  changes: [],
+  currentVersionId: null,
+  fullGraph: null,
+  graphIndex: null,
+  currentSubgraph: null,
+  activeView: 'graph',
+  selectedArtifactId: null,
+  isLoading: false,
+  settings: {
+    graphFocusDepth: DEFAULT_NEIGHBORHOOD_DEPTH,
+    docsFocusDepth: 1,
+    defaultDocsFocusMode: true,
+    showWeakRelations: false,
+    language: 'EN',
+  },
+  globalFilters: {
+    layer: 'ALL',
+    owner: 'ALL',
+    team: 'ALL',
+  },
+  updateSettings: (newSettings) => {
+    set((state) => ({ settings: { ...state.settings, ...newSettings } }));
+    get().refreshSubgraph();
+  },
+  setGlobalFilter: (filterType, value) => {
+    set((state) => ({
+      globalFilters: {
+        ...state.globalFilters,
+        [filterType]: value
+      }
+    }));
+    get().refreshSubgraph();
+  },
+  
+  refreshSubgraph: () => {
+    const { fullGraph, graphIndex, selectedArtifactId, settings, globalFilters } = get();
+    if (!fullGraph || !graphIndex) return;
+
+    const options: GraphQueryOptions = {
+        focusId: selectedArtifactId || undefined,
+        depth: settings.graphFocusDepth,
+        showWeakRelations: settings.showWeakRelations,
+        filterLayer: globalFilters.layer,
+        filterOwner: globalFilters.owner,
+        filterTeam: globalFilters.team
+    };
+
+    const subgraph = projectSubgraph(fullGraph, graphIndex, options);
+    set({ currentSubgraph: subgraph });
+  },
+
+  initializeStore: async () => {
+    
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/graph-data.json');
+      if (!response.ok) throw new Error("Failed to load graph data");
+      
+      cachedData = await response.json();
+      
+      if (cachedData) {
+        const { versions, systemVersions, changes } = cachedData;
+        set({ 
+          versions, 
+          systemVersions: systemVersions || [],
+          changes,
+          isLoading: false
+        });
+        
+        if (versions.length > 0 && !get().currentVersionId) {
+          get().setVersion(versions[versions.length - 1].id);
+        }
+      }
+    } catch (e) {
+      console.error("OpenLAG Error: Could not fetch static data.", e);
+      set({ isLoading: false });
+    }
+  },
+
+  setVersion: (versionId) => {
+    if (!cachedData) return;
+    const fullGraph = cachedData.graphs[versionId] || null;
+    let graphIndex = null;
+    if (fullGraph) {
+       graphIndex = buildGraphIndex(fullGraph);
+    }
+    set({ currentVersionId: versionId, selectedArtifactId: null, fullGraph, graphIndex });
+    get().refreshSubgraph();
+  },
+
+  setView: (view) => set({ activeView: view }),
+  setSelectedArtifact: (id) => {
+      set({ selectedArtifactId: id });
+      get().refreshSubgraph();
+  }
+}));