ea 0.4.0 → 0.5.0

data/frontend/src/types.ts

@@ -0,0 +1,221 @@
+export interface SpaCardinality {
+  min?: string
+  max?: string
+}
+
+export interface SpaAttribute {
+  id: string
+  name: string
+  type: string
+  visibility?: string
+  owner: string
+  ownerName: string
+  cardinality?: SpaCardinality
+  definition?: string
+  stereotypes: string[]
+  isStatic: boolean
+  isReadOnly: boolean
+  defaultValue?: string
+}
+
+export interface SpaAssociationEnd {
+  class?: string
+  className?: string
+  role?: string
+  cardinality?: SpaCardinality
+  aggregation?: string
+}
+
+export interface SpaAssociation {
+  id: string
+  xmiId: string
+  name: string
+  type: string
+  definition?: string
+  source?: SpaAssociationEnd
+  target?: SpaAssociationEnd
+}
+
+export interface SpaOperation {
+  id: string
+  name: string
+  visibility?: string
+  returnType?: string
+  owner: string
+  ownerName: string
+  parameters: SpaParameter[]
+  isStatic: boolean
+  isAbstract: boolean
+}
+
+export interface SpaParameter {
+  name: string
+  type?: string
+  direction?: string
+}
+
+export interface SpaLiteral {
+  name: string
+  definition?: string
+}
+
+export interface SpaInheritedAttribute {
+  attributeId: string
+  attribute: SpaAttribute
+  inheritedFrom: string
+  inheritedFromName: string
+  parentOrder: number
+}
+
+export interface SpaInheritedAssociation {
+  associationId: string
+  inheritedFrom: string
+  inheritedFromName: string
+  parentOrder: number
+  localRole: string
+}
+
+export interface SpaClass {
+  id: string
+  xmiId: string
+  name: string
+  qualifiedName: string
+  type: string
+  package?: string
+  stereotypes: string[]
+  definition?: string
+  attributes: string[]
+  operations: string[]
+  associations: string[]
+  generalizations: string[]
+  specializations: string[]
+  isAbstract: boolean
+  literals: SpaLiteral[]
+  inheritedAttributes: SpaInheritedAttribute[]
+  inheritedAssociations: SpaInheritedAssociation[]
+}
+
+export interface SpaPackage {
+  id: string
+  xmiId: string
+  name: string
+  path: string
+  definition?: string
+  stereotypes: string[]
+  classes: string[]
+  subPackages: string[]
+  diagrams: string[]
+  parent?: string
+}
+
+export interface SpaTreeClassRef {
+  id: string
+  name: string
+  stereotypes: string[]
+}
+
+export interface SpaPackageTreeNode {
+  id: string
+  name: string
+  path: string
+  stereotypes: string[]
+  classCount: number
+  classes: SpaTreeClassRef[]
+  children: SpaPackageTreeNode[]
+}
+
+export interface SpaDiagram {
+  id: string
+  xmiId: string
+  name: string
+  type: string
+  package?: string
+  objectCount: number
+  linkCount: number
+  svg?: string
+}
+
+export interface SpaStatistics {
+  packages: number
+  classes: number
+  associations: number
+  attributes: number
+  operations: number
+}
+
+export interface SpaLogoVariant {
+  path?: string
+  url?: string
+}
+
+export interface SpaLogoConfig {
+  light: SpaLogoVariant
+  dark: SpaLogoVariant
+}
+
+export interface SpaLogos {
+  square?: SpaLogoConfig
+  long?: SpaLogoConfig
+}
+
+export interface SpaAppearance {
+  logos?: SpaLogos
+}
+
+export interface SpaMetadata {
+  title?: string
+  description?: string
+  generated: string
+  generator: string
+  version: string
+  homepage?: string
+  repository?: string
+  license?: string
+  authors?: string
+  tags?: string[]
+  appearance?: SpaAppearance
+  statistics: SpaStatistics
+}
+
+export interface SpaSearchEntry {
+  id: string
+  type: string
+  entityType: string
+  entityId: string
+  name: string
+  qualifiedName: string
+  package: string
+  content: string
+  boost: number
+}
+
+export interface SpaSearchIndex {
+  version: string
+  fields: { name: string; boost: number }[]
+  ref: string
+  documentStore: SpaSearchEntry[]
+  pipeline: string[]
+}
+
+export interface SpaDocument {
+  metadata: SpaMetadata
+  packageTree: SpaPackageTreeNode
+  packages: Record<string, SpaPackage>
+  classes: Record<string, SpaClass>
+  attributes: Record<string, SpaAttribute>
+  associations: Record<string, SpaAssociation>
+  operations: Record<string, SpaOperation>
+  diagrams: Record<string, SpaDiagram>
+}
+
+export interface SpaData {
+  metadata: SpaMetadata
+  packageTree: SpaPackageTreeNode
+  packages: Record<string, SpaPackage>
+  classes: Record<string, SpaClass>
+  attributes: Record<string, SpaAttribute>
+  associations: Record<string, SpaAssociation>
+  operations: Record<string, SpaOperation>
+  diagrams: Record<string, SpaDiagram>
+  searchIndex: SpaSearchIndex
+}

data/frontend/tests/e2e/render.spec.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import puppeteer, { type Browser, type Page } from 'puppeteer'
+import path from 'path'
+import fs from 'fs'
+
+const NEW_HTML = '/tmp/lutaml_test_new.html'
+const SCREENSHOT_DIR = path.join(__dirname, '__screenshots__')
+
+describe('Lutaml SPA rendering', () => {
+  let browser: Browser
+  let page: Page
+  const consoleErrors: string[] = []
+
+  beforeAll(async () => {
+    fs.mkdirSync(SCREENSHOT_DIR, { recursive: true })
+
+    browser = await puppeteer.launch({
+      headless: true,
+      args: ['--no-sandbox', '--disable-setuid-sandbox'],
+    })
+    page = await browser.newPage()
+    await page.setViewport({ width: 1280, height: 800 })
+
+    page.on('pageerror', (err) => {
+      consoleErrors.push(`PageError: ${err.message}`)
+    })
+    page.on('console', (msg) => {
+      if (msg.type() === 'error') {
+        consoleErrors.push(`ConsoleError: ${msg.text()}`)
+      }
+    })
+  })
+
+  afterAll(async () => {
+    await browser.close()
+  })
+
+  it('loads without JS errors', async () => {
+    await page.goto(`file://${NEW_HTML}`, { waitUntil: 'networkidle0', timeout: 10000 })
+
+    // Wait for Vue to mount
+    await page.waitForSelector('#app', { timeout: 5000 })
+    await new Promise((r) => setTimeout(r, 500))
+
+    const criticalErrors = consoleErrors.filter(
+      (e) =>
+        !e.includes('favicon') &&
+        !e.includes('fonts.googleapis.com') &&
+        !e.includes('Download the React DevTools')
+    )
+    expect(criticalErrors).toEqual([])
+  })
+
+  it('renders the sidebar', async () => {
+    const sidebar = await page.$('.sidebar')
+    expect(sidebar).not.toBeNull()
+
+    const branding = await page.$('.sidebar-branding')
+    expect(branding).not.toBeNull()
+
+    const overviewBtn = await page.$('.overview-btn')
+    expect(overviewBtn).not.toBeNull()
+  })
+
+  it('renders the header', async () => {
+    const header = await page.$('.header')
+    expect(header).not.toBeNull()
+
+    const searchTrigger = await page.$('.search-trigger')
+    expect(searchTrigger).not.toBeNull()
+
+    const themeBtn = await page.$('.theme-btn')
+    expect(themeBtn).not.toBeNull()
+  })
+
+  it('renders the package tree', async () => {
+    const treeNodes = await page.$$('.tree-node')
+    expect(treeNodes.length).toBeGreaterThan(0)
+  })
+
+  it('renders the welcome view by default', async () => {
+    const welcome = await page.$('.view-welcome')
+    expect(welcome).not.toBeNull()
+
+    const stats = await page.$$('.welcome-stat')
+    expect(stats.length).toBeGreaterThan(0)
+  })
+
+  it('takes a screenshot of the welcome page', async () => {
+    await page.screenshot({
+      path: path.join(SCREENSHOT_DIR, 'new-welcome.png'),
+      fullPage: false,
+    })
+  })
+
+  it('toggles dark mode', async () => {
+    // Check initial theme
+    const initialTheme = await page.evaluate(() => {
+      return document.querySelector('.app-layout')?.getAttribute('data-theme')
+    })
+    expect(initialTheme).toBe('light')
+
+    // Click theme toggle
+    await page.click('.theme-btn')
+    await new Promise((r) => setTimeout(r, 200))
+
+    const darkTheme = await page.evaluate(() => {
+      return document.querySelector('.app-layout')?.getAttribute('data-theme')
+    })
+    expect(darkTheme).toBe('dark')
+
+    await page.screenshot({
+      path: path.join(SCREENSHOT_DIR, 'new-dark-mode.png'),
+      fullPage: false,
+    })
+
+    // Toggle back
+    await page.click('.theme-btn')
+    await new Promise((r) => setTimeout(r, 200))
+  })
+
+  it('collapses and expands sidebar', async () => {
+    // Sidebar should be visible initially
+    const sidebarClass = await page.evaluate(() => {
+      return document.querySelector('.sidebar')?.className
+    })
+    expect(sidebarClass).not.toContain('collapsed')
+
+    // Click sidebar toggle
+    await page.click('.sidebar-toggle')
+    await new Promise((r) => setTimeout(r, 300))
+
+    const collapsedClass = await page.evaluate(() => {
+      return document.querySelector('.sidebar')?.className
+    })
+    expect(collapsedClass).toContain('collapsed')
+
+    await page.screenshot({
+      path: path.join(SCREENSHOT_DIR, 'new-sidebar-collapsed.png'),
+      fullPage: false,
+    })
+
+    // Expand again
+    await page.click('.sidebar-toggle')
+    await new Promise((r) => setTimeout(r, 300))
+  })
+
+  it('opens search modal with / key', async () => {
+    await page.keyboard.press('/')
+    await new Promise((r) => setTimeout(r, 200))
+
+    const modal = await page.$('.search-modal-overlay')
+    expect(modal).not.toBeNull()
+
+    await page.screenshot({
+      path: path.join(SCREENSHOT_DIR, 'new-search-modal.png'),
+      fullPage: false,
+    })
+
+    // Close
+    await page.keyboard.press('Escape')
+    await new Promise((r) => setTimeout(r, 200))
+  })
+
+  it('clicks a package in the tree and shows details', async () => {
+    // Click the first package label in the tree
+    const clicked = await page.evaluate(() => {
+      const label = document.querySelector('.tree-label') as HTMLElement
+      if (label) {
+        label.click()
+        return true
+      }
+      return false
+    })
+    expect(clicked).toBe(true)
+
+    await new Promise((r) => setTimeout(r, 300))
+
+    // Should show package details or class details
+    const detailView = await page.$('.detail-view')
+    expect(detailView).not.toBeNull()
+
+    await page.screenshot({
+      path: path.join(SCREENSHOT_DIR, 'new-package-details.png'),
+      fullPage: false,
+    })
+  })
+})

data/frontend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "noEmit": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue"],
+  "exclude": ["node_modules", "dist"]
+}

data/frontend/vite.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { resolve } from 'path'
+
+export default defineConfig({
+  plugins: [vue()],
+  define: {
+    'process.env.NODE_ENV': JSON.stringify('production'),
+  },
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/app.ts'),
+      name: 'LutamlUmlSpa',
+      formats: ['iife'],
+      fileName: () => 'app.iife.js',
+    },
+    rollupOptions: {
+      external: [],
+      output: {
+        assetFileNames: 'style.[ext]',
+      },
+    },
+    outDir: 'dist',
+    emptyOutDir: true,
+  },
+})

data/frontend/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    testTimeout: 30000,
+    hookTimeout: 30000,
+  },
+})

data/lib/ea/cli/app.rb

@@ -88,8 +88,6 @@ module Ea
       desc "svg NAME FILE", "Render a diagram from QEA/XMI to standalone SVG"
       option :output, **OUTPUT_OPTION,
              desc: "Output path (default: <basename>.<diagram>.svg)"
-      option :mode, type: :string, default: "ea",
-                    desc: "Output mode: ea (default, matches EA SVG structure) | thin (compact)"
       option :all, type: :boolean, default: false,
                    desc: "Render every diagram in the source file (NAME ignored)"
       option :output_dir, type: :string,
@@ -98,6 +96,63 @@ module Ea
         Command::Svg.new(name: name, file: file, **symbolize(options)).call
       end
 
+      desc "diff OLD NEW", "Compare two QEA files structurally"
+      option :format, type: :string, default: "table",
+                      desc: "Output format: table | json | html"
+      option :output, **OUTPUT_OPTION, desc: "Output path (html format)"
+      def diff(old, new)
+        Command::Diff.new(old: old, new: new, **symbolize(options)).call
+      end
+
+      desc "render NAME FILE", "Render diagram(s) to SVG/PNG/PDF"
+      option :output, **OUTPUT_OPTION,
+             desc: "Output path (default: <basename>.<diagram>.<ext>)"
+      option :all, type: :boolean, default: false,
+                   desc: "Render every diagram in the source file (NAME ignored)"
+      option :format, type: :string, default: "svg",
+                      desc: "Output format: svg | png | pdf"
+      option :output_dir, type: :string,
+                          desc: "Directory for --all output (default: <basename>.renders/)"
+      def render(name = nil, file = nil)
+        Command::Render.new(name: name, file: file, **symbolize(options)).call
+      end
+
+      desc "export SUB FILE", "Export model (SUB: xmi|json|plantuml|xsd)"
+      option :output, **OUTPUT_OPTION, desc: "Output path"
+      option :package, type: :string, desc: "Restrict to a package name"
+      def export(sub, file)
+        Command::Export.new(sub: sub, file: file, **symbolize(options)).call
+      end
+
+      desc "mdg ACTION [ARG]", "MDG technologies: list | show NAME"
+      option :format, type: :string, default: "table"
+      def mdg(action, arg = nil)
+        Command::Mdg.new(action: action, arg: arg, **symbolize(options)).call
+      end
+
+      desc "lint FILE", "Run model quality lint rules"
+      option :rule, type: :string, desc: "Filter by rule name substring"
+      option :severity, type: :string, desc: "Filter: error | warning | info"
+      option :format, type: :string, default: "table"
+      def lint(file)
+        Command::Lint.new(file: file, **symbolize(options)).call
+      end
+
+      desc "query FILE", "Filter model elements by criteria"
+      option :type, type: :string, desc: "Filter by object_type (Class, etc.)"
+      option :package, type: :string, desc: "Restrict to a package name"
+      option :stereotype, type: :string, desc: "Filter by stereotype name"
+      option :format, type: :string, default: "table"
+      def query(file)
+        Command::Query.new(file: file, **symbolize(options)).call
+      end
+
+      desc "info NAME FILE", "Show details of a single element"
+      option :format, type: :string, default: "table"
+      def info(name, file)
+        Command::Info.new(name: name, file: file, **symbolize(options)).call
+      end
+
       private
 
       def symbolize(opts)

data/lib/ea/cli/command/diagrams.rb

@@ -6,19 +6,13 @@ module Ea
       # `ea diagrams ACTION FILE [NAME]`
       #
       # Actions:
-      #   list FILE           — list diagrams in a QEA/XMI/LUR file (standalone)
+      #   list FILE           — list diagrams in a QEA/XMI file
       #   extract FILE NAME   — render the named diagram to SVG
       #
-      # `list` reads the EA database directly (no lutaml-uml required
-      # for QEA; XMI parsing via xmi gem only).
-      #
-      # `extract` accepts QEA, XMI, or LUR. The Repository is built
-      # from the input file via `RepositoryBuilder` (single source of
-      # truth — QEA/XMI are parsed via `Ea::Transformations`, LUR is
-      # loaded natively via `Repository.from_file`).
+      # Both actions use the modern Ea::Model pipeline (parsed via
+      # Ea::Sources::Qea/Xmi::Adapter, rendered via
+      # Ea::Svg::EaEmitter::Document). No lutaml-uml dependency.
       class Diagrams < Base
-        include RepositoryBuilder
-
         ACTIONS = %w[list extract].freeze
 
         def call
@@ -41,34 +35,49 @@ module Ea
         end
 
         def list
-          db = load_database
-          rows = db.diagrams.map { |d| [d.name, diagram_type_label(d), d.ea_guid] }
-          formatter.render(rows, columns: %i[name type guid])
+          rows = document.diagrams.map do |d|
+            [d.name, diagram_type_label(d)]
+          end
+          formatter.render(rows, columns: %i[name type])
         end
 
         def extract
-          repository = RepositoryBuilder.build_repository(file_path)
-          result = extractor.extract_one(repository, name, extract_options)
-          raise Ea::Cli::Error, result[:message] unless result[:success]
+          diagram = document.diagrams.find { |d| d.name == name }
+          unless diagram
+            raise Ea::Cli::Error,
+                  "Diagram #{name.inspect} not found in #{file_path}. " \
+                  "Use `ea diagrams list #{file_path}` to see names."
+          end
 
-          path = result[:path] || write_output(result.fetch(:svg_content),
-                                                default_name: "#{name}.svg")
+          svg = Ea::Svg::EaEmitter::Document.new(diagram,
+                                                   model_index: document.index_by_id,
+                                                   document: document).render
+          path = options[:output] || begin
+            base = File.basename(file_path, ".*")
+            dir = File.dirname(file_path)
+            safe_name = (diagram.name || "diagram").gsub(/[^\w.\-]+/, "_")
+            File.join(dir, "#{base}.#{safe_name}.svg")
+          end
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, svg)
           formatter.render([[path]], columns: [:written_to])
         end
 
-        def extractor
-          Ea::Diagram::Extractor.new
-        end
-
-        def extract_options
-          opts = {}
-          opts[:output] = options[:output] if options[:output]
-          opts
-        end
-
         def diagram_type_label(diagram)
           diagram.diagram_type || "Logical"
         end
+
+        def document
+          @document ||= case File.extname(file_path).downcase
+                        when ".qea"
+                          Ea::Sources::Qea::Adapter.from_path(file_path)
+                        when ".xmi", ".xml"
+                          Ea::Sources::Xmi::Adapter.from_path(file_path)
+                        else
+                          raise Ea::Cli::UnsupportedFormat,
+                                "Unknown file format: #{File.extname(file_path)}"
+                        end
+        end
       end
     end
   end

data/lib/ea/cli/command/diff.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    module Command
+      # `ea diff OLD_FILE NEW_FILE`
+      #
+      # Standalone — does not require lutaml-uml. Loads two QEA databases
+      # and reports added / removed / renamed entities.
+      #
+      # Exit code: 0 if identical, 1 if any differences found.
+      class Diff < Base
+        COLUMNS = %i[change kind id name].freeze
+
+        def call
+          if options[:format] == "html"
+            write_html_report
+          else
+            rows = comparator.differences.map do |diff|
+              [diff.change, diff.kind, diff.id, diff.name]
+            end
+            formatter.render(rows, columns: COLUMNS)
+          end
+          exit(1) if comparator.differences.any?
+        end
+
+        private
+
+        def write_html_report
+          html = Ea::Diff::HtmlReporter.new(comparator).render
+          path = options[:output] || "diff_report.html"
+          File.write(path, html)
+          formatter.render([[path]], columns: [:written_to])
+        end
+
+        def comparator
+          @comparator ||= begin
+            old_db = load_database(options[:old])
+            new_db = load_database(options[:new])
+            Ea::Diff::Comparator.new(old_db, new_db)
+          end
+        end
+      end
+    end
+  end
+end