Introduce Command Structure for CLI with New Generate, Info, and Validate Commands (#5)

**Overview:**
This pull request refactors and enhances the command-line interface
(CLI) of the project by introducing a structured command system. The
main additions include the implementation of new commands—`generate`,
`info`, and `validate`—which provide better organization and flexibility
for interacting with the project’s structure generation capabilities.

**Changes:**
- **New Commands:** 
- Added `GenerateCommand` to handle the creation of project structures
based on a YAML configuration file.
  - Added `InfoCommand` to display information about the package.
- Added `ValidateCommand` to validate the YAML configuration file used
for structure generation.
- **Refactoring:**
- Reorganized the main CLI entry point (`struct_module/main.py`) to
support subcommands using the argparse module.
- Removed redundant code from the `utils.py` file, consolidating the
responsibilities into the newly created command classes.
- Updated the `setup.py` to reflect the new command structure, ensuring
that the correct entry points are used.
- **README Updates:**
- Adjusted the documentation to reflect changes in CLI usage,
specifically replacing instances of the old command syntax with the new
`generate` subcommand.
- **Test Suite Changes:**
- Removed obsolete test scripts that no longer align with the new
command structure, ensuring that the test suite remains relevant to the
current codebase.

**Justification:**
This refactor significantly improves the maintainability and
extensibility of the CLI, making it easier to introduce new commands and
features in the future. By organizing commands into distinct classes, we
enhance the clarity and separation of concerns within the codebase.

**Impact:**
- Users will need to update their workflows to use the new `generate`,
`info`, and `validate` subcommands.
- Existing documentation and usage examples are updated to align with
the new command structure, ensuring a smooth transition for users.
- This change lays the groundwork for further enhancements to the CLI,
potentially leading to more robust and feature-rich command options in
the future.

Author: httpdss

README.md

@@ -72,7 +72,7 @@ docker run \
   -v $(pwd):/workdir \
   -e OPENAI_API_KEY=your-key \
   -u $(id -u):$(id -g) \
-  ghcr.io/httpdss/struct:main \
+  ghcr.io/httpdss/struct:main generate \
   /workdir/example/structure.yaml \
   /workdir/example_output
 ```
@@ -97,7 +97,7 @@ cd example/
 touch structure.yaml
 vim structure.yaml # copy the content from the example folder
 export OPENAI_API_KEY=something
-struct structure.yaml .
+struct generate structure.yaml .
 ```
 
 ## 📝 Usage
@@ -121,13 +121,13 @@ usage: struct [-h] [--log LOG] [--dry-run] [--vars VARS] [--backup BACKUP] [--fi
 ### Simple Example
 
 ```sh
-struct /path/to/your/structure.yaml /path/to/your/output/directory
+struct generate /path/to/your/structure.yaml /path/to/your/output/directory
 ```
 
 ### More Complete Example
 
 ```sh
-struct \
+struct generate \
   --log=DEBUG \
   --dry-run \
   --vars="project_name=MyProject,author_name=JohnDoe" \

docker-compose.yaml

@@ -7,6 +7,7 @@ services:
     env_file:
       - .env
     command: [
+      "generate",
       "--log=DEBUG",
       "--dry-run",
       "--vars=project_name=MyProject,author_name=JohnDoe",
@@ -24,6 +25,7 @@ services:
     env_file:
       - .env
     command: [
+      "generate",
       "--log=DEBUG",
       "--vars=project_name=MyProject,author_name=JohnDoe",
       "--backup=/app/backup",

setup.py

@@ -12,7 +12,7 @@ def parse_requirements(filename):
     install_requires=parse_requirements('requirements.txt'),
     entry_points={
         'console_scripts': [
-            'struct = struct_module:main',
+            'struct = struct_module.main:main',
         ],
     },
 )

struct_module/commands/__init__.py

@@ -0,0 +1,16 @@
+import logging
+
+# Base command class
+class Command:
+    def __init__(self, parser):
+        self.parser = parser
+        self.logger = logging.getLogger(__name__)
+        self.add_common_arguments()
+
+    def add_common_arguments(self):
+        self.parser.add_argument('-l', '--log', type=str, default='INFO', help='Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)')
+        self.parser.add_argument('-c', '--config-file', type=str, help='Path to a configuration file')
+        self.parser.add_argument('-i', '--log-file', type=str, help='Path to a log file')
+
+    def execute(self, args):
+        raise NotImplementedError("Subclasses should implement this!")

struct_module/commands/generate.py

@@ -0,0 +1,58 @@
+from struct_module.commands import Command
+import os
+import yaml
+from struct_module.file_item import FileItem
+
+# Generate command class
+class GenerateCommand(Command):
+  def __init__(self, parser):
+    super().__init__(parser)
+    parser.add_argument('yaml_file', type=str, help='Path to the YAML configuration file')
+    parser.add_argument('base_path', type=str, help='Base path where the structure will be created')
+    parser.add_argument('-d', '--dry-run', action='store_true', help='Perform a dry run without creating any files or directories')
+    parser.add_argument('-v', '--vars', type=str, help='Template variables in the format KEY1=value1,KEY2=value2')
+    parser.add_argument('-b', '--backup', type=str, help='Path to the backup folder')
+    parser.add_argument('-f', '--file-strategy', type=str, choices=['overwrite', 'skip', 'append', 'rename', 'backup'], default='overwrite', help='Strategy for handling existing files')
+    parser.add_argument('-p', '--global-system-prompt', type=str, help='Global system prompt for OpenAI')
+    parser.set_defaults(func=self.execute)
+
+  def execute(self, args):
+    self.logger.info(f"Generating structure at {args.base_path} with config {args.yaml_file}")
+
+    if args.backup and not os.path.exists(args.backup):
+      os.makedirs(args.backup)
+
+    if args.base_path and not os.path.exists(args.base_path):
+      self.logger.info(f"Creating base path: {args.base_path}")
+      os.makedirs(args.base_path)
+
+    self._create_structure(args)
+
+
+  def _create_structure(self, args):
+    with open(args.yaml_file, 'r') as f:
+      config = yaml.safe_load(f)
+
+    template_vars = dict(item.split('=') for item in args.vars.split(',')) if args.vars else None
+    structure = config.get('structure', [])
+
+    for item in structure:
+      self.logger.debug(f"Processing item: {item}")
+      for name, content in item.items():
+        self.logger.debug(f"Processing name: {name}, content: {content}")
+        if isinstance(content, dict):
+          content["name"] = name
+          content["global_system_prompt"] = args.global_system_prompt
+          file_item = FileItem(content)
+          file_item.fetch_content()
+        elif isinstance(content, str):
+          file_item = FileItem({"name": name, "content": content})
+
+          file_item.apply_template_variables(template_vars)
+          file_item.process_prompt(args.dry_run)
+          file_item.create(
+            args.base_path,
+            args.dry_run or False,
+            args.backup_path or None,
+            args.file_strategy or 'overwrite'
+          )

struct_module/commands/info.py

@@ -0,0 +1,15 @@
+from struct_module.commands import Command
+# Info command class
+class InfoCommand(Command):
+    def __init__(self, parser):
+        super().__init__(parser)
+        parser.set_defaults(func=self.execute)
+
+    def execute(self, args):
+        print("STRUCT")
+        print("")
+        print("Generate project structure from YAML configuration.")
+        print("Commands:")
+        print("  generate    Generate the project structure")
+        print("  validate    Validate the YAML configuration file")
+        print("  info        Show information about the package")

struct_module/commands/validate.py

@@ -0,0 +1,54 @@
+import os
+import yaml
+from dotenv import load_dotenv
+from struct_module.commands import Command
+
+load_dotenv()
+
+openai_api_key = os.getenv("OPENAI_API_KEY")
+openai_model = os.getenv("OPENAI_MODEL")
+
+# Validate command class
+class ValidateCommand(Command):
+    def __init__(self, parser):
+        super().__init__(parser)
+        parser.add_argument('yaml_file', type=str, help='Path to the YAML configuration file')
+        parser.set_defaults(func=self.execute)
+
+    def execute(self, args):
+        self.logger.info(f"Validating {args.yaml_file}")
+
+        with open(args.yaml_file, 'r') as f:
+            config = yaml.safe_load(f)
+
+        self._validate_configuration(config.get('structure', []))
+
+
+    def _validate_configuration(self, structure):
+        if not isinstance(structure, list):
+            raise ValueError("The 'structure' key must be a list.")
+        for item in structure:
+            if not isinstance(item, dict):
+                raise ValueError("Each item in the 'structure' list must be a dictionary.")
+            for name, content in item.items():
+                if not isinstance(name, str):
+                    raise ValueError("Each name in the 'structure' item must be a string.")
+                if isinstance(content, dict):
+                    # Check that any of the keys 'content', 'file' or 'prompt' is present
+                    if 'content' not in content and 'file' not in content and 'user_prompt' not in content:
+                        raise ValueError(f"Dictionary item '{name}' must contain either 'content' or 'file' or 'user_prompt' key.")
+                    # Check if 'file' key is present and its value is a string
+                    if 'file' in content and not isinstance(content['file'], str):
+                        raise ValueError(f"The 'file' value for '{name}' must be a string.")
+                    # Check if 'permissions' key is present and its value is a string
+                    if 'permissions' in content and not isinstance(content['permissions'], str):
+                        raise ValueError(f"The 'permissions' value for '{name}' must be a string.")
+                    # Check if 'prompt' key is present and its value is a string
+                    if 'prompt' in content and not isinstance(content['prompt'], str):
+                        raise ValueError(f"The 'prompt' value for '{name}' must be a string.")
+                    # Check if 'prompt' key is present but no OpenAI API key is found
+                    if 'prompt' in content and not openai_api_key:
+                        raise ValueError("Using prompt property and no OpenAI API key was found. Please set it in the .env file.")
+                elif not isinstance(content, str):
+                    raise ValueError(f"The content of '{name}' must be a string or dictionary.")
+        self.logger.info("Configuration validation passed.")

struct_module/main.py

@@ -1,8 +1,12 @@
 import os
 import logging
-import yaml
 from dotenv import load_dotenv
-from .utils import read_config_file, merge_configs, validate_configuration, create_structure
+from struct_module.utils import read_config_file, merge_configs
+from struct_module.commands.generate import GenerateCommand
+from struct_module.commands.info import InfoCommand
+from struct_module.commands.validate import ValidateCommand
+
+import argparse
 
 load_dotenv()
 
@@ -14,59 +18,40 @@
 
 
 def main():
-    import argparse
-
     parser = argparse.ArgumentParser(
         description="Generate project structure from YAML configuration.",
         prog="struct",
         epilog="Thanks for using %(prog)s! :)",
-
     )
-    parser.add_argument('yaml_file', type=str, help='Path to the YAML configuration file')
-    parser.add_argument('base_path', type=str, help='Base path where the structure will be created')
-    parser.add_argument('-c', '--config-file', type=str, help='Path to a configuration file')
-    parser.add_argument('-l', '--log', type=str, default='INFO', help='Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)')
-    parser.add_argument('-d', '--dry-run', action='store_true', help='Perform a dry run without creating any files or directories')
-    parser.add_argument('-v', '--vars', type=str, help='Template variables in the format KEY1=value1,KEY2=value2')
-    parser.add_argument('-b', '--backup', type=str, help='Path to the backup folder')
-    parser.add_argument('-f', '--file-strategy', type=str, choices=['overwrite', 'skip', 'append', 'rename', 'backup'], default='overwrite', help='Strategy for handling existing files')
-    parser.add_argument('-i', '--log-file', type=str, help='Path to a log file')
-    parser.add_argument('-p', '--global-system-prompt', type=str, help='Global system prompt for OpenAI')
 
+    # Create subparsers
+    subparsers = parser.add_subparsers()
+
+
+    InfoCommand(subparsers.add_parser('info', help='Show information about the package'))
+    ValidateCommand(subparsers.add_parser('validate', help='Validate the YAML configuration file'))
+    GenerateCommand(subparsers.add_parser('generate', help='Generate the project structure'))
     args = parser.parse_args()
 
+    # Check if a subcommand was provided
+    if not hasattr(args, 'func'):
+        parser.print_help()
+        parser.exit()
+
     # Read config file if provided
     if args.config_file:
         file_config = read_config_file(args.config_file)
         args = argparse.Namespace(**merge_configs(file_config, args))
 
     logging_level = getattr(logging, args.log.upper(), logging.INFO)
-    template_vars = dict(item.split('=') for item in args.vars.split(',')) if args.vars else None
-    backup_path = args.backup
-
-    if backup_path and not os.path.exists(backup_path):
-        os.makedirs(backup_path)
-
-    if args.base_path and not os.path.exists(args.base_path):
-        logging.info(f"Creating base path: {args.base_path}")
-        os.makedirs(args.base_path)
 
     logging.basicConfig(
         level=logging_level,
         filename=args.log_file,
         format='[%(asctime)s][%(levelname)s][struct] >>> %(message)s',
     )
-    logging.info(f"Starting to create project structure from {args.yaml_file} in {args.base_path}")
-    logging.debug(f"YAML file path: {args.yaml_file}, Base path: {args.base_path}, Dry run: {args.dry_run}, Template vars: {template_vars}, Backup path: {backup_path}")
-
-    with open(args.yaml_file, 'r') as f:
-        config = yaml.safe_load(f)
-
-    validate_configuration(config.get('structure', []))
-    create_structure(args.base_path, config.get('structure', []), args.dry_run, template_vars, backup_path, args.file_strategy, args.global_system_prompt)
-
-    logging.info("Finished creating project structure")
 
+    args.func(args)
 
 if __name__ == "__main__":
     main()

struct_module/utils.py

@@ -10,52 +10,10 @@
 openai_model = os.getenv("OPENAI_MODEL")
 
 
-def validate_configuration(structure):
-    if not isinstance(structure, list):
-        raise ValueError("The 'structure' key must be a list.")
-    for item in structure:
-        if not isinstance(item, dict):
-            raise ValueError("Each item in the 'structure' list must be a dictionary.")
-        for name, content in item.items():
-            if not isinstance(name, str):
-                raise ValueError("Each name in the 'structure' item must be a string.")
-            if isinstance(content, dict):
-                # Check that any of the keys 'content', 'file' or 'prompt' is present
-                if 'content' not in content and 'file' not in content and 'user_prompt' not in content:
-                    raise ValueError(f"Dictionary item '{name}' must contain either 'content' or 'file' or 'user_prompt' key.")
-                # Check if 'file' key is present and its value is a string
-                if 'file' in content and not isinstance(content['file'], str):
-                    raise ValueError(f"The 'file' value for '{name}' must be a string.")
-                # Check if 'permissions' key is present and its value is a string
-                if 'permissions' in content and not isinstance(content['permissions'], str):
-                    raise ValueError(f"The 'permissions' value for '{name}' must be a string.")
-                # Check if 'prompt' key is present and its value is a string
-                if 'prompt' in content and not isinstance(content['prompt'], str):
-                    raise ValueError(f"The 'prompt' value for '{name}' must be a string.")
-                # Check if 'prompt' key is present but no OpenAI API key is found
-                if 'prompt' in content and not openai_api_key:
-                    raise ValueError("Using prompt property and no OpenAI API key was found. Please set it in the .env file.")
-            elif not isinstance(content, str):
-                raise ValueError(f"The content of '{name}' must be a string or dictionary.")
-    logging.info("Configuration validation passed.")
 
 
-def create_structure(base_path, structure, dry_run=False, template_vars=None, backup_path=None, file_strategy='overwrite', global_system_prompt=None):
-    for item in structure:
-        logging.debug(f"Processing item: {item}")
-        for name, content in item.items():
-            logging.debug(f"Processing name: {name}, content: {content}")
-            if isinstance(content, dict):
-                content["name"] = name
-                content["global_system_prompt"] = global_system_prompt
-                file_item = FileItem(content)
-                file_item.fetch_content()
-            elif isinstance(content, str):
-                file_item = FileItem({"name": name, "content": content})
 
-            file_item.apply_template_variables(template_vars)
-            file_item.process_prompt(dry_run)
-            file_item.create(base_path, dry_run, backup_path, file_strategy)
+
 
 
 def read_config_file(file_path):