sqlseed 0.1.8__tar.gz → 0.1.9__tar.gz

{sqlseed-0.1.8 → sqlseed-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlseed
-Version: 0.1.8
+Version: 0.1.9
 Summary: Declarative SQLite test data generation toolkit
 Project-URL: Homepage, https://github.com/sunbos/sqlseed
 Project-URL: Documentation, https://github.com/sunbos/sqlseed#readme

sqlseed-0.1.9/plugins/mcp-server-sqlseed/README.md

@@ -0,0 +1,49 @@
+# mcp-server-sqlseed
+
+[Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for [sqlseed](https://github.com/sunbos/sqlseed) — enabling AI assistants to generate SQLite test data.
+
+## Overview
+
+`mcp-server-sqlseed` exposes sqlseed's capabilities as MCP tools, allowing AI assistants (Claude, Cursor, etc.) to inspect database schemas, generate YAML configurations, and execute data fills seamlessly.
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `sqlseed_inspect_schema` | Inspect database table structure, columns, indexes, and sample data |
+| `sqlseed_generate_yaml` | Generate a YAML configuration file for data generation |
+| `sqlseed_execute_fill` | Execute data generation and fill a database table |
+
+### MCP Resource
+
+- `sqlseed://schema/{db_path}/{table_name}` — Read-only schema information for a specific table
+
+## Installation
+
+```bash
+pip install mcp-server-sqlseed
+```
+
+## Configuration
+
+Add to your MCP client configuration (e.g., Claude Desktop):
+
+```json
+{
+  "mcpServers": {
+    "sqlseed": {
+      "command": "mcp-server-sqlseed"
+    }
+  }
+}
+```
+
+## Requirements
+
+- Python >= 3.10
+- `sqlseed >= 0.1.0`
+- `mcp >= 1.0`
+
+## License
+
+AGPL-3.0-or-later

sqlseed-0.1.9/plugins/mcp-server-sqlseed/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-server-sqlseed"
+dynamic = ["version"]
+requires-python = ">=3.10"
+description = "MCP server for sqlseed - AI-powered SQLite test data generation"
+readme = "README.md"
+license = "AGPL-3.0-or-later"
+authors = [
+    {name = "SunBo", email = "1443584939@qq.com"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "sqlseed>=0.1.0",
+    "mcp>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/sunbos/sqlseed"
+Repository = "https://github.com/sunbos/sqlseed/tree/main/plugins/mcp-server-sqlseed"
+
+[project.optional-dependencies]
+ai = ["sqlseed-ai"]
+
+[project.scripts]
+mcp-server-sqlseed = "mcp_server_sqlseed:main"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0.0.0"
+
+[tool.hatch.version.raw-options]
+root = "../.."
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_server_sqlseed"]

sqlseed-0.1.9/plugins/mcp-server-sqlseed/src/mcp_server_sqlseed/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from mcp_server_sqlseed.server import mcp
+
+
+def main() -> None:
+    mcp.run()

sqlseed-0.1.9/plugins/mcp-server-sqlseed/src/mcp_server_sqlseed/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from mcp_server_sqlseed import main
+
+if __name__ == "__main__":
+    main()

sqlseed-0.1.9/plugins/mcp-server-sqlseed/src/mcp_server_sqlseed/config.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class MCPServerConfig(BaseModel):
+    db_path: str | None = None
+    host: str = "localhost"
+    port: int = 8000

sqlseed-0.1.9/plugins/mcp-server-sqlseed/src/mcp_server_sqlseed/server.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("sqlseed")
+
+
+def _serialize_schema_context(ctx: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "table_name": ctx["table_name"],
+        "columns": [
+            {
+                "name": c.name,
+                "type": c.type,
+                "nullable": c.nullable,
+                "default": c.default,
+                "is_primary_key": c.is_primary_key,
+                "is_autoincrement": c.is_autoincrement,
+            }
+            for c in ctx["columns"]
+        ],
+        "foreign_keys": [
+            {"column": fk.column, "ref_table": fk.ref_table, "ref_column": fk.ref_column}
+            for fk in ctx["foreign_keys"]
+        ],
+        "indexes": ctx["indexes"],
+        "sample_data": ctx["sample_data"],
+        "all_table_names": ctx["all_table_names"],
+    }
+
+
+def _compute_schema_hash(schema_ctx: dict[str, Any]) -> str:
+    hash_input = json.dumps(
+        {
+            "columns": [
+                {"name": c.name, "type": c.type, "nullable": c.nullable}
+                for c in schema_ctx["columns"]
+            ],
+            "foreign_keys": [
+                {"column": fk.column, "ref_table": fk.ref_table}
+                for fk in schema_ctx["foreign_keys"]
+            ],
+        },
+        sort_keys=True,
+    )
+    return hashlib.sha256(hash_input.encode()).hexdigest()[:16]
+
+
+@mcp.resource("sqlseed://schema/{db_path}/{table_name}")
+def get_schema_resource(db_path: str, table_name: str) -> str:
+    from sqlseed.core.orchestrator import DataOrchestrator
+
+    with DataOrchestrator(db_path) as orch:
+        ctx = orch.get_schema_context(table_name)
+        serializable_ctx = _serialize_schema_context(ctx)
+        return json.dumps(serializable_ctx, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+def sqlseed_inspect_schema(db_path: str, table_name: str | None = None) -> dict[str, Any]:
+    """Inspect database schema. Returns column info, foreign keys, indexes,
+    sample data, and schema_hash for specified table or all tables."""
+    from sqlseed.core.orchestrator import DataOrchestrator
+
+    with DataOrchestrator(db_path) as orch:
+        tables = [table_name] if table_name else orch._db.get_table_names()
+        result: dict[str, Any] = {}
+        for tbl in tables:
+            ctx = orch.get_schema_context(tbl)
+            result[tbl] = _serialize_schema_context(ctx)
+            result[tbl]["schema_hash"] = _compute_schema_hash(ctx)
+        return result
+
+
+@mcp.tool()
+def sqlseed_generate_yaml(db_path: str, table_name: str, max_retries: int = 3) -> str:
+    """Generate YAML config for a table using AI analysis with self-correction.
+    Returns YAML string for human review. Requires sqlseed-ai plugin and API key."""
+    import yaml
+    from sqlseed_ai.analyzer import SchemaAnalyzer
+    from sqlseed_ai.refiner import AiConfigRefiner, AISuggestionFailedError
+
+    analyzer = SchemaAnalyzer()
+    refiner = AiConfigRefiner(analyzer, db_path)
+
+    try:
+        result = refiner.generate_and_refine(
+            table_name=table_name,
+            max_retries=max_retries,
+        )
+    except AISuggestionFailedError as e:
+        return f"# AI suggestion failed: {e}"
+    except Exception as e:
+        return f"# Error: {e}"
+
+    if result:
+        output = {"db_path": db_path, "provider": "mimesis", "locale": "zh_CN", "tables": [result]}
+        return yaml.dump(output, allow_unicode=True, sort_keys=False, default_flow_style=False)
+    return "# No AI suggestions available. Ensure sqlseed-ai plugin is installed and API key is configured."
+
+
+@mcp.tool()
+def sqlseed_execute_fill(
+    db_path: str,
+    table_name: str,
+    count: int = 1000,
+    yaml_config: str | None = None,
+) -> dict[str, Any]:
+    """Execute data generation for a table. Optionally provide YAML config string for column rules."""
+    from sqlseed.core.orchestrator import DataOrchestrator
+
+    with DataOrchestrator(db_path) as orch:
+        column_configs = None
+        clear_before = False
+        seed = None
+
+        if yaml_config:
+            import yaml as _yaml
+
+            from sqlseed.config.models import GeneratorConfig
+
+            data = _yaml.safe_load(yaml_config)
+            config = GeneratorConfig(**data)
+            for t in config.tables:
+                if t.name == table_name:
+                    column_configs = t.columns
+                    clear_before = t.clear_before
+                    seed = t.seed
+                    break
+
+        result = orch.fill_table(
+            table_name=table_name,
+            count=count,
+            column_configs=column_configs,
+            clear_before=clear_before,
+            seed=seed,
+        )
+
+        return {
+            "table_name": result.table_name,
+            "count": result.count,
+            "elapsed": result.elapsed,
+            "errors": result.errors,
+        }

sqlseed-0.1.9/plugins/sqlseed-ai/README.md

@@ -0,0 +1,38 @@
+# sqlseed-ai
+
+AI-powered data generation plugin for [sqlseed](https://github.com/sunbos/sqlseed).
+
+## Overview
+
+`sqlseed-ai` extends sqlseed with LLM-driven intelligent data generation capabilities. It analyzes your database schema and produces high-quality, context-aware YAML configuration suggestions.
+
+### Features
+
+- **Schema Analysis** — LLM-powered table structure understanding via `SchemaAnalyzer`
+- **AI Config Refiner** — Self-correcting feedback loop with up to 3 retry rounds
+- **Column-level Suggestions** — Smart per-column generation strategy recommendations
+- **Natural Language Config** — Describe what you want in plain text, get YAML config
+- **Few-shot Examples** — Built-in example library for improved LLM output quality
+
+## Installation
+
+```bash
+pip install sqlseed-ai
+```
+
+## Quick Start
+
+```bash
+# Generate AI-suggested YAML config for a table
+sqlseed ai-suggest test.db --table users --output users.yaml
+```
+
+## Requirements
+
+- Python >= 3.10
+- `sqlseed >= 0.1.0`
+- An OpenAI-compatible API key (set via `OPENAI_API_KEY` environment variable)
+
+## License
+
+AGPL-3.0-or-later

sqlseed-0.1.9/plugins/sqlseed-ai/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sqlseed-ai"
+dynamic = ["version"]
+requires-python = ">=3.10"
+description = "AI-powered data generation plugin for sqlseed"
+readme = "README.md"
+license = "AGPL-3.0-or-later"
+authors = [
+    {name = "SunBo", email = "1443584939@qq.com"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "sqlseed>=0.1.0",
+    "openai>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/sunbos/sqlseed"
+Repository = "https://github.com/sunbos/sqlseed/tree/main/plugins/sqlseed-ai"
+
+[project.entry-points."sqlseed"]
+ai = "sqlseed_ai:plugin"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0.0.0"
+
+[tool.hatch.version.raw-options]
+root = "../.."
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sqlseed_ai"]

sqlseed-0.1.9/plugins/sqlseed-ai/src/sqlseed_ai/__init__.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from sqlseed.plugins.hookspecs import hookimpl
+from sqlseed_ai.analyzer import SchemaAnalyzer
+
+_SIMPLE_COL_RE = re.compile(
+    r'(^|[_\s])('
+    r'name|email|phone|address|url|uuid|'
+    r'date|time|datetime|timestamp|boolean|'
+    r'int|float|double|real|text|string|'
+    r'char|varchar|blob|byte|id|code|title|'
+    r'description|status|type|category|count|'
+    r'amount|price|value|number|index|order|level'
+    r')($|[_\s])',
+    re.IGNORECASE,
+)
+
+
+class AISqlseedPlugin:
+    def __init__(self) -> None:
+        self._analyzer: SchemaAnalyzer | None = None
+
+    def _get_analyzer(self) -> SchemaAnalyzer:
+        if self._analyzer is None:
+            self._analyzer = SchemaAnalyzer()
+        return self._analyzer
+
+    def _is_simple_column(self, column_name: str, column_type: str) -> bool:
+        return bool(
+            _SIMPLE_COL_RE.search(column_name) or _SIMPLE_COL_RE.search(column_type)
+        )
+
+    @hookimpl
+    def sqlseed_ai_analyze_table(
+        self,
+        table_name: str,
+        columns: list[Any],
+        indexes: list[dict[str, Any]],
+        sample_data: list[dict[str, Any]],
+        foreign_keys: list[Any],
+        all_table_names: list[str],
+    ) -> dict[str, Any] | None:
+        analyzer = self._get_analyzer()
+        return analyzer.analyze_table(
+            table_name=table_name,
+            columns=columns,
+            indexes=indexes,
+            sample_data=sample_data,
+            foreign_keys=foreign_keys,
+            all_table_names=all_table_names,
+        )
+
+    @hookimpl
+    def sqlseed_pre_generate_templates(
+        self,
+        table_name: str,
+        column_name: str,
+        column_type: str,
+        count: int,
+        sample_data: list[Any],
+    ) -> list[Any] | None:
+        if self._is_simple_column(column_name, column_type):
+            return None
+
+        analyzer = self._get_analyzer()
+        try:
+            return analyzer.generate_template_values(
+                column_name=column_name,
+                column_type=column_type,
+                count=min(count, 50),
+                sample_data=sample_data,
+            )
+        except Exception:
+            return None
+
+    @hookimpl
+    def sqlseed_register_providers(self, registry: Any) -> None:
+        pass
+
+    @hookimpl
+    def sqlseed_register_column_mappers(self, mapper: Any) -> None:
+        pass
+
+
+plugin = AISqlseedPlugin()

sqlseed-0.1.9/plugins/sqlseed-ai/src/sqlseed_ai/_client.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlseed._utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_openai_client(config: Any | None = None) -> Any:
+    try:
+        from openai import OpenAI
+
+        from sqlseed_ai.config import AIConfig
+
+        if config is None:
+            config = AIConfig.from_env()
+
+        api_key = config.api_key if hasattr(config, "api_key") else None
+        base_url = config.base_url if hasattr(config, "base_url") else None
+
+        if not api_key:
+            raise ValueError(
+                "AI API key not configured. Set SQLSEED_AI_API_KEY or OPENAI_API_KEY environment variable."
+            )
+
+        return OpenAI(api_key=api_key, base_url=base_url)
+    except ImportError:
+        raise ImportError(
+            "openai is not installed. Install it with: pip install sqlseed-ai"
+        ) from None

sqlseed-0.1.9/plugins/sqlseed-ai/src/sqlseed_ai/_json_utils.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def parse_json_response(content: str) -> dict[str, Any]:
+    cleaned = content.strip()
+    if cleaned.startswith("```json"):
+        cleaned = cleaned[7:]
+    if cleaned.startswith("```"):
+        cleaned = cleaned[3:]
+    if cleaned.endswith("```"):
+        cleaned = cleaned[:-3]
+    cleaned = cleaned.strip()
+
+    try:
+        result = json.loads(cleaned)
+        if isinstance(result, dict):
+            return result
+    except json.JSONDecodeError:
+        pass
+
+    return {}