codeboarding 0.9.5__tar.gz → 0.10.0__tar.gz

{codeboarding-0.9.5/codeboarding.egg-info → codeboarding-0.10.0}/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.9.5
+Version: 0.10.0
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
-License: MIT
+License-Expression: MIT
 Project-URL: Repository, https://github.com/CodeBoarding/CodeBoarding
 Project-URL: Documentation, https://github.com/CodeBoarding/CodeBoarding/blob/main/.codeboarding/overview.md
 Keywords: code-understanding,code-visualization,code-analysis,diagrams,documentation,llm,static-analysis,mermaid,onboarding
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Documentation
@@ -17,23 +16,14 @@ Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: asgiref>=3.9
-Requires-Dist: async-timeout>=4.0
 Requires-Dist: docker>=7.1
 Requires-Dist: dotenv>=0.9
 Requires-Dist: duckdb>=1.3
 Requires-Dist: dulwich>=0.22
-Requires-Dist: email-validator>=2.2
-Requires-Dist: exceptiongroup>=1.2
 Requires-Dist: fastapi>=0.115
 Requires-Dist: filelock>=3.12
 Requires-Dist: gitpython>=3.1
 Requires-Dist: google-api-core>=2.10
-Requires-Dist: google-genai>=1.10
-Requires-Dist: gql>=3.5
-Requires-Dist: injector>=0.21
-Requires-Dist: ipykernel>=6.29
-Requires-Dist: isort>=6.0
 Requires-Dist: jsonschema>=4.25
 Requires-Dist: langchain>=1.2
 Requires-Dist: langchain-anthropic>=1.3
@@ -46,21 +36,13 @@ Requires-Dist: langchain-openai>=1.1
 Requires-Dist: markdown>=3.8
 Requires-Dist: markdown-it-py>=3.0
 Requires-Dist: markitdown>=0.1
-Requires-Dist: matplotlib>=3.10
 Requires-Dist: networkx>=3.4
-Requires-Dist: openpyxl>=3.1
-Requires-Dist: pandas>=2.2
 Requires-Dist: pathspec>=0.12
-Requires-Dist: pydot>=3.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: regex>=2024.11
 Requires-Dist: rich>=12.6
-Requires-Dist: seaborn>=0.13
-Requires-Dist: tomli>=2.2
 Requires-Dist: trustcall>=0.0.39
-Requires-Dist: typer>=0.9
 Requires-Dist: uvicorn>=0.23
-Requires-Dist: wcwidth>=0.2.13
 Provides-Extra: dev
 Requires-Dist: pytest>=8.3; extra == "dev"
 Requires-Dist: pytest-cov>=7.0; extra == "dev"
@@ -91,12 +73,26 @@ Dynamic: license-file
 
 ---
 
+## Requirements
+
+- **Python 3.12 or 3.13** — other versions are currently not supported.
+
 ## Installation
 
+The recommended way to install the CLI is with [pipx](https://pipx.pypa.io), which automatically creates an isolated environment:
+
+```bash
+pipx install codeboarding --python python3.12
+```
+
+Alternatively, install into an existing virtual environment with pip:
+
 ```bash
 pip install codeboarding
 ```
 
+> Installing into the global Python environment with `pip` is not recommended — it can cause dependency conflicts and will fail if the system Python is not 3.12 or 3.13.
+
 Language server binaries are downloaded automatically on first use. To pre-install them explicitly (useful in CI or restricted environments):
 
 ```bash

{codeboarding-0.9.5 → codeboarding-0.10.0}/PYPI.md

@@ -14,12 +14,26 @@
 
 ---
 
+## Requirements
+
+- **Python 3.12 or 3.13** — other versions are currently not supported.
+
 ## Installation
 
+The recommended way to install the CLI is with [pipx](https://pipx.pypa.io), which automatically creates an isolated environment:
+
+```bash
+pipx install codeboarding --python python3.12
+```
+
+Alternatively, install into an existing virtual environment with pip:
+
 ```bash
 pip install codeboarding
 ```
 
+> Installing into the global Python environment with `pip` is not recommended — it can cause dependency conflicts and will fail if the system Python is not 3.12 or 3.13.
+
 Language server binaries are downloaded automatically on first use. To pre-install them explicitly (useful in CI or restricted environments):
 
 ```bash

{codeboarding-0.9.5 → codeboarding-0.10.0}/README.md

@@ -6,7 +6,7 @@ CodeBoarding gives developers and coding agents a visual map of a codebase. It c
 
 [Website](https://codeboarding.org) · [Open VSX extension](https://open-vsx.org/extension/CodeBoarding/codeboarding) · [Explore examples](https://codeboarding.org/diagrams) · [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Codeboarding.codeboarding) · [GitHub Action](https://github.com/marketplace/actions/codeboarding-diagram-first-documentation) ·[Discord](https://discord.gg/T5zHTJYFuy)
 
-[![CodeBoarding demo](docs/assets/codeboarding-demo.gif)](https://open-vsx.org/extension/CodeBoarding/codeboarding)
+[![CodeBoarding demo](https://gist.githubusercontent.com/ivanmilevtues/1c4f921066613516cfd7b938014a6877/raw/611aec7711556807860ff2e1679a5dc4c0c23fed/CodeBoarding_extension_demo.gif)](https://open-vsx.org/extension/CodeBoarding/codeboarding)
 
 Install the extension from Open VSX.
 
@@ -73,6 +73,16 @@ python main.py --local /path/to/repo
 
 ### Use the packaged CLI
 
+Requires **Python 3.12 or 3.13**. The recommended install method is [pipx](https://pipx.pypa.io), which keeps the CLI in its own isolated environment:
+
+```bash
+pipx install codeboarding --python python3.12
+codeboarding-setup
+codeboarding --local /path/to/repo
+```
+
+Or, if you prefer pip, install into a virtual environment (not the global Python):
+
 ```bash
 pip install codeboarding
 codeboarding-setup
@@ -117,7 +127,7 @@ python main.py --local ./my-project --depth-level 2
 python main.py --local ./my-project --incremental
 
 # Update a single component by ID
-python main.py --local ./my-project --partial-component-id "a3f2b1c4d5e6f789"
+python main.py --local ./my-project --partial-component-id "1.2"
 
 # Analyze a remote GitHub repository
 python main.py https://github.com/pytorch/pytorch

{codeboarding-0.9.5 → codeboarding-0.10.0}/agents/abstraction_agent.py

@@ -1,8 +1,8 @@
 import logging
 from pathlib import Path
 
-from langchain_core.prompts import PromptTemplate
 from langchain_core.language_models import BaseChatModel
+from langchain_core.prompts import PromptTemplate
 
 from agents.agent import CodeBoardingAgent
 from agents.agent_responses import (
@@ -11,24 +11,26 @@ from agents.agent_responses import (
     MetaAnalysisInsights,
     assign_component_ids,
 )
+from agents.cluster_methods_mixin import ClusterMethodsMixin
 from agents.prompts import (
-    get_system_message,
     get_cluster_grouping_message,
     get_final_analysis_message,
+    get_system_message,
 )
-from agents.cluster_methods_mixin import ClusterMethodsMixin
 from agents.validation import (
     ValidationContext,
     validate_cluster_coverage,
-    validate_component_relationships,
+    validate_group_name_coverage,
     validate_key_entities,
-    validate_cluster_ids_populated,
     validate_relation_component_names,
 )
 from monitoring import trace
 from static_analyzer.analysis_result import StaticAnalysisResults
+from static_analyzer.cluster_helpers import (
+    build_all_cluster_results,
+    get_all_cluster_ids,
+)
 from static_analyzer.graph import ClusterResult
-from static_analyzer.cluster_helpers import build_all_cluster_results, get_all_cluster_ids
 
 logger = logging.getLogger(__name__)
 
@@ -86,19 +88,20 @@ class AbstractionAgent(ClusterMethodsMixin, CodeBoardingAgent):
                 cluster_results=cluster_results,
                 expected_cluster_ids=get_all_cluster_ids(cluster_results),
             ),
+            max_validation_attempts=3,
         )
         return cluster_analysis
 
     @trace
     def step_final_analysis(
-        self, cluster_analysis: ClusterAnalysis, cluster_results: dict[str, ClusterResult]
+        self, llm_cluster_analysis: ClusterAnalysis, cluster_results: dict[str, ClusterResult]
     ) -> AnalysisInsights:
         logger.info(f"[AbstractionAgent] Generating final analysis for: {self.project_name}")
 
         meta_context_str = self.meta_context.llm_str() if self.meta_context else "No project context available."
         project_type = self.meta_context.project_type if self.meta_context else "unknown"
 
-        cluster_str = cluster_analysis.llm_str() if cluster_analysis else "No cluster analysis available."
+        cluster_str = llm_cluster_analysis.llm_str() if llm_cluster_analysis else "No cluster analysis available."
 
         prompt = self.prompts["final_analysis"].format(
             project_name=self.project_name,
@@ -111,6 +114,8 @@ class AbstractionAgent(ClusterMethodsMixin, CodeBoardingAgent):
         context = ValidationContext(
             cluster_results=cluster_results,
             cfg_graphs={lang: self.static_analysis.get_cfg(lang) for lang in self.static_analysis.get_languages()},
+            static_analysis=self.static_analysis,
+            llm_cluster_analysis=llm_cluster_analysis,
         )
 
         return self._validation_invoke(
@@ -118,11 +123,11 @@ class AbstractionAgent(ClusterMethodsMixin, CodeBoardingAgent):
             AnalysisInsights,
             validators=[
                 validate_relation_component_names,
-                validate_component_relationships,
+                validate_group_name_coverage,
                 validate_key_entities,
-                validate_cluster_ids_populated,
             ],
             context=context,
+            max_validation_attempts=3,
         )
 
     def run(self):
@@ -134,17 +139,19 @@ class AbstractionAgent(ClusterMethodsMixin, CodeBoardingAgent):
 
         # Step 2: Generate abstract components from grouped clusters
         analysis = self.step_final_analysis(cluster_analysis, cluster_results)
-        # Step 3: Sanitize cluster IDs (remove invalid ones)
-        self._sanitize_component_cluster_ids(analysis, cluster_results=cluster_results)
-        # Step 4: Assign files to components (deterministic + LLM-based with validation)
-        self.classify_files(analysis, cluster_results, self.static_analysis.get_all_source_files())
-        # Step 5: Fix source code reference lines (resolves reference_file paths for key_entities)
+        # Step 3: Assign hierarchical component IDs ("1", "2", "3", ...)
+        assign_component_ids(analysis)
+        # Step 4: Resolve cluster IDs deterministically from group names
+        self._resolve_cluster_ids_from_groups(analysis, cluster_analysis)
+        # Step 5: Populate file_methods deterministically from cluster results + orphan assignment
+        self.populate_file_methods(analysis, cluster_results)
+
+        # Step 6: Build static inter-component relations from CFG edges
+        self.build_static_relations(analysis)
+
+        # Step 7: Fix source code reference lines (resolves reference_file paths for key_entities)
         analysis = self.fix_source_code_reference_lines(analysis)
-        # Step 6: Ensure unique key entities across components
+        # Step 8: Ensure unique key entities across components
         self._ensure_unique_key_entities(analysis)
-        # Step 7: Ensure unique file assignments across components
-        self._ensure_unique_file_assignments(analysis)
-        # Step 8: Assign deterministic component IDs
-        assign_component_ids(analysis)
 
         return analysis, cluster_results

{codeboarding-0.9.5 → codeboarding-0.10.0}/agents/agent.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import os
 import time
 from pathlib import Path
 
@@ -15,14 +14,10 @@ from langgraph.graph.state import CompiledStateGraph
 from pydantic import ValidationError
 from trustcall import create_extractor
 
-from agents.agent_responses import AnalysisInsights, ComponentFiles, FileClassification
-from agents.prompts import (
-    get_unassigned_files_classification_message,
-    get_validation_feedback_message,
-)
+from agents.prompts import get_validation_feedback_message
 from agents.tools.base import RepoContext
 from agents.tools.toolkit import CodeBoardingToolkit
-from agents.validation import ValidationContext, validate_file_classifications
+from agents.validation import ValidationResult, score_validation_results, VALIDATOR_WEIGHTS, DEFAULT_VALIDATOR_WEIGHT
 from monitoring.mixin import MonitoringMixin
 from repo_utils.ignore import RepoIgnoreManager
 from agents.llm_config import MONITORING_CALLBACK
@@ -217,55 +212,123 @@ class CodeBoardingAgent(ReferenceResolverMixin, MonitoringMixin):
         except Empty:
             raise RuntimeError("Agent invocation completed but no result was returned")
 
-    def _parse_invoke(self, prompt, type):
+    def _parse_invoke(self, prompt: str, type: type):
         response = self._invoke(prompt)
         assert isinstance(response, str), f"Expected a string as response type got {response}"
         return self._parse_response(prompt, response, type)
 
+    def _score_result(self, result, validators: list, context) -> tuple[float, list[tuple[float, str]]]:
+        """Run all validators on a result and return (score, prioritized_feedback).
+
+        The score is computed using weighted validators where coverage-related
+        validators (cluster coverage, group name coverage) carry significantly
+        more weight than others.
+
+        Feedback messages are returned as (weight, message) tuples sorted by
+        weight descending, so that the LLM focuses on the most critical issues
+        (cluster/group coverage) before lower-priority ones (key entities).
+        """
+        validator_results: list[tuple] = []
+        weighted_feedback: list[tuple[float, str]] = []
+        for validator in validators:
+            validator_result: ValidationResult = validator(result, context)
+            validator_results.append((validator, validator_result))
+            if not validator_result.is_valid:
+                weight = VALIDATOR_WEIGHTS.get(validator.__name__, DEFAULT_VALIDATOR_WEIGHT)
+                for msg in validator_result.feedback_messages:
+                    weighted_feedback.append((weight, msg))
+
+        # Sort by weight descending so critical feedback comes first
+        weighted_feedback.sort(key=lambda x: x[0], reverse=True)
+
+        score = score_validation_results(validator_results)
+        return score, weighted_feedback
+
     def _validation_invoke(
-        self, prompt: str, return_type: type, validators: list, context, max_validation_retries: int = 1
+        self, prompt: str, return_type: type, validators: list, context, max_validation_attempts: int = 1
     ):
         """
-        Invoke LLM with validation and feedback loop.
+        Invoke LLM with validation, feedback loop, and best-of-N selection.
+
+        Each attempt (initial + retries) is scored using weighted validators.
+        Coverage validators (validate_cluster_coverage, validate_group_name_coverage)
+        are weighted ~2x higher than other validators, so the selection strongly
+        favours results with complete coverage.
+
+        If any attempt scores perfectly (all validators pass), it is returned
+        immediately. Otherwise the highest-scoring result across all attempts is
+        returned.
 
         Args:
             prompt: The original prompt
             return_type: Pydantic type to parse into
             validators: List of validation functions to run
             context: ValidationContext with data needed for validation
-            max_validation_retries: Maximum retry attempts with feedback (default: 1)
+            max_validation_attempts: Maximum validation attempts (initial attempt included).
+                Retries occur only when this value is greater than 1. (default: 1)
 
         Returns:
-            Validated result of return_type
+            The highest-scoring result of return_type across all attempts
         """
+        # Compute the maximum possible score so we can detect a perfect result
+        max_possible_score = sum(VALIDATOR_WEIGHTS.get(v.__name__, DEFAULT_VALIDATOR_WEIGHT) for v in validators)
+
         result = self._parse_invoke(prompt, return_type)
 
-        for attempt in range(max_validation_retries):
-            # Run all validators
-            all_feedback = []
-            for validator in validators:
-                validation_result = validator(result, context)
-                if not validation_result.is_valid:
-                    all_feedback.extend(validation_result.feedback_messages)
+        # Track the best candidate across all attempts
+        best_result = result
+        best_score = -1.0
+
+        # Weight threshold: validators above this are tagged [CRITICAL]
+        critical_threshold = 10.0
+
+        for attempt in range(1, max_validation_attempts + 1):
+            score, weighted_feedback = self._score_result(result, validators, context)
+
+            logger.info(
+                f"[Validation] Attempt {attempt}/{max_validation_attempts} "
+                f"score: {score}/{max_possible_score} "
+                f"({len(weighted_feedback)} issue(s))"
+            )
+
+            if score > best_score:
+                best_score = score
+                best_result = result
+
+            # Perfect score — return immediately
+            if score >= max_possible_score:
+                logger.info(f"[Validation] Perfect score on attempt {attempt}, returning result")
+                return result
 
-            if not all_feedback:
-                logger.info(f"[Validation] All validations passed on attempt {attempt + 1}")
-                return result  # All validations passed
+            # On the last attempt, don't retry — just fall through to return best
+            if attempt == max_validation_attempts:
+                logger.warning(
+                    f"[Validation] Final attempt reached. Best score: {best_score}/{max_possible_score}. "
+                    f"Returning best result."
+                )
+                break
+
+            # Build feedback prompt for the next attempt.
+            # Feedback is sorted by weight; high-weight items are tagged [CRITICAL].
+            feedback_lines: list[str] = []
+            for weight, msg in weighted_feedback:
+                tag = "CRITICAL" if weight >= critical_threshold else "Secondary"
+                feedback_lines.append(f"- [{tag}] {msg}")
 
-            # Build feedback prompt using the prompt factory
             feedback_template = get_validation_feedback_message()
             feedback_prompt = feedback_template.format(
                 original_output=result.llm_str(),
-                feedback_list="\n".join(f"- {msg}" for msg in all_feedback),
+                feedback_list="\n".join(feedback_lines),
                 original_prompt=prompt,
             )
 
             logger.info(
-                f"[Validation] Retry {attempt + 1}/{max_validation_retries} with {len(all_feedback)} feedback items"
+                f"[Validation] Preparing attempt {attempt + 1}/{max_validation_attempts} "
+                f"with {len(weighted_feedback)} feedback items"
             )
             result = self._parse_invoke(feedback_prompt, return_type)
 
-        return result
+        return best_result
 
     def _parse_response(self, prompt, response, return_type, max_retries=5, attempt=0):
         if attempt >= max_retries:
@@ -305,6 +368,9 @@ class CodeBoardingAgent(ReferenceResolverMixin, MonitoringMixin):
             # try to parse with the json parser if possible
             logger.warning(f"IndexError while parsing response (attempt {attempt + 1}/{max_retries}): {e}")
             return self._parse_response(prompt, response, return_type, max_retries, attempt + 1)
+        except (json.JSONDecodeError, ValueError) as e:
+            logger.warning(f"Parse error (attempt {attempt + 1}/{max_retries}): {e}")
+            return self._parse_response(prompt, response, return_type, max_retries, attempt + 1)
         except ResourceExhausted as e:
             # Parsing uses exponential backoff for rate limits
             if attempt < max_retries - 1:
@@ -344,133 +410,3 @@ class CodeBoardingAgent(ReferenceResolverMixin, MonitoringMixin):
                 except:
                     pass
         raise ValueError(f"Couldn't parse {message_content}")
-
-    def classify_files(self, analysis: AnalysisInsights, cluster_results: dict, scope_files: list[str]) -> None:
-        """
-        Two-pass file assignment for AnalysisInsights:
-        1. Deterministic: assign files from cluster_ids and key_entities
-        2. LLM-based: classify remaining unassigned files
-
-        Args:
-            analysis: AnalysisInsights object to classify files for
-            cluster_results: Dict mapping language -> ClusterResult (for the relevant scope)
-            scope_files: List of file paths to limit classification scope.
-
-        Requires self to be a mixin with ClusterMethodsMixin for helper methods.
-        """
-        for comp in analysis.components:
-            # Deterministic assignment (uses mixin methods)
-            self._assign_files_to_component(comp, cluster_results)  # type: ignore[attr-defined]
-        self._classify_unassigned_files_llm(analysis, scope_files)
-        self._log_unclassified_files_count(analysis, scope_files)
-
-    def _classify_unassigned_files_llm(self, analysis: AnalysisInsights, scope_files: list[str]) -> None:
-        """
-        Classify files from the scope files that weren't assigned to any component.
-        Uses a single LLM call to classify all unassigned files.
-        Args:
-            analysis: AnalysisInsights object
-            scope_files: List of file paths to limit classification scope.
-        """
-        # Get unassigned files using the helper method
-        unassigned_files = self._get_unassigned_files(analysis, scope_files)
-
-        if not unassigned_files:
-            logger.info("[Agent] All files already assigned, skipping LLM classification")
-            return
-
-        logger.info(f"[Agent] Found {len(unassigned_files)} unassigned files, using LLM classification")
-
-        # 4. Build component summary for LLM using llm_str()
-        valid_components = [comp for comp in analysis.components if comp.name != "Unclassified"]
-        components_summary = "\n\n".join(comp.llm_str() for comp in valid_components)
-        component_map = {comp.name: comp for comp in valid_components}
-
-        # 5. Classify all unassigned files with LLM
-        classifications: list[FileClassification] = self._classify_unassigned_files_with_llm(
-            unassigned_files, components_summary, analysis
-        )
-
-        # 6. Append successfully classified files to components
-        for fc in classifications:
-            if fc.component_name in component_map:
-                comp = component_map[fc.component_name]
-                if fc.file_path not in comp.assigned_files:
-                    comp.assigned_files.append(fc.file_path)
-                    logger.debug(f"[Agent] Assigned {fc.file_path} to {fc.component_name}")
-            else:
-                logger.warning(
-                    f"[Agent] Invalid component name '{fc.component_name}' for file {fc.file_path}, skipping"
-                )
-
-        logger.info(f"[Agent] File classification complete: {len(classifications)} files classified")
-
-    def _get_unassigned_files(self, analysis: AnalysisInsights, scope_files: list[str]) -> list[str]:
-        """
-        Check which files remain unassigned after classification.
-        Args:
-            analysis: AnalysisInsights object with classified components
-            scope_files: List of file paths to limit the scope.
-        Returns:
-            List of file paths that are still unassigned
-        """
-        # 1. Gather all assigned files
-        assigned_files = set()
-        for comp in analysis.components:
-            for f in comp.assigned_files:
-                abs_path = os.path.join(self.repo_dir, f) if not os.path.isabs(f) else f
-                assigned_files.add(os.path.relpath(abs_path, self.repo_dir))
-
-        # 2. Get files to consider for classification
-        # If scope_files is provided (e.g., DetailsAgent), use those
-        # Otherwise use all source files from static_analysis (e.g., AbstractionAgent)
-        all_files = set()
-        for file_path in scope_files:
-            file_path_str = str(file_path)
-            rel_path = os.path.relpath(file_path_str, self.repo_dir) if os.path.isabs(file_path_str) else file_path_str
-            all_files.add(rel_path)
-
-        # 3. Return unassigned files
-        return sorted(all_files - assigned_files)
-
-    def _log_unclassified_files_count(self, analysis: AnalysisInsights, scope_files: list[str]) -> None:
-        """
-        Log how many files remain unclassified within the analysis.
-
-        Args:
-            analysis: AnalysisInsights object with classified components
-            scope_files: List of file paths which are expected to be within the analysis.
-        """
-        unassigned = self._get_unassigned_files(analysis, scope_files)
-        if unassigned:
-            logger.warning(f"[Agent] {len(unassigned)} files have not been classified successfully: {unassigned}")
-        else:
-            logger.info("[Agent] All files have been classified successfully")
-
-    def _classify_unassigned_files_with_llm(
-        self, unassigned_files: list[str], components_summary: str, analysis: AnalysisInsights
-    ) -> list[FileClassification]:
-        """
-        Classify unassigned files using LLM with validation.
-        Returns list of FileClassification objects.
-        """
-
-        prompt = PromptTemplate(
-            template=get_unassigned_files_classification_message(), input_variables=["unassigned_files", "components"]
-        ).format(unassigned_files="\n".join(unassigned_files), components=components_summary)
-
-        # Get valid component names from the components_summary
-        # Parse component names from the summary (components have format "**Component:** `ComponentName`")
-        valid_component_names = set([comp.name for comp in analysis.components])
-
-        # Build validation context
-        context = ValidationContext(
-            expected_files=set(unassigned_files),
-            valid_component_names=valid_component_names,
-            repo_dir=str(self.repo_dir),
-        )
-
-        file_classifications = self._validation_invoke(
-            prompt, ComponentFiles, validators=[validate_file_classifications], context=context
-        )
-        return file_classifications.file_paths