vclient 0.2.0__py3-none-any.whl

src/__init__.py

@@ -0,0 +1,15 @@
+"""Dynamic API Adapter - Auto-discover and adapt to API schemas."""
+
+from .inferrer import SchemaInferrer, infer_property_schema, infer_object_schema
+from .sampler import EndpointSampler
+from .codegen import ClientGenerator
+
+__all__ = [
+    "SchemaInferrer",
+    "EndpointSampler",
+    "ClientGenerator",
+    "infer_property_schema",
+    "infer_object_schema",
+]
+
+__version__ = "0.1.0"

src/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for vclient CLI when run as a module or executable."""
+from src.cli import cli
+
+if __name__ == "__main__":
+    cli()

src/cache.py

@@ -0,0 +1,159 @@
+"""SQLite-based schema caching."""
+import sqlite3
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+DEFAULT_DB_PATH = Path.home() / ".api-adapter" / "cache.db"
+
+
+class SchemaCache:
+    """Persistent schema cache using SQLite."""
+
+    def __init__(self, db_path: str | Path | None = None) -> None:
+        self.db_path = Path(db_path) if db_path else DEFAULT_DB_PATH
+        self._conn: sqlite3.Connection | None = None
+
+    def __enter__(self) -> "SchemaCache":
+        self.connect()
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+
+    def connect(self) -> None:
+        """Open connection and initialize schema."""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(self.db_path))
+        self._conn.row_factory = sqlite3.Row
+        self._init_schema()
+
+    def close(self) -> None:
+        """Commit and close connection."""
+        if self._conn:
+            self._conn.commit()
+            self._conn.close()
+            self._conn = None
+
+    def _init_schema(self) -> None:
+        """Create tables if they don't exist."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS schema_snapshots (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                base_url    TEXT NOT NULL,
+                captured_at TEXT NOT NULL,
+                schema_json TEXT NOT NULL
+            )
+        """)
+
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_snapshots_url
+            ON schema_snapshots(base_url)
+        """)
+
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS drift_events (
+                id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                base_url        TEXT NOT NULL,
+                detected_at     TEXT NOT NULL,
+                old_snapshot_id INTEGER NOT NULL REFERENCES schema_snapshots(id),
+                new_snapshot_id INTEGER NOT NULL REFERENCES schema_snapshots(id),
+                similarity      REAL NOT NULL,
+                diff_json       TEXT NOT NULL
+            )
+        """)
+
+        self._conn.commit()
+
+    def save_snapshot(self, base_url: str, schema: Dict[str, Any]) -> int:
+        """Save schema snapshot and return row id."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+        now = datetime.now(timezone.utc).isoformat()
+        schema_json = json.dumps(schema, default=str)
+
+        cursor.execute(
+            "INSERT INTO schema_snapshots (base_url, captured_at, schema_json) VALUES (?, ?, ?)",
+            (base_url, now, schema_json)
+        )
+        self._conn.commit()
+        return cursor.lastrowid
+
+    def latest_snapshot(self, base_url: str) -> Optional[Dict[str, Any]]:
+        """Get most recent snapshot for base_url."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT schema_json FROM schema_snapshots WHERE base_url=? ORDER BY captured_at DESC LIMIT 1",
+            (base_url,)
+        )
+        row = cursor.fetchone()
+        if row:
+            return json.loads(row[0])
+        return None
+
+    def all_snapshots(self, base_url: str) -> list[Dict[str, Any]]:
+        """Get all snapshots for base_url ordered by captured_at DESC."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT schema_json FROM schema_snapshots WHERE base_url=? ORDER BY captured_at DESC",
+            (base_url,)
+        )
+        return [json.loads(row[0]) for row in cursor.fetchall()]
+
+    def save_drift_event(
+        self,
+        base_url: str,
+        old_id: int,
+        new_id: int,
+        similarity: float,
+        diff: Dict[str, Any],
+    ) -> int:
+        """Save drift event and return row id."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+        now = datetime.now(timezone.utc).isoformat()
+        diff_json = json.dumps(diff, default=str)
+
+        cursor.execute(
+            "INSERT INTO drift_events (base_url, detected_at, old_snapshot_id, new_snapshot_id, similarity, diff_json) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (base_url, now, old_id, new_id, similarity, diff_json)
+        )
+        self._conn.commit()
+        return cursor.lastrowid
+
+    def drift_history(self, base_url: str) -> list[Dict[str, Any]]:
+        """Get all drift events for base_url ordered by detected_at DESC."""
+        if not self._conn:
+            raise RuntimeError("Not connected to database")
+
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT id, detected_at, similarity, diff_json FROM drift_events WHERE base_url=? ORDER BY detected_at DESC",
+            (base_url,)
+        )
+        results = []
+        for row in cursor.fetchall():
+            results.append({
+                "id": row[0],
+                "detected_at": row[1],
+                "similarity": row[2],
+                "diff": json.loads(row[3])
+            })
+        return results

src/cli.py

@@ -0,0 +1,262 @@
+"""Command-line interface for API Adapter."""
+import click
+import json
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+from .sampler import EndpointSampler
+from .inferrer import SchemaInferrer, compute_drift_diff
+from .codegen import ClientGenerator
+from .cache import SchemaCache
+
+
+@click.group()
+def cli():
+    """Dynamic API Adapter - Infer schemas from live APIs."""
+    pass
+
+
+@cli.command()
+@click.argument("url")
+@click.option("--output", "-o", default="schema.json", help="Output file for inferred schema")
+@click.option("--gen-python", is_flag=True, help="Generate Python client")
+@click.option("--gen-typescript", is_flag=True, help="Generate TypeScript client")
+@click.option("--gen-go", is_flag=True, help="Generate Go client")
+@click.option("--gen-rust", is_flag=True, help="Generate Rust client")
+@click.option("--gen-java", is_flag=True, help="Generate Java client")
+@click.option("--gen-ruby", is_flag=True, help="Generate Ruby client")
+@click.option("--timeout", "-t", default=10, help="Request timeout in seconds")
+@click.option("--max-endpoints", "-e", default=50, help="Maximum endpoints to sample")
+@click.option("--no-cache", is_flag=True, default=False, help="Skip cache read/write")
+@click.option("--cache-db", default=None, help="Path to SQLite cache DB")
+def infer(
+    url: str,
+    output: str,
+    gen_python: bool,
+    gen_typescript: bool,
+    gen_go: bool,
+    gen_rust: bool,
+    gen_java: bool,
+    gen_ruby: bool,
+    timeout: int,
+    max_endpoints: int,
+    no_cache: bool,
+    cache_db: Optional[str],
+):
+    """Infer API schema from a live API.
+
+    Example:
+      api-adapter infer https://api.example.com --output schema.json --gen-python
+    """
+    click.echo(f"🔍 Discovering endpoints from {url}...")
+
+    sampler = EndpointSampler(url, timeout=timeout, max_endpoints=max_endpoints)
+    responses = sampler.run()
+
+    click.echo(f"✅ Sampled {len(responses)} endpoints")
+
+    # Infer schema
+    click.echo("📊 Inferring schema...")
+    inferrer = SchemaInferrer(base_url=url)
+
+    for key, response in responses.items():
+        method, endpoint = key.split(" ", 1)
+        inferrer.add_response(endpoint, method, response)
+
+    schema = inferrer.to_dict()
+
+    # Save schema
+    output_path = Path(output)
+    output_path.write_text(inferrer.to_json())
+    click.echo(f"💾 Schema saved to {output}")
+
+    # Save to cache if not disabled
+    if not no_cache:
+        try:
+            with SchemaCache(db_path=cache_db) as cache:
+                snapshot_id = cache.save_snapshot(url, schema)
+                click.echo(f"📦 Snapshot cached (id={snapshot_id})")
+        except Exception as e:
+            click.echo(f"⚠️  Cache write failed: {e}")
+
+    # Generate clients if requested
+    if gen_python:
+        models_code = ClientGenerator.generate_python_models(url, schema["endpoints"])
+        models_file = Path("models.py")
+        models_file.write_text(models_code)
+        click.echo(f"🏗️  Python models generated: {models_file}")
+
+        client_code = ClientGenerator.generate_python(url, schema["endpoints"])
+        python_file = Path("client.py")
+        python_file.write_text(client_code)
+        click.echo(f"🐍 Python client generated: {python_file}")
+
+    if gen_typescript:
+        schemas_code = ClientGenerator.generate_typescript_schemas(url, schema["endpoints"])
+        schemas_file = Path("schemas.ts")
+        schemas_file.write_text(schemas_code)
+        click.echo(f"🔐 TypeScript schemas generated: {schemas_file}")
+
+        client_code = ClientGenerator.generate_typescript(url, schema["endpoints"])
+        ts_file = Path("client.ts")
+        ts_file.write_text(client_code)
+        click.echo(f"📘 TypeScript client generated: {ts_file}")
+
+    if gen_go:
+        client_code = ClientGenerator.generate_go(url, schema["endpoints"])
+        go_file = Path("client.go")
+        go_file.write_text(client_code)
+        click.echo(f"🐹 Go client generated: {go_file}")
+
+    if gen_rust:
+        client_code = ClientGenerator.generate_rust(url, schema["endpoints"])
+        rs_file = Path("client.rs")
+        rs_file.write_text(client_code)
+        click.echo(f"🦀 Rust client generated: {rs_file}")
+
+    if gen_java:
+        client_code = ClientGenerator.generate_java(url, schema["endpoints"])
+        java_file = Path("Client.java")
+        java_file.write_text(client_code)
+        click.echo(f"☕ Java client generated: {java_file}")
+
+    if gen_ruby:
+        client_code = ClientGenerator.generate_ruby(url, schema["endpoints"])
+        rb_file = Path("client.rb")
+        rb_file.write_text(client_code)
+        click.echo(f"💎 Ruby client generated: {rb_file}")
+
+    click.echo("✨ Done!")
+
+
+@cli.command()
+@click.argument("schema_file")
+@click.option("--python", "output_python", help="Output file for Python client")
+@click.option("--typescript", "output_typescript", help="Output file for TypeScript client")
+@click.option("--go", "output_go", help="Output file for Go client")
+@click.option("--rust", "output_rust", help="Output file for Rust client")
+@click.option("--java", "output_java", help="Output file for Java client")
+@click.option("--ruby", "output_ruby", help="Output file for Ruby client")
+def codegen(
+    schema_file: str,
+    output_python: Optional[str],
+    output_typescript: Optional[str],
+    output_go: Optional[str],
+    output_rust: Optional[str],
+    output_java: Optional[str],
+    output_ruby: Optional[str],
+):
+    """Generate clients from an inferred schema.
+
+    Example:
+      api-adapter codegen schema.json --python client.py --typescript client.ts
+    """
+    schema_path = Path(schema_file)
+    if not schema_path.exists():
+        click.echo(f"❌ Schema file not found: {schema_file}", err=True)
+        return
+
+    with open(schema_path) as f:
+        schema = json.load(f)
+
+    base_url = schema.get("base_url", "https://api.example.com")
+    endpoints = schema.get("endpoints", {})
+
+    if output_python:
+        client_code = ClientGenerator.generate_python(base_url, endpoints)
+        Path(output_python).write_text(client_code)
+        click.echo(f"🐍 Python client: {output_python}")
+
+    if output_typescript:
+        client_code = ClientGenerator.generate_typescript(base_url, endpoints)
+        Path(output_typescript).write_text(client_code)
+        click.echo(f"📘 TypeScript client: {output_typescript}")
+
+    if output_go:
+        client_code = ClientGenerator.generate_go(base_url, endpoints)
+        Path(output_go).write_text(client_code)
+        click.echo(f"🐹 Go client: {output_go}")
+
+    if output_rust:
+        client_code = ClientGenerator.generate_rust(base_url, endpoints)
+        Path(output_rust).write_text(client_code)
+        click.echo(f"🦀 Rust client: {output_rust}")
+
+    if output_java:
+        client_code = ClientGenerator.generate_java(base_url, endpoints)
+        Path(output_java).write_text(client_code)
+        click.echo(f"☕ Java client: {output_java}")
+
+    if output_ruby:
+        client_code = ClientGenerator.generate_ruby(base_url, endpoints)
+        Path(output_ruby).write_text(client_code)
+        click.echo(f"💎 Ruby client: {output_ruby}")
+
+
+@cli.command()
+@click.argument("url")
+@click.argument("schema_file")
+@click.option("--threshold", default=0.9, help="Similarity threshold for drift detection")
+@click.option("--no-cache", is_flag=True, default=False, help="Skip cache write")
+@click.option("--cache-db", default=None, help="Path to SQLite cache DB")
+def drift(url: str, schema_file: str, threshold: float, no_cache: bool, cache_db: Optional[str]):
+    """Detect schema drift from previous inference.
+
+    Example:
+      api-adapter drift https://api.example.com schema.json
+    """
+    schema_path = Path(schema_file)
+    if not schema_path.exists():
+        click.echo(f"❌ Schema file not found: {schema_file}", err=True)
+        return
+
+    with open(schema_path) as f:
+        old_schema = json.load(f)
+
+    click.echo(f"🔍 Re-inferring schema from {url}...")
+    sampler = EndpointSampler(url)
+    responses = sampler.run()
+
+    inferrer = SchemaInferrer(base_url=url)
+    for key, response in responses.items():
+        method, endpoint = key.split(" ", 1)
+        inferrer.add_response(endpoint, method, response)
+
+    new_schema = inferrer.to_dict()
+
+    # Compute drift diff using threshold
+    diff = compute_drift_diff(old_schema, new_schema)
+    similarity = diff["similarity"]
+
+    if similarity < threshold:
+        click.echo(f"⚠️  Schema drift detected! Similarity: {similarity:.2%} (threshold: {threshold:.0%})")
+        if diff["added_endpoints"]:
+            click.echo(f"  Added endpoints: {', '.join(diff['added_endpoints'])}")
+        if diff["removed_endpoints"]:
+            click.echo(f"  Removed endpoints: {', '.join(diff['removed_endpoints'])}")
+        if diff["added_fields"]:
+            click.echo(f"  Added fields: {len(diff['added_fields'])}")
+        if diff["removed_fields"]:
+            click.echo(f"  Removed fields: {len(diff['removed_fields'])}")
+        if diff["changed_types"]:
+            click.echo(f"  Changed types: {len(diff['changed_types'])}")
+    else:
+        click.echo(f"✅ No significant drift (similarity: {similarity:.2%}, threshold: {threshold:.0%})")
+
+    # Save drift event to cache if not disabled
+    if not no_cache and similarity < threshold:
+        try:
+            with SchemaCache(db_path=cache_db) as cache:
+                old_snap = cache.latest_snapshot(url)
+                if old_snap:
+                    old_id = 1  # In real usage, would query the ID
+                    new_id = cache.save_snapshot(url, new_schema)
+                    cache.save_drift_event(url, old_id, new_id, similarity, diff)
+                    click.echo(f"📦 Drift event cached")
+        except Exception as e:
+            click.echo(f"⚠️  Cache write failed: {e}")
+
+
+if __name__ == "__main__":
+    cli()