archsight 0.1.0

data/lib/archsight/resources/business_product.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+# BusinessProduct represents a product or service offered to customers
+class Archsight::Resources::BusinessProduct < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents a coherent collection of services offered to customers.
+
+    ## ArchiMate Definition
+
+    **Layer:** Business
+    **Aspect:** Passive Structure
+
+    A product represents a coherent collection of services and/or passive structure elements,
+    accompanied by a contract/set of agreements, which is offered as a whole to customers.
+    Products are the marketable offerings that deliver value.
+
+    ## Usage
+
+    Use BusinessProduct to represent:
+
+    - Cloud services (Compute, Storage, Networking)
+    - Managed database offerings
+    - Kubernetes services
+    - Enterprise support packages
+    - API products
+  MD
+
+  icon "box-iso"
+  layer "business"
+
+  computed_annotation "repository/artifacts/total",
+                      title: "Total Git Repositories",
+                      description: "Number of related git repositories across all related application components",
+                      type: Integer do
+    sum(outgoing_transitive(:ApplicationService), "repository/artifacts/total")
+  end
+
+  computed_annotation "repository/artifacts/active",
+                      title: "Active Git Repositories",
+                      description: "Number of related git repositories across all related application components",
+                      type: Integer do
+    sum(outgoing_transitive(:ApplicationService), "repository/artifacts/active")
+  end
+
+  computed_annotation "repository/artifacts/abandoned",
+                      title: "Abandoned Git Repositories",
+                      description: "Number of related git repositories across all related application components",
+                      type: Integer do
+    sum(outgoing_transitive(:ApplicationService), "repository/artifacts/abandoned")
+  end
+
+  computed_annotation "repository/artifacts/highBusFactor",
+                      title: "High Bus Factor Repositories",
+                      description: "Number of active git repositories with high bus factor across all related application components",
+                      type: Integer do
+    sum(outgoing_transitive(:ApplicationService), "repository/artifacts/highBusFactor")
+  end
+
+  computed_annotation "repository/artifacts/archived",
+                      title: "Archived Repositories",
+                      description: "Number of archived git repositories across all related application services",
+                      type: Integer do
+    sum(outgoing_transitive(:ApplicationService), "repository/artifacts/archived")
+  end
+
+  %w[scc/estimatedCost scc/estimatedScheduleMonths scc/estimatedPeople].each do |anno_key|
+    computed_annotation anno_key,
+                        title: "Total #{anno_key.split("/").last.split(/(?=[A-Z])/).map(&:capitalize).join(" ")}",
+                        description: "Total estimated #{anno_key.split("/").last} from related artifacts across all related application components",
+                        type: Integer do
+      sum(outgoing_transitive(:ApplicationService), anno_key)
+    end
+  end
+
+  computed_annotation "activity/commits",
+                      title: "Monthly Commits",
+                      description: "Accumulated monthly commit counts across all related application services",
+                      sidebar: false do
+    services = outgoing_transitive(:ApplicationService)
+    next nil if services.empty?
+
+    # Collect all commit arrays from services (they all end at the current month)
+    # Use get() to trigger computation of computed annotations on ApplicationServices
+    commit_arrays = services.map do |service|
+      commits_str = get(service, "activity/commits")
+      next nil if commits_str.nil? || commits_str.empty?
+
+      commits_str.split(",").map(&:to_i)
+    end.compact
+
+    next nil if commit_arrays.empty?
+
+    # Find the maximum length (oldest service determines the timeline)
+    max_length = commit_arrays.map(&:length).max
+
+    # Pad shorter arrays at the beginning with zeros and sum
+    result = Array.new(max_length, 0)
+    commit_arrays.each do |arr|
+      offset = max_length - arr.length
+      arr.each_with_index do |count, idx|
+        result[offset + idx] += count
+      end
+    end
+
+    result.join(",")
+  end
+
+  computed_annotation "activity/createdAt",
+                      title: "Created",
+                      description: "Earliest repository creation date across all related application services",
+                      list: true,
+                      type: Time do
+    services = outgoing_transitive(:ApplicationService)
+    next nil if services.empty?
+
+    # Use get() to trigger computation of computed annotations on ApplicationServices
+    dates = services.map do |service|
+      date_val = get(service, "activity/createdAt")
+      next nil if date_val.nil?
+
+      if date_val.is_a?(Time)
+        date_val
+      else
+        begin
+          Time.parse(date_val.to_s)
+        rescue StandardError
+          nil
+        end
+      end
+    end.compact
+
+    dates.min
+  end
+
+  computed_annotation "activity/contributors",
+                      title: "Monthly Contributors",
+                      description: "Accumulated monthly unique contributor counts across all related application services",
+                      sidebar: false do
+    services = outgoing_transitive(:ApplicationService)
+    next nil if services.empty?
+
+    # Collect all contributor arrays from services (they all end at the current month)
+    # Use get() to trigger computation of computed annotations on ApplicationServices
+    contrib_arrays = services.map do |service|
+      contrib_str = get(service, "activity/contributors")
+      next nil if contrib_str.nil? || contrib_str.empty?
+
+      contrib_str.split(",").map(&:to_i)
+    end.compact
+
+    next nil if contrib_arrays.empty?
+
+    # Find the maximum length (oldest service determines the timeline)
+    max_length = contrib_arrays.map(&:length).max
+
+    # Pad shorter arrays at the beginning with zeros and sum
+    result = Array.new(max_length, 0)
+    contrib_arrays.each do |arr|
+      offset = max_length - arr.length
+      arr.each_with_index do |count, idx|
+        result[offset + idx] += count
+      end
+    end
+
+    result.join(",")
+  end
+
+  computed_annotation "activity/contributors/6m",
+                      title: "Contributors (6 months)",
+                      description: "Sum of unique contributors in the last 6 months across related services",
+                      list: true,
+                      type: Integer do
+    services = outgoing_transitive(:ApplicationService)
+    next nil if services.empty?
+
+    # Sum unique contributor counts from related services
+    total = services.sum do |service|
+      get(service, "activity/contributors/6m").to_i
+    end
+    total.positive? ? total : nil
+  end
+
+  computed_annotation "activity/contributors/total",
+                      title: "Contributors (total)",
+                      description: "Sum of unique contributors across related services",
+                      type: Integer do
+    services = outgoing_transitive(:ApplicationService)
+    next nil if services.empty?
+
+    # Sum unique contributor counts from related services
+    total = services.sum do |service|
+      get(service, "activity/contributors/total").to_i
+    end
+    total.positive? ? total : nil
+  end
+
+  relation :realizes, :strategyCapabilities, :StrategyCapability
+  relation :realizes, :businessConstraints, :BusinessConstraint
+  relation :realizes, :businessRequirements, :BusinessRequirement
+  relation :servedBy, :businessActors, :BusinessActor
+  relation :servedBy, :applicationServices, :ApplicationService
+  relation :exposes, :applicationInterfaces, :ApplicationInterface
+  relation :provides, :complianceEvidences, :ComplianceEvidence
+end

data/lib/archsight/resources/business_requirement.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# BusinessRequirement represents functional or non-functional requirements
+class Archsight::Resources::BusinessRequirement < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents a statement of need that must be realized by the architecture.
+
+    ## ArchiMate Definition
+
+    **Layer:** Motivation
+    **Aspect:** Passive Structure
+
+    A requirement represents a statement of need defining a property that applies to a
+    specific system. Requirements can be functional (what the system should do) or
+    non-functional (how the system should behave).
+
+    ## Usage
+
+    Use BusinessRequirement to represent:
+
+    - Compliance requirements (C5, ISO 27001)
+    - Security requirements
+    - Performance requirements
+    - Functional specifications
+    - Legal obligations (GDPR, NIS2)
+  MD
+
+  icon "task-list"
+  layer "business"
+
+  annotation "requirement/type",
+             description: "Type of requirement (business or legal)",
+             enum: %w[business legal compliance functional non-functional]
+
+  annotation "requirement/reference",
+             description: "Regulatory or standard reference (comma-separated for multiple)",
+             filter: :list,
+             enum: %w[c5-2020 itgs-2023 gdpr-2018 nis1 nis2 iso27001 sox pci-dss hipaa eu-data-act-2025 ens
+                      iso27001-2022],
+             list: true
+
+  annotation "requirement/priority",
+             description: "Implementation priority (must, should, may)",
+             filter: :word,
+             enum: %w[must should may],
+             list: true
+
+  annotation "requirement/story",
+             description: "One-line business value statement explaining what the requirement enables",
+             title: "Story",
+             format: :markdown
+
+  relation :realizes, :outcomes, :MotivationOutcome
+end

data/lib/archsight/resources/compliance_evidence.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# ComplianceEvidence represents proof of compliance with requirements
+class Archsight::Resources::ComplianceEvidence < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents documentation or artifacts that demonstrate compliance with requirements.
+
+    ## ArchiMate Definition
+
+    **Layer:** Implementation & Migration
+    **Aspect:** Passive Structure
+
+    Compliance evidence represents tangible proof that a system or process meets specific
+    requirements. It bridges the gap between stated requirements and their actual
+    implementation in the architecture.
+
+    ## Usage
+
+    Use ComplianceEvidence to represent:
+
+    - Audit reports
+    - Security certifications
+    - Test results and reports
+    - Configuration documentation
+    - Process documentation
+  MD
+
+  icon "shield-check"
+  layer "business"
+
+  annotation "evidence/type",
+             description: "Type of evidence",
+             enum: %w[documentation process configuration audit-log technical-control]
+
+  annotation "evidence/status",
+             description: "Current status of evidence",
+             enum: %w[implemented partial not-implemented]
+
+  relation :satisfies, :businessRequirements, :BusinessRequirement
+end

data/lib/archsight/resources/data_object.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# DataObject represents data structured for automated processing (ArchiMate Application Layer)
+class Archsight::Resources::DataObject < Archsight::Resources::Base
+  include_annotations :git, :architecture, :generated
+
+  description <<~MD
+    Represents data structured for automated processing by applications.
+
+    ## ArchiMate Definition
+
+    **Layer:** Application
+    **Aspect:** Passive Structure
+
+    A data object represents data structured for automated processing. Data objects are
+    typically accessed and manipulated by application services and components, representing
+    the information model of the system.
+
+    ## Usage
+
+    Use DataObject to represent:
+
+    - API request/response schemas
+    - Database entities
+    - Message payloads
+    - Configuration structures
+    - Domain models
+  MD
+
+  icon "database"
+  layer "application"
+
+  annotation "data/application",
+             description: "Source API/application name",
+             title: "Application",
+             filter: :word
+
+  annotation "data/visibility",
+             description: "API visibility level",
+             title: "Visibility",
+             enum: %w[public private]
+
+  annotation "generated/variants",
+             description: "OpenAPI schema variants compacted into this DataObject",
+             title: "Schema Variants",
+             sidebar: false
+
+  relation :realizes, :businessConstraints, :BusinessConstraint
+end

data/lib/archsight/resources/motivation_goal.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# MotivationGoal represents a high-level statement of intent, direction, or desired end state
+# for an organization and its stakeholders (ArchiMate Motivation Layer)
+class Archsight::Resources::MotivationGoal < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents a high-level statement of intent or desired end state for the organization.
+
+    ## ArchiMate Definition
+
+    **Layer:** Motivation
+    **Aspect:** Behavior
+
+    A goal represents a high-level statement of intent, direction, or desired end state for
+    an organization and its stakeholders. Goals are typically refined into more specific
+    requirements that can be implemented.
+
+    ## Usage
+
+    Use MotivationGoal to represent:
+
+    - Strategic objectives
+    - Business targets
+    - Quality goals
+    - Compliance objectives
+    - Performance targets
+  MD
+
+  icon "archery"
+  layer "motivation"
+
+  relation :realizes, :outcomes, :MotivationOutcome
+  relation :refinedBy, :goals, :MotivationGoal
+  relation :realizes, :businessRequirements, :BusinessRequirement
+end

data/lib/archsight/resources/motivation_outcome.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# MotivationOutcome represents an end result, effect, or consequence of a certain state of affairs
+# (ArchiMate Motivation Layer)
+class Archsight::Resources::MotivationOutcome < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents an end result that has been achieved or is intended to be achieved.
+
+    ## ArchiMate Definition
+
+    **Layer:** Motivation
+    **Aspect:** Passive Structure
+
+    An outcome represents an end result that has been achieved. Outcomes are measurable
+    results that indicate whether goals have been reached, providing concrete evidence
+    of progress or success.
+
+    ## Usage
+
+    Use MotivationOutcome to represent:
+
+    - Achieved milestones
+    - Measurable results
+    - Key performance indicators (KPIs)
+    - Success criteria
+    - Deliverables
+  MD
+
+  icon "badge-check"
+  layer "motivation"
+end

data/lib/archsight/resources/motivation_stakeholder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# MotivationStakeholder represents the role of an individual, team, or organization
+# that represents their interests in the effects of the architecture (ArchiMate Motivation Layer)
+class Archsight::Resources::MotivationStakeholder < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents the interest of an individual, team, or organization in the architecture.
+
+    ## ArchiMate Definition
+
+    **Layer:** Motivation
+    **Aspect:** Active Structure
+
+    A stakeholder represents the role of an individual, team, or organization that
+    represents their interests in the effects of the architecture. Stakeholders have
+    concerns about capabilities, requirements, and constraints.
+
+    ## Usage
+
+    Use MotivationStakeholder to represent:
+
+    - Product owners
+    - Executive sponsors
+    - Customer representatives
+    - Regulatory bodies
+    - Technical leadership
+  MD
+
+  icon "user-crown"
+  layer "motivation"
+
+  relation :hasConcern, :strategyCapabilities, :StrategyCapability
+  relation :hasConcern, :businessRequirements, :BusinessRequirement
+  relation :hasConcern, :businessConstraints, :BusinessConstraint
+  relation :hasConcern, :goals, :MotivationGoal
+end

data/lib/archsight/resources/strategy_capability.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# StrategyCapability represents a strategic ability or function (ArchiMate Strategy Layer)
+class Archsight::Resources::StrategyCapability < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents an ability that an organization possesses to achieve specific outcomes.
+
+    ## ArchiMate Definition
+
+    **Layer:** Strategy
+    **Aspect:** Behavior
+
+    A capability represents an ability that an active structure element, such as an
+    organization, possesses. Capabilities are realized through a combination of people,
+    processes, and technology working together.
+
+    ## Usage
+
+    Use StrategyCapability to represent:
+
+    - Business capabilities (e.g., "Customer Provisioning")
+    - Technical capabilities (e.g., "Automated Deployment")
+    - Organizational abilities
+    - Core competencies
+    - Value-generating functions
+  MD
+
+  icon "strategy"
+  layer "strategy"
+
+  relation :realizes, :businessConstraints, :BusinessConstraint
+  relation :realizes, :businessRequirements, :BusinessRequirement
+  relation :servedBy, :businessActors, :BusinessActor
+  relation :servedBy, :applicationServices, :ApplicationService
+  relation :servedBy, :businessProcesses, :BusinessProcess
+end

data/lib/archsight/resources/technology_artifact.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "uri"
+
+# TechnologyArtifact usually a source code repository or container
+class Archsight::Resources::TechnologyArtifact < Archsight::Resources::Base
+  include_annotations :git, :architecture, :generated
+
+  description <<~MD
+    Represents a source code repository or container artifact.
+
+    ## ArchiMate Definition
+
+    **Layer:** Technology
+    **Aspect:** Passive Structure
+
+    An artifact represents a piece of data that is used or produced in a software development
+    process, or by deployment and operation of an IT system. In this tool, artifacts primarily
+    represent source code repositories.
+
+    ## Usage
+
+    Use TechnologyArtifact to represent:
+
+    - Git repositories
+    - Container images
+    - Build artifacts
+    - Configuration packages
+  MD
+
+  icon "puzzle"
+  layer "technology"
+
+  # Artifact classification
+  annotation "artifact/type",
+             description: "Type of technology artifact",
+             title: "Artifact Type",
+             enum: %w[repo container chart deb rpm]
+
+  # Dynamic annotations (patterns with *)
+  annotation "link/*",
+             description: "Documentation and resource links",
+             sidebar: false
+  annotation "scc/language/*/loc",
+             description: "Lines of code per programming language",
+             sidebar: false
+  annotation "scc/languages",
+             description: "Comma-separated list of programming languages",
+             filter: :list,
+             title: "Languages",
+             sidebar: false
+  annotation "scc/estimatedCost",
+             description: "Estimated project cost",
+             title: "Estimated Cost",
+             type: Float
+  annotation "scc/estimatedScheduleMonths",
+             description: "Estimated schedule in months",
+             title: "Estimated Schedule",
+             type: Float
+  annotation "scc/estimatedPeople",
+             description: "Estimated number of people required",
+             title: "Estimated People",
+             type: Float
+  annotation "activity/commits",
+             description: "Monthly commit counts (comma-separated, oldest to newest)",
+             title: "Commits",
+             sidebar: false
+  annotation "activity/contributors",
+             description: "Monthly unique contributor counts (comma-separated, oldest to newest)",
+             title: "Contributors",
+             sidebar: false
+  annotation "activity/status",
+             description: "Repository activity status",
+             title: "Activity Status",
+             enum: %w[active abandoned bot-only archived],
+             list: true
+  annotation "activity/busFactor",
+             description: "Bus factor assessment",
+             title: "Bus Factor",
+             enum: %w[high medium low unknown],
+             list: true
+  annotation "activity/createdAt",
+             description: "Date of first commit (repository creation)",
+             title: "Created",
+             type: Time
+  annotation "agentic/tools",
+             description: "Agentic tools detected in repository",
+             title: "Agentic Tools",
+             filter: :list,
+             enum: %w[claude cursor aider github-copilot agents none]
+  annotation "workflow/platforms",
+             description: "CI/CD workflow platforms",
+             title: "Workflow Platforms",
+             filter: :list,
+             enum: %w[github-actions gitlab-ci makefile none]
+  annotation "workflow/types",
+             description: "CI/CD workflow types",
+             title: "Workflow Types",
+             filter: :list,
+             enum: %w[build test unit-test integration-test smoke-test deploy lint security-scan dependency-update
+                      ticket-creation none]
+
+  # Urls for for git, chart repo, container repo
+  annotation "repository/artifacts",
+             description: "Types of artifacts produced by this repository",
+             title: "Artifacts",
+             filter: :list,
+             enum: %w[container chart debian rpm binary none]
+  annotation "repository/git",
+             description: "Git repository URL",
+             title: "Git Repository",
+             type: URI
+  annotation "repository/chart",
+             description: "Helm chart repository URL",
+             title: "Chart Repository",
+             type: URI
+  annotation "repository/container",
+             description: "Container registry URL",
+             title: "Container Repository",
+             type: URI
+  annotation "repository/visibility",
+             description: "Repository visibility classification",
+             title: "Visibility",
+             enum: %w[internal open-source public]
+  annotation "deployment/images",
+             description: "OCI container image names published by this repository",
+             title: "Container Images",
+             sidebar: false,
+             filter: :list
+  annotation "deployment/privileges/user",
+             description: "User privilege level for deployment",
+             title: "Deployment User Privileges",
+             enum: %w[as-root as-root-gvisor as-user-gvisor as-user-reduced-priviledges
+                      as-user-reduced-priviledges-gvisor]
+  annotation "deployment/privileges/container",
+             description: "Container privilege level",
+             title: "Deployment Container Privileges",
+             enum: %w[unprivileged privileged]
+
+  # Contributor metrics (unique counts, stored during import)
+  annotation "activity/contributors/6m",
+             title: "Contributors (6 months)",
+             description: "Unique contributors in the last 6 months",
+             type: Integer
+  annotation "activity/contributors/total",
+             title: "Contributors (total)",
+             description: "Total unique contributors",
+             type: Integer
+
+  relation :servedBy, :technologyComponents, :TechnologyArtifact
+  relation :suppliedBy, :technologyComponents, :TechnologyService
+  relation :maintainedBy, :businessActors, :BusinessActor
+  relation :contributedBy, :businessActors, :BusinessActor
+end