wexample-wex-addon-dev-php 12.0.3__tar.gz → 12.2.0__tar.gz

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-php
-Version: 12.0.3
+Version: 12.2.0
 Summary: Extends wex with PHP-specific development commands for Composer, Laravel, Symfony, and WordPress services running in Docker containers
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -12,9 +12,9 @@ Requires-Python: >=3.10
 Requires-Dist: attrs>=23.1.0
 Requires-Dist: cattrs>=23.1.0
 Requires-Dist: wexample-filestate-php>=6.4.0
-Requires-Dist: wexample-filestate-symfony>=1.1.0
-Requires-Dist: wexample-wex-addon-ai>=14.3.0
-Requires-Dist: wexample-wex-addon-app>=31.0.0
+Requires-Dist: wexample-filestate-symfony>=2.0.0
+Requires-Dist: wexample-wex-addon-ai>=15.0.0
+Requires-Dist: wexample-wex-addon-app>=31.1.0
 Requires-Dist: wexample-wex-addon-dev-javascript>=8.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 # wex_addon_dev_php
 
-Version: 12.0.3
+Version: 12.2.0
 
 `wex_addon_dev_php` extends the wex CLI with PHP-specific development commands for Composer, Laravel, Symfony, and WordPress services running in Docker containers. It is aimed at PHP developers who manage their apps through wex and need framework-aware automation — dependency wiring, migration runs, lock-file refreshes — executed directly inside the running service containers. The addon registers four workdir types (`php`, `php-package`, `php-packages-suite`, `php-symfony`) and contributes its commands through the standard `PhpAddonManager` plugin point.
 
@@ -274,9 +274,9 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - attrs: >=23.1.0
 - cattrs: >=23.1.0
 - wexample-filestate-php: >=6.4.0
-- wexample-filestate-symfony: >=1.1.0
-- wexample-wex-addon-ai: >=14.3.0
-- wexample-wex-addon-app: >=31.0.0
+- wexample-filestate-symfony: >=2.0.0
+- wexample-wex-addon-ai: >=15.0.0
+- wexample-wex-addon-app: >=31.1.0
 - wexample-wex-addon-dev-javascript: >=8.1.0
 
 ## Versioning & Compatibility Policy

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/README.md

@@ -1,6 +1,6 @@
 # wex_addon_dev_php
 
-Version: 12.0.3
+Version: 12.2.0
 
 `wex_addon_dev_php` extends the wex CLI with PHP-specific development commands for Composer, Laravel, Symfony, and WordPress services running in Docker containers. It is aimed at PHP developers who manage their apps through wex and need framework-aware automation — dependency wiring, migration runs, lock-file refreshes — executed directly inside the running service containers. The addon registers four workdir types (`php`, `php-package`, `php-packages-suite`, `php-symfony`) and contributes its commands through the standard `PhpAddonManager` plugin point.
 
@@ -251,9 +251,9 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - attrs: >=23.1.0
 - cattrs: >=23.1.0
 - wexample-filestate-php: >=6.4.0
-- wexample-filestate-symfony: >=1.1.0
-- wexample-wex-addon-ai: >=14.3.0
-- wexample-wex-addon-app: >=31.0.0
+- wexample-filestate-symfony: >=2.0.0
+- wexample-wex-addon-ai: >=15.0.0
+- wexample-wex-addon-app: >=31.1.0
 - wexample-wex-addon-dev-javascript: >=8.1.0
 
 ## Versioning & Compatibility Policy

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "wexample-wex-addon-dev-php"
-version = "12.0.3"
+version = "12.2.0"
 description = "Extends wex with PHP-specific development commands for Composer, Laravel, Symfony, and WordPress services running in Docker containers"
 authors = [
     { name = "weeger", email = "contact@wexample.com" },
@@ -21,9 +21,9 @@ dependencies = [
     "attrs>=23.1.0",
     "cattrs>=23.1.0",
     "wexample-filestate-php>=6.4.0",
-    "wexample-filestate-symfony>=1.1.0",
-    "wexample-wex-addon-ai>=14.3.0",
-    "wexample-wex-addon-app>=31.0.0",
+    "wexample-filestate-symfony>=2.0.0",
+    "wexample-wex-addon-ai>=15.0.0",
+    "wexample-wex-addon-app>=31.1.0",
     "wexample-wex-addon-dev-javascript>=8.1.0",
 ]
 
@@ -43,6 +43,9 @@ dev = [
     "pytest-cov",
 ]
 
+[project.entry-points."wex.addons"]
+php = "wexample_wex_addon_dev_php.php_addon_manager:PhpAddonManager"
+
 [tool.setuptools.packages.find]
 include = [
     "*",

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/src/wexample_wex_addon_dev_php/resources/design_rules/php_code.md

@@ -15,6 +15,17 @@ is already a decision made.
 - Suffix the name with the kind where the kind is the whole point: `ArrayHelper`,
   `WithDomId` for a trait, `AbstractFromArrayObject` for a base class. The reader picks
   up what a class is for from its name before opening it.
+- A route says who it is for in its **path**, never in its name. A path opening on an
+  underscore — `/_system/component`, `/_forms/submit`, `/_live/subscribe-info` — is
+  reached by a program; one without is a page someone opens and reads. Route *names*
+  never carry that underscore, whichever kind they are: `system_component_render`, not
+  `_system_component_render`. The rule reads in one direction only, so a name can be
+  renamed without moving a url and a page can be turned into an endpoint without
+  touching every `path()` call. Symfony's own `_profiler` and `_wdt` carry it on both
+  and are left alone.
+  The one exception is `/api`, which holds machine endpoints and, at `/api/`, the page
+  documenting them. Two natures under one prefix: moving it to `/_api` would rewrite the
+  `baseUrl` of every client for a gain nobody reads, so it stays as it is.
 - Helper classes are `final`-shaped by use: only `public static` methods, no state, no
   instantiation. A helper that needs a constructor has stopped being a helper and belongs
   in `Class/`.

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/src/wexample_wex_addon_dev_php/services/symfony/ai/agents/editor/agent.yml

@@ -1,5 +1,5 @@
 description: Edits this app's Symfony code, following the conventions of this stack
-model: claude:sonnet-5
+model: claude-sonnet-5
 modes: talk
 # `reset` until extraction exists would drop a conversation before anything took its
 # value out. Switch back once `/session-extract` runs ahead of it.

wexample_wex_addon_dev_php-12.2.0/src/wexample_wex_addon_dev_php/services/symfony/knowledge/entity.md

@@ -0,0 +1,80 @@
+A Symfony entity must extend, directly or indirectly, the abstract class
+`Wexample\SymfonyHelpers\Entity\AbstractEntity`. It provides the `id` column, the
+`BaseEntityTrait` and the entity naming/path helpers the rest of the framework relies
+on — an entity that does not extend it is not wired into those conventions.
+
+Writing that class is one step of six. The five others are what turn a Doctrine row into
+something the API and the front can address, and each is carried by a package that
+documents it under its own `.wex/knowledge/`.
+
+| # | Step | Produces |
+|---|---|---|
+| 1 | Write the class and its attributes | `src/Entity/{Entity}.php` |
+| 2 | `wex app::state/rectify` | manipulator trait, repository, and one artefact family per attribute declared |
+| 3 | Write the DTO and return it from the scaffolded normalizer | `src/Api/Dto/{Entity}Dto.php` |
+| 4 | `php bin/console pseudocode:generate:pseudocode` | `pseudocode/entity/{entity}.yml` |
+| 5 | `php bin/console api:export:entities`, then js-api's `generate-entities` and `generate-repositories` | the json schema, the TypeScript entity and its repository |
+| 6 | Consume it from the front | — |
+
+Where each one is described:
+
+- steps 1 and 2 — `wexample-filestate-symfony`, `cookbook/create-an-entity`. `#[ApiEntity]`,
+  `#[EntityForm]`, `#[LinkableEntity]`, `#[ImportableEntity]` and `#[ApiEndpoint]` each
+  scaffold their own family; nothing existing is ever rewritten, so a second pass is
+  harmless and the generated body is a starting point rather than a contract.
+- step 4 — `wexample/symfony-pseudocode`, `usage/overview`.
+- step 5 — `wexample/symfony-api`, `usage/entity-export-pipeline`. The three commands are
+  run by hand from the app, because the first needs a booted kernel to scan. An entity
+  belonging to a bundle still has its artefacts belonging to the bundle, which is a matter
+  of path arguments — and this is the only part of the chain with traps, listed there.
+- step 6 — `@wexample/js-api`, `usage/overview`.
+
+Step 3 is the one piece nothing scaffolds, because the serialized shape is a choice and not
+a deduction. The DTO extends `AbstractEntityDto`, and the generated normalizer returns
+`{Entity}Dto::fromEntity($entity)` instead of the generic array, its return type widened to
+`NormalizableDataInterface`. A DTO property is named after the *entity* property rather than
+the column: that name is the one the step-5 schema makes the browser check.
+
+## Nothing creates an entity but its repository
+
+`new {Entity}()` written outside the repository is not allowed. `AbstractRepository`
+resolves `createNew{Entity}()` and `saveNew{Entity}()` magically: both call the
+`createNew{Entity}()` the repository declares, and `saveNew` persists and flushes what it
+returns. So the repository carries one hand-written method, and the caller only ever sees
+the magic one — declared in the class docblock, which is what makes the IDE and static
+analysis follow it:
+
+```php
+/**
+ * @method Message saveNewMessage(Session $session, string $type, string $body)
+ */
+```
+
+The magic matches the entity's short name and nothing else, so a special case is written
+out in full as `createNew{Entity}From{Source}()` and called by that name. Being an ordinary
+method it persists nothing unless it says so — `MessageRepository::saveNewMessageAndPushEvent()`
+in `wexample/symfony-ai` is that shape, delegating to `saveNewMessage()` and dispatching
+only once the row is written.
+
+## Posted data comes from a DTO, never from the request
+
+`$request->getPayload()` is not read. A POST body is declared as a DTO and validated before
+the controller method runs:
+
+```php
+#[ValidateRequestContent(dto: CreateMessageDto::class, attributeName: 'createMessageDto')]
+public function create(CreateMessageDto $createMessageDto, ...): ApiResponse
+```
+
+The DTO extends `AbstractDto`, sits in `Api\Dto\Entity\{Entity}\`, and carries its
+constraints on its properties — `#[Type]`, `#[NotBlank]`, `#[RequiredDtoProperty]`. It is
+modelled on the entity it feeds, one property per field written, and modelled on it rather
+than copied from it: what a caller may set is not what the entity holds. `CreateMessageDto`
+asks for `session` and `body` and not for `type`, because a caller allowed to name the
+author of a turn would be allowed to write the answers.
+
+This is not the family of step 3: that DTO extends `AbstractEntityDto` and goes out through
+the normalizer, this one comes in.
+
+Forms branch off the same rectify and go nowhere near pseudocode or js-api —
+`wexample/symfony-forms`, `cookbook/create-a-form`.

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/src/wexample_wex_addon_dev_php/workdir/php_package_workdir.py

@@ -27,6 +27,16 @@ if TYPE_CHECKING:
 
 @base_class
 class PhpPackageWorkdir(WithRunnerWorkdirMixin, PhpWorkdir):
+    @staticmethod
+    def line_opens_a_comment(line: str) -> bool:
+        """Whether a line is a comment, judged on the characters it opens with.
+
+        A line-level test and not a parse: it catches the docblock body and the `//`
+        line, which is where a class gets *mentioned* rather than used. A name trailing
+        real code after a `//` on the same line stays reported — rarer, and for a
+        dependency check erring toward reporting is the right way round.
+        """
+        return line.lstrip().startswith(("*", "//", "#", "/*"))
     def get_package_import_name(self) -> str:
         """Get the full package import name with vendor prefix."""
         return f"{string_to_pascal_case(self.get_vendor_name())}\\{string_to_pascal_case(self.get_project_name())}"
@@ -60,12 +70,37 @@ class PhpPackageWorkdir(WithRunnerWorkdirMixin, PhpWorkdir):
     def search_imports_in_codebase(
         self, searched_package: PhpPackageWorkdir
     ) -> list[SearchResult]:
-        """Find PHP `use`/qualified references to the given package."""
+        """Find PHP `use`/qualified references to the given package.
+
+        Two shapes count as an import: the `use` statement, and the fully qualified
+        name written inline (`new \\Wexample\\Foo\\Bar()`). The second is why matches
+        have to be sifted afterwards — a fully qualified name reads the same inside a
+        docblock, and an `@deprecated` note pointing at the class that replaces this
+        one is documentation, not a dependency.
+
+        The `use` branch needs no sifting: it is anchored on `^\\s*use`, which a
+        docblock's leading `*` already prevents from matching.
+        """
         import re
 
         pkg = re.escape(searched_package.get_package_import_name())
         pattern = rf"(?m)^\s*use\s+{pkg}(?:\\\\[\w]+)*\s*;|{pkg}(?:\\\\[\w]+)*(?!\w)"
-        return self.search_in_codebase(pattern, regex=True, flags=re.MULTILINE)
+        results = self.search_in_codebase(pattern, regex=True, flags=re.MULTILINE)
+
+        lines_by_path: dict[str, list[str]] = {}
+        kept: list[SearchResult] = []
+
+        for result in results:
+            path = str(result.item.get_path())
+            if path not in lines_by_path:
+                lines_by_path[path] = result.item.read_text().splitlines()
+
+            lines = lines_by_path[path]
+            line = lines[result.line - 1] if result.line <= len(lines) else ""
+            if not self.line_opens_a_comment(line):
+                kept.append(result)
+
+        return kept
 
     def search_in_codebase(
         self, string: str, *, regex: bool = False, flags: int = 0

{wexample_wex_addon_dev_php-12.0.3 → wexample_wex_addon_dev_php-12.2.0}/src/wexample_wex_addon_dev_php/workdir/php_symfony_workdir.py

@@ -7,6 +7,9 @@ from wexample_helpers.decorator.base_class import base_class
 from wexample_wex_addon_dev_php.workdir.php_workdir import PhpWorkdir
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pathlib import Path
+
     from wexample_config.const.types import DictConfig
     from wexample_config.options_provider.abstract_options_provider import (
         AbstractOptionsProvider,
@@ -19,6 +22,40 @@ if TYPE_CHECKING:
 
 @base_class
 class PhpSymfonyWorkdir(PhpWorkdir):
+    @staticmethod
+    def _create_install_nodes(leaves: dict[str, dict]) -> list[dict]:
+        from wexample_filestate.const.disk import DiskItemType
+
+        roots: list[dict] = []
+        directories: dict[str, dict] = {}
+
+        for destination in sorted(leaves):
+            *parents, filename = destination.split("/")
+            siblings = roots
+            prefix = ""
+
+            for part in parents:
+                prefix = f"{prefix}/{part}" if prefix else part
+                node = directories.get(prefix)
+                if node is None:
+                    node = {
+                        "name": part,
+                        "type": DiskItemType.DIRECTORY,
+                        "children": [],
+                    }
+                    directories[prefix] = node
+                    siblings.append(node)
+                siblings = node["children"]
+
+            siblings.append(
+                {
+                    "name": filename,
+                    "type": DiskItemType.FILE,
+                    **leaves[destination],
+                }
+            )
+
+        return roots
     def get_options_providers(self) -> list[type[AbstractOptionsProvider]]:
         from wexample_filestate_symfony.options_provider.symfony_options_provider import (
             SymfonyOptionsProvider,
@@ -129,6 +166,14 @@ class PhpSymfonyWorkdir(PhpWorkdir):
             src_excluded.append("Repository")
             src_dir["children"].append(repository_dir)
 
+        # Only the entity that asked for a provider of its own. `#[Searchable]`
+        # alone is served by the generic provider of wexample/symfony-search and
+        # needs no class, so this subtree stays empty in most applications.
+        search_dir = self._create_search_subtree(entity_dir)
+        if search_dir is not None:
+            src_excluded.append("Search")
+            src_dir["children"].append(search_dir)
+
         # Same reserve as the repository subtree: no entity asking for a form
         # means no src/Form and no src/Service/FormProcessor to bring into
         # being.
@@ -149,6 +194,9 @@ class PhpSymfonyWorkdir(PhpWorkdir):
         if services_subtree is not None:
             src_dir["children"].append(services_subtree)
 
+        # What packages ask for lands beside src/, not inside it.
+        raw_value["children"] += self._create_install_subtrees()
+
         # An app without src/Api is not an API app: nothing to scaffold, and
         # declaring the subtree would create the directories out of thin air.
         if (self.get_path() / "src" / "Api").is_dir():
@@ -560,6 +608,50 @@ class PhpSymfonyWorkdir(PhpWorkdir):
             ],
         }
 
+    def _create_install_subtrees(self) -> list[dict]:
+        """The nodes installed packages ask for through `extra.install`.
+
+        Three things a package may need from the application that hosts it: its
+        bundle listed in `config/bundles.php`, a configuration file dropped once
+        and then left to the reader, and a block kept up to date inside a file
+        the reader owns. Everything is declared in the package's composer.json,
+        so installing it is enough for `rectify` to know.
+        """
+        # An application file only: a bundle has no bundle list of its own.
+        if not (self.get_path() / "config" / "bundles.php").is_file():
+            return []
+
+        from wexample_filestate_symfony.option.symfony.bundles_registration_option import (
+            BundlesRegistrationOption,
+        )
+
+        leaves: dict[str, dict] = {
+            "config/bundles.php": {
+                "symfony": [BundlesRegistrationOption.get_name()],
+            }
+        }
+
+        for name, directory, install in self._declared_installs():
+            for source, destination in install.get("files", {}).items():
+                template = directory / source
+                if template.is_file():
+                    leaves.setdefault(destination, {}).update(
+                        {
+                            "should_exist": True,
+                            "default_content": template.read_text(),
+                        }
+                    )
+
+            for source, destination in install.get("blocks", {}).items():
+                template = directory / source
+                if template.is_file():
+                    blocks = leaves.setdefault(destination, {}).setdefault(
+                        "managed_blocks", {}
+                    )
+                    blocks[name] = template.read_text()
+
+        return self._create_install_nodes(leaves)
+
     def _create_php_file_children_filter(self) -> ChildrenFileFactoryOption:
         from wexample_filestate_symfony.option.symfony.entity_extend_option import (
             EntityExtendOption,
@@ -646,6 +738,73 @@ class PhpSymfonyWorkdir(PhpWorkdir):
             ],
         }
 
+    def _create_search_subtree(self, entity_dir: dict) -> dict | None:
+        """The providers written by hand for entities that reason.
+
+        `#[Searchable]` declares a field list and the generic provider searches
+        it — that is the ordinary case and it produces no file. `provider: true`
+        is the entity whose answer depends on who is asking, and that one needs
+        a class.
+        """
+        from wexample_filestate.const.disk import DiskItemType
+        from wexample_filestate.option.sidecar_of_option import SidecarOfOption
+        from wexample_filestate_symfony.file.symfony_entity_search_provider_file import (
+            SymfonyEntitySearchProviderFile,
+        )
+        from wexample_filestate_symfony.file.symfony_entity_search_scoring_file import (
+            SymfonyEntitySearchScoringFile,
+        )
+        from wexample_filestate_symfony.helper.entity import (
+            entity_attribute_flag,
+            entity_attribute_names_argument,
+        )
+
+        search_path = self.get_path() / "src" / "Search"
+
+        def _is_missing_provider(path) -> bool:
+            if not entity_attribute_flag(path, "Searchable", "provider"):
+                return False
+            # An existing provider is declared by the sweep beside; declaring it
+            # here too would build two items for the one path.
+            return not (search_path / f"{path.stem}SearchProvider.php").exists()
+
+        # `scoring: InvoiceSearchScoring::class` asks for a class of that name;
+        # the sidecar writes it under the name the convention gives, which is
+        # the one the attribute is expected to have used.
+        def _is_missing_scoring(path) -> bool:
+            if not entity_attribute_names_argument(path, "Searchable", "scoring"):
+                return False
+            return not (search_path / f"{path.stem}SearchScoring.php").exists()
+
+        entity_paths = list((self.get_path() / "src" / "Entity").glob("*.php"))
+        if (
+            not search_path.is_dir()
+            and not any(map(_is_missing_provider, entity_paths))
+            and not any(map(_is_missing_scoring, entity_paths))
+        ):
+            return None
+
+        return {
+            "name": "Search",
+            "type": DiskItemType.DIRECTORY,
+            "should_exist": True,
+            "children": [
+                self._create_php_file_children_filter(),
+                SidecarOfOption(
+                    primary=entity_dir,
+                    filename="{stem}SearchProvider.php",
+                    cls=SymfonyEntitySearchProviderFile,
+                    filter=_is_missing_provider,
+                ),
+                SidecarOfOption(
+                    primary=entity_dir,
+                    filename="{stem}SearchScoring.php",
+                    cls=SymfonyEntitySearchScoringFile,
+                    filter=_is_missing_scoring,
+                ),
+            ],
+        }
+
     def _create_services_subtree(self) -> dict | None:
         from wexample_filestate.const.disk import DiskItemType
         from wexample_filestate_symfony.option.symfony.services_resource_option import (
@@ -690,3 +849,11 @@ class PhpSymfonyWorkdir(PhpWorkdir):
         runner.workdir = runner.rebase_path(self.get_path())
 
         return runner
+
+    def _declared_installs(self) -> Iterator[tuple[str, Path, dict]]:
+        from wexample_filestate_symfony.helper.composer import installed_packages
+
+        for name, directory, manifest in installed_packages(self.get_path()):
+            install = manifest.get("extra", {}).get("install", {})
+            if install:
+                yield name, directory, install

wexample_wex_addon_dev_php-12.2.0/tests/workdir/test_php_package_workdir.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import pytest
+
+# The line that set this off: an `@deprecated` note naming the class that replaces
+# this one. Verbatim from symfony-helpers' SystemParameter.php.
+DEPRECATION_NOTE = (
+    " * @deprecated use `Wexample\\SymfonyPlatform\\Entity\\Configuration`, which holds a"
+)
+
+
+def test_a_docblock_body_is_a_comment() -> None:
+    assert _line_opens_a_comment(DEPRECATION_NOTE)
+
+
+def test_a_name_trailing_real_code_stays_reported() -> None:
+    """Documented limit: only the line's opening decides, so this is still an import."""
+    assert not _line_opens_a_comment(
+        "$c = new \\Wexample\\SymfonyPlatform\\Entity\\Configuration(); // built here"
+    )
+
+
+@pytest.mark.parametrize(
+    "line",
+    [
+        "// use Wexample\\SymfonyPlatform\\Entity\\Configuration;",
+        "# Wexample\\SymfonyPlatform\\Entity\\Configuration",
+        "/* Wexample\\SymfonyPlatform\\Entity\\Configuration */",
+        "    * @see Wexample\\SymfonyPlatform\\Entity\\Configuration",
+    ],
+)
+def test_every_comment_opener_is_recognised(line: str) -> None:
+    assert _line_opens_a_comment(line)
+
+
+@pytest.mark.parametrize(
+    "line",
+    [
+        "use Wexample\\SymfonyPlatform\\Entity\\Configuration;",
+        "    use Wexample\\SymfonyPlatform\\Entity\\Configuration;",
+        "        $c = new \\Wexample\\SymfonyPlatform\\Entity\\Configuration();",
+        "class SystemParameter extends AbstractEntity",
+    ],
+)
+def test_real_code_is_not_a_comment(line: str) -> None:
+    assert not _line_opens_a_comment(line)
+
+
+def _line_opens_a_comment(line: str) -> bool:
+    from wexample_wex_addon_dev_php.workdir.php_package_workdir import (
+        PhpPackageWorkdir,
+    )
+
+    return PhpPackageWorkdir.line_opens_a_comment(line)

wexample_wex_addon_dev_php-12.0.3/src/wexample_wex_addon_dev_php/services/symfony/knowledge/entity.md

@@ -1,4 +0,0 @@
-A Symfony entity must extend, directly or indirectly, the abstract class
-`Wexample\SymfonyHelpers\Entity\AbstractEntity`. It provides the `id` column, the
-`BaseEntityTrait` and the entity naming/path helpers the rest of the framework relies
-on — an entity that does not extend it is not wired into those conventions.