opencode-skills-collection 3.1.9 → 3.1.11

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

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Keyword (BM25) search on a Weaviate collection.
+
+Usage:
+    uv run keyword_search.py --query "your query" --collection "CollectionName" [--limit 10] [--json]
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+"""
+
+import json
+import sys
+
+import typer
+import weaviate
+from weaviate.classes.query import MetadataQuery
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+def parse_properties(properties_str: str | None) -> list[str] | None:
+    """Parse comma-separated property names with optional boost."""
+    if not properties_str:
+        return None
+    return [p.strip() for p in properties_str.split(",") if p.strip()]
+
+
+@app.command()
+def main(
+    query: str = typer.Option(..., "--query", "-q", help="Keyword search query"),
+    collection: str = typer.Option(..., "--collection", "-c", help="Collection name"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Maximum results to return"),
+    properties: str = typer.Option(
+        None,
+        "--properties",
+        "-p",
+        help="Properties to search with optional boost (e.g., 'title^2,content')",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Perform keyword (BM25) search on a Weaviate collection."""
+    query_properties = parse_properties(properties)
+
+    try:
+        with get_client() as client:
+            if not client.collections.exists(collection):
+                print(f"Error: Collection '{collection}' not found.", file=sys.stderr)
+                raise typer.Exit(1)
+
+            coll = client.collections.use(collection)
+
+            print("Searching...", file=sys.stderr)
+            response = coll.query.bm25(
+                query=query,
+                limit=limit,
+                query_properties=query_properties,
+                return_metadata=MetadataQuery(score=True),
+            )
+            print("Done.", file=sys.stderr)
+
+            objects = []
+            for obj in response.objects:
+                obj_data = {
+                    "uuid": str(obj.uuid),
+                    "properties": dict(obj.properties),
+                    "score": obj.metadata.score if obj.metadata else None,
+                }
+                objects.append(obj_data)
+
+            result = {
+                "query": query,
+                "collection": collection,
+                "limit": limit,
+                "query_properties": query_properties,
+                "objects": objects,
+                "object_count": len(objects),
+            }
+
+            if json_output:
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                print(f"## Keyword Search Results\n")
+                print(f"**Query:** {query}")
+                print(f"**Collection:** {collection}")
+                if query_properties:
+                    print(f"**Properties:** {', '.join(query_properties)}")
+                print(f"**Found:** {len(objects)} objects\n")
+
+                if objects:
+                    all_props = set()
+                    for obj in objects:
+                        all_props.update(obj.get("properties", {}).keys())
+                    sorted_props = sorted(list(all_props))
+
+                    headers = ["#", "UUID", "Score"] + sorted_props
+                    header_row = "| " + " | ".join(headers) + " |"
+                    separator_row = "| " + " | ".join(["---"] * len(headers)) + " |"
+
+                    print(header_row)
+                    print(separator_row)
+
+                    for idx, obj in enumerate(objects, 1):
+                        score = obj.get("score")
+                        score_str = f"{score:.4f}" if score is not None else "N/A"
+                        row_data = [
+                            str(idx),
+                            str(obj.get("uuid", "N/A")),
+                            score_str,
+                        ]
+
+                        props = obj.get("properties", {})
+                        for prop in sorted_props:
+                            val = props.get(prop, "-")
+                            val_str = str(val).replace("\n", " ").replace("|", "\\|")
+                            row_data.append(val_str)
+
+                        print("| " + " | ".join(row_data) + " |")
+                    print()
+                else:
+                    print("No objects found matching the query.\n")
+
+    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/list_collections.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+List all Weaviate collections.
+
+Usage:
+    uv run list_collections.py [--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(
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """List all Weaviate collections."""
+    try:
+        with get_client() as client:
+            print("Fetching collections...", file=sys.stderr)
+            collections = client.collections.list_all(simple=False)
+            print(f"Found {len(collections)} collections.", file=sys.stderr)
+
+            if json_output:
+                result = []
+                for name, config in collections.items():
+                    result.append(
+                        {
+                            "name": name,
+                            "description": config.description,
+                            "properties": [
+                                {"name": p.name, "data_type": str(p.data_type)}
+                                for p in config.properties
+                            ],
+                        }
+                    )
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                if not collections:
+                    print("No collections found.")
+                else:
+                    print("## Collections\n")
+                    print("| Name | Description | Properties |")
+                    print("|------|-------------|------------|")
+                    for name, config in collections.items():
+                        props = ", ".join([p.name for p in config.properties])
+                        desc = config.description or "N/A"
+                        print(f"| {name} | {desc} | {props} |")
+
+    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/query_search.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "weaviate-agents==1.2.0",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Query Weaviate using Query Agent in Search mode.
+
+Usage:
+    uv run search.py --query "your query" --collections "Collection1,Collection2" [--limit 10] [--json]
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+    + Any provider API keys (OPENAI_API_KEY, COHERE_API_KEY, etc.) - auto-detected
+"""
+
+import json
+import sys
+
+import typer
+import weaviate
+from weaviate.agents.query import QueryAgent
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+def parse_collections(collections_str: str) -> list[str]:
+    """Parse comma-separated collection names."""
+    collections = [c.strip() for c in collections_str.split(",") if c.strip()]
+    if not collections:
+        print("Error: At least one collection name required", file=sys.stderr)
+        raise typer.Exit(1)
+    return collections
+
+
+@app.command()
+def main(
+    query: str = typer.Option(
+        ..., "--query", "-q", help="Natural language search query"
+    ),
+    collections: str = typer.Option(
+        ..., "--collections", "-c", help="Comma-separated collection names"
+    ),
+    limit: int = typer.Option(10, "--limit", "-l", help="Maximum results to return"),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Query Weaviate using Query Agent in Search mode (retrieves raw objects)."""
+    collection_list = parse_collections(collections)
+
+    try:
+        with get_client() as client:
+            agent = QueryAgent(client=client, collections=collection_list)
+
+            print("Searching...", file=sys.stderr)
+            response = agent.search(query, limit=limit)
+            print("Done.", file=sys.stderr)
+
+            # Extract objects from search results
+            objects = []
+            if hasattr(response, "search_results") and response.search_results:
+                search_results = response.search_results
+                if hasattr(search_results, "objects") and search_results.objects:
+                    for obj in search_results.objects:
+                        obj_data = {
+                            "uuid": str(getattr(obj, "uuid", "")),
+                            "collection": getattr(obj, "collection", None),
+                            "properties": dict(getattr(obj, "properties", {})),
+                        }
+                        objects.append(obj_data)
+
+            result = {
+                "query": query,
+                "collections": collection_list,
+                "limit": limit,
+                "objects": objects,
+                "object_count": len(objects),
+            }
+
+            if json_output:
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                print(f"## Search Results\n")
+                print(f"**Query:** {query}")
+                print(f"**Collections:** {', '.join(collection_list)}")
+                print(f"**Found:** {len(objects)} objects\n")
+
+                if objects:
+                    # Collect all property keys
+                    all_props = set()
+                    for obj in objects:
+                        all_props.update(obj.get("properties", {}).keys())
+                    sorted_props = sorted(list(all_props))
+
+                    headers = ["#", "UUID", "Collection"] + sorted_props
+                    header_row = "| " + " | ".join(headers) + " |"
+                    separator_row = "| " + " | ".join(["---"] * len(headers)) + " |"
+
+                    print(header_row)
+                    print(separator_row)
+
+                    for idx, obj in enumerate(objects, 1):
+                        row_data = [
+                            str(idx),
+                            str(obj.get("uuid", "N/A")),
+                            str(obj.get("collection", "N/A")),
+                        ]
+
+                        props = obj.get("properties", {})
+                        for prop in sorted_props:
+                            val = props.get(prop, "-")
+                            val_str = str(val).replace("\n", " ").replace("|", "\\|")
+                            row_data.append(val_str)
+
+                        print("| " + " | ".join(row_data) + " |")
+                    print()
+                else:
+                    print("No objects found matching the query.\n")
+
+    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/semantic_search.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "weaviate-client==4.19.2",
+#   "typer==0.21.0",
+# ]
+# ///
+"""
+Semantic (vector) search on a Weaviate collection.
+
+Usage:
+    uv run semantic_search.py --query "your query" --collection "CollectionName" [--limit 10] [--json]
+
+Environment Variables:
+    WEAVIATE_URL: Weaviate Cloud cluster URL
+    WEAVIATE_API_KEY: API key for authentication
+    + Any provider API keys (OPENAI_API_KEY, COHERE_API_KEY, etc.) - auto-detected
+"""
+
+import json
+import sys
+
+import typer
+import weaviate
+from weaviate.classes.query import MetadataQuery
+
+# Import shared connection utilities (local to this skill)
+from weaviate_conn import get_client
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    query: str = typer.Option(..., "--query", "-q", help="Search query text"),
+    collection: str = typer.Option(..., "--collection", "-c", help="Collection name"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Maximum results to return"),
+    distance: float = typer.Option(
+        None, "--distance", "-d", help="Maximum distance threshold"
+    ),
+    target_vector: str = typer.Option(
+        None,
+        "--target-vector",
+        "-t",
+        help="Target vector name for named vector collections",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Perform semantic (vector similarity) search on a Weaviate collection."""
+    try:
+        with get_client() as client:
+            if not client.collections.exists(collection):
+                print(f"Error: Collection '{collection}' not found.", file=sys.stderr)
+                raise typer.Exit(1)
+
+            coll = client.collections.use(collection)
+
+            print("Searching...", file=sys.stderr)
+            response = coll.query.near_text(
+                query=query,
+                limit=limit,
+                distance=distance,
+                target_vector=target_vector,
+                return_metadata=MetadataQuery(distance=True),
+            )
+            print("Done.", file=sys.stderr)
+
+            objects = []
+            for obj in response.objects:
+                obj_data = {
+                    "uuid": str(obj.uuid),
+                    "properties": dict(obj.properties),
+                    "distance": obj.metadata.distance if obj.metadata else None,
+                }
+                objects.append(obj_data)
+
+            result = {
+                "query": query,
+                "collection": collection,
+                "limit": limit,
+                "distance_threshold": distance,
+                "target_vector": target_vector,
+                "objects": objects,
+                "object_count": len(objects),
+            }
+
+            if json_output:
+                print(json.dumps(result, indent=2, default=str))
+            else:
+                print(f"## Semantic Search Results\n")
+                print(f"**Query:** {query}")
+                print(f"**Collection:** {collection}")
+                if distance:
+                    print(f"**Max Distance:** {distance}")
+                print(f"**Found:** {len(objects)} objects\n")
+
+                if objects:
+                    all_props = set()
+                    for obj in objects:
+                        all_props.update(obj.get("properties", {}).keys())
+                    sorted_props = sorted(list(all_props))
+
+                    headers = ["#", "UUID", "Distance"] + sorted_props
+                    header_row = "| " + " | ".join(headers) + " |"
+                    separator_row = "| " + " | ".join(["---"] * len(headers)) + " |"
+
+                    print(header_row)
+                    print(separator_row)
+
+                    for idx, obj in enumerate(objects, 1):
+                        dist = obj.get("distance")
+                        dist_str = f"{dist:.4f}" if dist is not None else "N/A"
+                        row_data = [
+                            str(idx),
+                            str(obj.get("uuid", "N/A")),
+                            dist_str,
+                        ]
+
+                        props = obj.get("properties", {})
+                        for prop in sorted_props:
+                            val = props.get(prop, "-")
+                            val_str = str(val).replace("\n", " ").replace("|", "\\|")
+                            row_data.append(val_str)
+
+                        print("| " + " | ".join(row_data) + " |")
+                    print()
+                else:
+                    print("No objects found matching the query.\n")
+
+    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()