specfact-cli 0.4.0__py3-none-any.whl

specfact_cli/common/logging_utils.py

@@ -0,0 +1,41 @@
+"""Logging helpers with graceful fallback when SpecFact CLI common module is unavailable."""
+
+from __future__ import annotations
+
+import logging
+
+from beartype import beartype
+from icontract import ensure, require
+
+
+@beartype
+@require(lambda name: isinstance(name, str) and len(name) > 0, "Name must be non-empty string")
+@require(lambda level: isinstance(level, str) and len(level) > 0, "Level must be non-empty string")
+@ensure(lambda result: isinstance(result, logging.Logger), "Must return Logger instance")
+def get_bridge_logger(name: str, level: str = "INFO") -> logging.Logger:
+    """
+    Retrieve a configured logger.
+
+    If the SpecFact CLI `common.logger_setup` module is available we reuse it, otherwise
+    we create a standard library logger to keep the bridge self-contained.
+    """
+    logger = _try_common_logger(name, level)
+    if logger is not None:
+        return logger
+
+    fallback_logger = logging.getLogger(name)
+    if not fallback_logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s")
+        handler.setFormatter(formatter)
+        fallback_logger.addHandler(handler)
+    fallback_logger.setLevel(level.upper())
+    return fallback_logger
+
+
+def _try_common_logger(name: str, level: str) -> logging.Logger | None:
+    try:
+        from specfact_cli.common.logger_setup import LoggerSetup  # type: ignore[import]
+    except ImportError:
+        return None
+    return LoggerSetup.create_logger(name, log_level=level)

specfact_cli/common/text_utils.py

@@ -0,0 +1,52 @@
+"""
+Text utility functions for SpecFact CLI modules
+"""
+
+import re
+import textwrap
+
+from beartype import beartype
+from icontract import ensure, require
+
+
+class TextUtils:
+    """A utility class for text manipulation."""
+
+    @staticmethod
+    @beartype
+    @require(lambda max_length: max_length > 0, "Max length must be positive")
+    @ensure(lambda result: result is None or isinstance(result, str), "Must return None or string")
+    def shorten_text(text: str | None, max_length: int = 50) -> str | None:
+        """Shorten text to a maximum length, appending '...' if truncated."""
+        if text is None:
+            return None
+        return text if len(text) <= max_length else text[:max_length] + "..."
+
+    @staticmethod
+    @beartype
+    @require(lambda code: isinstance(code, str), "Code must be string")
+    @ensure(lambda result: isinstance(result, str), "Must return string")
+    def clean_code(code: str) -> str:
+        """
+        Extract code from markdown triple-backtick fences. If multiple fenced
+        blocks are present, only the first block is returned. Language hints
+        (e.g. ```python) are stripped. Leading indentation inside the block is
+        removed via ``textwrap.dedent`` to make assertions deterministic.
+        """
+        # Use regex that handles both real newline and literal \n inside the string.
+        pattern = r"```(?:[a-zA-Z0-9_-]+)?(?:\\n|\n)([\s\S]*?)```"
+        match = re.search(pattern, code)
+
+        if not match:
+            return code.strip()
+
+        content = match.group(1)
+
+        # Dedent and strip
+        content = textwrap.dedent(content).strip()
+        # If the cleaned content ends with a *literal* "\\n" sequence (common when the
+        # source string itself contains escaped new-line characters), remove it so that
+        # callers do not have to account for this artefact in expectations.
+        if content.endswith("\\n"):
+            content = content[:-2]
+        return content

specfact_cli/common/utils.py

@@ -0,0 +1,48 @@
+"""Utility helpers for the Spec-Kit compatibility layer."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from beartype import beartype
+from icontract import ensure, require
+
+
+@beartype
+@require(lambda path: isinstance(path, Path) and path.exists(), "Path must exist")
+@ensure(lambda result: isinstance(result, str) and result.startswith("sha256:"), "Must return sha256 hash string")
+def compute_sha256(path: Path) -> str:
+    """Compute the SHA256 hash of a file."""
+    hasher = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(65536), b""):
+            hasher.update(chunk)
+    return f"sha256:{hasher.hexdigest()}"
+
+
+@beartype
+@require(lambda path: isinstance(path, Path), "Path must be Path instance")
+def ensure_directory(path: Path) -> None:
+    """Ensure that the directory for *path* exists."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+@beartype
+@require(lambda path: isinstance(path, Path), "Path must be Path instance")
+def dump_json(data: Any, path: Path) -> None:
+    """Write *data* as formatted JSON to *path*."""
+    ensure_directory(path)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2, sort_keys=True)
+
+
+@beartype
+@require(lambda path: isinstance(path, Path) and path.exists(), "Path must exist")
+@ensure(lambda result: result is not None, "Must return parsed content")
+def load_json(path: Path) -> Any:
+    """Load JSON data from *path*."""
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)

specfact_cli/comparators/__init__.py

@@ -0,0 +1,10 @@
+"""
+Comparators module for SpecFact CLI.
+
+This module provides classes for comparing specifications, plans, and protocols
+to detect deviations and generate comparison reports.
+"""
+
+from specfact_cli.comparators.plan_comparator import PlanComparator
+
+__all__ = ["PlanComparator"]

specfact_cli/comparators/plan_comparator.py

@@ -0,0 +1,391 @@
+"""Plan comparator for detecting deviations between plan bundles."""
+
+from __future__ import annotations
+
+from beartype import beartype
+from icontract import ensure, require
+
+from specfact_cli.models.deviation import Deviation, DeviationReport, DeviationSeverity, DeviationType
+from specfact_cli.models.plan import PlanBundle
+from specfact_cli.utils.feature_keys import normalize_feature_key
+
+
+class PlanComparator:
+    """
+    Compares two plan bundles to detect deviations.
+
+    Identifies differences between manual (source of truth) and auto-derived
+    (reverse-engineered from code) plan bundles.
+    """
+
+    @beartype
+    @require(lambda manual_plan: isinstance(manual_plan, PlanBundle), "Manual plan must be PlanBundle instance")
+    @require(lambda auto_plan: isinstance(auto_plan, PlanBundle), "Auto plan must be PlanBundle instance")
+    @require(
+        lambda manual_label: isinstance(manual_label, str) and len(manual_label) > 0,
+        "Manual label must be non-empty string",
+    )
+    @require(
+        lambda auto_label: isinstance(auto_label, str) and len(auto_label) > 0, "Auto label must be non-empty string"
+    )
+    @ensure(lambda result: isinstance(result, DeviationReport), "Must return DeviationReport")
+    @ensure(lambda result: len(result.manual_plan) > 0, "Manual plan label must be non-empty")
+    @ensure(lambda result: len(result.auto_plan) > 0, "Auto plan label must be non-empty")
+    def compare(
+        self,
+        manual_plan: PlanBundle,
+        auto_plan: PlanBundle,
+        manual_label: str = "manual_plan",
+        auto_label: str = "auto_plan",
+    ) -> DeviationReport:
+        """
+        Compare two plan bundles and generate deviation report.
+
+        Args:
+            manual_plan: Manually created plan (source of truth)
+            auto_plan: Auto-derived plan from code analysis
+            manual_label: Label for manual plan (e.g., file path)
+            auto_label: Label for auto plan (e.g., file path)
+
+        Returns:
+            DeviationReport with all detected deviations
+        """
+        deviations: list[Deviation] = []
+
+        # Compare ideas
+        deviations.extend(self._compare_ideas(manual_plan, auto_plan))
+
+        # Compare business context
+        deviations.extend(self._compare_business(manual_plan, auto_plan))
+
+        # Compare product
+        deviations.extend(self._compare_product(manual_plan, auto_plan))
+
+        # Compare features
+        deviations.extend(self._compare_features(manual_plan, auto_plan))
+
+        # Build summary statistics
+        summary: dict[str, int] = {}
+        for deviation in deviations:
+            deviation_type = deviation.type.value
+            summary[deviation_type] = summary.get(deviation_type, 0) + 1
+
+        return DeviationReport(
+            manual_plan=manual_label,
+            auto_plan=auto_label,
+            deviations=deviations,
+            summary=summary,
+        )
+
+    def _compare_ideas(self, manual: PlanBundle, auto: PlanBundle) -> list[Deviation]:
+        """Compare idea sections of two plans."""
+        deviations: list[Deviation] = []
+
+        # Check if both have ideas
+        if manual.idea is None and auto.idea is None:
+            return deviations
+
+        if manual.idea is None and auto.idea is not None:
+            deviations.append(
+                Deviation(
+                    type=DeviationType.EXTRA_IMPLEMENTATION,
+                    severity=DeviationSeverity.LOW,
+                    description="Auto plan has Idea section but manual plan does not",
+                    location="idea",
+                    fix_hint="Consider removing auto-derived Idea or adding it to manual plan",
+                )
+            )
+            return deviations
+
+        if manual.idea is not None and auto.idea is None:
+            deviations.append(
+                Deviation(
+                    type=DeviationType.MISSING_FEATURE,
+                    severity=DeviationSeverity.MEDIUM,
+                    description="Manual plan has Idea section but auto plan does not",
+                    location="idea",
+                    fix_hint="Add Idea section to auto-derived plan",
+                )
+            )
+            return deviations
+
+        # Both have ideas, compare fields
+        if manual.idea is not None and auto.idea is not None:
+            if manual.idea.title != auto.idea.title:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.LOW,
+                        description=f"Idea title differs: manual='{manual.idea.title}', auto='{auto.idea.title}'",
+                        location="idea.title",
+                        fix_hint="Update auto plan title to match manual plan",
+                    )
+                )
+
+            if manual.idea.narrative != auto.idea.narrative:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.LOW,
+                        description="Idea narrative differs between plans",
+                        location="idea.narrative",
+                        fix_hint="Update narrative to match manual plan",
+                    )
+                )
+
+        return deviations
+
+    def _compare_business(self, manual: PlanBundle, auto: PlanBundle) -> list[Deviation]:
+        """Compare business context sections."""
+        deviations: list[Deviation] = []
+
+        if manual.business is not None and auto.business is None:
+            deviations.append(
+                Deviation(
+                    type=DeviationType.MISSING_BUSINESS_CONTEXT,
+                    severity=DeviationSeverity.MEDIUM,
+                    description="Manual plan has Business context but auto plan does not",
+                    location="business",
+                    fix_hint="Add business context to auto-derived plan",
+                )
+            )
+
+        return deviations
+
+    def _compare_product(self, manual: PlanBundle, auto: PlanBundle) -> list[Deviation]:
+        """Compare product sections (themes, releases)."""
+        deviations: list[Deviation] = []
+
+        # Compare themes
+        manual_themes = set(manual.product.themes)
+        auto_themes = set(auto.product.themes)
+
+        missing_themes = manual_themes - auto_themes
+        extra_themes = auto_themes - manual_themes
+
+        for theme in missing_themes:
+            deviations.append(
+                Deviation(
+                    type=DeviationType.MISMATCH,
+                    severity=DeviationSeverity.LOW,
+                    description=f"Product theme '{theme}' in manual plan but not in auto plan",
+                    location="product.themes",
+                    fix_hint=f"Add theme '{theme}' to auto plan",
+                )
+            )
+
+        for theme in extra_themes:
+            deviations.append(
+                Deviation(
+                    type=DeviationType.MISMATCH,
+                    severity=DeviationSeverity.LOW,
+                    description=f"Product theme '{theme}' in auto plan but not in manual plan",
+                    location="product.themes",
+                    fix_hint=f"Remove theme '{theme}' from auto plan or add to manual",
+                )
+            )
+
+        return deviations
+
+    def _compare_features(self, manual: PlanBundle, auto: PlanBundle) -> list[Deviation]:
+        """Compare features between two plans using normalized keys."""
+        deviations: list[Deviation] = []
+
+        # Build feature maps by normalized key for comparison
+        manual_features_by_norm = {normalize_feature_key(f.key): f for f in manual.features}
+        auto_features_by_norm = {normalize_feature_key(f.key): f for f in auto.features}
+
+        # Also build by original key for display
+        manual_features = {f.key: f for f in manual.features}
+        auto_features = {f.key: f for f in auto.features}
+
+        # Check for missing features (in manual but not in auto) using normalized keys
+        for norm_key in manual_features_by_norm:
+            if norm_key not in auto_features_by_norm:
+                manual_feature = manual_features_by_norm[norm_key]
+                # Higher severity if feature has stories
+                severity = DeviationSeverity.HIGH if manual_feature.stories else DeviationSeverity.MEDIUM
+
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISSING_FEATURE,
+                        severity=severity,
+                        description=f"Feature '{manual_feature.key}' ({manual_feature.title}) in manual plan but not implemented",
+                        location=f"features[{manual_feature.key}]",
+                        fix_hint=f"Implement feature '{manual_feature.key}' or update manual plan",
+                    )
+                )
+
+        # Check for extra features (in auto but not in manual) using normalized keys
+        for norm_key in auto_features_by_norm:
+            if norm_key not in manual_features_by_norm:
+                auto_feature = auto_features_by_norm[norm_key]
+                # Higher severity if feature has many stories or high confidence
+                severity = DeviationSeverity.MEDIUM
+                if len(auto_feature.stories) > 3 or auto_feature.confidence >= 0.8:
+                    severity = DeviationSeverity.HIGH
+                elif len(auto_feature.stories) == 0 or auto_feature.confidence < 0.5:
+                    severity = DeviationSeverity.LOW
+
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.EXTRA_IMPLEMENTATION,
+                        severity=severity,
+                        description=f"Feature '{auto_feature.key}' ({auto_feature.title}) found in code but not in manual plan",
+                        location=f"features[{auto_feature.key}]",
+                        fix_hint=f"Add feature '{auto_feature.key}' to manual plan or remove from code",
+                    )
+                )
+
+        # Compare common features using normalized keys
+        common_norm_keys = set(manual_features_by_norm.keys()) & set(auto_features_by_norm.keys())
+        for norm_key in common_norm_keys:
+            manual_feature = manual_features_by_norm[norm_key]
+            auto_feature = auto_features_by_norm[norm_key]
+            key = manual_feature.key  # Use manual key for display
+
+            # Compare feature titles
+            if manual_feature.title != auto_feature.title:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.LOW,
+                        description=f"Feature '{key}' title differs: manual='{manual_feature.title}', auto='{auto_feature.title}'",
+                        location=f"features[{key}].title",
+                        fix_hint="Update feature title in code or manual plan",
+                    )
+                )
+
+            # Compare stories
+            deviations.extend(self._compare_stories(manual_feature, auto_feature, key))
+
+        return deviations
+
+    def _compare_stories(self, manual_feature, auto_feature, feature_key: str) -> list[Deviation]:
+        """Compare stories within a feature with enhanced detection."""
+        deviations: list[Deviation] = []
+
+        # Build story maps by key
+        manual_stories = {s.key: s for s in manual_feature.stories}
+        auto_stories = {s.key: s for s in auto_feature.stories}
+
+        # Check for missing stories
+        for key in manual_stories:
+            if key not in auto_stories:
+                manual_story = manual_stories[key]
+                # Higher severity if story has high value points or is not a draft
+                value_points = manual_story.value_points or 0
+                severity = (
+                    DeviationSeverity.HIGH
+                    if (value_points >= 8 or not manual_story.draft)
+                    else DeviationSeverity.MEDIUM
+                )
+
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISSING_STORY,
+                        severity=severity,
+                        description=f"Story '{key}' ({manual_story.title}) in manual plan but not implemented",
+                        location=f"features[{feature_key}].stories[{key}]",
+                        fix_hint=f"Implement story '{key}' or update manual plan",
+                    )
+                )
+
+        # Check for extra stories
+        for key in auto_stories:
+            if key not in manual_stories:
+                auto_story = auto_stories[key]
+                # Medium severity if story has high confidence or value points
+                value_points = auto_story.value_points or 0
+                severity = (
+                    DeviationSeverity.MEDIUM
+                    if (auto_story.confidence >= 0.8 or value_points >= 8)
+                    else DeviationSeverity.LOW
+                )
+
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.EXTRA_IMPLEMENTATION,
+                        severity=severity,
+                        description=f"Story '{key}' ({auto_story.title}) found in code but not in manual plan",
+                        location=f"features[{feature_key}].stories[{key}]",
+                        fix_hint=f"Add story '{key}' to manual plan or remove from code",
+                    )
+                )
+
+        # Compare common stories
+        common_keys = set(manual_stories.keys()) & set(auto_stories.keys())
+        for key in common_keys:
+            manual_story = manual_stories[key]
+            auto_story = auto_stories[key]
+
+            # Title mismatch
+            if manual_story.title != auto_story.title:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.LOW,
+                        description=f"Story '{key}' title differs: manual='{manual_story.title}', auto='{auto_story.title}'",
+                        location=f"features[{feature_key}].stories[{key}].title",
+                        fix_hint="Update story title in code or manual plan",
+                    )
+                )
+
+            # Acceptance criteria drift
+            manual_acceptance = set(manual_story.acceptance or [])
+            auto_acceptance = set(auto_story.acceptance or [])
+            if manual_acceptance != auto_acceptance:
+                missing_criteria = manual_acceptance - auto_acceptance
+                extra_criteria = auto_acceptance - manual_acceptance
+
+                if missing_criteria:
+                    deviations.append(
+                        Deviation(
+                            type=DeviationType.ACCEPTANCE_DRIFT,
+                            severity=DeviationSeverity.HIGH,
+                            description=f"Story '{key}' missing acceptance criteria: {', '.join(missing_criteria)}",
+                            location=f"features[{feature_key}].stories[{key}].acceptance",
+                            fix_hint=f"Ensure all acceptance criteria are implemented: {', '.join(missing_criteria)}",
+                        )
+                    )
+
+                if extra_criteria:
+                    deviations.append(
+                        Deviation(
+                            type=DeviationType.ACCEPTANCE_DRIFT,
+                            severity=DeviationSeverity.MEDIUM,
+                            description=f"Story '{key}' has extra acceptance criteria in code: {', '.join(extra_criteria)}",
+                            location=f"features[{feature_key}].stories[{key}].acceptance",
+                            fix_hint=f"Update manual plan to include: {', '.join(extra_criteria)}",
+                        )
+                    )
+
+            # Story points mismatch (if significant)
+            manual_points = manual_story.story_points or 0
+            auto_points = auto_story.story_points or 0
+            if abs(manual_points - auto_points) >= 3:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.MEDIUM,
+                        description=f"Story '{key}' story points differ significantly: manual={manual_points}, auto={auto_points}",
+                        location=f"features[{feature_key}].stories[{key}].story_points",
+                        fix_hint="Re-evaluate story complexity or update manual plan",
+                    )
+                )
+
+            # Value points mismatch (if significant)
+            manual_value = manual_story.value_points or 0
+            auto_value = auto_story.value_points or 0
+            if abs(manual_value - auto_value) >= 5:
+                deviations.append(
+                    Deviation(
+                        type=DeviationType.MISMATCH,
+                        severity=DeviationSeverity.MEDIUM,
+                        description=f"Story '{key}' value points differ significantly: manual={manual_value}, auto={auto_value}",
+                        location=f"features[{feature_key}].stories[{key}].value_points",
+                        fix_hint="Re-evaluate business value or update manual plan",
+                    )
+                )
+
+        return deviations

specfact_cli/generators/__init__.py

@@ -0,0 +1,13 @@
+"""Generators for plan bundles, protocols, reports, and workflows."""
+
+from specfact_cli.generators.plan_generator import PlanGenerator
+from specfact_cli.generators.protocol_generator import ProtocolGenerator
+from specfact_cli.generators.report_generator import ReportGenerator
+from specfact_cli.generators.workflow_generator import WorkflowGenerator
+
+__all__ = [
+    "PlanGenerator",
+    "ProtocolGenerator",
+    "ReportGenerator",
+    "WorkflowGenerator",
+]

specfact_cli/generators/plan_generator.py

@@ -0,0 +1,105 @@
+"""Plan bundle generator using direct YAML serialization."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from beartype import beartype
+from icontract import ensure, require
+from jinja2 import Environment, FileSystemLoader
+
+from specfact_cli.models.plan import PlanBundle
+from specfact_cli.utils.yaml_utils import dump_yaml, yaml_to_string
+
+
+class PlanGenerator:
+    """
+    Generator for plan bundle YAML files.
+
+    Uses direct YAML serialization for reliable output.
+    """
+
+    @beartype
+    def __init__(self, templates_dir: Path | None = None) -> None:
+        """
+        Initialize plan generator.
+
+        Args:
+            templates_dir: Directory containing Jinja2 templates (default: resources/templates)
+        """
+        if templates_dir is None:
+            # Default to resources/templates relative to project root
+            templates_dir = Path(__file__).parent.parent.parent.parent / "resources" / "templates"
+
+        self.templates_dir = Path(templates_dir)
+        self.env = Environment(
+            loader=FileSystemLoader(self.templates_dir),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    @beartype
+    @require(lambda plan_bundle: isinstance(plan_bundle, PlanBundle), "Must be PlanBundle instance")
+    @require(lambda output_path: output_path is not None, "Output path must not be None")
+    @ensure(lambda output_path: output_path.exists(), "Output file must exist after generation")
+    def generate(self, plan_bundle: PlanBundle, output_path: Path) -> None:
+        """
+        Generate plan bundle YAML file from model.
+
+        Args:
+            plan_bundle: PlanBundle model to generate from
+            output_path: Path to write the generated YAML file
+
+        Raises:
+            IOError: If unable to write output file
+        """
+        # Convert model to dict, excluding None values
+        plan_data = plan_bundle.model_dump(exclude_none=True)
+
+        # Write to file using YAML dump
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        dump_yaml(plan_data, output_path)
+
+    @beartype
+    @require(
+        lambda template_name: isinstance(template_name, str) and len(template_name) > 0,
+        "Template name must be non-empty string",
+    )
+    @require(lambda context: isinstance(context, dict), "Context must be dictionary")
+    @require(lambda output_path: output_path is not None, "Output path must not be None")
+    @ensure(lambda output_path: output_path.exists(), "Output file must exist after generation")
+    def generate_from_template(self, template_name: str, context: dict, output_path: Path) -> None:
+        """
+        Generate file from custom template.
+
+        Args:
+            template_name: Name of the template file
+            context: Context dictionary for template rendering
+            output_path: Path to write the generated file
+
+        Raises:
+            FileNotFoundError: If template file doesn't exist
+            IOError: If unable to write output file
+        """
+        template = self.env.get_template(template_name)
+        rendered = template.render(**context)
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(rendered, encoding="utf-8")
+
+    @beartype
+    @require(lambda plan_bundle: isinstance(plan_bundle, PlanBundle), "Must be PlanBundle instance")
+    @ensure(lambda result: isinstance(result, str), "Must return string")
+    @ensure(lambda result: len(result) > 0, "Result must be non-empty")
+    def render_string(self, plan_bundle: PlanBundle) -> str:
+        """
+        Render plan bundle to YAML string without writing to file.
+
+        Args:
+            plan_bundle: PlanBundle model to render
+
+        Returns:
+            Rendered YAML string
+        """
+        plan_data = plan_bundle.model_dump(exclude_none=True)
+        return yaml_to_string(plan_data)