structkit 3.0.0__py3-none-any.whl

structkit/file_item.py

@@ -0,0 +1,182 @@
+# FILE: file_item.py
+import requests
+import os
+import shutil
+import logging
+import time
+from dotenv import load_dotenv
+from structkit.template_renderer import TemplateRenderer
+from structkit.content_fetcher import ContentFetcher
+from structkit.model_wrapper import ModelWrapper
+
+load_dotenv()
+
+class FileItem:
+    def __init__(self, properties):
+      self.logger = logging.getLogger(__name__)
+      self.name = properties.get("name")
+      self.file_directory = self._get_file_directory()
+      self.content = properties.get("content")
+      self.config_variables = properties.get("config_variables")
+      self.content_location = properties.get("file")
+      self.permissions = properties.get("permissions")
+      self.input_store = properties.get("input_store")
+      self.non_interactive = properties.get("non_interactive")
+      self.skip = properties.get("skip", False)
+      self.skip_if_exists = properties.get("skip_if_exists", False)
+
+      self.content_fetcher = ContentFetcher()
+
+      self.system_prompt = properties.get("system_prompt") or properties.get("global_system_prompt")
+      self.user_prompt = properties.get("user_prompt")
+      self.mappings = properties.get("mappings", {})
+
+      self.model_wrapper = ModelWrapper(self.logger)
+
+      self.template_renderer = TemplateRenderer(
+          self.config_variables,
+          self.input_store,
+          self.non_interactive,
+          self.mappings
+      )
+      # internal flags used for reporting
+      self._last_action = None
+
+    def _get_file_directory(self):
+        return os.path.dirname(self.name)
+
+    def process_prompt(self, dry_run=False, existing_content=None):
+      if self.user_prompt:
+
+        if not self.system_prompt:
+          system_prompt = "You are a software developer working on a project. You need to create a file with the following content:"
+        else:
+          system_prompt = self.system_prompt
+
+        user_prompt = self.user_prompt
+        if existing_content:
+          user_prompt += f"\n\nCurrent file content (if any):\n```\n{existing_content}\n```\n\nPlease modify existing content so that it meets the new requirements. Your output should be plain text, without any code blocks or formatting. Do not include any explanations or comments. Just provide the final content of the file."
+
+        self.logger.debug(f"Using system prompt: {system_prompt}")
+        self.logger.debug(f"Using user prompt: {user_prompt}")
+
+        self.content = self.model_wrapper.generate_content(
+            system_prompt,
+            user_prompt,
+            dry_run=dry_run
+        )
+        self.logger.debug(f"Generated content: \n\n{self.content}")
+
+    def fetch_content(self):
+      if self.content_location:
+        self.logger.debug(f"Fetching content from: {self.content_location}")
+        try:
+          raw_content = self.content_fetcher.fetch_content(
+              self.content_location)
+          self.logger.debug(f"Fetched content: {raw_content}")
+          # Render the fetched content using the template renderer
+          template_vars = self._merge_default_template_vars(
+              self.config_variables)
+          missing_vars = self.template_renderer.prompt_for_missing_vars(
+              raw_content, template_vars)
+          template_vars.update(missing_vars)
+          self.content = self.template_renderer.render_template(
+              raw_content, template_vars)
+          self.logger.debug(f"Rendered content: {self.content}")
+        except Exception as e:
+          self.logger.error(f"❗ Failed to fetch content from {self.content_location}: {e}")
+
+    def _merge_default_template_vars(self, template_vars):
+      default_vars = {
+        "file_name": self.name,
+        "file_directory": self.file_directory,
+      }
+      if not template_vars:
+        return default_vars
+      return {**default_vars, **template_vars}
+
+    def apply_template_variables(self, template_vars):
+      vars = self._merge_default_template_vars(template_vars)
+      self.logger.debug(f"Applying template variables: {vars}")
+
+      missing_vars = self.template_renderer.prompt_for_missing_vars(self.content, vars)
+      vars.update(missing_vars)
+
+      self.vars = vars
+      self.logger.debug(f"Final template variables: {self.vars}")
+
+      self.content = self.template_renderer.render_template(self.content, vars)
+
+    def create(self, base_path, dry_run=False, backup_path=None, file_strategy='overwrite'):
+      file_path = os.path.join(base_path, self.name)
+
+      file_path = self.template_renderer.render_template(file_path, self.vars)
+
+      # default result
+      result = {"action": None, "path": file_path}
+
+      if self.skip:
+        self.logger.info(f"⏭️ Skipped (skip=true): {file_path}")
+        result["action"] = "skipped"
+        return result
+
+      if dry_run:
+        self.logger.info(f"[DRY RUN] Would create/update: {file_path}")
+        result["action"] = "dry_run"
+        return result
+
+      if self.skip_if_exists and os.path.exists(file_path):
+        self.logger.info(f"⏭️ Skipped (exists and skip_if_exists=true): {file_path}")
+        result["action"] = "skipped"
+        return result
+
+      # Create the directory if it does not exist
+      os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+      existed_before = os.path.exists(file_path)
+      renamed_from = None
+      backed_up_to = None
+
+      if existed_before:
+        if file_strategy == 'backup' and backup_path:
+          backup_file_path = os.path.join(backup_path, os.path.basename(file_path))
+          shutil.copy2(file_path, backup_file_path)
+          backed_up_to = backup_file_path
+          self.logger.info(f"🗄️ Backed up: {file_path} -> {backup_file_path}")
+        elif file_strategy == 'skip':
+          self.logger.info(f"⏭️ Skipped (exists): {file_path}")
+          result["action"] = "skipped"
+          return result
+        elif file_strategy == 'append':
+          with open(file_path, 'a') as f:
+              f.write(f"{self.content}\n")
+          self.logger.info(f"📝 Appended: {file_path}")
+          result.update({"action": "appended"})
+          return result
+        elif file_strategy == 'rename':
+          new_name = f"{file_path}.{int(time.time())}"
+          os.rename(file_path, new_name)
+          renamed_from = new_name
+          self.logger.info(f"🔁 Renamed: {file_path} -> {new_name}")
+
+      # Write/overwrite the file
+      with open(file_path, 'w') as f:
+        f.write(f"{self.content}\n")
+
+      action = "created" if not existed_before else "updated"
+      if action == "created":
+        self.logger.info(f"✅ Created: {file_path}")
+      else:
+        self.logger.info(f"✅ Updated: {file_path}")
+      self.logger.debug(f"Content: \n\n{self.content}")
+
+      if self.permissions:
+        os.chmod(file_path, int(self.permissions, 8))
+        self.logger.info(f"🔐 Set permissions: {self.permissions} on {file_path}")
+
+      result.update({
+        "action": action,
+        "renamed_from": renamed_from,
+        "backed_up_to": backed_up_to,
+      })
+      return result

structkit/filters.py

@@ -0,0 +1,112 @@
+import os
+import re
+import json
+from uuid import uuid4
+from datetime import datetime, timezone
+from typing import Any
+
+import yaml
+from github import Github
+from cachetools import TTLCache, cached
+
+cache = TTLCache(maxsize=100, ttl=600)
+
+@cached(cache)
+def get_latest_release(repo_name):
+    token = os.getenv('GITHUB_TOKEN')
+
+    # Use the token if available, otherwise proceed without authentication
+    if token:
+      g = Github(token)
+    else:
+      g = Github()
+
+    try:
+      # Get the repository object
+      repo = g.get_repo(repo_name)
+      # Get the latest release
+      latest_release = repo.get_latest_release()
+      return latest_release.tag_name
+    except Exception:
+      # If an error occurs, return the default branch name
+      try:
+        default_branch = repo.default_branch
+        return default_branch
+      except Exception as e:
+        return "LATEST_RELEASE_ERROR"
+
+@cached(cache)
+def get_default_branch(repo_name):
+    token = os.getenv('GITHUB_TOKEN')
+
+    if token:
+        g = Github(token)
+    else:
+        g = Github()
+
+    try:
+        repo = g.get_repo(repo_name)
+        return repo.default_branch
+    except Exception:
+        return "DEFAULT_BRANCH_ERROR"
+
+def slugify(value):
+    # Convert to lowercase
+    value = value.lower()
+    # Replace spaces with hyphens
+    value = re.sub(r'\s+', '-', value)
+    # Remove any non-alphanumeric characters (except hyphens)
+    value = re.sub(r'[^a-z0-9-]', '', value)
+    return value
+
+# -----------------------------
+# Additional helpers/filters
+# -----------------------------
+
+def gen_uuid() -> str:
+    return str(uuid4())
+
+
+def now_iso() -> str:
+    # UTC ISO8601 string
+    return datetime.now(timezone.utc).isoformat()
+
+
+def env(name: str, default: str = "") -> str:
+    return os.getenv(name, default)
+
+
+def read_file(path: str, encoding: str = "utf-8") -> str:
+    try:
+        with open(path, "r", encoding=encoding) as f:
+            return f.read()
+    except Exception:
+        return ""
+
+
+def to_yaml(obj: Any) -> str:
+    try:
+        return yaml.safe_dump(obj, sort_keys=False)
+    except Exception:
+        return ""
+
+
+def from_yaml(s: str) -> Any:
+    try:
+        return yaml.safe_load(s)
+    except Exception:
+        return None
+
+
+def to_json(obj: Any, indent: int | None = None) -> str:
+    try:
+        return json.dumps(obj, indent=indent)
+    except Exception:
+        return ""
+
+
+def from_json(s: str) -> Any:
+    try:
+        return json.loads(s)
+    except Exception:
+        return None

structkit/input_store.py

@@ -0,0 +1,35 @@
+import json
+import os
+
+class InputStore:
+
+  def __init__(self, input_file):
+    self.input_file = input_file
+    self.data = None
+
+    # create directory if it doesn't exist
+    directory = os.path.dirname(input_file)
+    if not os.path.exists(directory):
+      os.makedirs(directory)
+
+    # create file if it doesn't exist
+    if not os.path.exists(input_file):
+      with open(input_file, 'w') as f:
+        json.dump({}, f)
+
+  def load(self):
+    with open(self.input_file, 'r') as f:
+      self.data = json.load(f)
+
+  def get_data(self):
+    return self.data
+
+  def get_value(self, key):
+    return self.data[key]
+
+  def set_value(self, key, value):
+    self.data[key] = value
+
+  def save(self):
+    with open(self.input_file, 'w') as f:
+      json.dump(self.data, f, indent=2)

structkit/logging_config.py

@@ -0,0 +1,36 @@
+# FILE: structkit/logging_config.py
+import logging
+import colorlog
+
+def configure_logging(level=logging.INFO, log_file=None):
+    """Configure logging with colorlog."""
+    handler = colorlog.StreamHandler()
+
+    line_format = "%(log_color)s%(message)s"
+    if level == logging.DEBUG:
+      line_format = "%(log_color)s[%(asctime)s][%(levelname)s][%(filename)s:%(lineno)d] >> %(message)s"
+
+    handler.setFormatter(colorlog.ColoredFormatter(
+        line_format,
+        datefmt='%Y-%m-%d %H:%M:%S',
+        log_colors={
+            'DEBUG': 'cyan',
+            'INFO': 'green',
+            'WARNING': 'yellow',
+            'ERROR': 'red',
+            'CRITICAL': 'bold_red',
+        }
+    ))
+
+    logging.basicConfig(
+        level=level,
+        handlers=[handler],
+    )
+
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(logging.Formatter(
+            "[%(asctime)s][%(levelname)s][struct] >>> %(message)s",
+            datefmt='%Y-%m-%d %H:%M:%S'
+        ))
+        logging.getLogger().addHandler(file_handler)

structkit/main.py

@@ -0,0 +1,85 @@
+import argparse
+import logging
+import os
+from dotenv import load_dotenv
+from structkit.utils import read_config_file, merge_configs
+from structkit.commands.generate import GenerateCommand
+from structkit.commands.info import InfoCommand
+from structkit.commands.validate import ValidateCommand
+from structkit.commands.list import ListCommand
+from structkit.commands.generate_schema import GenerateSchemaCommand
+from structkit.commands.mcp import MCPCommand
+from structkit.logging_config import configure_logging
+
+# Optional dependency: shtab for static shell completion generation
+try:
+    import shtab  # type: ignore
+except Exception:  # pragma: no cover - optional at runtime
+    shtab = None
+
+load_dotenv()
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+      description="Generate project structure from YAML configuration.",
+      prog="structkit",
+      epilog="Thanks for using %(prog)s! :)",
+    )
+
+    # 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'))
+    ListCommand(subparsers.add_parser('list', help='List available structures'))
+    GenerateSchemaCommand(subparsers.add_parser('generate-schema', help='Generate JSON schema for available structures'))
+    MCPCommand(subparsers.add_parser('mcp', help='MCP (Model Context Protocol) support'))
+
+    # init to create a basic .struct.yaml
+    from structkit.commands.init import InitCommand
+    InitCommand(subparsers.add_parser('init', help='Initialize a basic .struct.yaml in the target directory'))
+
+    # completion manager
+    from structkit.commands.completion import CompletionCommand
+    CompletionCommand(subparsers.add_parser('completion', help='Manage shell completions'))
+
+    # Add shtab completion printing flags if available
+    if shtab is not None:
+        # Adds --print-completion and --shell flags
+        shtab.add_argument_to(parser)
+
+    return parser
+
+def main():
+    parser = get_parser()
+
+    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 getattr(args, 'config_file', None):
+      file_config = read_config_file(args.config_file)
+      args = argparse.Namespace(**merge_configs(file_config, args))
+
+    # Resolve logging level precedence: STRUCTKIT_LOG_LEVEL env > --debug (if present) > --log
+    env_level = os.getenv('STRUCTKIT_LOG_LEVEL')
+    if env_level:
+        logging_level = getattr(logging, env_level.upper(), logging.INFO)
+    else:
+        # Some commands (like mcp) may add a --debug flag; respect it
+        if getattr(args, 'debug', False):
+            logging_level = logging.DEBUG
+        else:
+            logging_level = getattr(logging, getattr(args, 'log', 'INFO').upper(), logging.INFO)
+
+    configure_logging(level=logging_level, log_file=getattr(args, 'log_file', None))
+
+    args.func(args)
+
+if __name__ == "__main__":
+    main()