plan-manager-client 0.1.52__py3-none-any.whl

plan_manager_client/__init__.py

@@ -0,0 +1,9 @@
+"""plan_manager_client: first-class client library for the plan_manager JSON-RPC API.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+__version__ = "0.1.52"
+
+__all__: list[str] = []

plan_manager_client/client.py

@@ -0,0 +1,64 @@
+"""Composed full-surface facade client for the plan_manager JSON-RPC API.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mcp_proxy_adapter.client.jsonrpc_client.client import JsonRpcClient
+
+from plan_manager_client.dispatch import _CommandDispatchMixin
+from plan_manager_client.facade_bug_project_mixin import BugProjectCommandsMixin
+from plan_manager_client.facade_context_gate_mixin import ContextGateCommandsMixin
+from plan_manager_client.facade_plan_hrs_mixin import PlanHrsCommandsMixin
+from plan_manager_client.facade_runtime_mixin import RuntimeCommandsMixin
+from plan_manager_client.facade_step_graph_mixin import StepGraphCommandsMixin
+
+
+class PlanManagerClient(
+    _CommandDispatchMixin,
+    PlanHrsCommandsMixin,
+    StepGraphCommandsMixin,
+    ContextGateCommandsMixin,
+    RuntimeCommandsMixin,
+    BugProjectCommandsMixin,
+):
+    """Full command-surface facade for the plan_manager JSON-RPC API.
+
+    Composes (HOLDS, never inherits) a
+    mcp_proxy_adapter.client.jsonrpc_client.client.JsonRpcClient on the private
+    attribute ``self._rpc``, which supplies transport (http/https/mTLS), token
+    authentication, queued-job polling, and chunked file transfer with sha256
+    verification and resume. Because the transport client is held rather than
+    inherited, the network interaction is fully hidden: the public surface of
+    this class is exactly one public async method per plan_manager command,
+    contributed by the internal _call dispatch coroutine (queued-command
+    auto-polling per queue_get_job_status semantics) from _CommandDispatchMixin
+    and the five command-family mixins, together covering every name in
+    plan_manager_client.server_api.COMMAND_NAMES. Construct directly with the
+    JsonRpcClient constructor arguments, or via
+    PlanManagerClient(**config.to_jsonrpc_kwargs()) using a
+    plan_manager_client.config.ClientConnectionConfig instance. Connections are
+    direct to the plan_manager server; this class performs no proxy call_server
+    routing.
+    """
+
+    def __init__(self, **jsonrpc_kwargs: Any) -> None:
+        """Compose the underlying JsonRpcClient from JsonRpcClient constructor kwargs.
+
+        Accepts exactly the keyword arguments of
+        mcp_proxy_adapter.client.jsonrpc_client.client.JsonRpcClient (protocol,
+        host, port, token_header, token, cert, key, ca, check_hostname,
+        timeout), so PlanManagerClient(**config.to_jsonrpc_kwargs()) from a
+        plan_manager_client.config.ClientConnectionConfig works directly. The
+        constructed client is stored on the private attribute self._rpc and is
+        never exposed as a public method, keeping the public surface exactly the
+        canonical command methods.
+        """
+        self._rpc = JsonRpcClient(**jsonrpc_kwargs)
+
+
+__all__ = ["PlanManagerClient"]

plan_manager_client/config.py

@@ -0,0 +1,68 @@
+"""Direct-connection configuration for a single plan_manager_client server.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class ClientConnectionConfig:
+    """Direct-connection parameters for one JSON-RPC server.
+
+    Mirrors, field for field, the constructor of
+    mcp_proxy_adapter.client.jsonrpc_client.client.JsonRpcClient:
+
+        def __init__(
+            self,
+            protocol: str = "http",
+            host: str = "127.0.0.1",
+            port: int = 8080,
+            token_header: Optional[str] = None,
+            token: Optional[str] = None,
+            cert: Optional[str] = None,
+            key: Optional[str] = None,
+            ca: Optional[str] = None,
+            check_hostname: bool = False,
+            timeout: Optional[float] = None,
+        ) -> None: ...
+
+    Instances are immutable. Use to_jsonrpc_kwargs() to build the keyword
+    arguments for JsonRpcClient(**kwargs) or for any other client built on the
+    same constructor shape (for example a code-analysis-client construction
+    helper), so one configuration entity serves either server.
+    """
+
+    protocol: str = "http"
+    host: str = "127.0.0.1"
+    port: int = 8080
+    token_header: Optional[str] = None
+    token: Optional[str] = None
+    cert: Optional[str] = None
+    key: Optional[str] = None
+    ca: Optional[str] = None
+    check_hostname: bool = False
+    timeout: Optional[float] = None
+
+    def to_jsonrpc_kwargs(self) -> dict[str, Any]:
+        """Return constructor kwargs for JsonRpcClient(**kwargs)."""
+        return {
+            "protocol": self.protocol,
+            "host": self.host,
+            "port": self.port,
+            "token_header": self.token_header,
+            "token": self.token,
+            "cert": self.cert,
+            "key": self.key,
+            "ca": self.ca,
+            "check_hostname": self.check_hostname,
+            "timeout": self.timeout,
+        }
+
+
+__all__ = ["ClientConnectionConfig"]

plan_manager_client/delivery/__init__.py

@@ -0,0 +1,7 @@
+"""Delivery module boundary for the plan_manager client library.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+This sub-package establishes the two-path delivery model (C-001) structurally: the module boundary where Path A (a code-analysis project specified; delivered by a later G-005 branch) and Path B (no project specified; delivered by a later G-004 branch) each add their own composition module, both consuming the plan_manager_client facade (client/plan_manager_client/client.py) and, for Path A, the code-analysis-client dependency. This package intentionally defines no dataclasses, function signatures, or interface contracts here: those are the design decisions of the G-004 and G-005 branches that will populate this sub-package, per the L1 ruling (decision comment 10eba9c2 resolving escalation 4f4a04bb) that this branch (G-003) must make the module boundary explicit without pre-empting their design.
+"""

plan_manager_client/delivery/archive.py

@@ -0,0 +1,140 @@
+"""Path A verified export tree materialization from the archive.
+
+Verifies the retrieved export archive against its declared sha256 BEFORE
+unpacking anything (DeliveryIntegrityContract, MRS concept C-007), then
+unpacks the gzip-compressed tar in memory into ordered tree entries that
+preserve every original name and relative position (ExportArchive, MRS
+concept C-016). Every entry is validated before any entry is materialized,
+so a refusal leaves nothing behind. Nothing enumerates an export, so the
+archive is the only way Path A obtains a whole tree. Produces no local
+files.
+"""
+
+from __future__ import annotations
+import hashlib
+import io
+import tarfile
+from dataclasses import dataclass
+
+
+class ArchiveIntegrityError(Exception):
+    """Raised when the export archive does not match its declared sha256.
+
+    Raised by :func:`materialize_tree` before any unpacking is attempted,
+    per DeliveryIntegrityContract (MRS concept C-007). Nothing is unpacked
+    and nothing reaches any destination when this is raised.
+    """
+    pass
+
+
+class ArchiveEntryRefusedError(Exception):
+    """Raised when an archive entry is refused during validation.
+
+    Raised by :func:`materialize_tree` for an entry whose stored path is
+    absolute or contains a '..' segment, or which is neither a regular
+    file nor a directory. Per ExportArchive (MRS concept C-016) every
+    entry is validated before any entry is materialized, so a refusal
+    leaves nothing behind.
+    """
+    pass
+
+
+@dataclass(frozen=True)
+class TreeEntry:
+    """One file of the verified export tree, in memory.
+
+    Attributes:
+        relative_path: The entry's POSIX path relative to the plan export
+            root, exactly as stored in the archive (for example
+            'spec.yaml' or 'G-001-foo/T-001-bar/atomic_steps/A-001-baz.yaml').
+        content: The entry's unpacked bytes, byte-for-byte as archived.
+        sha256: The hex sha256 digest computed over content.
+    """
+    relative_path: str
+    content: bytes
+    sha256: str
+
+
+def _validate_member(member: tarfile.TarInfo) -> None:
+    """Validate one archive member, refusing it if it is unsafe.
+
+    Args:
+        member: The archive member to validate.
+
+    Raises:
+        ArchiveEntryRefusedError: If member is neither a regular file nor
+            a directory, or if member.name starts with '/' or any
+            '/'-separated segment of member.name equals '..'.
+    """
+    if not member.isfile() and not member.isdir():
+        raise ArchiveEntryRefusedError(
+            f"archive entry is neither a regular file nor a directory: {member.name!r}"
+        )
+
+    if member.name.startswith('/') or '..' in member.name.split('/'):
+        raise ArchiveEntryRefusedError(
+            f"archive entry escapes the destination: {member.name!r}"
+        )
+
+
+def materialize_tree(
+    archive_bytes: bytes,
+    declared_archive_sha256: str,
+) -> list[TreeEntry]:
+    """Verify the archive, then unpack its tree in memory.
+
+    Validation is exhaustive and precedes materialization: every member is
+    validated before any member's bytes are read, so a refusal returns
+    nothing and leaves nothing behind (ExportArchive, MRS concept C-016).
+
+    Args:
+        archive_bytes: The already-retrieved archive content, a
+            gzip-compressed tar.
+        declared_archive_sha256: The archive's declared whole-archive
+            sha256 hex digest.
+
+    Returns:
+        The tree entries in the order the archive stores them, each
+        carrying its export-root-relative path, its unpacked content, and
+        the sha256 computed over that content. Directory members are
+        skipped rather than returned.
+
+    Raises:
+        ArchiveIntegrityError: If sha256(archive_bytes) does not equal
+            declared_archive_sha256. Raised before any unpacking; nothing
+            is unpacked.
+        ArchiveEntryRefusedError: If ANY member is refused by
+            _validate_member. Raised during the validation pass, before
+            any member's bytes are read, so no entry is returned.
+    """
+    computed = hashlib.sha256(archive_bytes).hexdigest()
+
+    if computed != declared_archive_sha256:
+        raise ArchiveIntegrityError(
+            f"archive digest mismatch: expected {declared_archive_sha256}, computed {computed}"
+        )
+
+    with tarfile.open(fileobj=io.BytesIO(archive_bytes), mode="r:gz") as tar:
+        # Validation pass: exhaustive check before any materialization
+        members = tar.getmembers()
+        for member in members:
+            _validate_member(member)
+
+        # Materialization pass: extract bytes and build entries
+        result: list[TreeEntry] = []
+        for member in members:
+            if member.isdir():
+                continue
+
+            extracted_file = tar.extractfile(member)
+            content = extracted_file.read()
+            entry_digest = hashlib.sha256(content).hexdigest()
+            result.append(
+                TreeEntry(
+                    relative_path=member.name,
+                    content=content,
+                    sha256=entry_digest,
+                )
+            )
+
+        return result

plan_manager_client/delivery/atomicity.py

@@ -0,0 +1,93 @@
+"""Path A failure atomicity and partial-write outcome tracking.
+
+Assembles the delivery outcome record naming exactly which destination
+paths were written and whether a commit was made, distinguishing every
+abort point of the Path A composition, realizing DeliveryFailureAtomicity
+(MRS concept C-011). An archive-verification or archive-entry-refusal
+abort leaves nothing behind, so the record cannot express either of them
+alongside written paths.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+FailurePoint = Literal["archive_verification", "archive_entry_refused", "digest_verification", "upload", "commit"]
+# The Path A composition stage at which a delivery failed, when it failed (MRS concept C-011).
+
+
+@dataclass(frozen=True)
+class DeliveryOutcome:
+    """Outcome of one Path A delivery attempt.
+
+    Attributes:
+        written_paths: Destination paths successfully written to the CA
+            project during this attempt, in delivery order, each carrying
+            its entry's relative position beneath the destination
+            subdirectory.
+        commit_made: True when a git commit was made for this attempt.
+        commit_hash: The git commit hash, when commit_made is True;
+            otherwise None.
+        failure_point: The composition stage at which the delivery failed,
+            or None when the delivery completed successfully. A failure at
+            'archive_verification' or 'archive_entry_refused' always
+            carries an empty written_paths: the archive was rejected or
+            the whole tree was refused before any entry was materialized,
+            so nothing was written and nothing was left behind.
+    """
+
+    written_paths: list[str] = field(default_factory=list)
+    commit_made: bool = False
+    commit_hash: Optional[str] = None
+    failure_point: Optional[FailurePoint] = None
+
+
+_VALID_FAILURE_POINTS: tuple[str, ...] = ("archive_verification", "archive_entry_refused", "digest_verification", "upload", "commit")
+
+_NOTHING_WRITTEN_FAILURE_POINTS: tuple[str, ...] = ("archive_verification", "archive_entry_refused")
+# Abort points that precede every write: the archive never verified, or the whole tree was refused before any entry was materialized. Both leave nothing behind, so neither can accompany a non-empty written_paths.
+
+
+def build_delivery_outcome(
+    written_paths: list[str],
+    commit_hash: Optional[str],
+    failure_point: Optional[FailurePoint] = None,
+) -> DeliveryOutcome:
+    """Assemble a DeliveryOutcome from one Path A delivery attempt's results.
+
+    Args:
+        written_paths: Destination paths successfully written during this
+            attempt, in delivery order.
+        commit_hash: The git commit hash if a commit was made, else None.
+        failure_point: The stage at which the delivery failed, or None for
+            a fully successful delivery.
+
+    Returns:
+        A DeliveryOutcome with commit_made set to (commit_hash is not
+        None), and written_paths, commit_hash, failure_point carried
+        through unchanged (written_paths copied, not aliased).
+
+    Raises:
+        ValueError: If failure_point is not None and not one of
+            'archive_verification', 'archive_entry_refused',
+            'digest_verification', 'upload', 'commit'; or if
+            failure_point is 'archive_verification' or
+            'archive_entry_refused' while written_paths is non-empty,
+            which is an impossible outcome because both abort points
+            precede every write and leave nothing behind.
+    """
+    if failure_point is not None and failure_point not in _VALID_FAILURE_POINTS:
+        raise ValueError(f"invalid failure_point: {failure_point!r}")
+
+    if failure_point in _NOTHING_WRITTEN_FAILURE_POINTS and len(written_paths) > 0:
+        raise ValueError(f"failure_point {failure_point!r} leaves nothing behind but written_paths is non-empty: {list(written_paths)!r}")
+
+    commit_made = commit_hash is not None
+
+    return DeliveryOutcome(
+        written_paths=list(written_paths),
+        commit_made=commit_made,
+        commit_hash=commit_hash,
+        failure_point=failure_point,
+    )

plan_manager_client/delivery/commit.py

@@ -0,0 +1,113 @@
+"""Path A explicit git staging and commit composition.
+
+After the tree upload phase, explicitly stages the written destination
+paths and issues an explicit commit through the CA service's own client
+(CodeAnalysisClientDependency, MRS concept C-015), independent of the CA
+service's commit-on-write configuration, realizing the commit phase of
+PathACodeAnalysisDelivery (MRS concept C-003) and the deterministic-message
+requirement of DeliveryFailureAtomicity (MRS concept C-011).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional
+from code_analysis_client.client import CodeAnalysisAsyncClient
+
+
+@dataclass(frozen=True)
+class CommitReceipt:
+    """Outcome of the explicit git staging and commit composition.
+
+    Attributes:
+        commit_hash: The git commit hash the CA client returned, or None
+            when no commit was made (empty written_paths).
+        commit_message: The deterministic commit message text used, or
+            an empty string when no commit was made.
+    """
+
+    commit_hash: Optional[str]
+    commit_message: str
+
+
+def build_commit_message(
+    plan_name: str,
+    export_revision_uuid: str,
+    per_entry_digest_set: dict[str, str],
+) -> str:
+    """Build the deterministic Path A commit message.
+
+    Args:
+        plan_name: Name of the plan being delivered.
+        export_revision_uuid: Revision uuid of the export being delivered.
+        per_entry_digest_set: Mapping of each delivered tree entry's path
+            relative to the plan export root to its sha256 hex digest.
+
+    Returns:
+        A deterministic multi-line commit message: a header line naming
+        plan_name and export_revision_uuid, followed by one line per entry
+        of per_entry_digest_set sorted by relative path ascending (str
+        order), each formatted as two spaces then
+        '{relative_path}: sha256:{digest}'. Sorting makes the message
+        reproducible across retried deliveries regardless of input dict
+        ordering.
+    """
+    header = f"plan_manager export delivery: {plan_name} (revision {export_revision_uuid})"
+    lines = [header] + [f"  {relative_path}: sha256:{digest}" for relative_path, digest in sorted(per_entry_digest_set.items())]
+    return "\n".join(lines)
+
+
+async def stage_and_commit(
+    ca_client: CodeAnalysisAsyncClient,
+    resolved_project_id: str,
+    written_paths: list[str],
+    plan_name: str,
+    export_revision_uuid: str,
+    per_entry_digest_set: dict[str, str],
+) -> CommitReceipt:
+    """Explicitly stage and commit the written Path A tree.
+
+    Args:
+        ca_client: An already-connected CodeAnalysisAsyncClient instance
+            (MRS concept C-015); this function does not construct or
+            close it.
+        resolved_project_id: The CA project_id the tree was written into.
+        written_paths: Destination paths successfully uploaded, each
+            carrying its entry's relative position beneath the destination
+            subdirectory.
+        plan_name: Name of the plan being delivered.
+        export_revision_uuid: Revision uuid of the export being delivered.
+        per_entry_digest_set: Mapping of each delivered tree entry's
+            export-root-relative path to its sha256 digest.
+
+    Returns:
+        A CommitReceipt. When written_paths is empty, CommitReceipt(None, '')
+        is returned without any CA git call. Otherwise the CA client's
+        git_add is called with resolved_project_id and written_paths, then
+        its git_commit is called with resolved_project_id and the message
+        from build_commit_message; the returned CommitReceipt carries the
+        commit hash the CA client reports and the message used.
+    """
+    if len(written_paths) == 0:
+        return CommitReceipt(commit_hash=None, commit_message="")
+
+    await ca_client.commands.git_add(project_id=resolved_project_id, paths=written_paths)
+
+    message = build_commit_message(plan_name, export_revision_uuid, per_entry_digest_set)
+
+    result = await ca_client.commands.git_commit(project_id=resolved_project_id, message=message)
+
+    def extract_commit_hash(result_obj):
+        # Try attribute access first
+        if hasattr(result_obj, 'commit_hash'):
+            return result_obj.commit_hash
+        # Try dict-like access
+        try:
+            return result_obj["commit_hash"]
+        except (TypeError, KeyError):
+            pass
+        # Fall back to str
+        return str(result_obj)
+
+    commit_hash = extract_commit_hash(result)
+
+    return CommitReceipt(commit_hash=commit_hash, commit_message=message)

plan_manager_client/delivery/destination.py

@@ -0,0 +1,140 @@
+"""Path A destination resolution: CA project binding and tree paths.
+
+Resolves the target code-analysis project identity under SHARED PROJECT
+IDENTITY (DeliveryDestinationAddressing, MRS concept C-006) and maps each
+export tree entry to its destination path inside the project's
+documentation area, preserving the entry's relative position beneath the
+destination subdirectory so the delivered tree reproduces the export
+layout (PathACodeAnalysisDelivery, MRS concept C-003).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+class NoBoundProjectError(Exception):
+    """Raised when a Path A delivery is attempted with no bound CA project.
+
+    Raised by :func:`resolve_destination` when both ``plan_project_binding``
+    and ``project_id_override`` are ``None``: SHARED PROJECT IDENTITY (C-006)
+    requires the plan to carry a bound primary code-analysis project_id, or
+    an explicit override, before a Path A call may proceed.
+    """
+    pass
+
+
+class DestinationPathTraversalError(Exception):
+    """Raised when a resolved destination path escapes the project root.
+
+    Raised by :func:`resolve_destination` when the destination subdirectory
+    or a per-entry destination path is absolute or contains a '..' path
+    segment, per the traversal-refusal rule of DeliveryDestinationAddressing
+    (MRS concept C-006).
+    """
+    pass
+
+
+DEFAULT_DESTINATION_SUBDIRECTORY_TEMPLATE: str = "docs/plan-exports/{plan_name}/"
+# Default destination subdirectory template (MRS concept C-006); it roots the delivered tree and is formatted with plan_name when the caller supplies no override.
+
+
+@dataclass(frozen=True)
+class ResolvedDestination:
+    """Resolved CA project and per-entry destination paths for Path A.
+
+    Attributes:
+        resolved_project_id: The code-analysis project_id the delivery
+            will write into.
+        resolved_destination_subdirectory: The destination documentation
+            subdirectory rooting the delivered tree, project-relative
+            POSIX, always ending in a single trailing '/'.
+        resolved_destination_paths: Ordered per-entry project-relative
+            POSIX destination paths, one per entry of tree_relative_paths
+            in the same order, each preserving that entry's relative
+            position beneath the subdirectory.
+    """
+    resolved_project_id: str
+    resolved_destination_subdirectory: str
+    resolved_destination_paths: list[str] = field(default_factory=list)
+
+
+def _reject_traversal(path: str) -> None:
+    """Raise DestinationPathTraversalError for an unsafe POSIX path.
+
+    Args:
+        path: A POSIX path string to validate.
+
+    Raises:
+        DestinationPathTraversalError: If path starts with '/' or any
+            '/'-separated segment of path equals '..'.
+    """
+    if path.startswith('/') or '..' in path.split('/'):
+        raise DestinationPathTraversalError(f"destination path escapes the project root: {path!r}")
+
+
+def resolve_destination(
+        plan_name: str,
+        tree_relative_paths: list[str],
+        plan_project_binding: Optional[str],
+        project_id_override: Optional[str] = None,
+        destination_subdirectory_override: Optional[str] = None,
+    ) -> ResolvedDestination:
+    """Resolve the CA project and per-entry destination paths for Path A.
+
+    Args:
+        plan_name: Name of the plan being delivered; used to format the
+            default destination subdirectory when no override is supplied.
+        tree_relative_paths: The export tree entries' POSIX paths relative
+            to the plan export root, in tree order. These are nested paths
+            such as 'spec.yaml' or
+            'G-001-x/T-001-y/atomic_steps/A-001-z.yaml'; their relative
+            position is preserved into the destination.
+        plan_project_binding: The plan's bound primary code-analysis
+            project_id, or None when the plan has no bound project.
+        project_id_override: An explicit code-analysis project_id supplied
+            by the caller; takes precedence over plan_project_binding when
+            not None.
+        destination_subdirectory_override: An explicit destination
+            documentation subdirectory rooting the delivered tree; when
+            None, the default template formatted with plan_name is used.
+
+    Returns:
+        A ResolvedDestination carrying the resolved project_id, the
+        resolved destination subdirectory (normalized to end with a single
+        trailing '/'), and the per-entry destination paths in the same
+        order as tree_relative_paths.
+
+    Raises:
+        NoBoundProjectError: If both plan_project_binding and
+            project_id_override are None.
+        DestinationPathTraversalError: If the resolved destination
+            subdirectory is unsafe per _reject_traversal, or if any entry
+            of tree_relative_paths is itself unsafe per _reject_traversal,
+            or if any resolved destination path is unsafe per
+            _reject_traversal.
+    """
+    resolved_project_id = project_id_override if project_id_override is not None else plan_project_binding
+
+    if resolved_project_id is None:
+        raise NoBoundProjectError("Path A delivery requires a bound or overridden CA project_id")
+
+    subdirectory = destination_subdirectory_override if destination_subdirectory_override else DEFAULT_DESTINATION_SUBDIRECTORY_TEMPLATE.format(plan_name=plan_name)
+
+    if not subdirectory.endswith('/'):
+        subdirectory = subdirectory + '/'
+
+    _reject_traversal(subdirectory)
+
+    destination_paths = []
+    for relative_path in tree_relative_paths:
+        _reject_traversal(relative_path)
+        candidate = subdirectory + relative_path
+        _reject_traversal(candidate)
+        destination_paths.append(candidate)
+
+    return ResolvedDestination(
+        resolved_project_id=resolved_project_id,
+        resolved_destination_subdirectory=subdirectory,
+        resolved_destination_paths=destination_paths
+    )