plan-manager-client-dev 0.2.186__py3-none-any.whl

plan_manager_client/facade_bug_project_mixin.py

@@ -0,0 +1,202 @@
+"""Bug and project-dependency command-family facade mixin.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class BugProjectCommandsMixin:
+    """One method per plan_manager command in the bug and project-dependency family.
+
+    Assumes it is mixed into a class that also inherits
+    plan_manager_client.dispatch._CommandDispatchMixin, which supplies the
+    coroutine async def _call(self, command: str, params: dict[str, Any] | None = None) -> Any
+    used by every method below.
+    """
+
+    async def bug_create(self, **params: Any) -> Any:
+        """Create a new bug report with its single primary source anchor."""
+        return await self._call("bug_create", params)
+
+    async def bug_get(self, **params: Any) -> Any:
+        """Retrieve a single bug report by identifier."""
+        return await self._call("bug_get", params)
+
+    async def bug_list(self, **params: Any) -> Any:
+        """List bug reports with filtering and pagination."""
+        return await self._call("bug_list", params)
+
+    async def bug_update(self, **params: Any) -> Any:
+        """Patch mutable fields of an existing bug report."""
+        return await self._call("bug_update", params)
+
+    async def bug_reanchor(self, **params: Any) -> Any:
+        """Move a bug report's primary source anchor to a new target, with an audit record."""
+        return await self._call("bug_reanchor", params)
+
+    async def bug_triage(self, **params: Any) -> Any:
+        """Transition a bug report to status triaged."""
+        return await self._call("bug_triage", params)
+
+    async def bug_confirm(self, **params: Any) -> Any:
+        """Transition a bug report to status confirmed."""
+        return await self._call("bug_confirm", params)
+
+    async def bug_reject(self, **params: Any) -> Any:
+        """Transition a bug report to status rejected."""
+        return await self._call("bug_reject", params)
+
+    async def bug_mark_duplicate(self, **params: Any) -> Any:
+        """Mark a bug report as a duplicate of another bug report."""
+        return await self._call("bug_mark_duplicate", params)
+
+    async def bug_reopen(self, **params: Any) -> Any:
+        """Transition a bug report to status reopened on re-discovery."""
+        return await self._call("bug_reopen", params)
+
+    async def bug_close(self, **params: Any) -> Any:
+        """Transition a bug report to status closed after enforcing the closure discipline invariant on server-derived state."""
+        return await self._call("bug_close", params)
+
+    async def bug_delete(self, **params: Any) -> Any:
+        """Delete a bug report: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("bug_delete", params)
+
+    async def bug_impact_add(self, **params: Any) -> Any:
+        """Create one BugImpact record describing an object affected by a bug."""
+        return await self._call("bug_impact_add", params)
+
+    async def bug_impact_get(self, **params: Any) -> Any:
+        """Retrieve a single bug impact record by identifier."""
+        return await self._call("bug_impact_get", params)
+
+    async def bug_impact_update(self, **params: Any) -> Any:
+        """Transition the status or amend fields of an existing BugImpact record."""
+        return await self._call("bug_impact_update", params)
+
+    async def bug_impact_list(self, **params: Any) -> Any:
+        """List BugImpact records for a bug, with uniform filtering and pagination."""
+        return await self._call("bug_impact_list", params)
+
+    async def bug_impact_discover(self, **params: Any) -> Any:
+        """Auto-discover the suspected impact set of a bug from the reverse project dependency graph."""
+        return await self._call("bug_impact_discover", params)
+
+    async def bug_impact_delete(self, **params: Any) -> Any:
+        """Delete a bug impact record: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("bug_impact_delete", params)
+
+    async def bug_fix_create(self, **params: Any) -> Any:
+        """Create a new fix attempt for a bug (C-024)."""
+        return await self._call("bug_fix_create", params)
+
+    async def bug_fix_get(self, **params: Any) -> Any:
+        """Retrieve a single bug fix attempt by identifier."""
+        return await self._call("bug_fix_get", params)
+
+    async def bug_fix_update(self, **params: Any) -> Any:
+        """Update fields or advance the status of an existing bug fix attempt (C-024)."""
+        return await self._call("bug_fix_update", params)
+
+    async def bug_fix_list(self, **params: Any) -> Any:
+        """List the fix attempts recorded for a bug, filtered and paginated (read-only)."""
+        return await self._call("bug_fix_list", params)
+
+    async def bug_fix_verify(self, **params: Any) -> Any:
+        """Record a verification outcome for a fix attempt (C-024)."""
+        return await self._call("bug_fix_verify", params)
+
+    async def bug_fix_delete(self, **params: Any) -> Any:
+        """Delete a bug fix attempt: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("bug_fix_delete", params)
+
+    async def bug_propagation_create(self, **params: Any) -> Any:
+        """Create a bug fix propagation record for one impact target after a source fix."""
+        return await self._call("bug_propagation_create", params)
+
+    async def bug_propagation_get(self, **params: Any) -> Any:
+        """Retrieve a single bug fix propagation record by identifier."""
+        return await self._call("bug_propagation_get", params)
+
+    async def bug_propagation_list(self, **params: Any) -> Any:
+        """List a paginated page of bug fix propagation records filtered by bug fix or impact (read-only)."""
+        return await self._call("bug_propagation_list", params)
+
+    async def bug_propagation_update(self, **params: Any) -> Any:
+        """Update a bug fix propagation record's status, assignment, evidence, or linked TODO."""
+        return await self._call("bug_propagation_update", params)
+
+    async def bug_propagation_generate_todos(self, **params: Any) -> Any:
+        """Generate linked TODO items for every pending propagation of a bug fix."""
+        return await self._call("bug_propagation_generate_todos", params)
+
+    async def bug_fix_propagation_delete(self, **params: Any) -> Any:
+        """Delete a bug fix propagation record: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("bug_fix_propagation_delete", params)
+
+    async def project_dependency_add(self, **params: Any) -> Any:
+        """Create a project dependency edge between two external projects."""
+        return await self._call("project_dependency_add", params)
+
+    async def project_dependency_update(self, **params: Any) -> Any:
+        """Patch the mutable fields of an existing project dependency edge."""
+        return await self._call("project_dependency_update", params)
+
+    async def project_dependency_confirm(self, **params: Any) -> Any:
+        """Move a discovered project dependency edge's confidence off suspected to confirmed."""
+        return await self._call("project_dependency_confirm", params)
+
+    async def project_dependency_remove(self, **params: Any) -> Any:
+        """Soft-delete an existing project dependency edge."""
+        return await self._call("project_dependency_remove", params)
+
+    async def project_dependency_get(self, **params: Any) -> Any:
+        """Read one project dependency edge by its id (parameters passed through; the server validates them)."""
+        return await self._call("project_dependency_get", params)
+
+    async def project_dependency_delete(self, **params: Any) -> Any:
+        """Delete a project dependency edge: mark by default, hard=true removes a marked edge, dry_run previews (parameters passed through; the server validates them)."""
+        return await self._call("project_dependency_delete", params)
+
+    async def project_dependency_list(self, **params: Any) -> Any:
+        """List a paginated page of project dependency edges filtered by dependent/depends-on project and active status."""
+        return await self._call("project_dependency_list", params)
+
+    async def project_dependency_discover(self, **params: Any) -> Any:
+        """Discover the transitive reverse-dependent project set (suspected impact set) for a source project."""
+        return await self._call("project_dependency_discover", params)
+
+    async def project_dependents(self, **params: Any) -> Any:
+        """List the projects that directly depend on a given project (reverse-dependency lookup)."""
+        return await self._call("project_dependents", params)
+
+    async def project_import(self, **params: Any) -> Any:
+        """Import a code-analysis-server project into the registry (the only way a project enters it; idempotent)."""
+        return await self._call("project_import", params)
+
+    async def project_list(self, **params: Any) -> Any:
+        """List the imported projects, filtered by imported_by or imported_by_prefix, with owned and referenced counts."""
+        return await self._call("project_list", params)
+
+    async def project_remove(self, **params: Any) -> Any:
+        """Remove an imported project from the registry; refused while records own or reference it."""
+        return await self._call("project_remove", params)
+
+    async def project_update(self, **params: Any) -> Any:
+        """Change the comment of an imported project in place (parameters passed through; the server validates them)."""
+        return await self._call("project_update", params)
+
+    async def project_sync(self, **params: Any) -> Any:
+        """Sync the imported projects with the code-analysis server: refresh names, delete unreferenced vanished projects (dry_run previews)."""
+        return await self._call("project_sync", params)
+
+    async def project_view(self, **params: Any) -> Any:
+        """Project-centric aggregate view: paginated todos/bugs (plus a comments count) scoped to one project, direct or transitive via bound plans."""
+        return await self._call("project_view", params)
+
+
+__all__ = ["BugProjectCommandsMixin"]

plan_manager_client/facade_context_gate_mixin.py

@@ -0,0 +1,303 @@
+"""Context/prompt and gate/version/misc command-family facade mixin.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+
+class ContextGateCommandsMixin:
+    """One method per plan_manager command in the context/prompt and gate/version/misc family.
+
+    Assumes it is mixed into a class that also inherits
+    plan_manager_client.dispatch._CommandDispatchMixin, which supplies the
+    coroutine async def _call(self, command: str, params: dict[str, Any] | None = None) -> Any
+    used by every method below.
+    """
+
+    async def plan_prompt_chain(self, **params: Any) -> Any:
+        """Assemble a paginated page of the deterministic, deduplicated prompt-chain artifact for a gate-green plan scope."""
+        return await self._call("plan_prompt_chain", params)
+
+    async def plan_prompt_create(self, **params: Any) -> Any:
+        """Create the role prompt of a plan (plan, role, prompt_text, changed_by, idempotency_key; passed through).
+
+        The server answers a missing or invalid argument with the adapter's -32602 violation, not a Python TypeError.
+        """
+        return await self._call("plan_prompt_create", params)
+
+    async def plan_prompt_get(self, **params: Any) -> Any:
+        """Read a role prompt: exactly one of prompt_id, or plan together with role (passed through; a marked one carries deleted_at)."""
+        return await self._call("plan_prompt_get", params)
+
+    async def plan_prompt_list(self, **params: Any) -> Any:
+        """List role prompts without their text (plan, role, include_deleted, limit, offset; passed through)."""
+        return await self._call("plan_prompt_list", params)
+
+    async def plan_prompt_update(self, **params: Any) -> Any:
+        """Change the text of a prompt under expected_revision (prompt_id, prompt_text, changed_by, expected_revision, idempotency_key)."""
+        return await self._call("plan_prompt_update", params)
+
+    async def plan_prompt_delete(self, **params: Any) -> Any:
+        """Delete a prompt: soft (mark) by default, hard=true removes an already marked one that nothing refers to (passed through)."""
+        return await self._call("plan_prompt_delete", params)
+
+    async def attachment_create(self, **params: Any) -> Any:
+        """Create an attachment: owner, owner_type, role, target_kind, target_id, target_sha256 (document|paragraph|chunk) or target_entity_type (entity), fallback_text, changed_by, idempotency_key (passed through)."""
+        return await self._call("attachment_create", params)
+
+    async def attachment_get(self, **params: Any) -> Any:
+        """Read an attachment: exactly one of attachment_id, or owner with role (passed through; a marked one carries deleted_at)."""
+        return await self._call("attachment_get", params)
+
+    async def attachment_list(self, **params: Any) -> Any:
+        """List attachments without the fallback text (owner, role, target_id, target_state, include_deleted, limit, offset; passed through)."""
+        return await self._call("attachment_list", params)
+
+    async def attachment_update(self, **params: Any) -> Any:
+        """Change the reference or the fallback text under expected_revision (attachment_id, expected_revision, changed_by, idempotency_key; passed through)."""
+        return await self._call("attachment_update", params)
+
+    async def attachment_delete(self, **params: Any) -> Any:
+        """Delete an attachment: soft (mark) by default, hard=true removes an already marked one (passed through)."""
+        return await self._call("attachment_delete", params)
+
+    async def report_create(self, **params: Any) -> Any:
+        """Create a Report on an owner (passed through: owner, owner_type, title, text, changed_by, dry_run; no idempotency key)."""
+        return await self._call("report_create", params)
+
+    async def report_get(self, **params: Any) -> Any:
+        """Read one Report (passed through: report_id)."""
+        return await self._call("report_get", params)
+
+    async def report_list(self, **params: Any) -> Any:
+        """List Reports, rows without text (passed through: owner, include_deleted, limit, offset)."""
+        return await self._call("report_list", params)
+
+    async def report_update(self, **params: Any) -> Any:
+        """Change the title or the text of a Report (passed through: report_id, changed_by, title, text, dry_run; no owner, no revision check)."""
+        return await self._call("report_update", params)
+
+    async def report_delete(self, **params: Any) -> Any:
+        """Delete a Report: soft (mark) by default, hard=true removes an already marked one (passed through: report_id, changed_by, hard, recursive, dry_run)."""
+        return await self._call("report_delete", params)
+
+    async def plan_contract_create(self, **params: Any) -> Any:
+        """Declare the external-API contract of a plan: exactly three documents (matrix, relations, results).
+
+        Parameters are passed through unchanged (plan, documents, changed_by, idempotency_key) so that a missing or
+        invalid argument is refused by the server with the adapter's -32602 violation, not by a Python TypeError.
+        """
+        return await self._call("plan_contract_create", params)
+
+    async def plan_contract_get(self, **params: Any) -> Any:
+        """Read a contract declaration: exactly one of contract_id and plan (passed through; a marked one carries deleted_at)."""
+        return await self._call("plan_contract_get", params)
+
+    async def plan_contract_list(self, **params: Any) -> Any:
+        """List contract declarations (plan, project, include_deleted, limit, offset; passed through)."""
+        return await self._call("plan_contract_list", params)
+
+    async def plan_contract_update(self, **params: Any) -> Any:
+        """Replace the three documents of a declaration under expected_contract_revision (parameters passed through)."""
+        return await self._call("plan_contract_update", params)
+
+    async def plan_contract_delete(self, **params: Any) -> Any:
+        """Delete a declaration: soft (mark) by default, hard=true removes an already marked one (parameters passed through)."""
+        return await self._call("plan_contract_delete", params)
+
+    async def matrix_case_get(self, **params: Any) -> Any:
+        """Read one matrix case of a plan by namespace and case_id; a case marked deleted is read with its mark (parameters passed through)."""
+        return await self._call("matrix_case_get", params)
+
+    async def matrix_lint(self, **params: Any) -> Any:
+        """Lint the matrix parts of a plan and page the defects (parameters passed through)."""
+        return await self._call("matrix_lint", params)
+
+    async def matrix_call_upsert(self, **params: Any) -> Any:
+        """Create or replace a hand-authored matrix call (parameters passed through).
+
+        An int or number argument of call.args[] may carry the optional range {min, max} (numbers or null, at
+        least one given, min <= max); lint then reports a case value outside it (CASE_ARG_RANGE).
+        """
+        return await self._call("matrix_call_upsert", params)
+
+    async def matrix_call_delete(self, **params: Any) -> Any:
+        """Delete a matrix call of a namespace (parameters passed through)."""
+        return await self._call("matrix_call_delete", params)
+
+    async def matrix_case_upsert(self, **params: Any) -> Any:
+        """Create or replace a hand-authored matrix case (parameters passed through).
+
+        An error-expecting case names its defect kind in the optional expect.defect, allowed only with
+        expect.error: missing, unknown, type, enum, range, relation or state. expect.error is a domain code or
+        the protocol code "-32602" (text). Lint checks that the arguments contain that defect and nothing else.
+        """
+        return await self._call("matrix_case_upsert", params)
+
+    async def matrix_case_delete(self, **params: Any) -> Any:
+        """Delete a matrix case of a namespace (parameters passed through)."""
+        return await self._call("matrix_case_delete", params)
+
+    async def matrix_export(self, **params: Any) -> Any:
+        """Export the matrix of a plan as pipeline_yaml or contract_json (parameters passed through)."""
+        return await self._call("matrix_export", params)
+
+    async def plan_authoring_guide(self, **params: Any) -> Any:
+        """Read the authoring standards of one author type (hrs, mrs, matrix, g, t, a) or the overview (parameters passed through)."""
+        return await self._call("plan_authoring_guide", params)
+
+    async def plan_ref_check(self, **params: Any) -> Any:
+        """Check the references of steps to matrix calls and cases without writing (parameters passed through)."""
+        return await self._call("plan_ref_check", params)
+
+    async def matrix_get(self, **params: Any) -> Any:
+        """Read the matrix of a plan: summary, parts, or a page of calls or cases (parameters passed through)."""
+        return await self._call("matrix_get", params)
+
+    async def plan_contract_check(self, **params: Any) -> Any:
+        """Queue a read-only check of the plan's step texts against its declared contract (passed through)."""
+        return await self._call("plan_contract_check", params)
+
+    async def context_compile(self, **params: Any) -> Any:
+        """Compile a typed context block directly from concept ids."""
+        return await self._call("context_compile", params)
+
+    async def context_common(self, **params: Any) -> Any:
+        """Compile the shared common context block for a parent step (step, a uuid4; omitted: the plan root)."""
+        return await self._call("context_common", params)
+
+    async def context_specific(self, **params: Any) -> Any:
+        """Compile a child-specific delta over a common context block."""
+        return await self._call("context_specific", params)
+
+    async def context_bundle(self, **params: Any) -> Any:
+        """Compile a common context block and child-specific deltas."""
+        return await self._call("context_bundle", params)
+
+    async def block_get(self, **params: Any) -> Any:
+        """Return one stored context block by UUID, its 'blocks'/'content' entries paginated (bounded default 50, max 200 per page; small blocks return unchanged in one call)."""
+        return await self._call("block_get", params)
+
+    async def block_rebuild(self, **params: Any) -> Any:
+        """Rebuild stored context blocks in batch against the current working state and return summary-only rows with a total/limit/offset envelope."""
+        return await self._call("block_rebuild", params)
+
+    async def block_list(self, **params: Any) -> Any:
+        """List a paginated page of stored context block records for a plan."""
+        return await self._call("block_list", params)
+
+    async def branch_dump(self, **params: Any) -> Any:
+        """Write the executor prompt of every branch of the plan under the configured export root as an explicitly non-authoritative derived snapshot."""
+        return await self._call("branch_dump", params)
+
+    async def branch_weak(self, **params: Any) -> Any:
+        """Rank the plan's branches by ascending semantic index, refusing when the plan has not passed the mechanical gate."""
+        return await self._call("branch_weak", params)
+
+    async def branch_readiness(self, **params: Any) -> Any:
+        """Show whether each branch of the plan is ready and the path from its G to its first blocker, from stored readiness flags in one query."""
+        return await self._call("branch_readiness", params)
+
+    async def plan_validate(self, **params: Any) -> Any:
+        """Run the mechanical gate over a plan or one branch and report PASS/FAIL findings."""
+        return await self._call("plan_validate", params)
+
+    async def prompt_validate(self, **params: Any) -> Any:
+        """Run the deterministic prompt contour (16 prompt_integrity checks: 15 engine checks and the plan contract check) over a plan or one branch."""
+        return await self._call("prompt_validate", params)
+
+    async def run_all_checks(self, **params: Any) -> Any:
+        """Run every deterministic check surface (nine) over a plan or one branch and report one verdict."""
+        return await self._call("run_all_checks", params)
+
+    async def plan_score(self, **params: Any) -> Any:
+        """Run the semantic scoring layer over a plan or one branch and return index, trust, and color."""
+        return await self._call("plan_score", params)
+
+    async def plan_unfreeze(self, **params: Any) -> Any:
+        """Reopen the frozen steps of a plan (or of one branch: a step, its descendants and its ancestors, or of one HRS paragraph: the closure of its label) as drafts; dry_run lists them without writing; audited, one plan version, no cascade."""
+        return await self._call("plan_unfreeze", params)
+
+    async def plan_version_list(self, **params: Any) -> Any:
+        """List the versions of a plan (the database version history), newest first."""
+        return await self._call("plan_version_list", params)
+
+    async def plan_version_diff(self, **params: Any) -> Any:
+        """Compare two versions of a plan chosen by date: added, removed and changed records."""
+        return await self._call("plan_version_diff", params)
+
+    async def plan_rollback(self, **params: Any) -> Any:
+        """Return a plan to its state at a date: the version with the greatest creation date not later than it."""
+        return await self._call("plan_rollback", params)
+
+    async def srt_snapshot_create(self, **params: Any) -> Any:
+        """Create a semantic tree snapshot: the sole write operation of the SRT command surface. Snapshots the plan head."""
+        return await self._call("srt_snapshot_create", params)
+
+    async def srt_snapshot_list(self, **params: Any) -> Any:
+        """List a paginated page of the retained history of semantic tree snapshots for a plan, newest first, metadata only by default (view="summary"); pass view="full" for the complete record including tree_content (read-only)."""
+        return await self._call("srt_snapshot_list", params)
+
+    async def srt_diff(self, **params: Any) -> Any:
+        """Compute the semantic diff between two semantic tree snapshots (read-only)."""
+        return await self._call("srt_diff", params)
+
+    async def info(self, **params: Any) -> Any:
+        """Return the server self-description in pages of at most 16384 bytes: without section a first page (identity, build, runtime, contents with ready refs); with section, subsection, path, limit and offset one page of that node; follow next_offset until has_more is false (read-only)."""
+        return await self._call("info", params)
+
+    async def plan_text_check(self, **params: Any) -> Any:
+        """Check one plan text (form a: text with kind) or every stored text of a plan (form b: plan, with changed, step (the uuid4 of a step), limit and offset); read-only, nothing is written."""
+        return await self._call("plan_text_check", params)
+
+    async def command_catalog_dump(self, **params: Any) -> Any:
+        """Return the complete machine-readable command catalog, generated from the live command inventory."""
+        return await self._call("command_catalog_dump", params)
+
+    async def ops_status(self, **params: Any) -> Any:
+        """Return the deployed version, health state, and applied schema_migration rows in one read-only call."""
+        return await self._call("ops_status", params)
+
+    async def command_timing_stats(self, **params: Any) -> Any:
+        """Aggregate the command_metric store into per-command call counts and p50/p95/max latency percentiles (read-only, paginated)."""
+        return await self._call("command_timing_stats", params)
+
+    async def step_prompt_verify(self, **params: Any) -> Any:
+        """Compare candidate artifact content against a frozen step's content, field, or fenced code block, returning a match verdict (read-only, never mutates)."""
+        return await self._call("step_prompt_verify", params)
+
+    async def audit_list(self, **params: Any) -> Any:
+        """List runtime audit log entries newest-first, filterable by actor, action, entity, and time window (read-only, paginated)."""
+        return await self._call("audit_list", params)
+
+    async def runtime_purge_batch(self, **params: Any) -> Any:
+        """Purge a batch of already soft-deleted rows of one entity type, reporting per-row removals and reference-blocked refusals."""
+        return await self._call("runtime_purge_batch", params)
+
+    async def garbage_find(self, **params: Any) -> Any:
+        """List the lost records (owner, parent or anchor missing from the registry), the surplus records (test leftovers by creator prefix and age) or the registry rows without a record (group registry) that garbage_purge would remove (read-only, paginated)."""
+        return await self._call("garbage_find", params)
+
+    async def garbage_purge(self, **params: Any) -> Any:
+        """Remove exactly the records garbage_find lists for the same parameters, with their dependants, in one transaction (dry_run=true by default; optional ids narrow the selection)."""
+        return await self._call("garbage_purge", params)
+
+    async def reference_inspect(self, **params: Any) -> Any:
+        """Inspect the cross-entity reference graph around one entity: which live rows point at it, optionally traversed transitively with cycle detection (read-only, paginated)."""
+        return await self._call("reference_inspect", params)
+
+    async def id_resolve(self, **params: Any) -> Any:
+        """Resolve a partial identifier (any fragment of a UUID) to the full identifier(s) it matches, with each match's entity type and label (read-only, paginated)."""
+        return await self._call("id_resolve", params)
+
+    async def reference_repair(self, **params: Any) -> Any:
+        """Find dangling scalar UUID references (read-only), clear a statically-nullable one, or remove the carrier of one that cannot be cleared (dry_run=true by default for the destructive path)."""
+        return await self._call("reference_repair", params)
+
+
+__all__ = ["ContextGateCommandsMixin"]

plan_manager_client/facade_entity_common_mixin.py

@@ -0,0 +1,38 @@
+"""Entity common operations command-family facade mixin.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class EntityCommonCommandsMixin:
+    """One method per plan_manager command in the entity common operations family.
+
+    Assumes it is mixed into a class that also inherits
+    plan_manager_client.dispatch._CommandDispatchMixin, which supplies the
+    coroutine async def _call(self, command: str, params: dict[str, Any] | None = None) -> Any
+    used by every method below.
+    """
+
+    async def entity_reparent(self, **params: Any) -> Any:
+        """Reparent an entity to a new parent in the hierarchy."""
+        return await self._call("entity_reparent", params)
+
+    async def entity_copy(self, **params: Any) -> Any:
+        """Copy entities with everything they own under a new owner (new ids, the structure kept)."""
+        return await self._call("entity_copy", params)
+
+    async def entity_restore(self, **params: Any) -> Any:
+        """Clear the deletion mark of entities of any kind; recursive=true also clears the marked records they own."""
+        return await self._call("entity_restore", params)
+
+    async def entity_traversal(self, **params: Any) -> Any:
+        """Traverse the entity hierarchy with filtering and pagination."""
+        return await self._call("entity_traversal", params)
+
+
+__all__ = ["EntityCommonCommandsMixin"]