opencode-skills-collection 3.1.10 → 3.1.11

package/bundled-skills/weaviate/scripts/explore_collection.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Explore a Weaviate collection's data: metrics, unique values (top occurrences), and sample objects.
+
+Usage:
+    uv run explore_collection.py "CollectionName" [--limit 5] [--no-metrics] [--json]
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+"""
+
+import json
+import sys
+
+import typer
+import weaviate
+import weaviate.classes as wvc
+from weaviate.classes.aggregate import Metrics
+from weaviate.collections.classes.config import DataType
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+def get_metrics_for_property(prop_name: str, data_type: DataType | str) -> Metrics:
+    """
+    Return the appropriate Metrics object based on the property's data type.
+    """
+    # Text
+    if data_type in [DataType.TEXT, DataType.TEXT_ARRAY]:
+        return Metrics(prop_name).text(
+            count=True,
+            top_occurrences_count=True,
+            top_occurrences_value=True,
+            limit=5,
+        )
+    # Integer
+    elif data_type in [DataType.INT, DataType.INT_ARRAY]:
+        return Metrics(prop_name).integer(
+            count=True,
+            minimum=True,
+            maximum=True,
+            mean=True,
+            median=True,
+            mode=True,
+            sum_=True,
+        )
+    # Number
+    elif data_type in [DataType.NUMBER, DataType.NUMBER_ARRAY]:
+        return Metrics(prop_name).number(
+            count=True,
+            minimum=True,
+            maximum=True,
+            mean=True,
+            median=True,
+            mode=True,
+            sum_=True,
+        )
+    # Boolean
+    elif data_type in [DataType.BOOL, DataType.BOOL_ARRAY]:
+        return Metrics(prop_name).boolean(
+            count=True,
+            percentage_true=True,
+            percentage_false=True,
+            total_true=True,
+            total_false=True,
+        )
+    # Date
+    elif data_type in [DataType.DATE, DataType.DATE_ARRAY]:
+        return Metrics(prop_name).date_(
+            count=True,
+            minimum=True,
+            maximum=True,
+            median=True,
+            mode=True,
+        )
+    return None
+
+
+@app.command()
+def main(
+    name: str = typer.Argument(..., help="Collection name"),
+    limit: int = typer.Option(
+        5, "--limit", "-l", help="Number of sample objects to show"
+    ),
+    no_metrics: bool = typer.Option(
+        False, "--no-metrics", help="Skip calculating metrics (faster)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Explore data within a Weaviate collection."""
+    try:
+        with get_client() as client:
+            if not client.collections.exists(name):
+                print(f"Error: Collection '{name}' not found.", file=sys.stderr)
+                raise typer.Exit(1)
+
+            collection = client.collections.use(name)
+            config = collection.config.get()
+
+            # 1. Fetch Aggregation Metrics
+            metrics_data = {}
+            total_count = 0
+
+            if not no_metrics:
+                if not json_output:
+                    print("Calculating metrics...", file=sys.stderr)
+
+                return_metrics = []
+                # Add metrics for each property based on type
+                for prop in config.properties:
+                    m = get_metrics_for_property(prop.name, prop.data_type)
+                    if m:
+                        return_metrics.append(m)
+
+                try:
+                    # Always ask for total_count
+                    if return_metrics:
+                        agg_response = collection.aggregate.over_all(
+                            total_count=True, return_metrics=return_metrics
+                        )
+                    else:
+                        # Fallback if no properties to aggregate
+                        agg_response = collection.aggregate.over_all(total_count=True)
+
+                    total_count = agg_response.total_count
+
+                    for prop_name, agg_res in agg_response.properties.items():
+                        prop_metrics = {}
+
+                        # Helpers to extract common fields safely
+                        def extract_fields(obj, fields):
+                            for f in fields:
+                                val = getattr(obj, f, None)
+                                if val is not None:
+                                    prop_metrics[f] = val
+
+                        # Identify type of result by checking attributes
+                        if hasattr(agg_res, "top_occurrences"):
+                            # Text
+                            extract_fields(agg_res, ["count"])
+                            if agg_res.top_occurrences:
+                                prop_metrics["top_occurrences"] = [
+                                    {"value": to.value, "count": to.count}
+                                    for to in agg_res.top_occurrences
+                                ]
+                        elif hasattr(agg_res, "mean"):
+                            # Number/Int
+                            extract_fields(
+                                agg_res,
+                                [
+                                    "count",
+                                    "minimum",
+                                    "maximum",
+                                    "mean",
+                                    "median",
+                                    "mode",
+                                    "sum_",
+                                ],
+                            )
+                        elif hasattr(agg_res, "percentage_true"):
+                            # Boolean
+                            extract_fields(
+                                agg_res,
+                                [
+                                    "count",
+                                    "total_true",
+                                    "total_false",
+                                    "percentage_true",
+                                    "percentage_false",
+                                ],
+                            )
+                        elif hasattr(agg_res, "minimum") and not hasattr(
+                            agg_res, "mean"
+                        ):
+                            # Date (has min/max but no mean)
+                            extract_fields(
+                                agg_res,
+                                ["count", "minimum", "maximum", "median", "mode"],
+                            )
+
+                        if prop_metrics:
+                            metrics_data[prop_name] = prop_metrics
+
+                except Exception as e:
+                    if not json_output:
+                        print(f"Warning: Aggregation failed: {e}", file=sys.stderr)
+                    metrics_data["error"] = str(e)
+            else:
+                # Just get total count if metrics skipped
+                try:
+                    agg_response = collection.aggregate.over_all(total_count=True)
+                    total_count = agg_response.total_count
+                except Exception:
+                    pass
+
+            # 2. Fetch Sample Objects
+            if limit > 0:
+                if not json_output:
+                    print(f"Fetching {limit} sample objects...", file=sys.stderr)
+                # Fetch objects with all properties
+                objects_resp = collection.query.fetch_objects(limit=limit)
+                sample_objects = []
+                for obj in objects_resp.objects:
+                    sample_objects.append(
+                        {"uuid": str(obj.uuid), "properties": obj.properties}
+                    )
+            else:
+                sample_objects = []
+
+            # 3. Output
+            result = {
+                "collection": name,
+                "total_count": total_count,
+                "metrics": metrics_data,
+                "sample_objects": sample_objects,
+            }
+
+            if json_output:
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                # Markdown Output
+                print(f"## Collection Explorer: {name}\n")
+                print(f"**Total Objects:** {total_count}")
+
+                if metrics_data:
+                    print("\n### Property Metrics\n")
+
+                    prop_types = {p.name: p.data_type.value for p in config.properties}
+
+                    for prop_name, data in metrics_data.items():
+                        p_type = prop_types.get(prop_name, "unknown")
+                        print(f"**{prop_name}** ({p_type})")
+                        for k, v in data.items():
+                            if k == "top_occurrences":
+                                print(f"- Top Values:")
+                                for item in v:
+                                    # Escape pipes and newlines in values
+                                    val_str = (
+                                        str(item["value"])
+                                        .replace("\n", " ")
+                                        .replace("|", "\\|")
+                                    )
+                                    print(f"    - {val_str} ({item['count']})")
+                            else:
+                                label = k.replace("_", " ").capitalize()
+                                print(f"- {label}: {v}")
+                        print("")
+
+                if sample_objects:
+                    print(f"### Sample Objects (Limit: {limit})\n")
+
+                    all_props = set()
+                    for obj in sample_objects:
+                        all_props.update(obj["properties"].keys())
+                    sorted_props = sorted(list(all_props))
+
+                    headers = ["#", "UUID"] + sorted_props
+                    header_row = "| " + " | ".join(headers) + " |"
+                    separator_row = "| " + " | ".join(["---"] * len(headers)) + " |"
+
+                    print(header_row)
+                    print(separator_row)
+
+                    for idx, obj in enumerate(sample_objects, 1):
+                        row_data = [str(idx), str(obj["uuid"])]
+                        props = obj["properties"]
+                        for prop in sorted_props:
+                            val = props.get(prop, "-")
+                            val_str = str(val).replace("\n", " ").replace("|", "\\|")
+                            if len(val_str) > 100:
+                                val_str = val_str[:97] + "..."
+                            row_data.append(val_str)
+                        print("| " + " | ".join(row_data) + " |")
+                    print()
+
+    except weaviate.exceptions.WeaviateConnectionError as e:
+        print(f"Error: Connection failed - {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

package/bundled-skills/weaviate/scripts/fetch_filter.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Fetch and filter objects from a Weaviate collection.
+
+Usage:
+    # Fetch random 10 objects
+    uv run fetch_filter.py "JeopardyQuestion"
+
+    # Fetch by ID
+    uv run fetch_filter.py "JeopardyQuestion" --id "uuid-string"
+
+    # Filter with simple JSON
+    uv run fetch_filter.py "JeopardyQuestion" --filters '[{"property": "round", "operator": "equal", "value": "Double Jeopardy!"}]'
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+"""
+
+import json
+import sys
+from typing import Any, List, Optional
+
+import typer
+import weaviate
+from weaviate.classes.query import Filter
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+def parse_filter_item(item: Any) -> Optional[Filter]:
+    """
+    Recursively parse a single filter item (dict or list).
+
+    Supported structures:
+    1. List of filters (implicit AND): [filter1, filter2]
+    2. Explicit Logical Operators:
+       {"operator": "and", "filters": [...]}
+       {"operator": "or", "filters": [...]}
+    3. Property Filter:
+       {"property": "name", "operator": "equal", "value": "foo"}
+    """
+    if isinstance(item, list):
+        # Implicit AND for lists
+        sub_filters = [parse_filter_item(x) for x in item]
+        # Filter out Nones
+        sub_filters = [f for f in sub_filters if f is not None]
+        if not sub_filters:
+            return None
+        return Filter.all_of(sub_filters)
+
+    if not isinstance(item, dict):
+        return None
+
+    # Check for logical operators
+    op = item.get("operator")
+
+    if op == "and":
+        sub_items = item.get("filters", [])
+        sub_filters = [parse_filter_item(x) for x in sub_items]
+        sub_filters = [f for f in sub_filters if f is not None]
+        return Filter.all_of(sub_filters) if sub_filters else None
+
+    if op == "or":
+        sub_items = item.get("filters", [])
+        sub_filters = [parse_filter_item(x) for x in sub_items]
+        sub_filters = [f for f in sub_filters if f is not None]
+        return Filter.any_of(sub_filters) if sub_filters else None
+
+    # Property Filter
+    prop = item.get("property")
+    val = item.get("value")
+
+    if not prop or not op:
+        return None
+
+    current_filter = Filter.by_property(prop)
+
+    # Map operator string to method
+    if op == "equal":
+        return current_filter.equal(val)
+    elif op == "not_equal":
+        return current_filter.not_equal(val)
+    elif op == "less_than":
+        return current_filter.less_than(val)
+    elif op == "less_or_equal":
+        return current_filter.less_or_equal(val)
+    elif op == "greater_than":
+        return current_filter.greater_than(val)
+    elif op == "greater_or_equal":
+        return current_filter.greater_or_equal(val)
+    elif op == "like":
+        return current_filter.like(val)
+    elif op == "contains_any":
+        if not isinstance(val, list):
+            print(
+                f"Error: Value for 'contains_any' must be a list, got {type(val)}",
+                file=sys.stderr,
+            )
+            raise typer.Exit(1)
+        return current_filter.contains_any(val)
+    elif op == "contains_all":
+        if not isinstance(val, list):
+            print(
+                f"Error: Value for 'contains_all' must be a list, got {type(val)}",
+                file=sys.stderr,
+            )
+            raise typer.Exit(1)
+        return current_filter.contains_all(val)
+    elif op == "is_none":
+        return current_filter.is_none(bool(val))
+    else:
+        print(
+            f"Warning: Unknown operator '{op}' for property '{prop}'. Skipping.",
+            file=sys.stderr,
+        )
+        return None
+
+
+def parse_filters(filter_json: str) -> Optional[Filter]:
+    """
+    Parse a JSON string of filters into a Weaviate Filter object.
+    Supports complex nesting with AND/OR.
+    """
+    if not filter_json:
+        return None
+
+    try:
+        data = json.loads(filter_json)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing filters JSON: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+    return parse_filter_item(data)
+
+
+@app.command()
+def main(
+    collection_name: str = typer.Argument(..., help="Collection name"),
+    obj_id: str = typer.Option(None, "--id", help="Fetch specific object by UUID"),
+    filters: str = typer.Option(None, "--filters", "-f", help="JSON string of filters"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Number of objects to fetch"),
+    properties: str = typer.Option(
+        None,
+        "--properties",
+        "-p",
+        help="Comma-separated properties to include (default: all)",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Fetch objects with optional filtering."""
+    try:
+        with get_client() as client:
+            if not client.collections.exists(collection_name):
+                print(
+                    f"Error: Collection '{collection_name}' not found.", file=sys.stderr
+                )
+                raise typer.Exit(1)
+
+            collection = client.collections.use(collection_name)
+
+            # Determine return properties
+            return_properties = None
+            if properties:
+                return_properties = [
+                    p.strip() for p in properties.split(",") if p.strip()
+                ]
+
+            results = []
+
+            if obj_id:
+                # Fetch single object by ID
+                if not json_output:
+                    print(f"Fetching object {obj_id}...", file=sys.stderr)
+
+                obj = collection.query.fetch_object_by_id(obj_id)
+
+                if obj:
+                    results.append(obj)
+                else:
+                    print(f"Error: Object {obj_id} not found.", file=sys.stderr)
+                    raise typer.Exit(1)
+
+            else:
+                # Fetch multiple with filters
+                weaviate_filter = parse_filters(filters)
+
+                if not json_output:
+                    print(
+                        f"Fetching objects from '{collection_name}'...", file=sys.stderr
+                    )
+
+                response = collection.query.fetch_objects(
+                    filters=weaviate_filter,
+                    limit=limit,
+                    return_properties=return_properties,
+                )
+                results = list(response.objects)
+
+            # Output Formatting
+            output_data = []
+            for obj in results:
+                item = {
+                    "uuid": str(obj.uuid),
+                    "properties": obj.properties,
+                    "metadata": {
+                        "creation_time": str(obj.metadata.creation_time)
+                        if obj.metadata.creation_time
+                        else None,
+                    },
+                }
+                output_data.append(item)
+
+            if json_output:
+                print(json.dumps(output_data, indent=2, default=str))
+            else:
+                if not results:
+                    print("No objects found.")
+                else:
+                    print(f"## Found {len(results)} Objects\n")
+
+                    # Gather all property keys for the table headers
+                    all_keys = set()
+                    for item in output_data:
+                        all_keys.update(item["properties"].keys())
+                    sorted_keys = sorted(list(all_keys))
+
+                    # Table Header
+                    headers = ["UUID"] + sorted_keys
+                    print("| " + " | ".join(headers) + " |")
+                    print("| " + " | ".join(["---"] * len(headers)) + " |")
+
+                    for item in output_data:
+                        row = [str(item["uuid"])]
+                        for k in sorted_keys:
+                            val = item["properties"].get(k, "-")
+                            val_str = str(val).replace("\n", " ").replace("|", "\\|")
+                            if len(val_str) > 100:
+                                val_str = val_str[:97] + "..."
+                            row.append(val_str)
+                        print("| " + " | ".join(row) + " |")
+
+    except weaviate.exceptions.WeaviateConnectionError as e:
+        print(f"Error: Connection failed - {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

package/bundled-skills/weaviate/scripts/get_collection.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Get details of a specific Weaviate collection.
+
+Usage:
+    uv run get_collection.py --name "CollectionName" [--json]
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+"""
+
+import json
+import sys
+
+import typer
+import weaviate
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    name: str = typer.Option(..., "--name", "-n", help="Collection name"),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Get detailed configuration of a Weaviate collection."""
+    try:
+        with get_client() as client:
+            if not client.collections.exists(name):
+                print(f"Error: Collection '{name}' not found.", file=sys.stderr)
+                raise typer.Exit(1)
+
+            print("Fetching collection details...", file=sys.stderr)
+            collection = client.collections.use(name)
+            config = collection.config.get()
+
+            # Extract vectorizer config
+            vectorizer_config = None
+            if hasattr(config, "vectorizer_config") and config.vectorizer_config:
+                vc = config.vectorizer_config
+                if hasattr(vc, "vectorizer"):
+                    vectorizer_config = {
+                        "vectorizer": str(vc.vectorizer.value)
+                        if hasattr(vc.vectorizer, "value")
+                        else str(vc.vectorizer),
+                        "model": getattr(vc, "model", None),
+                    }
+
+            # Extract properties
+            properties = []
+            if hasattr(config, "properties") and config.properties:
+                for p in config.properties:
+                    prop_info = {
+                        "name": p.name,
+                        "data_type": str(p.data_type),
+                        "description": getattr(p, "description", None),
+                    }
+                    properties.append(prop_info)
+
+            result = {
+                "name": name,
+                "description": config.description,
+                "vectorizer_config": vectorizer_config,
+                "properties": properties,
+                "replication_factor": getattr(config.replication_config, "factor", None)
+                if hasattr(config, "replication_config")
+                else None,
+                "multi_tenancy_enabled": getattr(
+                    config.multi_tenancy_config, "enabled", False
+                )
+                if hasattr(config, "multi_tenancy_config")
+                else False,
+            }
+
+            if json_output:
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                print(f"## Collection: {name}\n")
+                print(f"**Description:** {config.description or 'N/A'}")
+
+                if vectorizer_config:
+                    print(
+                        f"**Vectorizer:** {vectorizer_config.get('vectorizer', 'N/A')}"
+                    )
+                    if vectorizer_config.get("model"):
+                        print(f"**Model:** {vectorizer_config['model']}")
+
+                print(
+                    f"**Replication Factor:** {result['replication_factor'] or 'N/A'}"
+                )
+                print(
+                    f"**Multi-Tenancy:** {'Enabled' if result['multi_tenancy_enabled'] else 'Disabled'}"
+                )
+
+                if properties:
+                    print(f"\n### Properties ({len(properties)})\n")
+                    print("| Name | Data Type | Description |")
+                    print("|------|-----------|-------------|")
+                    for prop in properties:
+                        desc = prop.get("description") or "-"
+                        print(f"| {prop['name']} | {prop['data_type']} | {desc} |")
+
+    except weaviate.exceptions.WeaviateConnectionError as e:
+        print(f"Error: Connection failed - {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()