opencode-skills-collection 2.0.0 → 2.0.2

package/bundled-skills/monte-carlo-validation-notebook/scripts/generate_notebook_url.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Encode a notebook YAML file into a base64 import URL and open it in the browser.
+
+Usage:
+    python3 generate_notebook_url.py <notebook_yaml_path> [--mc-base-url URL]
+"""
+
+import argparse
+import base64
+import os
+import re
+import subprocess
+import sys
+
+import yaml
+
+
+def sanitize_yaml(content: str) -> str:
+    """Replace non-ASCII characters with ASCII equivalents."""
+    replacements = {
+        "\u2014": "-",
+        "\u2013": "-",
+        "\u2018": "'",
+        "\u2019": "'",
+        "\u201c": '"',
+        "\u201d": '"',
+        "\u2026": "...",
+        "\u00a0": " ",
+    }
+    for char, replacement in replacements.items():
+        content = content.replace(char, replacement)
+    content = re.sub(r"[^\x00-\x7F]", "?", content)
+    return content
+
+
+def validate_yaml(content: str) -> None:
+    """Parse YAML, validate notebook schema, and exit with context on failure."""
+    try:
+        doc = yaml.safe_load(content)
+    except yaml.YAMLError as e:
+        print(f"YAML validation failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    errors: list[str] = []
+
+    # Top-level structure
+    if not isinstance(doc, dict):
+        errors.append("Root must be a mapping")
+    else:
+        if "version" not in doc:
+            errors.append("Missing top-level 'version'")
+        metadata = doc.get("metadata")
+        if not isinstance(metadata, dict):
+            errors.append("Missing or invalid 'metadata' mapping")
+        else:
+            for field in ("id", "name", "created_at", "updated_at"):
+                if field not in metadata:
+                    errors.append(f"metadata.{field}: missing required field")
+            for bad_field in ("title", "description", "pr_number", "generated_by"):
+                if bad_field in metadata:
+                    errors.append(
+                        f"metadata.{bad_field}: unexpected field (use 'name' for the notebook title)"
+                    )
+
+        cells = doc.get("cells")
+        if not isinstance(cells, list):
+            errors.append("Missing or invalid 'cells' list")
+        else:
+            for i, cell in enumerate(cells):
+                prefix = f"cells[{i}]"
+                if not isinstance(cell, dict):
+                    errors.append(f"{prefix}: must be a mapping")
+                    continue
+                if "id" not in cell:
+                    errors.append(f"{prefix}: missing 'id'")
+                if "type" not in cell:
+                    errors.append(f"{prefix}: missing 'type'")
+                cell_type = cell.get("type")
+                if cell_type not in ("sql", "markdown", "parameter"):
+                    errors.append(
+                        f"{prefix}: invalid type '{cell_type}' (must be sql, markdown, or parameter)"
+                    )
+                if "display_type" not in cell:
+                    errors.append(f"{prefix}: missing 'display_type'")
+                if cell_type == "parameter":
+                    content_val = cell.get("content")
+                    if not isinstance(content_val, dict):
+                        errors.append(f"{prefix}: parameter cell 'content' must be a mapping with 'name' and 'config'")
+                    else:
+                        if "name" not in content_val:
+                            errors.append(f"{prefix}: parameter content missing 'name'")
+                        if "config" not in content_val:
+                            errors.append(f"{prefix}: parameter content missing 'config'")
+
+    if errors:
+        print("Invalid notebook:", file=sys.stderr)
+        for err in errors:
+            print(f"  - {err}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Encode notebook YAML to import URL")
+    parser.add_argument("yaml_path", help="Path to notebook YAML file")
+    parser.add_argument(
+        "--mc-base-url",
+        default="https://getmontecarlo.com",
+        help="MC Bridge base URL",
+    )
+    args = parser.parse_args()
+
+    with open(args.yaml_path) as f:
+        notebook_yaml = f.read()
+
+    yaml_content = sanitize_yaml(notebook_yaml.strip())
+    validate_yaml(yaml_content)
+
+    encoded = base64.b64encode(yaml_content.encode()).decode()
+    url = f"{args.mc_base_url}/notebooks/import#{encoded}"
+
+    print(f"URL length: {len(url)} chars")
+
+    # Save URL to file alongside the YAML
+    url_file = os.path.join(os.path.dirname(os.path.abspath(args.yaml_path)), "notebook_url.txt")
+    with open(url_file, "w") as f:
+        f.write(url)
+    print(f"URL saved to: {url_file}")
+
+    print("\n" + "=" * 60)
+    print("NOTEBOOK URL:")
+    print("=" * 60)
+    print(url)
+    print("=" * 60 + "\n")
+
+    print("Opening notebook in browser...")
+    subprocess.run(["open", url])
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/monte-carlo-validation-notebook/scripts/resolve_dbt_schema.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Resolve the output schema for a dbt model.
+
+Usage:
+    python3 resolve_dbt_schema.py <dbt_project_yml_path> <model_sql_path>
+
+Returns the resolved schema name (uppercase), e.g., "PROD", "PROD_STAGE", "PROD_LINEAGE"
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union
+
+import yaml
+
+
+def parse_model_config_schema(model_content: str) -> Optional[str]:
+    """Extract schema from model's config block."""
+    pattern = r"\{\{\s*config\s*\([^)]*\bschema\s*=\s*['\"]([^'\"]+)['\"][^)]*\)\s*\}\}"
+    match = re.search(pattern, model_content, re.IGNORECASE | re.DOTALL)
+    if match:
+        return match.group(1).upper()
+
+    snapshot_pattern = r"target_schema\s*=\s*generate_schema_name\s*\(\s*['\"]([^'\"]+)['\"]"
+    match = re.search(snapshot_pattern, model_content, re.IGNORECASE | re.DOTALL)
+    if match:
+        return match.group(1).upper()
+
+    return None
+
+
+def parse_dbt_project_routing(
+    dbt_project: dict, project_name: str
+) -> Tuple[Dict[str, str], Dict[str, str]]:
+    """Extract schema and database routing rules from dbt_project.yml."""
+    schema_routing = {}  # type: Dict[str, str]
+    database_routing = {}  # type: Dict[str, str]
+
+    models_config = dbt_project.get("models", {})
+    project_config = models_config.get(project_name, {})
+
+    def extract_routing(config: dict, current_path: str = "") -> None:
+        for key, value in config.items():
+            if key.startswith("+"):
+                continue
+            if not isinstance(value, dict):
+                continue
+            new_path = f"{current_path}/{key}" if current_path else key
+            schema = value.get("schema") or value.get("+schema")
+            if schema:
+                if "{{" not in schema:
+                    schema_routing[new_path] = schema.upper()
+            database = value.get("database") or value.get("+database")
+            if database:
+                if "{{" not in database:
+                    database_routing[new_path] = database.upper()
+            extract_routing(value, new_path)
+
+    extract_routing(project_config)
+    return schema_routing, database_routing
+
+
+def parse_dbt_project_schema_routing(dbt_project: dict, project_name: str) -> Dict[str, str]:
+    schema_routing, _ = parse_dbt_project_routing(dbt_project, project_name)
+    return schema_routing
+
+
+def get_model_relative_path(dbt_project_path: Path, model_path: Path) -> str:
+    dbt_project_dir = dbt_project_path.parent
+    model_relative = model_path.relative_to(dbt_project_dir)
+    parts = model_relative.parts
+    if parts and parts[0] == "models":
+        return str(Path(*parts[1:]))
+    return str(model_relative)
+
+
+def find_matching_schema(
+    model_relative_path: str, routing: Dict[str, str]
+) -> Optional[str]:
+    model_dir = str(Path(model_relative_path).parent)
+    matches = []  # type: List[Tuple[str, str]]
+    for route_path, schema in routing.items():
+        if model_dir == route_path or model_dir.startswith(route_path + "/"):
+            matches.append((route_path, schema))
+    if not matches:
+        return None
+    matches.sort(key=lambda x: len(x[0]), reverse=True)
+    return matches[0][1]
+
+
+def apply_schema_prefix(schema: str, target_schema: str = "PROD") -> str:
+    if not schema or schema.upper() == target_schema.upper():
+        return target_schema.upper()
+    return f"{target_schema.upper()}_{schema.upper()}"
+
+
+def resolve_schema(
+    dbt_project_path: Union[str, Path],
+    model_path: Union[str, Path],
+    default_schema: str = "PROD",
+    apply_prefix: bool = True,
+) -> str:
+    dbt_project_path = Path(dbt_project_path)
+    model_path = Path(model_path)
+
+    model_content = model_path.read_text()
+
+    config_schema = parse_model_config_schema(model_content)
+    if config_schema:
+        if apply_prefix:
+            return apply_schema_prefix(config_schema, default_schema)
+        return config_schema
+
+    with open(dbt_project_path) as f:
+        dbt_project = yaml.safe_load(f)
+
+    project_name = dbt_project.get("name", "")
+
+    routing = parse_dbt_project_schema_routing(dbt_project, project_name)
+    model_relative = get_model_relative_path(dbt_project_path, model_path)
+    matched_schema = find_matching_schema(model_relative, routing)
+    if matched_schema:
+        if apply_prefix:
+            return apply_schema_prefix(matched_schema, default_schema)
+        return matched_schema
+
+    return default_schema.upper()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Resolve the output schema for a dbt model"
+    )
+    parser.add_argument("dbt_project_path", help="Path to dbt_project.yml")
+    parser.add_argument("model_path", help="Path to the model SQL file")
+    parser.add_argument("--default", default="PROD", help="Default schema (default: PROD)")
+    parser.add_argument("--no-prefix", action="store_true", help="Don't apply PROD_ prefix")
+
+    args = parser.parse_args()
+
+    dbt_project_path = Path(args.dbt_project_path)
+    model_path = Path(args.model_path)
+
+    if not dbt_project_path.exists():
+        print(f"Error: dbt_project.yml not found: {dbt_project_path}", file=sys.stderr)
+        sys.exit(1)
+
+    if not model_path.exists():
+        print(f"Error: Model file not found: {model_path}", file=sys.stderr)
+        sys.exit(1)
+
+    apply_prefix = not args.no_prefix
+    schema = resolve_schema(dbt_project_path, model_path, args.default, apply_prefix)
+    print(schema)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",