fix: add CLI integration tests for detect, formats, and positional convert arg by reviewer-B

Author: Coding-Dev-Tools

CHANGELOG.md

@@ -31,7 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `schemaforge mcp` command (stdio and SSE modes)
 - `schemaforge check` command — schema consistency across directories
 - `schemaforge formats` command — list supported formats
-- `schemaforge detect_format` command — identify format from filename
+- `schemaforge detect` command — identify format from filename
 - CI/CD workflow for automated testing and publishing
 
 ### Changed

README.md

@@ -1,6 +1,6 @@
 # SchemaForge
 
-> **Bidirectional ORM schema converter** — convert between SQL DDL, Prisma, Drizzle, TypeORM, Django, SQLAlchemy, Alembic migrations, JSON Schema, GraphQL SDL, EF Core (C#), and Scala case classes. **11 formats, 110 direction pairs.**
+> **Bidirectional ORM schema converter** — convert between SQL DDL, Prisma, Drizzle, TypeORM, Django, SQLAlchemy, Alembic migrations, JSON Schema, GraphQL SDL, EF Core (C#), and Scala case classes. **11 formats, 100 conversion directions.**
 
 [![GitHub stars](https://img.shields.io/github/stars/Coding-Dev-Tools/schemaforge?style=social)](https://github.com/Coding-Dev-Tools/schemaforge/stargazers)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://github.com/Coding-Dev-Tools/schemaforge)
@@ -55,7 +55,7 @@ Requires Python 3.10+.
 
 ### `schemaforge convert`
 
-Convert a schema from one format to another. All 11 formats support conversion to and from every other format (110 direction pairs).
+Convert a schema from one format to another. Every format converts to and from every other format, except Alembic which is generator-only (a target, not a source) — 100 direction pairs.
 
 ```bash
 # Format-specific examples
@@ -115,6 +115,11 @@ Detects added, removed, and modified tables, columns, indexes, and constraints.
 
 **Alembic** is generator-only: you can create migration scripts from any format, but parsing existing migrations back to IR is not yet supported.
 
+### Limitations
+
+- **Foreign keys & relationships** — the shared IR does not yet model foreign-key constraints or ORM relations, so `FOREIGN KEY` / `REFERENCES` clauses, Prisma/TypeORM relation fields, and Django `ForeignKey` fields are dropped during conversion rather than roundtripped. Tables, columns, types, defaults, indexes, unique constraints, and enums are preserved. FK support is on the roadmap.
+- **Alembic is generator-only** (see above) — you can generate migrations from any format but not parse them back.
+
 ### Format Identifiers for `--from` / `--to`
 
 | CLI identifier | Format |
@@ -135,8 +140,8 @@ Detects added, removed, and modified tables, columns, indexes, and constraints.
 
 SchemaForge uses a **shared Internal Representation (IR)** — all formats convert to and from this common schema definition. This architecture guarantees:
 
-- **Zero-loss roundtripping**: `sql → prisma → sql` produces the same schema you started with
-- **Bidirectional conversion**: every supported format can convert to every other format
+- **High-fidelity roundtripping**: `sql → prisma → sql` reproduces tables, columns, types, defaults, indexes, unique constraints, and enums. Foreign-key/relationship constraints are not yet modeled in the IR and are dropped (see [Limitations](#limitations)).
+- **Bidirectional conversion**: every format can convert to every other format, except Alembic, which is generator-only (a target, not a source)
 - **Extensibility**: adding a new format requires only a parser and a generator — no pairwise converters
 
 ```
@@ -238,8 +243,8 @@ Each fixture demonstrates the same blog schema so you can compare ORM syntax sid
 
 ## Features
 
-- **Bidirectional conversion** — all 11 formats convert to and from every other format
-- **Zero-loss roundtripping** — `sql → prisma → sql` reproduces the original schema exactly
+- **Bidirectional conversion** — every format converts to and from every other format (Alembic is generator-only: a target, not a source)
+- **High-fidelity roundtripping** — `sql → prisma → sql` reproduces tables, columns, types, defaults, indexes, and enums (foreign keys are not yet preserved — see [Limitations](#limitations))
 - **Custom type mappings** — YAML/JSON config files to override any type mapping with template variables
 - **VS Code extension** — live preview, schema diff, and one-click conversion from VS Code
 - **Alembic migration generation** — create database migration scripts from any schema format
@@ -253,7 +258,7 @@ Each fixture demonstrates the same blog schema so you can compare ORM syntax sid
 - **Function default preservation** — `CURRENT_TIMESTAMP`, `NOW()`, `gen_random_uuid()` survive roundtrips
 - **MySQL support** — ENGINE=InnoDB, AUTO_INCREMENT, DEFAULT CHARSET, COMMENT table options
 - **Inline ENUM** — `ENUM('small', 'medium', 'large')` column types parsed and roundtripped
-- **Relation preservation** — indexes, unique constraints maintained across all conversions
+- **Index & constraint preservation** — indexes and unique constraints maintained across all conversions (foreign-key/relationship constraints are not yet modeled — see [Limitations](#limitations))
 - **Custom type handling** — dialect-specific types (JSONB, etc.) pass through via CUSTOM type
 
 ## MCP Server

src/schemaforge/cli.py

@@ -36,7 +36,8 @@ def main() -> None:
     """SchemaForge — bidirectional ORM schema converter.
 
     Convert between SQL DDL, Prisma, Drizzle, TypeORM, Django, SQLAlchemy models,
-    Alembic migrations, JSON Schema, and GraphQL SDL with zero-loss roundtripping.
+    Alembic migrations, JSON Schema, and GraphQL SDL with high-fidelity
+    roundtripping (foreign-key/relationship constraints are not yet preserved).
     """
 
 

src/schemaforge/mcp_server.py

@@ -7,10 +7,31 @@
 
 from __future__ import annotations
 
+import os
 import click
 from pathlib import Path
 from typing import Any
 
+
+def _confined_directory(directory: str) -> Path:
+    """Resolve *directory* and confirm it stays within the allowed root.
+
+    The ``check`` tool iterates and reads files under the given directory. To
+    keep an AI agent (or, in SSE mode, a remote caller) from reading arbitrary
+    locations on the host, requests are confined to a root — the
+    ``SCHEMAFORGE_MCP_ROOT`` environment variable if set, otherwise the current
+    working directory the server was launched in. Escaping the root raises
+    ``PermissionError``.
+    """
+    root = Path(os.environ.get("SCHEMAFORGE_MCP_ROOT", Path.cwd())).resolve()
+    target = Path(directory).resolve()
+    if target != root and not target.is_relative_to(root):
+        raise PermissionError(
+            f"Directory '{directory}' is outside the allowed root '{root}'. "
+            f"Set SCHEMAFORGE_MCP_ROOT to permit a different base directory."
+        )
+    return target
+
 from .check import check_directory, detect_format
 from .convert import convert_schema
 from .diff import diff_schemas
@@ -156,10 +177,13 @@ def check_tool(
             type_map_path: Optional path to a YAML/JSON type mapping config file.
         """
         try:
+            safe_dir = _confined_directory(directory)
             result = check_directory(
-                directory, canonical=canonical, type_map_path=type_map_path
+                str(safe_dir), canonical=canonical, type_map_path=type_map_path
             )
             return result
+        except PermissionError as e:
+            return f"Error: {e}"
         except NotADirectoryError as e:
             return f"Error: {e}"
         except Exception as e:

tests/test_cli.py

@@ -653,3 +653,136 @@ def test_uppercase_extension(self):
         assert _detect_format("schema.PRISMA") == "prisma"
         assert _detect_format("schema.SQL") == "sql"
         assert _detect_format("schema.JSON") == "json_schema"
+
+
+# ═══════════════════════════════════════════════════════════════
+#  detect command (CLI integration)
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestDetectCommand:
+    """CLI integration tests for the `schemaforge detect` command."""
+
+    def test_detect_sql(self):
+        """detect should return 'sql' for .sql files."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sql", delete=False) as f:
+            f.write(SAMPLE_SQL)
+            tmpfile = f.name
+        try:
+            result = runner.invoke(main, ["detect", tmpfile])
+            assert result.exit_code == 0
+            assert result.output.strip() == "sql"
+        finally:
+            Path(tmpfile).unlink(missing_ok=True)
+
+    def test_detect_prisma(self):
+        """detect should return 'prisma' for .prisma files."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".prisma", delete=False) as f:
+            f.write(SAMPLE_PRISMA)
+            tmpfile = f.name
+        try:
+            result = runner.invoke(main, ["detect", tmpfile])
+            assert result.exit_code == 0
+            assert result.output.strip() == "prisma"
+        finally:
+            Path(tmpfile).unlink(missing_ok=True)
+
+    def test_detect_unknown(self):
+        """detect should return 'unknown' for unrecognized extensions."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("irrelevant content")
+            tmpfile = f.name
+        try:
+            result = runner.invoke(main, ["detect", tmpfile])
+            assert result.exit_code == 0
+            assert result.output.strip() == "unknown"
+        finally:
+            Path(tmpfile).unlink(missing_ok=True)
+
+    def test_detect_verbose(self):
+        """detect --verbose should show detailed info."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sql", delete=False) as f:
+            f.write(SAMPLE_SQL)
+            tmpfile = f.name
+        try:
+            result = runner.invoke(main, ["detect", "--verbose", tmpfile])
+            assert result.exit_code == 0
+            assert "file:" in result.output
+            assert "format:" in result.output
+            assert "method:" in result.output
+        finally:
+            Path(tmpfile).unlink(missing_ok=True)
+
+    def test_detect_missing_file(self):
+        """detect on a non-existent file should error."""
+        runner = CliRunner()
+        result = runner.invoke(main, ["detect", "nonexistent.sql"])
+        assert result.exit_code != 0
+        assert "does not exist" in result.output.lower() or "Error" in result.output
+
+
+# ═══════════════════════════════════════════════════════════════
+#  formats command (CLI integration)
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestFormatsCommand:
+    """CLI integration tests for the `schemaforge formats` command."""
+
+    def test_formats_list(self):
+        """formats should list all supported formats."""
+        runner = CliRunner()
+        result = runner.invoke(main, ["formats"])
+        assert result.exit_code == 0
+        for fmt in ["sql", "prisma", "drizzle", "django", "graphql", "scala", "ef"]:
+            assert fmt in result.output
+
+    def test_formats_json(self):
+        """formats --json should output a JSON array."""
+        runner = CliRunner()
+        result = runner.invoke(main, ["formats", "--json"])
+        assert result.exit_code == 0
+        import json
+        parsed = json.loads(result.output.strip())
+        assert isinstance(parsed, list)
+        assert "sql" in parsed
+        assert "prisma" in parsed
+
+
+# ═══════════════════════════════════════════════════════════════
+#  convert with positional argument (CLI integration)
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestConvertPositionalArg:
+    """Tests for the new positional input argument on `convert`."""
+
+    def test_convert_positional_arg(self):
+        """convert should accept a positional input argument."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sql", delete=False) as f:
+            f.write(SAMPLE_SQL)
+            tmpfile = f.name
+        try:
+            result = runner.invoke(
+                main,
+                ["convert", tmpfile, "--from", "sql", "--to", "prisma"],
+            )
+            assert result.exit_code == 0
+            assert "model users" in result.output
+        finally:
+            Path(tmpfile).unlink(missing_ok=True)
+
+    def test_convert_no_input_error(self):
+        """convert without any input should show error."""
+        runner = CliRunner()
+        result = runner.invoke(
+            main,
+            ["convert", "--from", "sql", "--to", "prisma"],
+        )
+        assert result.exit_code != 0
+        assert "no input file" in result.output.lower() or "Error" in result.output