Add ability to list bite.core targets

Signed-off-by: Alireza Poodineh <[email protected]>

Author: Aeliux

tools/pybite/__init__.py

@@ -1,7 +1,9 @@
 from .host import Host
 from .global_json import GlobalJson
+from .msbuild import MSBuildFile
 
 __all__ = [
     'Host',
     'GlobalJson'
+    'MSBuildFile'
 ]

tools/pybite/host.py

@@ -8,6 +8,7 @@
 from typing import Optional, Dict, Any, List, Callable
 
 from .global_json import GlobalJson
+from .msbuild import MSBuildFile, MSBuildTarget
 
 
 class Host:
@@ -144,9 +145,10 @@ def get_argparser(self) -> argparse.ArgumentParser:
                 usage=self.argparser_usage.replace('command', 'bite') + ' [target]',
             )
             bite_parser.add_argument('target', nargs='?', default='help', help='bite.core target to run, default is "help"')
+            bite_parser.add_argument('--list', '-l', action='store_true', help='List available targets')
             self.register_handler('bite', self._handle_bite)
 
-        dotnet_parser = subparsers.add_parser(
+        subparsers.add_parser(
             'dotnet',
             help='Run a dotnet command',
             epilog=self.argparser_epilog + ' (Dotnet CLI)',
@@ -232,43 +234,79 @@ def _handle_bite(self, args: argparse.Namespace, extras: List[str]) -> None:
         Handle the 'bite' command, running a custom msbuild target.
         Passes any extra arguments to msbuild.
         """
+        list_targets = getattr(args, 'list', False)
+        if list_targets:
+            dependant_targets: List[MSBuildTarget] = []
+            targets = self._get_bite_core_targets()
+            print("Available independent targets:")
+            for target in targets:
+                if getattr(target, 'AfterTargets', None) is None and getattr(target, 'BeforeTargets', None) is None:
+                    print(f"  {target.Name}")
+                else:
+                    dependant_targets.append(target)
+            if dependant_targets:
+                print("\nAvailable automated targets:")
+                for target in dependant_targets:
+                    print(f"  {target.Name}", end=' ')
+                    if getattr(target, 'AfterTargets', None):
+                        print(f"(after '{target.AfterTargets}')", end=' ')
+                    if getattr(target, 'BeforeTargets', None):
+                        print(f"(before '{target.BeforeTargets}')", end=' ')
+                    print()
+            return
         target = getattr(args, 'target', 'help')
         self.run_bite(target, *extras)
 
     # --- Dotnet/MSBuild Execution ---
 
-    def run(self, command: str, *args: str) -> None:
+    def run(self, command: str, *args: str, capture_output: bool = False) -> Optional[subprocess.CompletedProcess]:
         """
         Run a dotnet command.
 
         Args:
             command: The dotnet CLI command to run.
             *args: Additional arguments to pass to the command.
+            capture_output: If True, capture and return the output.
+
+        Returns:
+            subprocess.CompletedProcess if capture_output is True, otherwise None.
         """
         cmd = ['dotnet', command] + list(args)
-        subprocess.call(cmd)
+        if capture_output:
+            return subprocess.run(cmd, capture_output=True, text=True)
+        else:
+            subprocess.call(cmd)
+            return None
 
-    def run_builtin(self, command: str, *args: str) -> None:
+    def run_builtin(self, command: str, *args: str, capture_output: bool = False) -> Optional[subprocess.CompletedProcess]:
         """
         Run a built-in dotnet command with the solution file and default arguments.
 
         Args:
             command: The dotnet command to run (e.g., 'build', 'restore').
             *args: Additional arguments to pass to the dotnet cli.
+            capture_output: If True, capture and return the output.
+
+        Returns:
+            subprocess.CompletedProcess if capture_output is True, otherwise None.
         """
         cmd = [self.solution] + self.DEFAULT_ARGS + list(args)
-        self.run(command, *cmd)
+        return self.run(command, *cmd, capture_output=capture_output)
 
-    def run_bite(self, target: str, *args: str) -> None:
+    def run_bite(self, target: str, *args: str, capture_output: bool = False) -> Optional[subprocess.CompletedProcess]:
         """
         Run bite.core with the specified target and default arguments.
 
         Args:
             target: The bite.core target to run.
             *args: Additional arguments to pass to msbuild.
+            capture_output: If True, capture and return the output.
+
+        Returns:
+            subprocess.CompletedProcess if capture_output is True, otherwise None.
         """
         cmd = self.DEFAULT_ARGS + [f'-t:{target}', self.BITE_PROJ_PATH] + list(args)
-        self.run('msbuild', *cmd)
+        return self.run('msbuild', *cmd, capture_output=capture_output)
 
     # --- SDK Installation ---
 
@@ -384,7 +422,12 @@ def _resolve_requested_sdk(self) -> Optional[str]:
     def msbuild_path(path: str) -> str:
         """
         Convert a Python path string to an MSBuild-acceptable path for directory properties.
-        Ensures absolute path, uses backslashes, and ends with a backslash.
+
+        Args:
+            path (str): The path to convert.
+
+        Returns:
+            str: The MSBuild-compatible absolute path, quoted if it contains spaces, and ending with a backslash.
         """
         abs_path = os.path.abspath(path)
         msbuild_path = abs_path
@@ -394,6 +437,36 @@ def msbuild_path(path: str) -> str:
             msbuild_path = f'"{msbuild_path}"'
         return msbuild_path
 
+    def _get_bite_core_targets(self) -> List[MSBuildTarget]:
+        """
+        Retrieve all available MSBuild targets from bite.core or .bite.targets files.
+
+        Returns:
+            List[MSBuildTarget]: List of discovered MSBuildTarget objects.
+        """
+        targets: List[MSBuildTarget] = []
+
+        # Try to get targets from bite.core msbuild output
+        output = self.run_bite('help', '-pp', capture_output=True)
+        if output and output.stdout:
+            try:
+                # Parse the XML output directly if possible
+                targets = MSBuildFile(xml_string=output.stdout).get_targets()
+                return targets
+            except Exception:
+                pass
+
+        # Fallback: scan all .bite.targets files in the modules directory
+        pattern = os.path.join(self.MODULES_DIR, '**', '*.bite.targets')
+        for path in glob.glob(pattern, recursive=True):
+            try:
+                obj = MSBuildFile(path)
+                targets.extend(obj.get_targets())
+            except Exception:
+                continue
+
+        return targets
+
     def load_modules(self) -> Dict[str, Any]:
         """
         Load all .bite.py modules from the modules directory.

tools/pybite/msbuild.py

@@ -0,0 +1,194 @@
+import xml.etree.ElementTree as ET
+from typing import Optional, Dict, List
+
+class MSBuildElement:
+    """
+    Base wrapper for an XML element in an MSBuild file.
+    Provides attribute and child element lookup.
+    """
+    def __init__(self, element: ET.Element):
+        self._element = element
+
+    def __getattr__(self, name: str):
+        # Try attribute first, then child element
+        if name in self._element.attrib:
+            return self._element.attrib[name]
+        child = self._element.find(name)
+        if child is not None:
+            return child.text
+        raise AttributeError(f"{self.__class__.__name__} has no attribute '{name}'")
+
+    @property
+    def tag(self) -> str:
+        """Returns the XML tag name."""
+        return self._element.tag
+
+    @property
+    def attrib(self) -> Dict[str, str]:
+        """Returns the XML attributes as a dict."""
+        return self._element.attrib
+
+    @property
+    def text(self) -> Optional[str]:
+        """Returns the text content of the element."""
+        return self._element.text
+
+class MSBuildTarget(MSBuildElement):
+    """
+    Represents an MSBuild <Target> element.
+    Exposes common attributes and child elements as properties.
+    """
+    @property
+    def Name(self) -> Optional[str]:
+        """The Name attribute of the target."""
+        return self._element.attrib.get("Name")
+
+    @property
+    def DependsOnTargets(self) -> Optional[str]:
+        """The DependsOnTargets attribute."""
+        return self._element.attrib.get("DependsOnTargets")
+
+    @property
+    def Inputs(self) -> Optional[str]:
+        """The Inputs attribute."""
+        return self._element.attrib.get("Inputs")
+
+    @property
+    def Outputs(self) -> Optional[str]:
+        """The Outputs attribute."""
+        return self._element.attrib.get("Outputs")
+
+    @property
+    def Condition(self) -> Optional[str]:
+        """The Condition attribute."""
+        return self._element.attrib.get("Condition")
+
+    @property
+    def BeforeTargets(self) -> Optional[str]:
+        """The BeforeTargets attribute."""
+        return self._element.attrib.get("BeforeTargets")
+
+    @property
+    def AfterTargets(self) -> Optional[str]:
+        """The AfterTargets attribute."""
+        return self._element.attrib.get("AfterTargets")
+
+    @property
+    def Returns(self) -> Optional[str]:
+        """The Returns attribute."""
+        return self._element.attrib.get("Returns")
+
+    @property
+    def KeepDuplicateOutputs(self) -> Optional[str]:
+        """The KeepDuplicateOutputs attribute."""
+        return self._element.attrib.get("KeepDuplicateOutputs")
+
+    @property
+    def Tasks(self) -> List[MSBuildElement]:
+        """
+        Returns a list of child task elements (all direct children that are not PropertyGroup/ItemGroup/OnError).
+        """
+        return [MSBuildElement(e) for e in self._element if e.tag not in ("PropertyGroup", "ItemGroup", "OnError")]
+
+    @property
+    def OnError(self) -> List[MSBuildElement]:
+        """
+        Returns a list of <OnError> child elements.
+        """
+        return [MSBuildElement(e) for e in self._element.findall("OnError")]
+
+class MSBuildProperty(MSBuildElement):
+    """
+    Represents a property element in MSBuild.
+    """
+    @property
+    def name(self) -> str:
+        """The property name (tag)."""
+        return self._element.tag
+
+    @property
+    def value(self) -> Optional[str]:
+        """The property value (text)."""
+        return self._element.text
+
+class MSBuildItem(MSBuildElement):
+    """
+    Represents an item element in MSBuild.
+    """
+    @property
+    def Include(self) -> Optional[str]:
+        """The Include attribute."""
+        return self._element.attrib.get("Include")
+
+    @property
+    def Remove(self) -> Optional[str]:
+        """The Remove attribute."""
+        return self._element.attrib.get("Remove")
+
+    @property
+    def Update(self) -> Optional[str]:
+        """The Update attribute."""
+        return self._element.attrib.get("Update")
+
+    @property
+    def name(self) -> str:
+        """The item name (tag)."""
+        return self._element.tag
+
+class MSBuildFile:
+    """
+    Represents an MSBuild file and provides access to its structure.
+    """
+    def __init__(self, filepath: Optional[str] = None, xml_string: Optional[str] = None):
+        """
+        Initialize the MSBuildProject from a file or XML string.
+
+        :param filepath: Path to the MSBuild XML file.
+        :param xml_string: XML content as a string.
+        """
+        if filepath:
+            self.tree = ET.parse(filepath)
+            self.root = self.tree.getroot()
+        elif xml_string:
+            self.root = ET.fromstring(xml_string)
+            self.tree = ET.ElementTree(self.root)
+        else:
+            raise ValueError("Either filepath or xml_string must be provided.")
+
+    def get_property_groups(self) -> List[ET.Element]:
+        """
+        Returns a list of <PropertyGroup> elements.
+        """
+        return self.root.findall(".//PropertyGroup")
+
+    def get_item_groups(self) -> List[ET.Element]:
+        """
+        Returns a list of <ItemGroup> elements.
+        """
+        return self.root.findall(".//ItemGroup")
+
+    def get_properties(self) -> Dict[str, MSBuildProperty]:
+        """
+        Returns a dict of all properties in all <PropertyGroup>s as MSBuildProperty objects.
+        """
+        props: Dict[str, MSBuildProperty] = {}
+        for pg in self.get_property_groups():
+            for prop in pg:
+                props[prop.tag] = MSBuildProperty(prop)
+        return props
+
+    def get_items(self) -> Dict[str, List[MSBuildItem]]:
+        """
+        Returns a dict of item type to list of MSBuildItem objects in all <ItemGroup>s.
+        """
+        items: Dict[str, List[MSBuildItem]] = {}
+        for ig in self.get_item_groups():
+            for item in ig:
+                items.setdefault(item.tag, []).append(MSBuildItem(item))
+        return items
+
+    def get_targets(self) -> List[MSBuildTarget]:
+        """
+        Returns a list of MSBuildTarget objects for <Target> elements.
+        """
+        return [MSBuildTarget(e) for e in self.root.findall(".//Target")]