opencode-skills-collection 2.0.0 → 2.0.3

package/bundled-skills/monte-carlo-push-ingestion/scripts/templates/snowflake/collect_lineage.py

@@ -0,0 +1,349 @@
+#!/usr/bin/env python3
+"""
+Collect table and column lineage from Snowflake — collection only.
+
+Queries ACCOUNT_USAGE for DML/DDL statements in the last 24 hours, parses each
+QUERY_TEXT with regex to extract source and destination tables, then writes the
+resulting lineage edges to a JSON manifest file.
+
+Can be run standalone via CLI or imported (use the ``collect()`` function).
+
+Note: ACCOUNT_USAGE views have an approximate latency of 45 minutes, so very
+recent queries may not yet appear.
+
+Substitution points
+-------------------
+- SNOWFLAKE_ACCOUNT    (env) / --account    (CLI) : Snowflake account identifier
+- SNOWFLAKE_USER       (env) / --user       (CLI) : Snowflake username
+- SNOWFLAKE_PASSWORD   (env) / --password   (CLI) : Snowflake password
+- SNOWFLAKE_WAREHOUSE  (env) / --warehouse  (CLI) : Snowflake virtual warehouse
+
+Prerequisites
+-------------
+    pip install snowflake-connector-python
+
+Usage (table-level):
+    python collect_lineage.py \\
+        --account  <SNOWFLAKE_ACCOUNT> \\
+        --user     <SNOWFLAKE_USER> \\
+        --password <SNOWFLAKE_PASSWORD> \\
+        --warehouse <SNOWFLAKE_WAREHOUSE>
+
+Usage (column-level):
+    python collect_lineage.py ... --column-lineage
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import snowflake.connector
+
+# ← SUBSTITUTE: set RESOURCE_TYPE to match your Monte Carlo connection type
+RESOURCE_TYPE = "snowflake"
+
+
+def _check_available_memory(min_gb: float = 2.0) -> None:
+    """Warn if available memory is below the threshold."""
+    try:
+        if hasattr(os, "sysconf"):  # Linux / macOS
+            page_size = os.sysconf("SC_PAGE_SIZE")
+            avail_pages = os.sysconf("SC_AVPHYS_PAGES")
+            avail_gb = (page_size * avail_pages) / (1024 ** 3)
+        else:
+            return  # Windows — skip check
+    except (ValueError, OSError):
+        return
+    if avail_gb < min_gb:
+        print(
+            f"WARNING: Only {avail_gb:.1f} GB of memory available "
+            f"(minimum recommended: {min_gb:.1f} GB). "
+            f"Consider reducing the lookback window or increasing available memory."
+        )
+
+# Hours to look back in ACCOUNT_USAGE.QUERY_HISTORY
+# ← SUBSTITUTE: adjust the lookback window to match your collection cadence
+_LOOKBACK_HOURS = 24
+
+# Regex for CTAS: CREATE [OR REPLACE] [TRANSIENT] TABLE [IF NOT EXISTS] [db.][schema.]table AS SELECT
+_CTAS_RE = re.compile(
+    r"CREATE\s+(?:OR\s+REPLACE\s+)?(?:TRANSIENT\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"
+    r"(?:(?P<dest_db>\w+)\.)?(?:(?P<dest_schema>\w+)\.)?(?P<dest_table>\w+)"
+    r".*?AS\s+SELECT\s+(?P<select_cols>.+?)\s+FROM\s+"
+    r"(?:(?P<src_db>\w+)\.)?(?:(?P<src_schema>\w+)\.)?(?P<src_table>\w+)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Regex for INSERT INTO [db.][schema.]table SELECT ... FROM [db.][schema.]table
+_INSERT_RE = re.compile(
+    r"INSERT\s+(?:INTO|OVERWRITE)\s+"
+    r"(?:(?P<dest_db>\w+)\.)?(?:(?P<dest_schema>\w+)\.)?(?P<dest_table>\w+)"
+    r".*?SELECT\s+(?P<select_cols>.+?)\s+FROM\s+"
+    r"(?:(?P<src_db>\w+)\.)?(?:(?P<src_schema>\w+)\.)?(?P<src_table>\w+)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Regex for CREATE [OR REPLACE] VIEW [db.][schema.]view AS SELECT ... FROM ...
+_CREATE_VIEW_RE = re.compile(
+    r"CREATE\s+(?:OR\s+REPLACE\s+)?(?:SECURE\s+)?VIEW\s+"
+    r"(?:(?P<dest_db>\w+)\.)?(?:(?P<dest_schema>\w+)\.)?(?P<dest_table>\w+)"
+    r".*?AS\s+SELECT\s+(?P<select_cols>.+?)\s+FROM\s+"
+    r"(?:(?P<src_db>\w+)\.)?(?:(?P<src_schema>\w+)\.)?(?P<src_table>\w+)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Additional JOIN sources
+_JOIN_RE = re.compile(
+    r"JOIN\s+(?:(?P<src_db>\w+)\.)?(?:(?P<src_schema>\w+)\.)?(?P<src_table>\w+)",
+    re.IGNORECASE,
+)
+
+# Simple column alias extraction from SELECT clause
+_COL_RE = re.compile(r"(?:(\w+)\.)?(\w+)(?:\s+AS\s+(\w+))?", re.IGNORECASE)
+_SQL_KEYWORDS = {
+    "FROM", "SELECT", "WHERE", "JOIN", "ON", "AS", "*", "AND", "OR",
+    "GROUP", "ORDER", "BY", "HAVING", "LIMIT", "DISTINCT", "CASE", "WHEN",
+    "THEN", "ELSE", "END", "NULL", "NOT", "IN", "IS", "BETWEEN",
+}
+
+
+@dataclass
+class _LineageEdge:
+    dest_db: str
+    dest_schema: str
+    dest_table: str
+    sources: list[tuple[str, str, str]] = field(default_factory=list)
+    # col_mappings: (dest_col, src_table, src_col)
+    col_mappings: list[tuple[str, str, str]] = field(default_factory=list)
+
+
+def _parse_select_cols(select_clause: str, src_table: str) -> list[tuple[str, str, str]]:
+    mappings = []
+    for m in _COL_RE.finditer(select_clause):
+        src_col = m.group(2)
+        dest_col = m.group(3) or src_col
+        if src_col.upper() in _SQL_KEYWORDS:
+            continue
+        mappings.append((dest_col, src_table, src_col))
+    return mappings
+
+
+def _parse_edges(rows: list[dict]) -> list[_LineageEdge]:
+    """Parse QUERY_HISTORY rows into _LineageEdge objects."""
+    edges: dict[str, _LineageEdge] = {}
+
+    for row in rows:
+        query_text = row.get("QUERY_TEXT") or ""
+        default_db = (row.get("DATABASE_NAME") or "").lower()
+        sql_clean = re.sub(r"\s+", " ", query_text).strip()
+
+        for pattern in (_CTAS_RE, _INSERT_RE, _CREATE_VIEW_RE):
+            m = pattern.search(sql_clean)
+            if not m:
+                continue
+
+            dest_db = (m.group("dest_db") or default_db).lower()
+            dest_schema = (m.group("dest_schema") or "public").lower()
+            dest_table = m.group("dest_table").lower()
+            src_db = (m.group("src_db") or default_db).lower()
+            src_schema = (m.group("src_schema") or "public").lower()
+            src_table = m.group("src_table").lower()
+            select_cols = m.group("select_cols")
+
+            key = f"{dest_db}.{dest_schema}.{dest_table}"
+            if key not in edges:
+                edges[key] = _LineageEdge(
+                    dest_db=dest_db, dest_schema=dest_schema, dest_table=dest_table
+                )
+
+            edge = edges[key]
+            src_triple = (src_db, src_schema, src_table)
+            if src_triple not in edge.sources:
+                edge.sources.append(src_triple)
+
+            for jm in _JOIN_RE.finditer(sql_clean):
+                jt = jm.group("src_table").lower()
+                jschema = (jm.group("src_schema") or src_schema).lower()
+                jdb = (jm.group("src_db") or src_db).lower()
+                jp = (jdb, jschema, jt)
+                if jp not in edge.sources:
+                    edge.sources.append(jp)
+
+            edge.col_mappings.extend(_parse_select_cols(select_cols, src_table))
+            break
+
+    return list(edges.values())
+
+
+def _fetch_query_history(conn, lookback_hours: int) -> list[dict]:
+    cursor = conn.cursor()
+    cursor.execute(
+        f"""
+        SELECT QUERY_ID, QUERY_TEXT, START_TIME, END_TIME, USER_NAME, DATABASE_NAME, EXECUTION_STATUS
+        FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
+        WHERE START_TIME >= DATEADD(hour, -{lookback_hours}, CURRENT_TIMESTAMP())
+          AND EXECUTION_STATUS = 'SUCCESS'
+          AND QUERY_TYPE IN ('CREATE_TABLE_AS_SELECT', 'INSERT', 'MERGE', 'CREATE_VIEW')
+        ORDER BY START_TIME
+        LIMIT 50000
+        """
+        # ← SUBSTITUTE: adjust QUERY_TYPE list, LIMIT, or add a WHERE clause to scope to specific databases
+    )
+    columns = [col[0] for col in cursor.description]
+    rows = []
+    while True:
+        batch = cursor.fetchmany(1000)
+        if not batch:
+            break
+        rows.extend(dict(zip(columns, row)) for row in batch)
+    cursor.close()
+    return rows
+
+
+def collect(
+    account: str,
+    user: str,
+    password: str,
+    warehouse: str,
+    lookback_hours: int = _LOOKBACK_HOURS,
+    column_lineage: bool = False,
+    output_file: str = "lineage_output.json",
+) -> dict:
+    """
+    Connect to Snowflake, collect lineage edges, and write a JSON manifest.
+
+    Returns the manifest dict.
+    """
+    _check_available_memory()
+    print(f"Connecting to Snowflake account: {account} ...")
+    conn = snowflake.connector.connect(
+        account=account,
+        user=user,
+        password=password,
+        warehouse=warehouse,
+    )
+
+    print(f"Fetching QUERY_HISTORY for the last {lookback_hours} hour(s) ...")
+    rows = _fetch_query_history(conn, lookback_hours)
+    conn.close()
+    print(f"  Retrieved {len(rows)} qualifying query/queries.")
+
+    if not rows:
+        print("No lineage queries found in the specified window.")
+        manifest = {
+            "resource_type": RESOURCE_TYPE,
+            "collected_at": datetime.now(tz=timezone.utc).isoformat(),
+            "column_lineage": column_lineage,
+            "edges": [],
+        }
+        with open(output_file, "w") as fh:
+            json.dump(manifest, fh, indent=2)
+        return manifest
+
+    edges = _parse_edges(rows)
+    print(f"  Parsed {len(edges)} lineage edge(s).")
+
+    manifest = {
+        "resource_type": RESOURCE_TYPE,
+        "collected_at": datetime.now(tz=timezone.utc).isoformat(),
+        "column_lineage": column_lineage,
+        "edges": [
+            {
+                "destination": {
+                    "database": e.dest_db,
+                    "schema": e.dest_schema,
+                    "table": e.dest_table,
+                },
+                "sources": [
+                    {"database": sdb, "schema": sschema, "table": stbl}
+                    for sdb, sschema, stbl in e.sources
+                ],
+                "col_mappings": [
+                    {"dest_col": dc, "src_table": st, "src_col": sc}
+                    for dc, st, sc in e.col_mappings
+                ],
+            }
+            for e in edges
+        ],
+    }
+    with open(output_file, "w") as fh:
+        json.dump(manifest, fh, indent=2)
+    print(f"Lineage manifest written to {output_file}")
+
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Collect Snowflake lineage from ACCOUNT_USAGE and write to a manifest file",
+    )
+    parser.add_argument(
+        "--account",
+        default=os.environ.get("SNOWFLAKE_ACCOUNT"),
+        help="Snowflake account identifier (env: SNOWFLAKE_ACCOUNT)",
+    )
+    parser.add_argument(
+        "--user",
+        default=os.environ.get("SNOWFLAKE_USER"),
+        help="Snowflake username (env: SNOWFLAKE_USER)",
+    )
+    parser.add_argument(
+        "--password",
+        default=os.environ.get("SNOWFLAKE_PASSWORD"),
+        help="Snowflake password (env: SNOWFLAKE_PASSWORD)",
+    )
+    parser.add_argument(
+        "--warehouse",
+        default=os.environ.get("SNOWFLAKE_WAREHOUSE"),
+        help="Snowflake virtual warehouse (env: SNOWFLAKE_WAREHOUSE)",
+    )
+    parser.add_argument(
+        "--lookback-hours",
+        type=int,
+        default=_LOOKBACK_HOURS,
+        help=f"Hours of QUERY_HISTORY to scan (default: {_LOOKBACK_HOURS})",
+    )
+    parser.add_argument(
+        "--column-lineage",
+        action="store_true",
+        help="Include column-level lineage mappings in the manifest",
+    )
+    parser.add_argument(
+        "--output-file",
+        default="lineage_output.json",
+        help="Path to write the lineage manifest (default: lineage_output.json)",
+    )
+    args = parser.parse_args()
+
+    missing = [
+        name
+        for name, val in [
+            ("--account", args.account),
+            ("--user", args.user),
+            ("--password", args.password),
+            ("--warehouse", args.warehouse),
+        ]
+        if not val
+    ]
+    if missing:
+        parser.error(f"Missing required arguments: {', '.join(missing)}")
+
+    collect(
+        account=args.account,
+        user=args.user,
+        password=args.password,
+        warehouse=args.warehouse,
+        lookback_hours=args.lookback_hours,
+        column_lineage=args.column_lineage,
+        output_file=args.output_file,
+    )
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/monte-carlo-push-ingestion/scripts/templates/snowflake/collect_metadata.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""
+Collect table metadata from Snowflake — collection only.
+
+Connects to Snowflake, discovers all accessible databases and schemas, then
+queries INFORMATION_SCHEMA.TABLES for volume/freshness and
+INFORMATION_SCHEMA.COLUMNS for field definitions.  The collected assets are
+written to a JSON manifest file.
+
+Can be run standalone via CLI or imported (use the ``collect()`` function).
+
+Substitution points
+-------------------
+- SNOWFLAKE_ACCOUNT    (env) / --account    (CLI) : Snowflake account identifier (e.g. xy12345.us-east-1)
+- SNOWFLAKE_USER       (env) / --user       (CLI) : Snowflake username
+- SNOWFLAKE_PASSWORD   (env) / --password   (CLI) : Snowflake password
+- SNOWFLAKE_WAREHOUSE  (env) / --warehouse  (CLI) : Snowflake virtual warehouse
+
+Prerequisites
+-------------
+    pip install snowflake-connector-python
+
+Usage
+-----
+    python collect_metadata.py \\
+        --account  <SNOWFLAKE_ACCOUNT> \\
+        --user     <SNOWFLAKE_USER> \\
+        --password <SNOWFLAKE_PASSWORD> \\
+        --warehouse <SNOWFLAKE_WAREHOUSE>
+"""
+
+import argparse
+import json
+import os
+from datetime import datetime, timezone
+
+import snowflake.connector
+
+# ← SUBSTITUTE: set RESOURCE_TYPE to match your Monte Carlo connection type
+RESOURCE_TYPE = "snowflake"
+
+
+def _check_available_memory(min_gb: float = 2.0) -> None:
+    """Warn if available memory is below the threshold."""
+    try:
+        if hasattr(os, "sysconf"):  # Linux / macOS
+            page_size = os.sysconf("SC_PAGE_SIZE")
+            avail_pages = os.sysconf("SC_AVPHYS_PAGES")
+            avail_gb = (page_size * avail_pages) / (1024 ** 3)
+        else:
+            return  # Windows — skip check
+    except (ValueError, OSError):
+        return
+    if avail_gb < min_gb:
+        print(
+            f"WARNING: Only {avail_gb:.1f} GB of memory available "
+            f"(minimum recommended: {min_gb:.1f} GB). "
+            f"Consider reducing the lookback window or increasing available memory."
+        )
+
+# Databases that are Snowflake system databases — skip them
+_SKIP_DATABASES = {"SNOWFLAKE", "SNOWFLAKE_SAMPLE_DATA"}
+
+# Schemas that are Snowflake system schemas — skip them
+_SKIP_SCHEMAS = {"INFORMATION_SCHEMA"}
+
+
+# Snowflake TABLE_TYPE → Monte Carlo RelationalAsset.type mapping.
+# The MC API only accepts "TABLE" or "VIEW" (uppercase).
+_TABLE_TYPE_MAP = {
+    "BASE TABLE": "TABLE",
+    "TABLE": "TABLE",
+    "DYNAMIC TABLE": "TABLE",
+    "EXTERNAL TABLE": "TABLE",
+    "VIEW": "VIEW",
+    "MATERIALIZED VIEW": "VIEW",
+    "SECURE VIEW": "VIEW",
+}
+
+
+def _normalize_table_type(raw_type: str | None) -> str:
+    """Map Snowflake's TABLE_TYPE value to MC-accepted 'TABLE' or 'VIEW'."""
+    if not raw_type:
+        return "TABLE"
+    return _TABLE_TYPE_MAP.get(raw_type.upper(), "TABLE")
+
+
+def _connect(account: str, user: str, password: str, warehouse: str):
+    # ← SUBSTITUTE: add role= or authenticator= kwargs if your org requires them
+    return snowflake.connector.connect(
+        account=account,
+        user=user,
+        password=password,
+        warehouse=warehouse,
+    )
+
+
+def _collect_assets(conn) -> list[dict]:
+    """Collect table metadata from Snowflake and return as a list of dicts."""
+    cursor = conn.cursor()
+    assets: list[dict] = []
+
+    # --- Discover databases ---
+    cursor.execute("SHOW DATABASES")
+    # SHOW DATABASES returns (created_on, name, …); column index 1 is the name
+    all_db_rows = []
+    while True:
+        chunk = cursor.fetchmany(1000)
+        if not chunk:
+            break
+        all_db_rows.extend(chunk)
+    databases = [row[1] for row in all_db_rows if row[1] not in _SKIP_DATABASES]
+    print(f"  Found {len(databases)} database(s): {databases}")
+
+    for db in databases:
+        # --- Discover schemas in each database ---
+        try:
+            cursor.execute(f'SHOW SCHEMAS IN DATABASE "{db}"')
+        except Exception as exc:
+            print(f"  WARNING: could not list schemas in {db}: {exc}")
+            continue
+
+        # Column index 1 is the schema name
+        all_schema_rows = []
+        while True:
+            chunk = cursor.fetchmany(1000)
+            if not chunk:
+                break
+            all_schema_rows.extend(chunk)
+        schemas = [row[1] for row in all_schema_rows if row[1] not in _SKIP_SCHEMAS]
+
+        # --- Collect tables, volume, and freshness via INFORMATION_SCHEMA ---
+        try:
+            cursor.execute(
+                f"""
+                SELECT
+                    TABLE_CATALOG,
+                    TABLE_SCHEMA,
+                    TABLE_NAME,
+                    TABLE_TYPE,
+                    ROW_COUNT,
+                    BYTES,
+                    LAST_ALTERED,
+                    COMMENT
+                FROM "{db}".INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_SCHEMA != 'INFORMATION_SCHEMA'
+                ORDER BY TABLE_SCHEMA, TABLE_NAME
+                """
+            )
+        except Exception as exc:
+            print(f"  WARNING: could not query INFORMATION_SCHEMA.TABLES in {db}: {exc}")
+            continue
+
+        table_rows = []
+        while True:
+            chunk = cursor.fetchmany(1000)
+            if not chunk:
+                break
+            table_rows.extend(chunk)
+        print(f"  {db}: {len(table_rows)} table(s)")
+
+        # Build a set of schema names present in the table result to know which
+        # INFORMATION_SCHEMA.COLUMNS queries to run
+        schemas_with_tables: set[str] = {row[1] for row in table_rows}
+
+        # Pre-fetch all columns for this database in one query per schema
+        columns_by_table: dict[tuple[str, str], list[dict]] = {}
+        for schema in schemas_with_tables:
+            if schema not in schemas:
+                continue  # respect the earlier schema skip list
+            try:
+                cursor.execute(
+                    f"""
+                    SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, COMMENT
+                    FROM "{db}".INFORMATION_SCHEMA.COLUMNS
+                    WHERE TABLE_SCHEMA = %s
+                    ORDER BY TABLE_NAME, ORDINAL_POSITION
+                    """,
+                    (schema,),
+                )
+            except Exception as exc:
+                print(f"  WARNING: could not fetch columns for {db}.{schema}: {exc}")
+                continue
+
+            all_col_rows = []
+            while True:
+                chunk = cursor.fetchmany(1000)
+                if not chunk:
+                    break
+                all_col_rows.extend(chunk)
+            for col_row in all_col_rows:
+                table_name, col_name, data_type, col_comment = col_row
+                key = (schema, table_name)
+                if key not in columns_by_table:
+                    columns_by_table[key] = []
+                columns_by_table[key].append(
+                    {
+                        "name": col_name,
+                        "type": data_type,
+                        "description": col_comment or None,
+                    }
+                )
+
+        # Build asset dicts
+        for row in table_rows:
+            tbl_catalog, tbl_schema, tbl_name, tbl_type, row_count, byte_count, last_altered, tbl_comment = row
+
+            volume = None
+            if row_count is not None or byte_count is not None:
+                volume = {
+                    "row_count": int(row_count) if row_count is not None else None,
+                    "byte_count": int(byte_count) if byte_count is not None else None,
+                }
+
+            freshness = None
+            if last_altered is not None:
+                freshness = {
+                    "last_update_time": last_altered.isoformat() if hasattr(last_altered, "isoformat") else str(last_altered),
+                }
+
+            fields = columns_by_table.get((tbl_schema, tbl_name), [])
+
+            assets.append(
+                {
+                    "type": _normalize_table_type(tbl_type),
+                    "database": tbl_catalog,
+                    "schema": tbl_schema,
+                    "name": tbl_name,
+                    "description": tbl_comment or None,
+                    "fields": fields,
+                    "volume": volume,
+                    "freshness": freshness,
+                }
+            )
+            print(f"    + {tbl_catalog}.{tbl_schema}.{tbl_name} ({len(fields)} columns)")
+
+    cursor.close()
+    return assets
+
+
+def collect(
+    account: str,
+    user: str,
+    password: str,
+    warehouse: str,
+    output_file: str = "metadata_output.json",
+) -> dict:
+    """
+    Connect to Snowflake, collect table metadata, and write a JSON manifest.
+
+    Returns the manifest dict.
+    """
+    _check_available_memory()
+    print(f"Connecting to Snowflake account: {account} ...")
+    conn = _connect(account, user, password, warehouse)
+
+    print("Collecting table metadata ...")
+    assets = _collect_assets(conn)
+    conn.close()
+    print(f"\nCollected {len(assets)} table(s).")
+
+    manifest = {
+        "resource_type": RESOURCE_TYPE,
+        "collected_at": datetime.now(tz=timezone.utc).isoformat(),
+        "assets": assets,
+    }
+    with open(output_file, "w") as fh:
+        json.dump(manifest, fh, indent=2)
+    print(f"Asset manifest written to {output_file}")
+
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Collect Snowflake table metadata and write to a manifest file",
+    )
+    parser.add_argument(
+        "--account",
+        default=os.environ.get("SNOWFLAKE_ACCOUNT"),
+        help="Snowflake account identifier, e.g. xy12345.us-east-1 (env: SNOWFLAKE_ACCOUNT)",  # ← SUBSTITUTE
+    )
+    parser.add_argument(
+        "--user",
+        default=os.environ.get("SNOWFLAKE_USER"),
+        help="Snowflake username (env: SNOWFLAKE_USER)",  # ← SUBSTITUTE
+    )
+    parser.add_argument(
+        "--password",
+        default=os.environ.get("SNOWFLAKE_PASSWORD"),
+        help="Snowflake password (env: SNOWFLAKE_PASSWORD)",  # ← SUBSTITUTE
+    )
+    parser.add_argument(
+        "--warehouse",
+        default=os.environ.get("SNOWFLAKE_WAREHOUSE"),
+        help="Snowflake virtual warehouse (env: SNOWFLAKE_WAREHOUSE)",  # ← SUBSTITUTE
+    )
+    parser.add_argument(
+        "--output-file",
+        default="metadata_output.json",
+        help="Path to write the output manifest (default: metadata_output.json)",
+    )
+    args = parser.parse_args()
+
+    missing = [
+        name
+        for name, val in [
+            ("--account", args.account),
+            ("--user", args.user),
+            ("--password", args.password),
+            ("--warehouse", args.warehouse),
+        ]
+        if not val
+    ]
+    if missing:
+        parser.error(f"Missing required arguments: {', '.join(missing)}")
+
+    collect(
+        account=args.account,
+        user=args.user,
+        password=args.password,
+        warehouse=args.warehouse,
+        output_file=args.output_file,
+    )
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()