sqlseed 0.2.0__tar.gz → 0.2.3__tar.gz

{sqlseed-0.2.0 → sqlseed-0.2.3}/.gitignore

@@ -33,6 +33,7 @@ ENV/
 .idea/
 .trae/
 .claude/
+.gemini/
 .sonarlint/
 *.swp
 *.swo
@@ -62,6 +63,9 @@ examples/notebooks/batch_config.yaml
 *.nbconvert.ipynb
 .ipynb_checkpoints/
 
+# AI-generated config outputs
+*_config.yaml
+
 # OS
 .DS_Store
 

{sqlseed-0.2.0 → sqlseed-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlseed
-Version: 0.2.0
+Version: 0.2.3
 Summary: Declarative SQLite test data generation toolkit
 Project-URL: Homepage, https://github.com/sunbos/sqlseed
 Project-URL: Documentation, https://github.com/sunbos/sqlseed#readme
@@ -726,7 +726,7 @@ sqlseed ai-suggest app.db --table projects --output projects.yaml
 sqlseed ai-suggest app.db --table projects --output projects.yaml --verify
 
 # Specify model (defaults to Gemma 4 26B via Google AI Studio)
-sqlseed ai-suggest app.db --table projects --output projects.yaml --model gemma-4-26b-it
+sqlseed ai-suggest app.db --table projects --output projects.yaml --model gemma-4-26b-a4b-it
 
 # Use local LM Studio / Ollama
 sqlseed ai-suggest app.db --table projects --output projects.yaml --backend lm_studio --model google/gemma-4-e4b
@@ -1079,7 +1079,7 @@ Tests cover all core modules, with path structure mirroring `src/`: `test_core/`
 | `sqlseed[faker]` | + faker>=30.0 | Faker data engine |
 | `sqlseed[mimesis]` | + mimesis>=18.0 | Mimesis data engine (recommended) |
 | `sqlseed[docs]` | + mkdocs-material, mkdocstrings | Documentation build |
-| `sqlseed-ai` | sqlseed, **openai>=1.0**, **google-generativeai>=0.8** | AI plugin (Gemma 4 Native Function Calling), auto-registered via entry-point |
+| `sqlseed-ai` | sqlseed, **openai>=1.0** | AI plugin (Gemma 4 Native Function Calling), auto-registered via entry-point |
 | `mcp-server-sqlseed` | sqlseed, **mcp>=1.0** | MCP server, standalone CLI tool |
 | `mcp-server-sqlseed[ai]` | + sqlseed-ai | MCP server with AI support |
 

{sqlseed-0.2.0 → sqlseed-0.2.3}/README.md

@@ -666,7 +666,7 @@ sqlseed ai-suggest app.db --table projects --output projects.yaml
 sqlseed ai-suggest app.db --table projects --output projects.yaml --verify
 
 # Specify model (defaults to Gemma 4 26B via Google AI Studio)
-sqlseed ai-suggest app.db --table projects --output projects.yaml --model gemma-4-26b-it
+sqlseed ai-suggest app.db --table projects --output projects.yaml --model gemma-4-26b-a4b-it
 
 # Use local LM Studio / Ollama
 sqlseed ai-suggest app.db --table projects --output projects.yaml --backend lm_studio --model google/gemma-4-e4b
@@ -1019,7 +1019,7 @@ Tests cover all core modules, with path structure mirroring `src/`: `test_core/`
 | `sqlseed[faker]` | + faker>=30.0 | Faker data engine |
 | `sqlseed[mimesis]` | + mimesis>=18.0 | Mimesis data engine (recommended) |
 | `sqlseed[docs]` | + mkdocs-material, mkdocstrings | Documentation build |
-| `sqlseed-ai` | sqlseed, **openai>=1.0**, **google-generativeai>=0.8** | AI plugin (Gemma 4 Native Function Calling), auto-registered via entry-point |
+| `sqlseed-ai` | sqlseed, **openai>=1.0** | AI plugin (Gemma 4 Native Function Calling), auto-registered via entry-point |
 | `mcp-server-sqlseed` | sqlseed, **mcp>=1.0** | MCP server, standalone CLI tool |
 | `mcp-server-sqlseed[ai]` | + sqlseed-ai | MCP server with AI support |
 

{sqlseed-0.2.0 → sqlseed-0.2.3}/README.zh-CN.md

@@ -562,10 +562,10 @@ sqlseed ai-suggest app.db --table projects --output projects.yaml
 sqlseed ai-suggest app.db --table projects --output projects.yaml --verify
 
 # 指定模型（支持多后端：Google AI Studio、LM Studio、Ollama、OpenAI-compatible）
-sqlseed ai-suggest app.db --table projects -o projects.yaml --model gemma-4-26b-it --backend google_ai_studio
+sqlseed ai-suggest app.db --table projects -o projects.yaml --model gemma-4-26b-a4b-it --backend google_ai_studio
 sqlseed ai-suggest app.db --table projects -o projects.yaml --model gemma-4-31b-it --backend google_ai_studio
 sqlseed ai-suggest app.db --table projects -o projects.yaml --model google/gemma-4-e4b --backend lm_studio
-sqlseed ai-suggest app.db --table projects -o projects.yaml --model gemma-4-4b-it --backend ollama
+sqlseed ai-suggest app.db --table projects -o projects.yaml --model gemma-4-e4b-it --backend ollama
 ```
 
 **Gemma 4 原生函数调用（GEMMA_TOOLS）**：
@@ -697,8 +697,8 @@ sqlseed ai-suggest app.db -t users -o users.yaml --max-retries 0
 sqlseed ai-suggest app.db -t users -o users.yaml --no-cache
 
 # ═══ AI 后端选择 ═══
-sqlseed ai-suggest app.db -t users -o users.yaml --backend google_ai_studio --model gemma-4-26b-it
-sqlseed ai-suggest app.db -t users -o users.yaml --backend ollama --model gemma-4-4b-it
+sqlseed ai-suggest app.db -t users -o users.yaml --backend google_ai_studio --model gemma-4-26b-a4b-it
+sqlseed ai-suggest app.db -t users -o users.yaml --backend ollama --model gemma-4-e4b-it
 sqlseed ai-suggest app.db -t users -o users.yaml --backend lm_studio --model google/gemma-4-e4b
 sqlseed ai-suggest app.db -t users -o users.yaml --backend openai_compat --model your-model --base-url https://your-api-endpoint
 ```
@@ -827,7 +827,7 @@ mypy src/sqlseed/                   # 类型检查
 | `sqlseed[faker]` | + faker>=30.0 | Faker 数据引擎 |
 | `sqlseed[mimesis]` | + mimesis>=18.0 | Mimesis 数据引擎（推荐） |
 | `sqlseed[docs]` | + mkdocs-material, mkdocstrings | 文档构建 |
-| `sqlseed-ai` | sqlseed, **openai>=1.0**, **google-generativeai>=0.8** | AI 插件，通过 entry-point 自动注册，支持 Gemma 4 GEMMA_TOOLS |
+| `sqlseed-ai` | sqlseed, **openai>=1.0** | AI 插件，通过 entry-point 自动注册，支持 Gemma 4 GEMMA_TOOLS |
 | `mcp-server-sqlseed` | sqlseed, **mcp>=1.0** | MCP 服务器，独立 CLI 工具 |
 | `mcp-server-sqlseed[ai]` | + sqlseed-ai | MCP 服务器含 AI 支持 |
 

{sqlseed-0.2.0 → sqlseed-0.2.3}/examples/notebooks/07-ai-plugin.ipynb

@@ -367,32 +367,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "偏好免费模型 (12 个):\n",
-      "  1. nvidia/nemotron-3-super-120b-a12b:free\n",
-      "  2. tencent/hy3-preview:free\n",
-      "  3. inclusionai/ling-2.6-1t:free\n",
-      "  4. inclusionai/ling-2.6-flash:free\n",
-      "  5. z-ai/glm-4.5-air:free\n",
-      "  6. minimax/minimax-m2.5:free\n",
-      "  7. openai/gpt-oss-120b:free\n",
-      "  8. nvidia/nemotron-3-nano-30b-a3b:free\n",
-      "  9. google/gemma-4-31b-it:free\n",
-      "  10. nvidia/nemotron-nano-9b-v2:free\n",
-      "  11. openai/gpt-oss-20b:free\n",
-      "  12. google/gemma-4-26b-a4b-it:free\n",
+      "Gemma 4 模型优先级 (5 个):\n",
+      "  1. gemma-4-31b-it (Gemma 4 31B Dense)\n",
+      "  2. gemma-4-26b-a4b-it (Gemma 4 26B A4B MoE (Recommended))\n",
+      "  3. gemma-4-12b-it (Gemma 4 12B Unified (Laptop))\n",
+      "  4. gemma-4-e4b-it (Gemma 4 E4B (4B Effective, Edge))\n",
+      "  5. gemma-4-e2b-it (Gemma 4 E2B (2B Effective, Edge))\n",
       "\n",
-      "select_best_free_model() 按优先级尝试, 自动回退\n"
+      "select_gemma_model() 按优先级尝试, 自动回退\n"
      ]
     }
    ],
    "source": [
-    "from sqlseed_ai._model_selector import PREFERRED_FREE_MODELS\n",
+    "from sqlseed_ai._model_selector import _GEMMA_MODEL_PRIORITY\n",
     "\n",
-    "print(f'偏好免费模型 ({len(PREFERRED_FREE_MODELS)} 个):')\n",
-    "for i, model in enumerate(PREFERRED_FREE_MODELS, 1):\n",
-    "    print(f'  {i}. {model}')\n",
+    "print(f'Gemma 4 模型优先级 ({len(_GEMMA_MODEL_PRIORITY)} 个):')\n",
+    "for i, model in enumerate(_GEMMA_MODEL_PRIORITY, 1):\n",
+    "    print(f'  {i}. {model.value} ({model.display_name})')\n",
     "\n",
-    "print('\\nselect_best_free_model() 按优先级尝试, 自动回退')\n",
+    "print('\\nselect_gemma_model() 按优先级尝试, 自动回退')\n",
     "\n"
    ]
   },

sqlseed-0.2.3/examples/quick_demo.py

@@ -0,0 +1,148 @@
+"""
+QuickStart Demo Script with Real-time Progress Display
+
+Features:
+- Creates demo database with 8 tables
+- Fills data with real-time progress bars
+- Shows completion stats and sample data
+- Fast execution (~10 seconds total)
+
+Usage:
+    python quick_demo.py
+
+Perfect for live demonstrations!
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from build_demo_db import build as build_demo
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, TimeRemainingColumn
+from rich.table import Table
+
+from sqlseed import fill
+
+
+def main():
+    console = Console()
+
+    # Step 1: Create database
+    console.print("\n[bold blue]🚀 QuickStart Demo: sqlseed SQLite Test Data Generator[/bold blue]")
+    console.print("=" * 60)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=False,
+    ) as progress:
+        task = progress.add_task("Creating demo database...", total=None)
+        db_path = str(build_demo(Path(__file__).parent / "_demo.db"))
+        progress.update(task, completed=1)
+
+    console.print(f"✅ Database created: [green]{db_path}[/green]")
+
+    # Step 2: Fill data with progress
+    console.print("\n[bold blue]📊 Filling test data with real-time progress:[/bold blue]")
+
+    fill_stats = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeRemainingColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=False,
+        refresh_per_second=2,
+    ) as progress:
+        # organizations
+        task = progress.add_task("organizations", total=10)
+        result = fill(db_path, table="organizations", count=10)
+        fill_stats.append(("organizations", result.count, result.elapsed))
+        progress.update(task, completed=10)
+
+        # members
+        task = progress.add_task("members", total=100)
+        result = fill(db_path, table="members", count=100)
+        fill_stats.append(("members", result.count, result.elapsed))
+        progress.update(task, completed=100)
+
+        # projects
+        task = progress.add_task("projects", total=30)
+        result = fill(db_path, table="projects", count=30)
+        fill_stats.append(("projects", result.count, result.elapsed))
+        progress.update(task, completed=30)
+
+        # tasks
+        task = progress.add_task("tasks", total=200)
+        result = fill(db_path, table="tasks", count=200)
+        fill_stats.append(("tasks", result.count, result.elapsed))
+        progress.update(task, completed=200)
+
+    # Step 3: Show summary
+    console.print("\n[bold blue]📈 Fill Summary:[/bold blue]")
+    table = Table(show_header=True, header_style="bold green")
+    table.add_column("Table")
+    table.add_column("Rows")
+    table.add_column("Time (s)", justify="right")
+
+    total_rows = 0
+    total_time = 0.0
+    for table_name, count, elapsed in fill_stats:
+        table.add_row(table_name, str(count), f"{elapsed:.2f}")
+        total_rows += count
+        total_time += elapsed
+
+    table.add_row("[bold]Total[/bold]", str(total_rows), f"[bold]{total_time:.2f}[/bold]")
+    console.print(table)
+
+    # Step 4: Show sample data
+    console.print("\n[bold blue]🔍 Sample Data Preview:[/bold blue]")
+
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+
+    # Preview members
+    console.print("\n[bold green]members[/bold green] (3 rows):")
+    cursor = conn.execute("SELECT member_id, name, email, org_code FROM members LIMIT 3")
+    rows = cursor.fetchall()
+    member_table = Table()
+    for col in ("member_id", "name", "email", "org_code"):
+        member_table.add_column(col, style="cyan")
+    for row in rows:
+        member_table.add_row(*[str(row[c]) for c in ("member_id", "name", "email", "org_code")])
+    console.print(member_table)
+
+    # Preview tasks
+    console.print("\n[bold green]tasks[/bold green] (3 rows):")
+    cursor = conn.execute("SELECT task_id, project_id, title, priority, status FROM tasks LIMIT 3")
+    rows = cursor.fetchall()
+    task_table = Table()
+    for col in ("task_id", "project_id", "title", "priority", "status"):
+        task_table.add_column(col, style="cyan")
+    for row in rows:
+        task_table.add_row(*[str(row[c]) for c in ("task_id", "project_id", "title", "priority", "status")])
+    console.print(task_table)
+
+    conn.close()
+
+    # Step 5: Final message
+    console.print("\n" + "=" * 60)
+    console.print("[bold green]🎉 Demo Complete! [/bold green]")
+    console.print("\nKey Features Demonstrated:")
+    console.print("  • Auto-schema detection")
+    console.print("  • Smart column type matching")
+    console.print("  • Foreign key integrity")
+    console.print("  • Real-time progress tracking")
+    console.print(f"\n[italic]Total time:[/italic] [bold]{total_time:.2f} seconds[/bold]")
+
+
+if __name__ == "__main__":
+    main()

{sqlseed-0.2.0 → sqlseed-0.2.3}/pyproject.toml

@@ -84,7 +84,8 @@ packages = ["src/sqlseed"]
 exclude = [
     "docs/",
     "tests/",
-    "plugins/",
+    "plugins/sqlseed-ai/",
+    "plugins/mcp-server-sqlseed/",
     ".github/",
     ".trae/",
     ".gemini/",

{sqlseed-0.2.0 → sqlseed-0.2.3}/src/sqlseed/cli/main.py

@@ -8,8 +8,9 @@ from typing import Any
 import click
 import yaml
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.live import Live
 from rich.table import Table as RichTable
+from rich.text import Text
 
 from sqlseed import fill as api_fill
 from sqlseed import fill_from_config
@@ -21,17 +22,17 @@ from sqlseed.config.models import GeneratorConfig, ProviderType, TableConfig
 from sqlseed.config.snapshot import SnapshotManager
 from sqlseed.core.orchestrator import DataOrchestrator
 
-logger = get_logger(__name__)
-
 try:
     from sqlseed_ai.analyzer import SchemaAnalyzer
-    from sqlseed_ai.config import AIConfig
-    from sqlseed_ai.refiner import AiConfigRefiner, AISuggestionFailedError
+    from sqlseed_ai.config import AIBackend, AIConfig
+    from sqlseed_ai.refiner import AiConfigRefiner
 
     HAS_AI_PLUGIN = True
 except ImportError:
     HAS_AI_PLUGIN = False
 
+logger = get_logger(__name__)
+
 
 @click.group()
 @click.version_option(version=__version__, prog_name="sqlseed")
@@ -137,9 +138,6 @@ def fill(**kwargs: Any) -> None:
             "--count is required when not using --config. Use -n <number> to specify the number of rows to generate."
         )
 
-    if not config_path and count is None:
-        count = _FILL_DEFAULT_COUNT
-
     kwargs["count"] = count
     _execute_fill(kwargs)
 
@@ -355,52 +353,241 @@ def _sanitize_table_config(config_dict: dict[str, Any]) -> None:
                 col["name"] = re.sub(r"^[:.]+", "", col_name)
 
 
-def _handle_ai_verification(analyzer: Any, db_path: str, table: str, max_retries: int, no_cache: bool) -> Any:
+class _StreamingProgressDisplay:
+    """Rich Live display for streaming LLM output with phase indicators."""
+
+    def __init__(self) -> None:
+        self._phase = "connecting"
+        self._model = ""
+        self._token_count = 0
+        self._preview = ""
+        self._attempt = 0
+        self._max_retries = 0
+        self._live: Live | None = None
+
+    def _render(self) -> Text:
+        parts: list[tuple[str, str]] = []
+
+        # Phase icon and description
+        if self._phase == "connecting":
+            parts.append(("⏳", "bold yellow"))
+            parts.append((f" Connecting to {self._model}...", "yellow"))
+        elif self._phase == "streaming":
+            parts.append(("⚡", "bold cyan"))
+            parts.append((f" Generating ({self._token_count} tokens)", "cyan"))
+            if self._preview:
+                parts.append((f"  {self._preview[-60:]}", "dim"))
+        elif self._phase == "parsing":
+            parts.append(("📋", "bold blue"))
+            parts.append((f" Parsing response ({self._token_count} tokens)...", "blue"))
+        elif self._phase == "validating":
+            parts.append(("✅", "bold green"))
+            parts.append((" Validating configuration...", "green"))
+        elif self._phase == "refining":
+            parts.append(("🔄", "bold yellow"))
+            retry_info = f" (attempt {self._attempt + 1}/{self._max_retries})" if self._max_retries > 0 else ""
+            parts.append((f" Self-correction{retry_info}...", "yellow"))
+        elif self._phase == "done":
+            parts.append(("✅", "bold green"))
+            parts.append((f" Done ({self._token_count} tokens)", "green"))
+
+        text = Text("")
+        for content, style in parts:
+            text.append(content, style=style)
+        return text
+
+    def start(self) -> None:
+        self._live = Live(self._render(), console=Console(), transient=False, refresh_per_second=8)
+        self._live.start()
+
+    def stop(self) -> None:
+        if self._live:
+            self._live.stop()
+            self._live = None
+
+    def update(self, phase: str, info: dict[str, Any]) -> None:
+        self._phase = phase
+        if "model" in info:
+            self._model = info["model"]
+        if "count" in info:
+            self._token_count = info["count"]
+        if "token" in info:
+            # Show a rolling preview of the last few tokens
+            self._preview += info["token"]
+            if len(self._preview) > 80:
+                self._preview = self._preview[-80:]
+        if "tokens" in info:
+            self._token_count = info["tokens"]
+        if "attempt" in info:
+            self._attempt = info["attempt"]
+        if "max_retries" in info:
+            self._max_retries = info["max_retries"]
+        if self._live:
+            self._live.update(self._render())
+
+
+def _run_ai_analysis(
+    analyzer: Any,
+    db_path: str,
+    table: str,
+    verify: bool,
+    max_retries: int,
+    no_cache: bool,
+) -> Any:
+    config = analyzer._config
+    use_streaming = config.should_use_streaming() if config else True
+    use_compact = config.should_use_ultra_compact() if config else False
+
+    # Probe inference speed for local backends and show estimated time
+    if config and config.backend in (AIBackend.LM_STUDIO, AIBackend.OLLAMA):
+        speed_info = config.probe_inference_speed()
+        if speed_info and speed_info.get("is_slow"):
+            tps = speed_info["tokens_per_second"]
+            est_seconds = int(512 / tps) if tps > 0 else 120
+            timeout_display = int(config.resolve_timeout())
+            click.echo(
+                f"Local inference speed: ~{tps} tok/s. "
+                f"Estimated wait: ~{est_seconds}s (timeout: {timeout_display}s). "
+                f"Using optimized settings for {config.model}.",
+                err=True,
+            )
+        elif speed_info is None:
+            # Probe failed — LM Studio may not be running
+            click.echo(
+                "Warning: Could not probe local inference speed. "
+                "Ensure LM Studio/Ollama is running and a model is loaded.",
+                err=True,
+            )
+
+    if use_streaming:
+        display = _StreamingProgressDisplay()
+        if verify and max_retries > 0:
+            return _handle_ai_verification_streaming(
+                analyzer,
+                db_path,
+                table,
+                max_retries,
+                no_cache,
+                display,
+                use_compact=use_compact,
+            )
+        return _handle_ai_direct(analyzer, db_path, table, use_compact=use_compact, display=display)
+
+    # Small local models: non-streaming is 5-7x faster (14s vs 75-100s)
+    # because streaming TTFT is extremely high on limited GPU hardware.
+    if verify and max_retries > 0:
+        return _handle_ai_verification_non_streaming(
+            analyzer, db_path, table, max_retries, no_cache, use_compact=use_compact
+        )
+    return _handle_ai_direct(analyzer, db_path, table, use_compact=use_compact)
+
+
+def _handle_ai_direct(
+    analyzer: Any,
+    db_path: str,
+    table: str,
+    *,
+    use_compact: bool = False,
+    display: _StreamingProgressDisplay | None = None,
+) -> Any:
+    """Handle AI direct suggestion with prompt-level fallback.
+
+    Args:
+        analyzer: SchemaAnalyzer instance.
+        db_path: Path to the SQLite database.
+        table: Table name to analyze.
+        use_compact: Whether to force ultra-compact mode.
+        display: If provided, use streaming with this progress display.
+    """
+    with DataOrchestrator(db_path) as orch:
+        schema_ctx = orch.get_schema_context(table)
+
+        prompt_levels = [(True, True)] if use_compact else [(False, False), (True, False), (True, True)]
+
+        for compact, ultra in prompt_levels:
+            messages = analyzer.build_initial_messages(schema_ctx, compact=compact, ultra_compact=ultra)
+            try:
+                if display:
+                    display.start()
+                    result = analyzer.call_llm_streaming(messages, on_progress=display.update)
+                    display.stop()
+                else:
+                    mode = "ultra-compact" if ultra else ("compact" if compact else "standard")
+                    timeout_s = int(analyzer._config.resolve_timeout()) if analyzer._config else 300
+                    click.echo(f"Analyzing schema & generating AI suggestions ({mode} mode, timeout: {timeout_s}s)...")
+                    result = analyzer.call_llm(messages)
+                if result:
+                    return result
+                click.echo("AI returned empty result, retrying with shorter prompt...", err=True)
+                continue
+            except (ValueError, RuntimeError, OSError) as e:
+                if display:
+                    display.stop()
+                err_msg = str(e).lower()
+                if "context" in err_msg and "exceed" in err_msg and not ultra:
+                    click.echo("Context size exceeded, retrying with shorter prompt...", err=True)
+                    continue
+                click.echo(f"AI suggestion failed: {e}", err=True)
+                return None
+    return None
+
+
+def _handle_ai_verification_non_streaming(
+    analyzer: Any,
+    db_path: str,
+    table: str,
+    max_retries: int,
+    no_cache: bool,
+    *,
+    use_compact: bool = False,
+) -> Any:
+    if AiConfigRefiner is None:
+        raise ImportError("sqlseed-ai plugin not installed. Install with: pip install sqlseed-ai")
+
     refiner = AiConfigRefiner(analyzer, db_path)
     try:
+        timeout_s = int(analyzer._config.resolve_timeout()) if analyzer._config else 300
+        click.echo(f"Analyzing schema & generating AI suggestions with self-correction (timeout: {timeout_s}s)...")
         return refiner.generate_and_refine(
             table_name=table,
             max_retries=max_retries,
             no_cache=no_cache,
+            use_compact=use_compact,
         )
-    except AISuggestionFailedError as e:
+    except (ValueError, RuntimeError, OSError) as e:
         click.echo(f"AI suggestion failed: {e}", err=True)
         return None
 
 
-def _handle_ai_direct(analyzer: Any, db_path: str, table: str) -> Any:
-    with DataOrchestrator(db_path) as orch:
-        schema_ctx = orch.get_schema_context(table)
-        messages = analyzer.build_initial_messages(schema_ctx)
-        try:
-            return analyzer.call_llm(messages)
-        except (ValueError, RuntimeError) as e:
-            click.echo(f"AI suggestion failed: {e}", err=True)
-            return None
-
-
-def _run_ai_analysis(
+def _handle_ai_verification_streaming(
     analyzer: Any,
     db_path: str,
     table: str,
-    verify: bool,
     max_retries: int,
     no_cache: bool,
+    display: _StreamingProgressDisplay,
+    *,
+    use_compact: bool = False,
 ) -> Any:
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        TimeElapsedColumn(),
-        console=Console(),
-        transient=False,
-    ) as progress:
-        task = progress.add_task("Analyzing schema & generating AI suggestions...", total=None)
-        if verify and max_retries > 0:
-            result = _handle_ai_verification(analyzer, db_path, table, max_retries, no_cache)
-        else:
-            result = _handle_ai_direct(analyzer, db_path, table)
-        progress.update(task, completed=1, total=1)
-    return result
+    if AiConfigRefiner is None:
+        raise ImportError("sqlseed-ai plugin not installed. Install with: pip install sqlseed-ai")
+
+    refiner = AiConfigRefiner(analyzer, db_path)
+    try:
+        display.start()
+        result = refiner.generate_and_refine_streaming(
+            table_name=table,
+            max_retries=max_retries,
+            no_cache=no_cache,
+            on_progress=display.update,
+            use_compact=use_compact,
+        )
+        display.stop()
+        return result
+    except (ValueError, RuntimeError, OSError) as e:
+        display.stop()
+        click.echo(f"AI suggestion failed: {e}", err=True)
+        return None
 
 
 def _write_ai_output(output: str, db_path: str, result: Any) -> None:
@@ -444,7 +631,7 @@ def _report_ai_failure() -> None:
 @click.argument("db_path")
 @click.option("--table", "-t", required=True, help="Target table name")
 @click.option("--output", "-o", required=True, help="Output YAML file path")
-@click.option("--model", "-m", default=None, help="AI model name (default: auto-select best free model via OpenRouter)")
+@click.option("--model", "-m", default=None, help="AI model name (default: auto-select based on backend)")
 @click.option("--api-key", envvar="SQLSEED_AI_API_KEY", default=None, help="AI API key (env: SQLSEED_AI_API_KEY)")
 @click.option(
     "--base-url",
@@ -455,7 +642,7 @@ def _report_ai_failure() -> None:
 @click.option("--max-retries", default=3, type=int, help="Max refinement retries, 0=disable (default: 3)")
 @click.option("--verify/--no-verify", default=True, help="Enable AI config self-correction (default: verify)")
 @click.option("--no-cache", is_flag=True, help="Skip cached AI configs")
-@click.option("--timeout", default=120, type=float, help="API call timeout in seconds (default: 120)")
+@click.option("--timeout", default=0, type=float, help="API call timeout in seconds (0=auto, default: auto)")
 def ai_suggest(
     db_path: str,
     table: str,
@@ -490,7 +677,8 @@ def ai_suggest(
     click.echo(f"Using AI model: {resolved_model} (via {backend_name})")
 
     analyzer = SchemaAnalyzer(config=ai_config)
-    total_timeout = timeout * 2
+    resolved_timeout = ai_config.resolve_timeout()
+    total_timeout = resolved_timeout * 2
 
     old_handler: Any = None
     if hasattr(signal, "SIGALRM"):
@@ -507,9 +695,6 @@ def ai_suggest(
             if old_handler is not None:
                 signal.signal(signal.SIGALRM, old_handler)
 
-    if ai_config.model != resolved_model:
-        click.echo(f"Model fallback: {resolved_model} → {ai_config.model}")
-
     if result:
         _write_ai_output(output, db_path, result)
     else:

{sqlseed-0.2.0 → sqlseed-0.2.3}/src/sqlseed/config/models.py

@@ -12,7 +12,6 @@ class ProviderType(str, Enum):
     FAKER = "faker"
     MIMESIS = "mimesis"
     CUSTOM = "custom"
-    AI = "ai"
 
 
 class ColumnConstraintsConfig(BaseModel):
@@ -54,6 +53,11 @@ class ColumnConfig(BaseModel):
     # === 约束 ===
     constraints: ColumnConstraintsConfig | None = None
 
+    # === Native method overrides (from AI suggestions) ===
+    faker_method: str | None = None
+    mimesis_method: str | None = None
+    native_params: dict[str, Any] = Field(default_factory=dict)
+
     model_config = {"extra": "ignore"}
 
     @model_validator(mode="before")

{sqlseed-0.2.0 → sqlseed-0.2.3}/src/sqlseed/core/mapper.py

@@ -127,7 +127,7 @@ class ColumnMapper:
         "comment": {"min_length": 10, "max_length": 200},
     }
 
-    PATTERN_MATCH_RULES: ClassVar[list[tuple[str, str, dict[str, Any]]]] = [
+    PATTERN_MATCH_RULES: ClassVar[tuple[tuple[str, str, dict[str, Any]], ...]] = (
         (r"^id$", "autoincrement", {}),
         (r".*_id$", "foreign_key_or_integer", {}),
         (
@@ -159,7 +159,7 @@ class ColumnMapper:
         (r".*_address$", "address", {}),
         (r".*_description$|.*_desc$|.*_text$|.*_content$|.*_body$", "text", {"min_length": 50, "max_length": 300}),
         (r".*_title$|.*_subject$|.*_headline$", "sentence", {}),
-    ]
+    )
 
     TYPE_FALLBACK_RULES: ClassVar[dict[str, tuple[str, dict[str, Any]]]] = {
         "INTEGER": ("integer", {"min_value": 0, "max_value": 999999}),
@@ -229,6 +229,9 @@ class ColumnMapper:
                 params=user_config.params if hasattr(user_config, "params") else {},
                 null_ratio=user_config.null_ratio if hasattr(user_config, "null_ratio") else 0.0,
                 provider=provider_val,
+                native_faker_method=getattr(user_config, "faker_method", None),
+                native_mimesis_method=getattr(user_config, "mimesis_method", None),
+                native_params=getattr(user_config, "native_params", None) or None,
             )
         return None
 

{sqlseed-0.2.0 → sqlseed-0.2.3}/src/sqlseed/generators/stream.py

@@ -6,8 +6,6 @@ from typing import TYPE_CHECKING, Any
 from sqlseed._utils.logger import get_logger
 from sqlseed.generators._protocol import ConfigurationError, GenerationError, UnknownGeneratorError
 
-_NATIVE_MISS = object()
-
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
@@ -17,6 +15,7 @@ if TYPE_CHECKING:
     from sqlseed.core.mapper import GeneratorSpec
     from sqlseed.core.transform import RowTransformFn
 
+_NATIVE_MISS = object()
 logger = get_logger(__name__)
 
 

sqlseed-0.2.3/src/sqlseed/plugins/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from sqlseed.plugins.hookspecs import PROJECT_NAME, SqlseedHookSpec, hookimpl, hookspec
+from sqlseed.plugins.manager import PluginManager
+
+__all__ = [
+    "PROJECT_NAME",
+    "PluginManager",
+    "SqlseedHookSpec",
+    "hookimpl",
+    "hookspec",
+]

sqlseed-0.2.3/src/sqlseed/plugins/hookspecs.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pluggy
+
+hookspec = pluggy.HookspecMarker("sqlseed")
+hookimpl = pluggy.HookimplMarker("sqlseed")
+
+PROJECT_NAME = "sqlseed"
+
+
+class SqlseedHookSpec:
+    @hookspec
+    def sqlseed_register_providers(self, registry: Any) -> None:
+        raise NotImplementedError
+
+    @hookspec
+    def sqlseed_register_column_mappers(self, mapper: Any) -> None:
+        raise NotImplementedError
+
+    @hookspec(firstresult=True)
+    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:
+        """
+        [AI Hook] 分析整张表，返回完整的列配置建议。
+        """
+
+    @hookspec
+    def sqlseed_before_generate(
+        self,
+        table_name: str,
+        count: int,
+        config: Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @hookspec
+    def sqlseed_after_generate(
+        self,
+        table_name: str,
+        count: int,
+        elapsed: float,
+    ) -> None:
+        raise NotImplementedError
+
+    @hookspec
+    def sqlseed_transform_row(
+        self,
+        table_name: str,
+        row: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """
+        Transform/modify each generated row.
+        Return modified row, or None to keep unchanged.
+        Note: This hook is in the hot path - performance sensitive.
+        """
+
+    @hookspec
+    def sqlseed_transform_batch(
+        self,
+        table_name: str,
+        batch: list[dict[str, Any]],
+    ) -> list[dict[str, Any]] | None:
+        """
+        Transform/modify a batch of generated data.
+        Multiple plugins can chain: each plugin's output feeds into the next.
+        """
+
+    @hookspec
+    def sqlseed_before_insert(
+        self,
+        table_name: str,
+        batch_number: int,
+        batch_size: int,
+    ) -> None:
+        raise NotImplementedError
+
+    @hookspec
+    def sqlseed_after_insert(
+        self,
+        table_name: str,
+        batch_number: int,
+        rows_inserted: int,
+    ) -> None:
+        raise NotImplementedError
+
+    @hookspec
+    def sqlseed_shared_pool_loaded(
+        self,
+        table_name: str,
+        shared_pool: Any,
+    ) -> None:
+        """
+        Called after a table's generated values are loaded into the shared pool.
+        Other plugins can use this to track cross-table associations.
+        """
+
+    @hookspec(firstresult=True)
+    def sqlseed_pre_generate_templates(
+        self,
+        table_name: str,
+        column_name: str,
+        column_type: str,
+        count: int,
+        sample_data: list[Any],
+    ) -> list[Any] | None:
+        """
+        [AI Hook] Pre-generate candidate value pool for columns that cannot match
+        a deterministic generator. Called before DataStream creation.
+        Returns a list of template values, or None if the plugin does not handle this column.
+        """

sqlseed-0.2.3/src/sqlseed/plugins/manager.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pluggy
+
+from sqlseed._utils.logger import get_logger
+from sqlseed.plugins.hookspecs import PROJECT_NAME, SqlseedHookSpec
+
+logger = get_logger(__name__)
+
+
+class PluginManager:
+    def __init__(self) -> None:
+        self._pm = pluggy.PluginManager(PROJECT_NAME)
+        self._pm.add_hookspecs(SqlseedHookSpec)
+
+    def load_plugins(self) -> None:
+        self._pm.load_setuptools_entrypoints(PROJECT_NAME)
+        logger.debug("Loaded plugins", plugins=self._pm.get_plugins())
+
+    def register(self, plugin: Any, name: str | None = None) -> None:
+        self._pm.register(plugin, name=name)
+        logger.debug("Registered plugin", name=name or str(plugin))
+
+    def unregister(self, plugin: Any) -> None:
+        self._pm.unregister(plugin)
+
+    @property
+    def hook(self) -> Any:
+        return self._pm.hook
+
+    def get_plugins(self) -> set[Any]:
+        return self._pm.get_plugins()
+
+    def is_registered(self, plugin: Any) -> bool:
+        return self._pm.is_registered(plugin)

{sqlseed-0.2.0 → sqlseed-0.2.3}/src/sqlseed/database/_compat.py

@@ -5,8 +5,6 @@ from typing import Any
 
 from sqlseed._utils.logger import get_logger
 
-logger = get_logger(__name__)
-
 try:
     import sqlite_utils as _sqlite_utils
 
@@ -16,6 +14,8 @@ except ImportError:
     HAS_SQLITE_UTILS = False
     sqlite_utils = None
 
+logger = get_logger(__name__)
+
 __all__ = ["HAS_SQLITE_UTILS", "sqlite_utils"]