haraka 0.2.14__py3-none-any.whl → 0.2.15__py3-none-any.whl

haraka/post_gen/config/config.py

@@ -14,6 +14,7 @@ class PostGenConfig:
     description: str
     project_dir: Path
     create_repo: bool
+    verbose: bool = False
 
 
 def load_manifest(variant: str) -> list[str]:

haraka/post_gen/runner.py

@@ -1,5 +1,3 @@
-from post_gen.gen_ascii.ascii_art import goLang
-
 from haraka.art.create import Create
 from haraka.art.ascii.assets import *
 from .config import PostGenConfig
@@ -13,35 +11,61 @@ from haraka.post_gen.service.gitops import GitOps
 def main(cfg: PostGenConfig) -> None:
 
     _logger = Logger(cfg.variant)
-    logger = _logger.start_logger()
+
+    logger = _logger.start_logger(cfg.verbose)
+    logger.debug("Logger instance created for variant: {cfg.variant}")
+    logger.debug(f"Logger started with verbosity: {cfg.verbose}")
 
     try:
         cmd = CommandRunner(logger)
+        logger.debug("CommandRunner initialized")
+
         fops = FileOps(logger)
+        logger.debug("FileOps initialized")
+
         purge = ResourcePurger(fops, logger)
+        logger.debug("ResourcePurger initialized with FileOps")
+
         git = GitOps(cmd, logger)
+        logger.debug("GitOps initialized with CommandRunner")
     except Exception as e:
         logger.error(f"Failed to initialize components: {e}")
         raise
 
     divider("1️⃣  / 4️⃣  – Purge template junk")
+    logger.debug("Starting template junk purge")
+
     purge.purge(cfg.variant, cfg.project_dir)
+    logger.debug(f"Purge completed for variant: {cfg.variant} in directory: {cfg.project_dir}")
+
     logger.info("Skipping git repo creation (steps 2-4)...")
+    logger.debug(f"Configuration for create_repo: {cfg.create_repo}")
 
     if cfg.create_repo:
 
         divider("2️⃣  / 4️⃣  – Initialise Git repo")
+        logger.debug("Starting Git repository initialization")
+
         git.init_repo(cfg.project_dir)
+        logger.debug(f"Git repository initialized in directory: {cfg.project_dir}")
 
         divider("3️⃣  / 4️⃣  – Commit scaffold")
+        logger.debug("Starting staging and initial commit")
+
         git.stage_commit(cfg.project_dir)
+        logger.debug(f"Initial commit completed in directory: {cfg.project_dir}")
 
         divider("4️⃣  / 4️⃣  – Create GitHub repo & push")
+        logger.debug("Starting GitHub repository creation and push")
+
         git.push_to_github(cfg.project_dir, cfg.author, cfg.project_slug, cfg.description)
+        logger.debug(f"Pushed to GitHub: Author: {cfg.author}, Slug: {cfg.project_slug}, Description: {cfg.description}")
 
     divider("🎉 Project generation complete 🎉")
+    logger.debug("Project generation completed")
 
     if cfg.variant == "go-grpc-protoc":
+        logger.debug(f"Detected variant: {cfg.variant}, beginning Go-specific steps")
         go_emoji_logo = [emoji["go"]]
         go_performance_mode = [
             goLang, divider_xl, performance_mode, divider_l, tools, divider_s,
@@ -53,5 +77,10 @@ def main(cfg: PostGenConfig) -> None:
             by, wjb_dev
         ]
         Create.emoji(go_emoji_logo)
+        logger.debug("Generated Go emoji logo")
+
         Create.ascii(go_performance_mode)
+        logger.debug("Generated Go performance mode ASCII art")
+
         Create.logo(go_fast)
+        logger.debug("Generated Go fast ASCII logo")

haraka/post_gen/service/command.py

@@ -9,6 +9,7 @@ class CommandRunner:
 
     def __init__(self, logger: Logger) -> None:
         self._log = logger
+        self._log.debug("CommandRunner initialized with logger")
 
     def run(
         self,
@@ -18,8 +19,10 @@ class CommandRunner:
         check: bool = True,
     ) -> Optional[subprocess.CompletedProcess]:
         cmd_str = " ".join(cmd)
+        self._log.debug(f"Command to be run: {cmd_str}")
         self._log.info(f"Running: {cmd_str}")
         try:
+            self._log.debug(f"Executing command with subprocess: {cmd_str}, cwd={cwd}, check={check}")
             result = subprocess.run(
                 cmd,
                 cwd=str(cwd) if cwd else None,
@@ -28,13 +31,19 @@ class CommandRunner:
                 stderr=subprocess.PIPE,
                 text=True,
             )
+            self._log.debug(f"Command execution completed with return code: {result.returncode}")
             if result.stdout:
+
+                self._log.debug("Processing command stdout")
                 self._log.info(f"stdout:\n{result.stdout.strip()}")
+
+            self._log.debug("Checking for command stderr")
             if result.stderr:
                 self._log.warn(f"stderr:\n{result.stderr.strip()}", file=sys.stderr)
             return result
         except subprocess.CalledProcessError as e:
-            self._log.error(f"command failed: ({cmd_str})", file=sys.stderr)
+            self._log.error(f"Command execution raised CalledProcessError: ({cmd_str})", file=sys.stderr)
+            self._log.debug(f"Return code: {e.returncode}, stdout: {e.stdout}, stderr: {e.stderr}")
             if e.stdout:
                 self._log.error(f"stdout:\n{e.stdout.strip()}", file=sys.stderr)
             if e.stderr:
@@ -43,7 +52,8 @@ class CommandRunner:
                 sys.exit(e.returncode)
             return None
         except FileNotFoundError:
-            self._log.error(f"command not found: {cmd[0]}", file=sys.stderr)
+            self._log.error(f"Command not found: {cmd[0]}", file=sys.stderr)
+            self._log.debug(f"Ensure that the command '{cmd[0]}' is installed and available in PATH")
             if check:
                 sys.exit(1)
             return None

haraka/post_gen/service/files.py

@@ -15,31 +15,49 @@ class FileOps:
             return str(path) if self.test_mode else f"<non-project-path>: {path}"
 
     def remove_file(self, path: Path) -> None:
+        self.logger.debug(f"Attempting to remove file: {self._relpath(path)}")
         try:
             if path.is_file():
+                self.logger.debug(f"Confirmed {self._relpath(path)} is a file")
+
                 path.unlink()
+                self.logger.debug(f"File {self._relpath(path)} successfully unlinked")
                 self.logger.info(f"Removed file: {self._relpath(path)}")
             elif path.is_dir():
+                self.logger.debug(f"{self._relpath(path)} is a directory, not a file. Proceeding to remove it as a directory")
+
                 shutil.rmtree(path, ignore_errors=True)
+                self.logger.debug(f"Directory {self._relpath(path)} removed when file was expected")
                 self.logger.info(f"Removed directory (expected file): {self._relpath(path)}")
         except Exception as e:
+            self.logger.error(f"Error occurred while attempting to remove file {self._relpath(path)}: {e}")
             self.logger.warn(f"Could not remove {self._relpath(path)}: {e}")
 
     def remove_dir(self, path: Path) -> None:
+        self.logger.debug(f"Attempting to remove directory: {self._relpath(path)}")
+
         if path.exists():
+            self.logger.debug(f"Confirmed {self._relpath(path)} exists")
             try:
                 shutil.rmtree(path, ignore_errors=True)
+                self.logger.debug(f"Directory {self._relpath(path)} successfully removed")
                 self.logger.info(f"Removed directory: {self._relpath(path)}")
             except Exception as e:
+                self.logger.error(f"Error occurred while attempting to remove directory {self._relpath(path)}: {e}")
                 self.logger.warn(f"Could not remove directory {self._relpath(path)}: {e}")
 
     def print_tree(self, path: Path, prefix: str = "") -> None:
+        self.logger.debug(f"Printing directory tree starting at: {self._relpath(path)}")
+
         if not path.exists():
+            self.logger.debug(f"Path {self._relpath(path)} does not exist")
             self.logger.warn(f"Path does not exist: {path}")
             return
         entries = sorted(path.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
+        self.logger.debug(f"Found {len(entries)} entries in directory {self._relpath(path)}")
         for i, entry in enumerate(entries):
             branch = "└── " if i == len(entries) - 1 else "├── "
+            self.logger.debug(f"Processing entry: {entry.name} ({'directory' if entry.is_dir() else 'file'})")
             print(prefix + branch + entry.name)
             if entry.is_dir():
                 ext = "    " if i == len(entries) - 1 else "│   "

haraka/post_gen/service/gitops.py

@@ -14,47 +14,75 @@ class GitOps:
 
     # ------------- public API ----------------------------------------- #
     def init_repo(self, project_dir: Path) -> None:
+        self._log.debug(f"Checking if {project_dir}/.git exists…")
         if not (project_dir / ".git").exists():
+
             self._log.info("Initializing Git repository…")
+            self._log.debug(f"Running 'git init' in {project_dir}…")
+
             self._r.run(["git", "init"], cwd=project_dir)
+            self._log.debug("Git repository initialized successfully.")
+
+            self._log.debug("Setting default branch to 'main'…")
             self._r.run(["git", "branch", "-M", "main"], cwd=project_dir)
+            self._log.debug("Default branch set successfully.")
         else:
-            self._log.warn(".git already exists; skipping git init.")
+            self._log.warn(f"{project_dir}/.git already exists; skipping git init.")
 
     def stage_commit(self, project_dir: Path) -> None:
         self._log.info("Staging files…")
+        self._log.debug(f"Running 'git add .' in {project_dir}…")
+
         self._r.run(["git", "add", "."], cwd=project_dir)
+        self._log.debug("Files staged successfully.")
+
+        self._log.debug("Committing changes with message: 'Initial commit'…")
         res = self._r.run(["git", "commit", "-m", "Initial commit"],
                           cwd=project_dir, check=False)
         if not res or res.returncode:
-            self._log.error("'git commit' failed (maybe nothing to commit); continuing…", file=sys.stderr)
+            self._log.error("'git commit' failed (perhaps nothing to commit); continuing…", file=sys.stderr)
+        else:
+            self._log.debug("'git commit' executed successfully.")
 
     def push_to_github(self, project_dir: Path, author: str,
                        slug: str, description: str) -> None:
+        self._log.debug("Checking if GitHub CLI ('gh') is installed…")
         if not self._has_gh():
+            self._log.warn("GitHub CLI ('gh') not found; skipping.")
             return
+        self._log.debug(f"Checking existing remotes in {project_dir}…")
         if "origin" in self._current_remotes(project_dir):
+            self._log.debug("Remote 'origin' already exists; skipping creation.")
             self._log.warn("Remote 'origin' already exists; skipping create.")
             return
+        self._log.debug("No existing 'origin' found; proceeding to create a new GitHub repo.")
         repo = f"{author}/{slug}"
+        self._log.debug(f"Prepared repository slug: {repo}")
+
         self._log.info(f"Creating GitHub repo {repo} & pushing…")
+        self._log.debug(f"Running 'gh repo create' for {repo} with description: '{description}'…")
         self._r.run([
             "gh", "repo", "create", repo,
             "--public", "--description", description,
             "--source", ".", "--remote", "origin", "--push", "--confirm"
         ], cwd=project_dir)
+        self._log.debug(f"GitHub repo {repo} created and code pushed successfully.")
 
     # ------------- internals ------------------------------------------ #
-    @staticmethod
-    def _current_remotes(project_dir: Path):
+    def _current_remotes(self, project_dir: Path):
         try:
+            self._log.debug(f"Fetching remotes for repository at {project_dir}…")
             res = subprocess.run(["git", "remote"], cwd=project_dir,
                                  check=True, text=True,
                                  stdout=subprocess.PIPE)
-            return [r.strip() for r in res.stdout.splitlines()]
+            remotes = [r.strip() for r in res.stdout.splitlines()]
+            self._log.debug(f"Found remotes: {remotes}")
+            return remotes
         except subprocess.CalledProcessError:
+            self._log.warn("Failed to fetch remotes; returning an empty list.")
             return []
 
-    @staticmethod
-    def _has_gh() -> bool:
-        return shutil.which("gh") is not None
+    def _has_gh(self) -> bool:
+        result = shutil.which("gh") is not None
+        self._log.debug(f"'gh' command found: {result}")
+        return result

haraka/post_gen/service/purge.py

@@ -42,6 +42,7 @@ class ResourcePurger:
     def __init__(self, fops: FileOps, logger: Logger | None = None) -> None:
         self._f = fops
         self._log = logger or Logger("ResourcePurger")
+        self._log.debug("ResourcePurger initialized with FileOps instance and Logger.")
 
     # ------------------------------ public API ----------------------------- #
     def purge(self, variant: str, project_dir: Path) -> None:
@@ -57,13 +58,20 @@ class ResourcePurger:
         """
         variant = variant.lower()
         self._log.info(f"Starting purge for variant: {variant}")
+        self._log.debug(f"Loaded variant for purge: {variant}")
 
         keep_patterns = config.load_manifest(variant)
+        self._log.debug(f"Loaded manifest for variant '{variant}': {keep_patterns}")
+
         spec = config.build_spec(keep_patterns)
+        self._log.debug(f"Built PathSpec for keep patterns. Total patterns: {len(keep_patterns)}")
 
         self._log.info(f"Keeping {len(keep_patterns)} pattern(s)")
+        for pattern in keep_patterns:
+            self._log.debug(f"Keep pattern: {pattern}")
 
         self._purge_unrelated(project_dir, spec)
+        self._log.debug(f"Finished purging unrelated paths in project directory: {project_dir}")
 
         divider("Project tree after purge…")
         self._f.print_tree(project_dir)
@@ -73,13 +81,20 @@ class ResourcePurger:
         """
         Walk the project tree; delete every path NOT matched by *spec*.
         """
+
         for path in root.rglob("*"):
+            self._log.debug(f"Scanning path: {path}")
             rel = path.relative_to(root).as_posix()
+            self._log.debug(f"Relative path for inspection: {rel}")
 
             if spec.match_file(rel):
-                continue  # keep it
+                self._log.debug(f"Path matches keep patterns: {rel}")
+                self._log.debug(f"Keeping: {rel}")
+                continue
 
             if path.is_dir():
                 self._f.remove_dir(path)
+                self._log.debug(f"Deleted directory: {path}")
             else:
                 self._f.remove_file(path)
+                self._log.debug(f"Deleted file: {path}")

haraka/utils/logging/log_util.py

@@ -4,16 +4,21 @@ from typing import TextIO
 
 
 class Logger:
-    def __init__(self, label: str = ""):
+    def __init__(self, label: str = "", verbose: bool = False) -> None:
         self.label = label
+        self.verbose = verbose
 
-    def start_logger(self) -> Logger:
+    def start_logger(self, verbose) -> Logger:
         label = Logger.get_label(self.label)
-        return Logger(label)
+        return Logger(label, verbose)
 
     def info(self, msg: str) -> None:
         print(f"{self.label} INFO: {msg}")
 
+    def debug(self, msg: str) -> None:
+        if self.verbose:
+            print(f"🔴  DEBUG: {msg}")
+
     def warn(self, msg: str, file: TextIO = sys.stderr) -> None:
         print(f"{self.label} WARNING: {msg}", file=file)
 

haraka/utils/manifests/go-grpc-protoc.yml

@@ -2,15 +2,15 @@ variant: go-grpc-protoc
 
 keep:
   # ── application source (Go) ─────────────────────────
-  - cmd/**                 # main binary entry-point
-  - internal/**            # config, handlers, server logic
-  - pkg/proto/**           # generated protobuf / proto defs
-  - configs/**             # runtime config files
+  - cmd/**
+  - internal/**
+  - pkg/proto/**
+  - configs/**
   - go.mod
   - git.ignore
 
   # ── tests ───────────────────────────────────────────
-  - test/**                # Go integration + unit tests
+  - test/**
 
   # ── build & project metadata ────────────────────────
   - Makefile

{haraka-0.2.14.dist-info → haraka-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haraka
-Version: 0.2.14
+Version: 0.2.15
 Summary: Reusable post-generation helper for Cookiecutter micro-service templates
 Author-email: Will Burks <will@example.com>
 License: MIT

{haraka-0.2.14.dist-info → haraka-0.2.15.dist-info}/RECORD

@@ -8,25 +8,25 @@ haraka/art/ascii/frame/border.py,sha256=n7qaLxzzBmf8ewatbe5gN97DO4afZM67bBjpU1Oq
 haraka/art/ascii/frame/framer.py,sha256=s_-lsb-hGhlH_73q5iTtk8KHW0MSeSHSAvNFVmL1c9A,3951
 haraka/art/ascii/frame/width_utils.py,sha256=in4AV3gTBBXUX6N01j67Icu9vsHFomybBN8rpL3sQ5s,810
 haraka/post_gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haraka/post_gen/runner.py,sha256=J568noKQ3Cv44MzkFA3d2Vbwl6Tt8VPCfRj3_Y-hZSM,1923
+haraka/post_gen/runner.py,sha256=OLdB3ugDkBzeGBoVZ8RgxOHEy4aNT4icD10a1WwnyOo,3248
 haraka/post_gen/config/__init__.py,sha256=-_XkJ_Dni28yJCMfIceQSiH1wa_hHsZMoBTyvR9Ikbc,62
-haraka/post_gen/config/config.py,sha256=iC0p3UYrx-miszn_pUNX86kP499tG-CBYYlEn-xOfQM,1284
+haraka/post_gen/config/config.py,sha256=nmsQ19ONWE76GFQtah_PUO1HygE-ZCCOfK03M-t-kMs,1310
 haraka/post_gen/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haraka/post_gen/service/assets.py,sha256=-oz3vlBaVOjeCOO2QHRvOmfyurR1KgihqXqbTtxDNG4,461
-haraka/post_gen/service/command.py,sha256=5yxPSQmQpzAyPNoLtzxaUz1VWgPnTfD7XlkBUu5rIeI,1672
-haraka/post_gen/service/files.py,sha256=1hPHn_nYI5A2JKJqxmNFK5fpo9DNPcGR4K7qCPOO5GE,1993
-haraka/post_gen/service/gitops.py,sha256=hRnztg_5yW3L_bdh05gcgGQ25wwjSTn8pX1sja-m91s,2434
-haraka/post_gen/service/purge.py,sha256=cNs2pHkXN1EJS7RIGR7pAmqJcyQ4eUbhkGpPqrq0Zv4,2656
+haraka/post_gen/service/command.py,sha256=yvEzW9rMSXWeQ_2DXuQNtGH6sRuZnK6viMud-amFQXw,2348
+haraka/post_gen/service/files.py,sha256=fXhuCqp9iW34hEDKbZynHxB_QlZdxPHyKtLDV_KwG2I,3314
+haraka/post_gen/service/gitops.py,sha256=UHJFEGrz88NTB0-WKge_AiKO_yLFci6A7AM5kBIy0VQ,4029
+haraka/post_gen/service/purge.py,sha256=eDH5DLwaViu3jsqtPXeJWxS_Fs7RIEq6RKD8A8ny2vE,3536
 haraka/utils/__init__.py,sha256=3Cp4u0dyAGcmqes-tIr95KFsNsJx5Ji5Yzkto9546Hs,168
 haraka/utils/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haraka/utils/common/utils.py,sha256=kMnMXe_hcxGkD0MKGmR1lIwsRND7BaFPRbGN4PwonfM,360
 haraka/utils/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haraka/utils/logging/log_util.py,sha256=S876RggZrLVCLlsEM5i7w1PGKCvR1WECykwtJW83NO0,775
+haraka/utils/logging/log_util.py,sha256=Pf5uuxPfeaQDygOy3AWVj2W_4QSKM6V4FCHCJk6KypY,961
 haraka/utils/manifests/go-grpc-gateway-buf.yml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haraka/utils/manifests/go-grpc-protoc.yml,sha256=IqW6lQrB-UTmfQHYP4EaVK6NU6HknykXM7KxJPVENog,1049
+haraka/utils/manifests/go-grpc-protoc.yml,sha256=L_6zKnEpHHkEZfRy4PYhJqgle7lqDmcUVbnFjgK4WTI,839
 haraka/utils/manifests/java-springboot.yml,sha256=PRqxw9Ygop19hH-TRH31UL1HfEYEJaTq5ukaZX18UNQ,811
 haraka/utils/manifests/python-fastapi.yml,sha256=650oXVlLV4JE9_fg_YAr37BsGSLb3KRdc6D759Zv1W0,814
-haraka-0.2.14.dist-info/METADATA,sha256=6vTRWJdGBXnGg2T0DO-w-CJ4cruD_MCI_vkeguPWJyo,579
-haraka-0.2.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-haraka-0.2.14.dist-info/top_level.txt,sha256=1khpwypLKWoklVd_CgFiwAfcctVSXRoRPc3BI9lyIXo,7
-haraka-0.2.14.dist-info/RECORD,,
+haraka-0.2.15.dist-info/METADATA,sha256=M9taSx27sjz-qp0EeCHN6t3iv0RBCHOdIGDcaLZgy_A,579
+haraka-0.2.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+haraka-0.2.15.dist-info/top_level.txt,sha256=1khpwypLKWoklVd_CgFiwAfcctVSXRoRPc3BI9lyIXo,7
+haraka-0.2.15.dist-info/RECORD,,