hinge 0.1.0__py3-none-any.whl

hinge/__init__.py

@@ -0,0 +1,3 @@
+from hinge.frontends.lib import export, export_sql_projection, ingest, project, project_sql
+
+__all__ = ["export", "export_sql_projection", "ingest", "project", "project_sql"]

hinge/config/logging_setup.py

@@ -0,0 +1,63 @@
+"""Central logging configuration for hinge.
+
+Call ``setup_logging()`` once at process start (CLI entry-point or lib import).
+Every module then does ``logger = logging.getLogger(__name__)`` and logs normally.
+
+Environment variables
+---------------------
+HINGE_LOG_LEVEL   Verbosity for the hinge.* namespace. Default: INFO.
+                  Values: DEBUG, INFO, WARNING, ERROR
+HINGE_LOG_FILE    If set, logs are also written to this path in addition to
+                  stderr. Useful for CI or long ingest runs.
+"""
+
+from __future__ import annotations
+
+import logging
+import logging.handlers
+import os
+import sys
+from pathlib import Path
+
+_FMT = "%(asctime)s %(levelname)-8s %(name)s — %(message)s"
+_DATE_FMT = "%Y-%m-%d %H:%M:%S"
+_configured = False
+
+
+def setup_logging() -> None:
+    global _configured
+    if _configured:
+        return
+    _configured = True
+
+    level_name = os.environ.get("HINGE_LOG_LEVEL", "INFO").upper()
+    level = getattr(logging, level_name, logging.INFO)
+
+    formatter = logging.Formatter(_FMT, datefmt=_DATE_FMT)
+
+    # stderr handler — always on
+    stderr_handler = logging.StreamHandler(sys.stderr)
+    stderr_handler.setFormatter(formatter)
+    stderr_handler.setLevel(level)
+
+    root = logging.getLogger("hinge")
+    root.setLevel(level)
+    root.addHandler(stderr_handler)
+
+    # optional file handler
+    log_file = os.environ.get("HINGE_LOG_FILE")
+    if log_file:
+        path = Path(log_file)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.handlers.RotatingFileHandler(
+            path, maxBytes=10 * 1024 * 1024, backupCount=3, encoding="utf-8"
+        )
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)  # always full detail in the file
+        root.addHandler(file_handler)
+
+    # silence noisy third-party loggers unless user explicitly requests DEBUG
+    if level > logging.DEBUG:
+        logging.getLogger("dbt").setLevel(logging.WARNING)
+
+    root.debug("logging initialised (level=%s)", level_name)

hinge/config/settings.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def store_path() -> Path:
+    return Path(os.environ.get("HINGE_STORE_PATH", "./network.duckdb"))
+
+
+def log_level() -> str:
+    """Verbosity for hinge.* loggers. Values: DEBUG, INFO, WARNING, ERROR."""
+    return os.environ.get("HINGE_LOG_LEVEL", "INFO")
+
+
+def log_file() -> Path | None:
+    """Optional persistent log file. None means stderr only."""
+    val = os.environ.get("HINGE_LOG_FILE")
+    return Path(val) if val else None
+
+
+def types_yaml_path() -> Path:
+    return Path(__file__).with_name("types.yaml")

hinge/config/types.yaml

@@ -0,0 +1,42 @@
+# ─── HIN typed vocabulary — the single source of truth ────────────────────
+#
+# Editing this file is how you add or remove an allowed type label.
+#  - Bump ``schema_version`` whenever you change the vocabulary; existing
+#    DuckDB stores will refuse to open until re-ingested.
+#  - Stage code (readers, projections, exporters) treats labels as plain
+#    strings — there are no Python enums to update.
+#  - Projections may emit labels not listed here; only ingest-time validation
+#    is gated by this file. If a projection's new label should become a
+#    first-class part of the vocabulary, add it here and bump the version.
+
+schema_version: 1
+
+node_types:
+  - user
+  - repo
+  - artifact
+
+artifact_subtypes:
+  - pull_request
+  - issue
+  - push
+  - release
+  - wiki_page
+  - branch
+
+edge_types:
+  - opened
+  - reviewed
+  - commented_on
+  - review_commented_on
+  - merged
+  - closed
+  - reopened
+  - pushed
+  - commented_commits
+  - created_fork
+  - starred
+  - released
+  - wiki_edited
+  - member_of
+  - contains          # Repo -> Artifact structural edge

hinge/dbt/.user.yml

@@ -0,0 +1 @@
+id: e7925ad0-fe3a-4d78-8279-1724d2204227

hinge/dbt/dbt_project.yml

@@ -0,0 +1,18 @@
+name: hin_projections
+version: "0.1.0"
+config-version: 2
+
+profile: hinge
+
+model-paths: ["models"]
+seed-paths: ["seeds"]
+target-path: "target"
+clean-targets: ["target", "dbt_packages"]
+
+models:
+  hin_projections:
+    +materialized: table
+
+seeds:
+  hin_projections:
+    +quote_columns: false

hinge/dbt/macros/apply_time_window.sql

@@ -0,0 +1,11 @@
+{% macro apply_time_window(timestamp_col='occurred_at', start_date=None, end_date=None) %}
+(
+    true
+    {% if start_date is not none %}
+        AND {{ timestamp_col }} >= CAST('{{ start_date }}' AS TIMESTAMP)
+    {% endif %}
+    {% if end_date is not none %}
+        AND {{ timestamp_col }} < CAST('{{ end_date }}' AS TIMESTAMP)
+    {% endif %}
+)
+{% endmacro %}

hinge/dbt/macros/assert_recipe_supported.sql

@@ -0,0 +1,59 @@
+{% macro assert_recipe_supported(recipe_name, required_capabilities=none) %}
+    {% if execute %}
+        {% set missing_query %}
+            WITH required AS (
+                {% if required_capabilities is none %}
+                    SELECT required_capability AS capability
+                    FROM ref_recipe_requirements
+                    WHERE recipe_name = '{{ recipe_name }}'
+                {% else %}
+                    SELECT capability
+                    FROM (
+                        VALUES
+                        {%- for capability in required_capabilities %}
+                            ('{{ capability }}'){% if not loop.last %},{% endif %}
+                        {%- endfor %}
+                    ) AS values_table(capability)
+                {% endif %}
+            ),
+
+            manifest AS (
+                SELECT *
+                FROM {{ source('hin', 'active_contract_adapter_manifest') }}
+            ),
+
+            available AS (
+                SELECT 'has_accounts' AS capability, bool_or(coalesce(has_accounts, false)) AS is_available FROM manifest
+                UNION ALL SELECT 'has_repositories', bool_or(coalesce(has_repositories, false)) FROM manifest
+                UNION ALL SELECT 'has_commits', bool_or(coalesce(has_commits, false)) FROM manifest
+                UNION ALL SELECT 'has_file_touches', bool_or(coalesce(has_file_touches, false)) FROM manifest
+                UNION ALL SELECT 'has_line_touches', bool_or(coalesce(has_line_touches, false)) FROM manifest
+                UNION ALL SELECT 'has_pull_requests', bool_or(coalesce(has_pull_requests, false)) FROM manifest
+                UNION ALL SELECT 'has_pr_reviews', bool_or(coalesce(has_pr_reviews, false)) FROM manifest
+                UNION ALL SELECT 'has_issues', bool_or(coalesce(has_issues, false)) FROM manifest
+                UNION ALL SELECT 'has_comments', bool_or(coalesce(has_comments, false)) FROM manifest
+                UNION ALL SELECT 'has_stars', bool_or(coalesce(has_stars, false)) FROM manifest
+                UNION ALL SELECT 'has_watches', bool_or(coalesce(has_watches, false)) FROM manifest
+                UNION ALL SELECT 'has_forks', bool_or(coalesce(has_forks, false)) FROM manifest
+                UNION ALL SELECT 'has_follows', bool_or(coalesce(has_follows, false)) FROM manifest
+                UNION ALL SELECT 'has_mentions', bool_or(coalesce(has_mentions, false)) FROM manifest
+                UNION ALL SELECT 'has_artifact_refs', bool_or(coalesce(has_artifact_refs, false)) FROM manifest
+            )
+
+            SELECT required.capability
+            FROM required
+            LEFT JOIN available USING (capability)
+            WHERE coalesce(available.is_available, false) = false
+        {% endset %}
+        {% set missing = run_query(missing_query) %}
+        {% if missing is not none and missing.rows | length > 0 %}
+            {% set missing_names = [] %}
+            {% for row in missing.rows %}
+                {% do missing_names.append(row[0]) %}
+            {% endfor %}
+            {{ exceptions.raise_compiler_error(
+                'Cannot build `' ~ recipe_name ~ '` from this adapter run. Missing capabilities: ' ~ (missing_names | join(', '))
+            ) }}
+        {% endif %}
+    {% endif %}
+{% endmacro %}

hinge/dbt/macros/build_incidence.sql

@@ -0,0 +1,46 @@
+{% macro build_incidence(
+    left_type,
+    right_type,
+    edge_types=None,
+    left_subtypes=None,
+    right_subtypes=None,
+    bot_policy='include_bots',
+    weight_mode='event_count',
+    start_date=None,
+    end_date=None
+) %}
+WITH sliced_edges AS (
+    {{ slice_edges(
+        edge_types=edge_types,
+        source_types=[left_type],
+        target_types=[right_type],
+        source_subtypes=left_subtypes,
+        target_subtypes=right_subtypes,
+        bot_policy=bot_policy,
+        start_date=start_date,
+        end_date=end_date
+    ) }}
+)
+
+SELECT
+    source_node_id AS left_node_id,
+    source_node_type AS left_node_type,
+    source_node_subtype AS left_node_subtype,
+    target_node_id AS right_node_id,
+    target_node_type AS right_node_type,
+    target_node_subtype AS right_node_subtype,
+    edge_id AS evidence_edge_id,
+    edge_type AS role,
+    occurred_at,
+    {% if weight_mode == 'event_count' %}
+        coalesce(event_count, 1)
+    {% elif weight_mode == 'weight' %}
+        coalesce(weight, 1.0)
+    {% elif weight_mode == 'binary' %}
+        1
+    {% else %}
+        {{ exceptions.raise_compiler_error('Unknown incidence weight_mode: ' ~ weight_mode) }}
+    {% endif %} AS weight,
+    '{{ weight_mode }}' AS weight_kind
+FROM sliced_edges
+{% endmacro %}

hinge/dbt/macros/collapse_path.sql

@@ -0,0 +1,26 @@
+{% macro collapse_two_hop_path(
+    first_relation,
+    second_relation,
+    source_col,
+    mediator_col,
+    second_source_col,
+    target_col,
+    directed=true
+) %}
+SELECT
+    first_hop.{{ source_col }} AS source_node_id,
+    second_hop.{{ target_col }} AS target_node_id,
+    count(DISTINCT first_hop.{{ mediator_col }}) AS n_contexts,
+    list_distinct(list(first_hop.{{ mediator_col }})) AS context_node_ids,
+    min(least(first_hop.first_seen_at, second_hop.first_seen_at)) AS first_seen_at,
+    max(greatest(first_hop.last_seen_at, second_hop.last_seen_at)) AS last_seen_at
+FROM {{ first_relation }} AS first_hop
+JOIN {{ second_relation }} AS second_hop
+    ON first_hop.{{ mediator_col }} = second_hop.{{ second_source_col }}
+{% if directed %}
+WHERE first_hop.{{ source_col }} != second_hop.{{ target_col }}
+{% else %}
+WHERE first_hop.{{ source_col }} < second_hop.{{ target_col }}
+{% endif %}
+GROUP BY first_hop.{{ source_col }}, second_hop.{{ target_col }}
+{% endmacro %}

hinge/dbt/macros/filter_bots.sql

@@ -0,0 +1,23 @@
+{% macro filter_bots(source_alias='source_node', target_alias='target_node', policy='include_bots') %}
+(
+    {% if policy == 'include_bots' %}
+        true
+    {% elif policy == 'exclude_bots' %}
+        coalesce({{ source_alias }}.node_subtype, '') != 'bot'
+        AND coalesce({{ target_alias }}.node_subtype, '') != 'bot'
+    {% elif policy == 'only_bots' %}
+        (
+            coalesce({{ source_alias }}.node_subtype, '') = 'bot'
+            OR coalesce({{ target_alias }}.node_subtype, '') = 'bot'
+        )
+    {% elif policy == 'human_to_bot' %}
+        coalesce({{ source_alias }}.node_subtype, '') != 'bot'
+        AND coalesce({{ target_alias }}.node_subtype, '') = 'bot'
+    {% elif policy == 'bot_to_human' %}
+        coalesce({{ source_alias }}.node_subtype, '') = 'bot'
+        AND coalesce({{ target_alias }}.node_subtype, '') != 'bot'
+    {% else %}
+        {{ exceptions.raise_compiler_error('Unknown bot_policy: ' ~ policy) }}
+    {% endif %}
+)
+{% endmacro %}

hinge/dbt/macros/network_edges.sql

@@ -0,0 +1,39 @@
+{% macro network_edges(
+    relation,
+    recipe_name,
+    source_node_id,
+    source_node_type,
+    target_node_id,
+    target_node_type,
+    edge_type,
+    directed,
+    weight='NULL',
+    weight_kind='NULL',
+    n_contexts='NULL',
+    n_events='NULL',
+    first_seen_at='NULL',
+    last_seen_at='NULL',
+    time_bin='NULL',
+    bot_policy="'include'",
+    properties="'{}'"
+) %}
+SELECT
+    '{{ recipe_name }}'::TEXT AS recipe_name,
+    '1'::TEXT AS recipe_version,
+    {{ source_node_id }}::TEXT AS source_node_id,
+    {{ source_node_type }}::TEXT AS source_node_type,
+    {{ target_node_id }}::TEXT AS target_node_id,
+    {{ target_node_type }}::TEXT AS target_node_type,
+    {{ directed }}::BOOLEAN AS directed,
+    {{ edge_type }}::TEXT AS edge_type,
+    {{ weight }}::DOUBLE AS weight,
+    {{ weight_kind }}::TEXT AS weight_kind,
+    {{ n_contexts }}::INTEGER AS n_contexts,
+    {{ n_events }}::INTEGER AS n_events,
+    {{ first_seen_at }}::TIMESTAMP AS first_seen_at,
+    {{ last_seen_at }}::TIMESTAMP AS last_seen_at,
+    {{ time_bin }}::TEXT AS time_bin,
+    {{ bot_policy }}::TEXT AS bot_policy,
+    {{ properties }} AS properties
+FROM {{ relation }}
+{% endmacro %}

hinge/dbt/macros/project_bipartite.sql

@@ -0,0 +1,33 @@
+{% macro project_bipartite(
+    incidence_relation,
+    left_col,
+    right_col,
+    directed=false,
+    weight_mode='shared_count'
+) %}
+SELECT
+    a.{{ left_col }} AS source_node_id,
+    b.{{ left_col }} AS target_node_id,
+    {% if weight_mode == 'shared_count' %}
+        count(DISTINCT a.{{ right_col }})::DOUBLE AS weight,
+        'shared_count' AS weight_kind,
+    {% elif weight_mode == 'event_weighted' %}
+        sum(coalesce(a.weight, 1.0) * coalesce(b.weight, 1.0))::DOUBLE AS weight,
+        'event_weighted' AS weight_kind,
+    {% else %}
+        {{ exceptions.raise_compiler_error('Unknown projection weight_mode: ' ~ weight_mode) }}
+    {% endif %}
+    count(DISTINCT a.{{ right_col }}) AS n_contexts,
+    list_distinct(list(a.{{ right_col }})) AS context_node_ids,
+    min(least(a.first_seen_at, b.first_seen_at)) AS first_seen_at,
+    max(greatest(a.last_seen_at, b.last_seen_at)) AS last_seen_at
+FROM {{ incidence_relation }} AS a
+JOIN {{ incidence_relation }} AS b
+    ON a.{{ right_col }} = b.{{ right_col }}
+    {% if directed %}
+        AND a.{{ left_col }} != b.{{ left_col }}
+    {% else %}
+        AND a.{{ left_col }} < b.{{ left_col }}
+    {% endif %}
+GROUP BY a.{{ left_col }}, b.{{ left_col }}
+{% endmacro %}

hinge/dbt/macros/slice_edges.sql

@@ -0,0 +1,41 @@
+{% macro _sql_string_list(values) %}
+    {%- for value in values -%}
+        '{{ value }}'{% if not loop.last %}, {% endif %}
+    {%- endfor -%}
+{% endmacro %}
+
+{% macro slice_edges(
+    edge_types=None,
+    source_types=None,
+    target_types=None,
+    source_subtypes=None,
+    target_subtypes=None,
+    bot_policy='include_bots',
+    start_date=None,
+    end_date=None
+) %}
+SELECT e.*
+FROM {{ ref('hin_edges') }} AS e
+LEFT JOIN {{ ref('hin_nodes') }} AS source_node
+    ON source_node.node_id = e.source_node_id
+LEFT JOIN {{ ref('hin_nodes') }} AS target_node
+    ON target_node.node_id = e.target_node_id
+WHERE true
+{% if edge_types is not none %}
+  AND e.edge_type IN ({{ _sql_string_list(edge_types) }})
+{% endif %}
+{% if source_types is not none %}
+  AND e.source_node_type IN ({{ _sql_string_list(source_types) }})
+{% endif %}
+{% if target_types is not none %}
+  AND e.target_node_type IN ({{ _sql_string_list(target_types) }})
+{% endif %}
+{% if source_subtypes is not none %}
+  AND e.source_node_subtype IN ({{ _sql_string_list(source_subtypes) }})
+{% endif %}
+{% if target_subtypes is not none %}
+  AND e.target_node_subtype IN ({{ _sql_string_list(target_subtypes) }})
+{% endif %}
+  AND {{ filter_bots('source_node', 'target_node', bot_policy) }}
+  AND {{ apply_time_window('e.occurred_at', start_date, end_date) }}
+{% endmacro %}

hinge/dbt/models/hin/hin_accounts.sql

@@ -0,0 +1,14 @@
+{{ config(materialized='table') }}
+
+SELECT
+    account_key                             AS node_id,
+    github_id,
+    login,
+    coalesce(account_type, 'unknown')       AS account_type,
+    coalesce(is_bot, false)                 AS is_bot,
+    bot_confidence,
+    bot_source,
+    created_at,
+    observed_at,
+    profile_json                           AS properties
+FROM {{ ref('stg_accounts') }}

hinge/dbt/models/hin/hin_artifacts.sql

@@ -0,0 +1,23 @@
+{{ config(materialized='table') }}
+
+SELECT
+    artifact_key            AS node_id,
+    artifact_type,
+    repo_key                AS repo_node_id,
+    parent_artifact_key     AS parent_artifact_node_id,
+    github_id,
+    number,
+    sha,
+    url,
+    title,
+    state,
+    file_path,
+    start_line,
+    end_line,
+    created_at,
+    updated_at,
+    closed_at,
+    merged_at,
+    observed_at,
+    artifact_json           AS properties
+FROM {{ ref('stg_artifacts') }}

hinge/dbt/models/hin/hin_capabilities.sql

@@ -0,0 +1,42 @@
+{{ config(materialized='table') }}
+
+WITH manifest AS (
+    SELECT *
+    FROM {{ ref('stg_adapter_manifest') }}
+),
+
+capabilities AS (
+    SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_accounts' AS capability, has_accounts AS is_available FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_repositories', has_repositories FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_commits', has_commits FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_file_touches', has_file_touches FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_line_touches', has_line_touches FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_pull_requests', has_pull_requests FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_pr_reviews', has_pr_reviews FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_issues', has_issues FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_comments', has_comments FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_stars', has_stars FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_watches', has_watches FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_forks', has_forks FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_follows', has_follows FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_mentions', has_mentions FROM manifest
+    UNION ALL SELECT adapter_run_id, adapter_name, adapter_version, source_name, coverage_start, coverage_end,
+           'has_artifact_refs', has_artifact_refs FROM manifest
+)
+
+SELECT *
+FROM capabilities

hinge/dbt/models/hin/hin_edges.sql

@@ -0,0 +1,57 @@
+{{ config(materialized='table') }}
+
+WITH relations AS (
+    SELECT
+        relation_key AS edge_id,
+        source_node_key AS source_node_id,
+        CASE WHEN source_node_type = 'account' THEN 'user' ELSE source_node_type END AS source_node_type,
+        target_node_key AS target_node_id,
+        CASE WHEN target_node_type = 'account' THEN 'user' ELSE target_node_type END AS target_node_type,
+        relation_type AS edge_type,
+        relation_subtype AS edge_subtype,
+        directed,
+        occurred_at,
+        observed_at,
+        valid_from,
+        valid_to,
+        weight,
+        event_count,
+        adapter_run_id,
+        source_record_id,
+        properties
+    FROM {{ ref('stg_relations') }}
+)
+
+SELECT
+    r.edge_id,
+    r.source_node_id,
+    r.source_node_type,
+    sn.node_subtype AS source_node_subtype,
+    r.target_node_id,
+    r.target_node_type,
+    tn.node_subtype AS target_node_subtype,
+    r.edge_type,
+    r.edge_subtype,
+    r.directed,
+    r.occurred_at,
+    r.observed_at,
+    r.valid_from,
+    r.valid_to,
+    r.weight,
+    r.event_count,
+    CASE
+        WHEN r.source_node_type = 'repo' THEN r.source_node_id
+        WHEN r.target_node_type = 'repo' THEN r.target_node_id
+    END AS context_repo_node_id,
+    CASE
+        WHEN r.source_node_type = 'artifact' THEN r.source_node_id
+        WHEN r.target_node_type = 'artifact' THEN r.target_node_id
+    END AS context_artifact_node_id,
+    r.adapter_run_id,
+    r.source_record_id,
+    r.properties
+FROM relations AS r
+LEFT JOIN {{ ref('hin_nodes') }} AS sn
+    ON sn.node_id = r.source_node_id
+LEFT JOIN {{ ref('hin_nodes') }} AS tn
+    ON tn.node_id = r.target_node_id

hinge/dbt/models/hin/hin_nodes.sql

@@ -0,0 +1,44 @@
+{{ config(materialized='table') }}
+
+SELECT
+    node_id,
+    'user' AS node_type,
+    account_type AS node_subtype,
+    node_id AS natural_key,
+    login AS display_name,
+    created_at,
+    NULL::TIMESTAMP AS updated_at,
+    observed_at,
+    false AS is_stub,
+    properties
+FROM {{ ref('hin_accounts') }}
+
+UNION ALL
+
+SELECT
+    node_id,
+    'repo' AS node_type,
+    CASE WHEN is_fork THEN 'fork' ELSE 'repository' END AS node_subtype,
+    full_name AS natural_key,
+    full_name AS display_name,
+    created_at,
+    NULL::TIMESTAMP AS updated_at,
+    observed_at,
+    false AS is_stub,
+    properties
+FROM {{ ref('hin_repositories') }}
+
+UNION ALL
+
+SELECT
+    node_id,
+    'artifact' AS node_type,
+    artifact_type AS node_subtype,
+    node_id AS natural_key,
+    coalesce(title, node_id) AS display_name,
+    created_at,
+    updated_at,
+    observed_at,
+    false AS is_stub,
+    properties
+FROM {{ ref('hin_artifacts') }}

hinge/dbt/models/hin/hin_repositories.sql

@@ -0,0 +1,15 @@
+{{ config(materialized='table') }}
+
+SELECT
+    repo_key                        AS node_id,
+    github_id,
+    full_name,
+    owner_account_key               AS owner_account_node_id,
+    primary_language,
+    coalesce(is_fork, false)        AS is_fork,
+    forked_from_repo_key            AS forked_from_repo_node_id,
+    created_at,
+    archived_at,
+    observed_at,
+    repo_json                       AS properties
+FROM {{ ref('stg_repositories') }}

hinge/dbt/models/intermediate/int_developer_repo_affiliation.sql

@@ -0,0 +1,27 @@
+{{ config(materialized='table') }}
+
+WITH contains_edges AS (
+    {{ slice_edges(
+        edge_types=['contains'],
+        source_types=['repo'],
+        target_types=['artifact']
+    ) }}
+),
+
+affiliations AS (
+    SELECT
+        incidence.left_node_id AS user_node_id,
+        contains_edges.source_node_id AS repo_node_id,
+        min(incidence.occurred_at) AS first_seen_at,
+        max(incidence.occurred_at) AS last_seen_at,
+        sum(incidence.weight)::DOUBLE AS weight,
+        count(DISTINCT incidence.evidence_edge_id) AS n_events,
+        list_distinct(list(incidence.role)) AS roles
+    FROM {{ ref('int_user_artifact_incidence') }} AS incidence
+    JOIN contains_edges
+        ON contains_edges.target_node_id = incidence.right_node_id
+    GROUP BY incidence.left_node_id, contains_edges.source_node_id
+)
+
+SELECT *
+FROM affiliations