contractforge-fabric 0.1.0__tar.gz

contractforge_fabric-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.uv-cache/
+.venv/
+.tmp/
+dist/
+build/
+*.egg
+.coverage
+.coverage.*
+htmlcov/
+.DS_Store
+.env
+.env.*
+!.env.example
+api-key-*.txt

contractforge_fabric-0.1.0/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+All notable changes to `contractforge-fabric` are documented in this file.
+
+## 0.1.0
+
+- Added the initial render-only Fabric Lakehouse adapter package.
+- Added conservative capabilities, source-support classification, review
+  artifacts and CLI commands.

contractforge_fabric-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: contractforge-fabric
+Version: 0.1.0
+Summary: Microsoft Fabric adapter for ContractForge Core.
+Project-URL: Homepage, https://github.com/marquesantero/contractforge-core/tree/main/adapters/fabric
+Project-URL: Documentation, https://marquesantero.github.io/contractforge-core/docs/adapters/fabric
+Project-URL: Repository, https://github.com/marquesantero/contractforge-core
+Project-URL: Issues, https://github.com/marquesantero/contractforge-core/issues
+Project-URL: Changelog, https://github.com/marquesantero/contractforge-core/blob/main/adapters/fabric/CHANGELOG.md
+Author: ContractForge contributors
+License: MIT
+Keywords: contractforge,data-contracts,ingestion,lakehouse,microsoft-fabric,onelake
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: contractforge-core<0.2,>=0.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: runtime
+Description-Content-Type: text/markdown
+
+# contractforge-fabric
+
+`contractforge-fabric` is the Microsoft Fabric adapter package for
+ContractForge.
+
+The first adapter slice is intentionally conservative. It plans contracts
+against a Fabric Lakehouse target, renders review artifacts, publishes a
+machine-readable source-support catalog and documents the runtime boundaries for
+future deployment work.
+
+It does not yet call Fabric REST APIs, submit notebooks, create Data Factory
+pipelines or mutate Fabric workspaces.
+
+## Install
+
+```bash
+pip install contractforge-core contractforge-fabric
+```
+
+## Use
+
+```python
+from contractforge_fabric import plan_fabric_contract, render_fabric_contract
+
+contract = {
+    "source": {"type": "parquet", "path": "Files/orders"},
+    "target": {"catalog": "workspace", "schema": "bronze", "table": "orders"},
+    "mode": "overwrite",
+}
+
+planning = plan_fabric_contract(contract)
+artifacts = render_fabric_contract(contract)
+```
+
+CLI:
+
+```bash
+contractforge-fabric plan contracts/orders.ingestion.yaml
+contractforge-fabric render contracts/orders.ingestion.yaml
+contractforge-fabric sources
+```
+
+## Current scope
+
+- Subtarget: `fabric_lakehouse`.
+- Runtime status: render-only.
+- Native concepts: Fabric Workspace, Lakehouse, Warehouse, OneLake, shortcuts,
+  notebooks and Data Factory pipelines.
+- Evidence store target: Fabric Lakehouse Delta tables, review-only for now.
+
+The adapter returns `REVIEW_REQUIRED` for semantics that need a concrete Fabric
+runtime design before execution can be claimed.

contractforge_fabric-0.1.0/README.md

@@ -0,0 +1,52 @@
+# contractforge-fabric
+
+`contractforge-fabric` is the Microsoft Fabric adapter package for
+ContractForge.
+
+The first adapter slice is intentionally conservative. It plans contracts
+against a Fabric Lakehouse target, renders review artifacts, publishes a
+machine-readable source-support catalog and documents the runtime boundaries for
+future deployment work.
+
+It does not yet call Fabric REST APIs, submit notebooks, create Data Factory
+pipelines or mutate Fabric workspaces.
+
+## Install
+
+```bash
+pip install contractforge-core contractforge-fabric
+```
+
+## Use
+
+```python
+from contractforge_fabric import plan_fabric_contract, render_fabric_contract
+
+contract = {
+    "source": {"type": "parquet", "path": "Files/orders"},
+    "target": {"catalog": "workspace", "schema": "bronze", "table": "orders"},
+    "mode": "overwrite",
+}
+
+planning = plan_fabric_contract(contract)
+artifacts = render_fabric_contract(contract)
+```
+
+CLI:
+
+```bash
+contractforge-fabric plan contracts/orders.ingestion.yaml
+contractforge-fabric render contracts/orders.ingestion.yaml
+contractforge-fabric sources
+```
+
+## Current scope
+
+- Subtarget: `fabric_lakehouse`.
+- Runtime status: render-only.
+- Native concepts: Fabric Workspace, Lakehouse, Warehouse, OneLake, shortcuts,
+  notebooks and Data Factory pipelines.
+- Evidence store target: Fabric Lakehouse Delta tables, review-only for now.
+
+The adapter returns `REVIEW_REQUIRED` for semantics that need a concrete Fabric
+runtime design before execution can be claimed.

contractforge_fabric-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "contractforge-fabric"
+version = "0.1.0"
+description = "Microsoft Fabric adapter for ContractForge Core."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "ContractForge contributors" }]
+keywords = ["contractforge", "microsoft-fabric", "onelake", "lakehouse", "data-contracts", "ingestion"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = ["contractforge-core>=0.1,<0.2"]
+
+[project.urls]
+Homepage = "https://github.com/marquesantero/contractforge-core/tree/main/adapters/fabric"
+Documentation = "https://marquesantero.github.io/contractforge-core/docs/adapters/fabric"
+Repository = "https://github.com/marquesantero/contractforge-core"
+Issues = "https://github.com/marquesantero/contractforge-core/issues"
+Changelog = "https://github.com/marquesantero/contractforge-core/blob/main/adapters/fabric/CHANGELOG.md"
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+runtime = []
+
+[project.scripts]
+contractforge-fabric = "contractforge_fabric.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/contractforge_fabric"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src/contractforge_fabric", "/README.md", "/CHANGELOG.md", "/pyproject.toml"]

contractforge_fabric-0.1.0/src/contractforge_fabric/__init__.py

@@ -0,0 +1,28 @@
+"""Microsoft Fabric adapter for ContractForge."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from contractforge_fabric.adapter import FabricAdapter
+from contractforge_fabric.api import plan_fabric_contract, render_fabric_contract
+from contractforge_fabric.capabilities import FABRIC_SUBTARGET_LAKEHOUSE, fabric_lakehouse_capabilities
+from contractforge_fabric.sources import fabric_source_support, list_fabric_source_support
+from contractforge_fabric.subtargets import adapter_for_subtarget, list_fabric_subtargets
+
+try:
+    __version__ = version("contractforge-fabric")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"
+
+__all__ = [
+    "FABRIC_SUBTARGET_LAKEHOUSE",
+    "FabricAdapter",
+    "adapter_for_subtarget",
+    "fabric_lakehouse_capabilities",
+    "fabric_source_support",
+    "list_fabric_source_support",
+    "list_fabric_subtargets",
+    "plan_fabric_contract",
+    "render_fabric_contract",
+]

contractforge_fabric-0.1.0/src/contractforge_fabric/adapter.py

@@ -0,0 +1,63 @@
+"""ContractForge adapter implementation for Microsoft Fabric targets."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from contractforge_core.adapters import RenderedArtifacts
+from contractforge_core.capabilities import PlatformCapabilities
+from contractforge_core.planner import ExecutionPlan, PlanningResult, plan_contract
+from contractforge_core.semantic import SemanticContract
+from contractforge_fabric.capabilities import FABRIC_SUBTARGET_LAKEHOUSE, fabric_lakehouse_capabilities
+from contractforge_fabric.diagnostics import fabric_planning_warnings, unsupported_source_blockers
+from contractforge_fabric.environment import FabricEnvironment
+from contractforge_fabric.rendering import render_fabric_review_artifacts
+
+
+@dataclass(frozen=True)
+class FabricAdapter:
+    """Fabric Lakehouse adapter for planning and review artifact rendering."""
+
+    declared_capabilities: PlatformCapabilities
+    environment: FabricEnvironment = FabricEnvironment()
+    name: str = FABRIC_SUBTARGET_LAKEHOUSE
+
+    @classmethod
+    def lakehouse(cls, environment: dict[str, Any] | None = None) -> "FabricAdapter":
+        return cls(
+            fabric_lakehouse_capabilities(),
+            environment=FabricEnvironment.from_contract(environment),
+        )
+
+    def capabilities(self) -> PlatformCapabilities:
+        return self.declared_capabilities
+
+    def plan(self, contract: SemanticContract) -> PlanningResult:
+        source_blockers = unsupported_source_blockers(contract)
+        if source_blockers:
+            return PlanningResult(status="UNSUPPORTED", plan=None, blockers=source_blockers)
+
+        result = plan_contract(contract, self.capabilities())
+        warnings = result.warnings + fabric_planning_warnings(contract)
+        if result.status == "SUPPORTED":
+            return PlanningResult(status="SUPPORTED_WITH_WARNINGS", plan=result.plan, warnings=warnings)
+        return PlanningResult(
+            status=result.status,
+            plan=result.plan,
+            blockers=result.blockers,
+            warnings=warnings,
+        )
+
+    def render(self, plan: ExecutionPlan) -> RenderedArtifacts:
+        return render_fabric_review_artifacts(plan=plan, planning=None, environment=self.environment)
+
+    def render_contract(self, contract: SemanticContract, *, raw_contract: dict[str, Any] | None = None) -> RenderedArtifacts:
+        planning = self.plan(contract)
+        return render_fabric_review_artifacts(
+            plan=planning.plan,
+            planning=planning,
+            contract=contract,
+            raw_contract=raw_contract,
+            environment=self.environment,
+        )

contractforge_fabric-0.1.0/src/contractforge_fabric/api.py

@@ -0,0 +1,36 @@
+"""High-level Fabric adapter API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.adapters import RenderedArtifacts
+from contractforge_core.contracts import semantic_contract_from_mapping
+from contractforge_core.planner import PlanningResult
+from contractforge_fabric.capabilities import FABRIC_SUBTARGET_LAKEHOUSE
+from contractforge_fabric.subtargets import adapter_for_subtarget
+
+
+def plan_fabric_contract(
+    contract: dict[str, Any],
+    *,
+    subtarget: str = FABRIC_SUBTARGET_LAKEHOUSE,
+    environment: dict[str, Any] | None = None,
+) -> PlanningResult:
+    semantic = semantic_contract_from_mapping(contract)
+    adapter = adapter_for_subtarget(subtarget, environment=environment)
+    return adapter.plan(semantic)
+
+
+def render_fabric_contract(
+    contract: dict[str, Any],
+    *,
+    subtarget: str = FABRIC_SUBTARGET_LAKEHOUSE,
+    environment: dict[str, Any] | None = None,
+) -> RenderedArtifacts:
+    semantic = semantic_contract_from_mapping(contract)
+    adapter = adapter_for_subtarget(subtarget, environment=environment)
+    return adapter.render_contract(semantic, raw_contract=contract)
+
+
+__all__ = ["plan_fabric_contract", "render_fabric_contract"]

contractforge_fabric-0.1.0/src/contractforge_fabric/capabilities/__init__.py

@@ -0,0 +1,5 @@
+"""Fabric adapter capability declarations."""
+
+from contractforge_fabric.capabilities.lakehouse import FABRIC_SUBTARGET_LAKEHOUSE, fabric_lakehouse_capabilities
+
+__all__ = ["FABRIC_SUBTARGET_LAKEHOUSE", "fabric_lakehouse_capabilities"]

contractforge_fabric-0.1.0/src/contractforge_fabric/capabilities/lakehouse.py

@@ -0,0 +1,51 @@
+"""Capability declaration for the Microsoft Fabric Lakehouse adapter target."""
+
+from __future__ import annotations
+
+from contractforge_core.capabilities import PlatformCapabilities
+
+FABRIC_SUBTARGET_LAKEHOUSE = "fabric_lakehouse"
+
+
+def fabric_lakehouse_capabilities() -> PlatformCapabilities:
+    """Return conservative capabilities for the initial Fabric target.
+
+    Fabric has native Lakehouse, Warehouse, OneLake, notebook and Data Factory
+    surfaces. This first adapter slice is render-only, so execution-sensitive
+    semantics remain review-required until runtime evidence exists.
+    """
+
+    return PlatformCapabilities(
+        platform=FABRIC_SUBTARGET_LAKEHOUSE,
+        supports_append=True,
+        supports_overwrite=True,
+        supports_merge=True,
+        supports_hash_diff=False,
+        supports_scd2=False,
+        supports_snapshot_soft_delete=False,
+        supports_schema_evolution=True,
+        supports_row_filters=False,
+        supports_column_masks=False,
+        supports_available_now_streaming=False,
+        supports_required_columns_quality=True,
+        supports_unique_key_quality=True,
+        supports_max_null_ratio_quality=True,
+        supports_expression_quality=True,
+        supports_shape=True,
+        supports_transform=True,
+        evidence_stores=("fabric_lakehouse_delta_tables",),
+        review_required_semantics=(
+            "hash_diff_upsert",
+            "scd2_historical",
+            "snapshot_soft_delete",
+            "available_now_streaming",
+            "row_filters",
+            "column_masks",
+            "source.jdbc",
+            "source.rest_api",
+            "source.http_file",
+            "source.kafka_bounded",
+            "source.eventhubs_bounded",
+            "source.native_passthrough",
+        ),
+    )

contractforge_fabric-0.1.0/src/contractforge_fabric/cli.py

@@ -0,0 +1,80 @@
+"""Minimal CLI entry point for the Fabric adapter package."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from contractforge_fabric.api import plan_fabric_contract, render_fabric_contract
+from contractforge_fabric.sources import list_fabric_source_support
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="contractforge-fabric")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    plan = subparsers.add_parser("plan", help="Plan a contract against the Fabric Lakehouse target.")
+    plan.add_argument("contract", type=Path)
+    plan.add_argument("--environment", type=Path)
+
+    render = subparsers.add_parser("render", help="Render Fabric planning review artifacts.")
+    render.add_argument("contract", type=Path)
+    render.add_argument("--environment", type=Path)
+
+    subparsers.add_parser("sources", help="Print Fabric source support metadata.")
+
+    args = parser.parse_args(argv)
+    if args.command == "plan":
+        return _handle_plan(args.contract, args.environment)
+    if args.command == "render":
+        return _handle_render(args.contract, args.environment)
+    if args.command == "sources":
+        print(json.dumps(list(list_fabric_source_support()), indent=2, sort_keys=True))
+        return 0
+    return 2
+
+
+def _handle_plan(contract_path: Path, environment_path: Path | None) -> int:
+    result = plan_fabric_contract(_load_yaml(contract_path), environment=_load_optional_yaml(environment_path))
+    print(json.dumps(_planning_payload(result), indent=2, sort_keys=True))
+    return 0
+
+
+def _handle_render(contract_path: Path, environment_path: Path | None) -> int:
+    artifacts = render_fabric_contract(_load_yaml(contract_path), environment=_load_optional_yaml(environment_path))
+    print(json.dumps(artifacts.artifacts, indent=2, sort_keys=True))
+    return 0
+
+
+def _load_optional_yaml(path: Path | None) -> dict[str, Any] | None:
+    return None if path is None else _load_yaml(path)
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    payload = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected YAML object in {path}")
+    return payload
+
+
+def _planning_payload(result) -> dict[str, object]:
+    return {
+        "status": result.status,
+        "blockers": [{"code": item.code, "message": item.message} for item in result.blockers],
+        "warnings": [{"code": item.code, "message": item.message} for item in result.warnings],
+        "plan": None
+        if result.plan is None
+        else {
+            "platform": result.plan.platform,
+            "evidence_required": result.plan.evidence_required,
+            "steps": [{"name": step.name, "intent": step.intent} for step in result.plan.steps],
+        },
+    }
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

contractforge_fabric-0.1.0/src/contractforge_fabric/diagnostics.py

@@ -0,0 +1,38 @@
+"""Fabric planning diagnostics."""
+
+from __future__ import annotations
+
+from contractforge_core.planner import PlanningBlocker, PlanningWarning
+from contractforge_core.semantic import SemanticContract
+from contractforge_fabric.sources import classify_fabric_source
+
+
+def unsupported_source_blockers(contract: SemanticContract) -> tuple[PlanningBlocker, ...]:
+    classification = classify_fabric_source(contract.source.raw)
+    if classification.status != "UNSUPPORTED":
+        return ()
+    return (
+        PlanningBlocker(
+            code="FABRIC_UNSUPPORTED_SOURCE",
+            message=f"Fabric Lakehouse adapter has no declared source mapping for `{classification.source_type}`.",
+        ),
+    )
+
+
+def fabric_planning_warnings(contract: SemanticContract) -> tuple[PlanningWarning, ...]:
+    warnings: list[PlanningWarning] = []
+    classification = classify_fabric_source(contract.source.raw)
+    if classification.status in {"SUPPORTED_WITH_WARNINGS", "REVIEW_REQUIRED"}:
+        warnings.append(
+            PlanningWarning(
+                code="FABRIC_SOURCE_REVIEW",
+                message=f"`{classification.source_type}` maps to {classification.native_mapping or 'Fabric review'}: {classification.note}",
+            )
+        )
+    warnings.append(
+        PlanningWarning(
+            code="FABRIC_RENDER_ONLY",
+            message="The Fabric adapter currently renders review artifacts only; runtime execution is not yet implemented.",
+        )
+    )
+    return tuple(warnings)

contractforge_fabric-0.1.0/src/contractforge_fabric/environment.py

@@ -0,0 +1,48 @@
+"""Fabric adapter environment binding."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class FabricEnvironment:
+    """Adapter-owned interpretation of the core environment contract."""
+
+    workspace_id: str | None = None
+    workspace_name: str | None = None
+    lakehouse_id: str | None = None
+    lakehouse_name: str | None = None
+    warehouse_id: str | None = None
+    warehouse_name: str | None = None
+    evidence_lakehouse: str | None = None
+    evidence_schema: str | None = None
+    artifact_uri: str | None = None
+    runtime_kind: str | None = None
+    notebook_id: str | None = None
+    pipeline_id: str | None = None
+
+    @classmethod
+    def from_contract(cls, environment: dict[str, Any] | None = None) -> "FabricEnvironment":
+        if not environment:
+            return cls()
+        evidence = environment.get("evidence") if isinstance(environment.get("evidence"), dict) else {}
+        artifacts = environment.get("artifacts") if isinstance(environment.get("artifacts"), dict) else {}
+        runtime = environment.get("runtime") if isinstance(environment.get("runtime"), dict) else {}
+        parameters = environment.get("parameters") if isinstance(environment.get("parameters"), dict) else {}
+        fabric = parameters.get("fabric") if isinstance(parameters.get("fabric"), dict) else {}
+        return cls(
+            workspace_id=fabric.get("workspace_id"),
+            workspace_name=fabric.get("workspace_name"),
+            lakehouse_id=fabric.get("lakehouse_id"),
+            lakehouse_name=fabric.get("lakehouse_name"),
+            warehouse_id=fabric.get("warehouse_id"),
+            warehouse_name=fabric.get("warehouse_name"),
+            evidence_lakehouse=evidence.get("lakehouse") or evidence.get("database"),
+            evidence_schema=evidence.get("schema"),
+            artifact_uri=artifacts.get("uri"),
+            runtime_kind=runtime.get("kind"),
+            notebook_id=fabric.get("notebook_id"),
+            pipeline_id=fabric.get("pipeline_id"),
+        )

contractforge_fabric-0.1.0/src/contractforge_fabric/rendering/__init__.py

@@ -0,0 +1,5 @@
+"""Fabric artifact rendering."""
+
+from contractforge_fabric.rendering.review import render_fabric_review_artifacts
+
+__all__ = ["render_fabric_review_artifacts"]

contractforge_fabric-0.1.0/src/contractforge_fabric/rendering/review.py

@@ -0,0 +1,222 @@
+"""Render Fabric planning review artifacts."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from contractforge_core.adapters import RenderedArtifacts
+from contractforge_core.planner import ExecutionPlan, PlanningResult
+from contractforge_core.semantic import SemanticContract
+from contractforge_fabric.capabilities import FABRIC_SUBTARGET_LAKEHOUSE, fabric_lakehouse_capabilities
+from contractforge_fabric.environment import FabricEnvironment
+from contractforge_fabric.sources import list_fabric_source_support
+
+_PUBLIC_REVIEW_REQUIRED_SEMANTICS = {
+    "scd2_historical": "historical",
+    "snapshot_soft_delete": "snapshot_reconcile_soft_delete",
+}
+
+
+def render_fabric_review_artifacts(
+    *,
+    plan: ExecutionPlan | None,
+    planning: PlanningResult | None,
+    contract: SemanticContract | None = None,
+    raw_contract: dict[str, Any] | None = None,
+    environment: FabricEnvironment | None = None,
+) -> RenderedArtifacts:
+    env = environment or FabricEnvironment()
+    prefix = _artifact_prefix(contract, plan)
+    artifacts = {
+        f"{prefix}.fabric.review.md": _planning_markdown(
+            plan=plan,
+            planning=planning,
+            contract=contract,
+            environment=env,
+        ),
+        f"{prefix}.fabric.capabilities.json": _capabilities_json(plan=plan, planning=planning, environment=env),
+        f"{prefix}.fabric.source_support.json": json.dumps(list(list_fabric_source_support()), indent=2, sort_keys=True),
+        f"{prefix}.fabric.runtime.todo.md": _runtime_todo(contract=contract, environment=env),
+    }
+    if raw_contract is not None:
+        artifacts[f"{prefix}.fabric.contract.json"] = json.dumps(raw_contract, indent=2, sort_keys=True)
+    manifest_name = f"{prefix}.fabric.manifest.json"
+    artifacts[manifest_name] = _manifest_json(
+        plan=plan,
+        planning=planning,
+        artifacts=artifacts,
+        manifest_name=manifest_name,
+    )
+    return RenderedArtifacts(artifacts=artifacts)
+
+
+def _artifact_prefix(contract: SemanticContract | None, plan: ExecutionPlan | None) -> str:
+    if contract is None:
+        return (plan.platform if plan else FABRIC_SUBTARGET_LAKEHOUSE).replace(".", "_")
+    namespace = (contract.target.namespace or "default").replace(".", "_")
+    return f"{namespace}_{contract.target.name}"
+
+
+def _capabilities_json(
+    *,
+    plan: ExecutionPlan | None,
+    planning: PlanningResult | None,
+    environment: FabricEnvironment,
+) -> str:
+    capabilities = fabric_lakehouse_capabilities()
+    payload = {
+        "adapter": "fabric",
+        "subtarget": plan.platform if plan else FABRIC_SUBTARGET_LAKEHOUSE,
+        "planning_status": planning.status if planning else None,
+        "supports": {
+            "append": capabilities.supports_append,
+            "overwrite": capabilities.supports_overwrite,
+            "upsert": capabilities.supports_merge,
+            "hash_diff_upsert": capabilities.supports_hash_diff,
+            "historical": capabilities.supports_scd2,
+            "snapshot_reconcile_soft_delete": capabilities.supports_snapshot_soft_delete,
+            "schema_evolution": capabilities.supports_schema_evolution,
+            "row_filters": capabilities.supports_row_filters,
+            "column_masks": capabilities.supports_column_masks,
+            "available_now_streaming": capabilities.supports_available_now_streaming,
+            "shape": capabilities.supports_shape,
+            "transform": capabilities.supports_transform,
+            "expression_quality": capabilities.supports_expression_quality,
+        },
+        "evidence": {
+            "stores": list(capabilities.evidence_stores),
+            "lakehouse": environment.evidence_lakehouse,
+            "schema": environment.evidence_schema,
+        },
+        "runtime": {
+            "status": "render_only",
+            "workspace_id": environment.workspace_id,
+            "workspace_name": environment.workspace_name,
+            "lakehouse_id": environment.lakehouse_id,
+            "lakehouse_name": environment.lakehouse_name,
+            "warehouse_id": environment.warehouse_id,
+            "warehouse_name": environment.warehouse_name,
+            "artifact_uri": environment.artifact_uri,
+            "notebook_id": environment.notebook_id,
+            "pipeline_id": environment.pipeline_id,
+        },
+        "review_required_semantics": [
+            _PUBLIC_REVIEW_REQUIRED_SEMANTICS.get(item, item) for item in capabilities.review_required_semantics
+        ],
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def _planning_markdown(
+    *,
+    plan: ExecutionPlan | None,
+    planning: PlanningResult | None,
+    contract: SemanticContract | None,
+    environment: FabricEnvironment,
+) -> str:
+    lines = [
+        "# Fabric Lakehouse Planning Review",
+        "",
+        "This artifact summarizes how a ContractForge contract maps to the Microsoft Fabric Lakehouse surface.",
+        "The current adapter is render-only: it does not call Fabric REST APIs, submit notebooks or update Data Factory pipelines.",
+        "",
+        "## Fabric Binding",
+        "",
+        f"- Workspace: `{environment.workspace_name or environment.workspace_id or 'UNSPECIFIED'}`",
+        f"- Lakehouse: `{environment.lakehouse_name or environment.lakehouse_id or 'UNSPECIFIED'}`",
+        f"- Warehouse: `{environment.warehouse_name or environment.warehouse_id or 'UNSPECIFIED'}`",
+        f"- Evidence: `{_evidence_name(environment)}`",
+        "",
+    ]
+    if contract:
+        lines.extend(
+            [
+                "## Contract",
+                "",
+                f"- Source: `{contract.source.kind}`",
+                f"- Target: `{contract.target.namespace or 'default'}.{contract.target.name}`",
+                f"- Write mode: `{contract.write.mode}`",
+                "",
+            ]
+        )
+    if planning:
+        lines.extend(["## Planning Result", "", f"- Status: `{planning.status}`", ""])
+        if planning.blockers:
+            lines.extend(["### Blockers", ""])
+            lines.extend(f"- `{blocker.code}`: {blocker.message}" for blocker in planning.blockers)
+            lines.append("")
+        if planning.warnings:
+            lines.extend(["### Warnings", ""])
+            lines.extend(f"- `{warning.code}`: {warning.message}" for warning in planning.warnings)
+            lines.append("")
+    if plan:
+        lines.extend(["## Abstract Plan", "", "| Step | Intent |", "| --- | --- |"])
+        lines.extend(f"| `{step.name}` | {step.intent} |" for step in plan.steps)
+        lines.append("")
+    lines.extend(
+        [
+            "## Expected Fabric Mapping",
+            "",
+            "| ContractForge intent | Fabric target concept |",
+            "| --- | --- |",
+            "| Source read | OneLake Files/Tables, Lakehouse/Warehouse SQL endpoint, shortcut, Data Factory activity or notebook step |",
+            "| Write target | Lakehouse Delta table or Warehouse table, depending on runtime design |",
+            "| Transform | Notebook/Spark or SQL endpoint step |",
+            "| Evidence | Lakehouse Delta evidence tables |",
+            "| Deployment | Future Fabric REST/CLI/Data Factory pipeline integration |",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _runtime_todo(*, contract: SemanticContract | None, environment: FabricEnvironment) -> str:
+    target = f"{contract.target.namespace or 'default'}.{contract.target.name}" if contract else "UNKNOWN"
+    return "\n".join(
+        [
+            "# Fabric Runtime TODO",
+            "",
+            "This adapter version is render-only. To mature it, implement and validate:",
+            "",
+            "- Fabric workspace and item resolution.",
+            "- OneLake/Lakehouse table name resolution.",
+            "- Notebook or Data Factory pipeline artifact generation.",
+            "- Runtime submission through Fabric REST API or Fabric CLI.",
+            "- Delta/Lakehouse evidence table DDL and writes.",
+            "- End-to-end bronze-to-gold contract execution without workaround code.",
+            "",
+            f"Target contract: `{target}`",
+            f"Configured artifact URI: `{environment.artifact_uri or 'UNSPECIFIED'}`",
+            "",
+        ]
+    )
+
+
+def _manifest_json(
+    *,
+    plan: ExecutionPlan | None,
+    planning: PlanningResult | None,
+    artifacts: dict[str, str],
+    manifest_name: str,
+) -> str:
+    payload = {
+        "adapter": "fabric",
+        "subtarget": plan.platform if plan else FABRIC_SUBTARGET_LAKEHOUSE,
+        "planning_status": planning.status if planning else None,
+        "artifact_summary": {
+            "mode": "review_bundle",
+            "execution_model": "render_only",
+            "deployable": False,
+            "count": len(artifacts) + 1,
+            "bytes": sum(len(body.encode("utf-8")) for body in artifacts.values()),
+        },
+        "artifacts": sorted(tuple(artifacts) + (manifest_name,)),
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def _evidence_name(environment: FabricEnvironment) -> str:
+    lakehouse = environment.evidence_lakehouse or environment.lakehouse_name or "CONTRACTFORGE_EVIDENCE_LH"
+    schema = environment.evidence_schema or "contractforge"
+    return f"{lakehouse}.{schema}"

contractforge_fabric-0.1.0/src/contractforge_fabric/sources/__init__.py

@@ -0,0 +1,16 @@
+"""Fabric source mapping helpers."""
+
+from contractforge_fabric.sources.classification import (
+    FabricSourceClassification,
+    classify_fabric_source,
+    is_fabric_source_renderable,
+)
+from contractforge_fabric.sources.support import fabric_source_support, list_fabric_source_support
+
+__all__ = [
+    "FabricSourceClassification",
+    "classify_fabric_source",
+    "fabric_source_support",
+    "is_fabric_source_renderable",
+    "list_fabric_source_support",
+]

contractforge_fabric-0.1.0/src/contractforge_fabric/sources/classification.py

@@ -0,0 +1,182 @@
+"""Fabric source connector classification."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from contractforge_core.connectors import (
+    JDBC_CONNECTORS,
+    is_available_now_stream_source,
+    is_bounded_stream_source,
+    is_catalog_source,
+    is_delta_share_source,
+    is_file_source,
+    is_http_file_source,
+    is_native_passthrough_source,
+    is_rest_api_connector,
+)
+
+SUPPORTED = "SUPPORTED"
+SUPPORTED_WITH_WARNINGS = "SUPPORTED_WITH_WARNINGS"
+REVIEW_REQUIRED = "REVIEW_REQUIRED"
+UNSUPPORTED = "UNSUPPORTED"
+
+
+@dataclass(frozen=True)
+class FabricSourceClassification:
+    source_type: str
+    status: str
+    native_mapping: str | None
+    note: str
+    renderable: bool
+
+
+@dataclass(frozen=True)
+class _SourceRule:
+    matches: Callable[[dict[str, Any]], bool]
+    classify: Callable[[dict[str, Any], str], FabricSourceClassification]
+
+
+def classify_fabric_source(source: dict[str, Any] | str) -> FabricSourceClassification:
+    payload = {"type": source} if isinstance(source, str) else dict(source)
+    source_type = str(payload.get("connector") or payload.get("type") or "").strip().lower()
+    for rule in _CLASSIFICATION_RULES:
+        if rule.matches(payload):
+            return rule.classify(payload, source_type)
+    return FabricSourceClassification(
+        source_type=source_type,
+        status=UNSUPPORTED,
+        native_mapping=None,
+        note="No Fabric source mapping is declared for this connector.",
+        renderable=False,
+    )
+
+
+def is_fabric_source_renderable(source: dict[str, Any]) -> bool:
+    return classify_fabric_source(source).renderable
+
+
+def _is_jdbc_source(source: dict[str, Any]) -> bool:
+    connector = source.get("connector") or source.get("type")
+    return connector in JDBC_CONNECTORS or source.get("type") == "jdbc"
+
+
+def _supported(
+    source_type: str,
+    *,
+    native_mapping: str,
+    note: str,
+    status: str = SUPPORTED,
+    renderable: bool = True,
+) -> FabricSourceClassification:
+    return FabricSourceClassification(
+        source_type=source_type,
+        status=status,
+        native_mapping=native_mapping,
+        note=note,
+        renderable=renderable,
+    )
+
+
+def _catalog_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        native_mapping="Fabric Lakehouse/Warehouse table or SQL endpoint",
+        note="Logical refs are resolved to Fabric item/table names by the adapter.",
+    )
+
+
+def _file_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        native_mapping="OneLake Files/Tables path read",
+        note="Batch file mapping for Lakehouse runtime artifacts.",
+    )
+
+
+def _jdbc_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric Data Factory pipeline or notebook JDBC read",
+        note="Driver, gateway, credential and private-network choices must be reviewed.",
+        renderable=False,
+    )
+
+
+def _http_file_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric notebook or Data Factory web activity",
+        note="Bounded fetch is portable, but Fabric runtime ownership is not implemented yet.",
+        renderable=False,
+    )
+
+
+def _rest_api_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric Data Factory REST copy or notebook fetch",
+        note="Generic bounded REST runtime needs explicit Fabric execution design.",
+        renderable=False,
+    )
+
+
+def _incremental_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric Data Factory incremental pipeline or notebook checkpoint",
+        note="File-discovery and checkpoint semantics require runtime evidence.",
+        renderable=False,
+    )
+
+
+def _bounded_stream_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric Real-Time Intelligence or notebook bounded replay",
+        note="Continuous and bounded replay semantics are not implemented in v0.",
+        renderable=False,
+    )
+
+
+def _delta_share_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=SUPPORTED_WITH_WARNINGS,
+        native_mapping="Delta Sharing client materialized into OneLake",
+        note="Requires runtime dependency and credential review.",
+    )
+
+
+def _native_passthrough_classification(_source: dict[str, Any], source_type: str) -> FabricSourceClassification:
+    return _supported(
+        source_type,
+        status=REVIEW_REQUIRED,
+        native_mapping="Fabric native connector, shortcut or Data Factory activity",
+        note="Native connector handoff must be reviewed per source system.",
+        renderable=False,
+    )
+
+
+def _is_incremental_files(source: dict[str, Any]) -> bool:
+    return str(source.get("type") or "").strip().lower() == "incremental_files"
+
+
+_CLASSIFICATION_RULES = (
+    _SourceRule(_is_incremental_files, _incremental_classification),
+    _SourceRule(_is_jdbc_source, _jdbc_classification),
+    _SourceRule(is_catalog_source, _catalog_classification),
+    _SourceRule(is_http_file_source, _http_file_classification),
+    _SourceRule(is_rest_api_connector, _rest_api_classification),
+    _SourceRule(is_available_now_stream_source, _bounded_stream_classification),
+    _SourceRule(is_bounded_stream_source, _bounded_stream_classification),
+    _SourceRule(is_delta_share_source, _delta_share_classification),
+    _SourceRule(is_file_source, _file_classification),
+    _SourceRule(is_native_passthrough_source, _native_passthrough_classification),
+)

contractforge_fabric-0.1.0/src/contractforge_fabric/sources/support.py

@@ -0,0 +1,33 @@
+"""Fabric source connector support declarations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.connectors.registry import CONNECTOR_CATALOG
+from contractforge_fabric.sources.classification import FabricSourceClassification, classify_fabric_source
+
+_NON_RUNTIME_SOURCE_TYPES = frozenset({"connection"})
+
+
+def fabric_source_support(source: dict[str, Any] | str) -> dict[str, Any]:
+    """Return Fabric Lakehouse support metadata for a source connector."""
+
+    return _entry(classify_fabric_source(source))
+
+
+def list_fabric_source_support() -> tuple[dict[str, Any], ...]:
+    sources = tuple(name for name in CONNECTOR_CATALOG if name not in _NON_RUNTIME_SOURCE_TYPES)
+    return tuple(fabric_source_support(source) for source in sources)
+
+
+def _entry(classification: FabricSourceClassification) -> dict[str, Any]:
+    entry: dict[str, Any] = {
+        "adapter": "fabric",
+        "source_type": classification.source_type,
+        "status": classification.status,
+        "note": classification.note,
+    }
+    if classification.native_mapping:
+        entry["native_mapping"] = classification.native_mapping
+    return entry

contractforge_fabric-0.1.0/src/contractforge_fabric/subtargets.py

@@ -0,0 +1,27 @@
+"""Fabric adapter subtarget registry."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from contractforge_fabric.adapter import FabricAdapter
+from contractforge_fabric.capabilities import FABRIC_SUBTARGET_LAKEHOUSE
+
+_ADAPTER_FACTORIES: dict[str, Callable[..., FabricAdapter]] = {
+    FABRIC_SUBTARGET_LAKEHOUSE: FabricAdapter.lakehouse,
+}
+
+
+def adapter_for_subtarget(subtarget: str, *, environment: dict[str, Any] | None = None) -> FabricAdapter:
+    try:
+        return _ADAPTER_FACTORIES[subtarget](environment=environment)
+    except KeyError as exc:
+        raise ValueError(f"Unsupported Fabric adapter subtarget: {subtarget}") from exc
+
+
+def validate_fabric_subtarget(subtarget: str) -> None:
+    adapter_for_subtarget(subtarget)
+
+
+def list_fabric_subtargets() -> tuple[str, ...]:
+    return tuple(_ADAPTER_FACTORIES)