structkit 3.0.0__py3-none-any.whl

structkit/mcp_server.py

@@ -0,0 +1,347 @@
+"""
+MCP Server implementation for the structkit tool using FastMCP stdio transport.
+
+This module provides MCP (Model Context Protocol) support for:
+1. Listing available structures
+2. Getting detailed information about structures
+3. Generating structures with various options
+4. Validating structure configurations
+"""
+import asyncio
+import logging
+import os
+import sys
+import yaml
+from typing import Any, Dict, Optional
+
+from fastmcp import FastMCP
+
+from structkit.commands.generate import GenerateCommand
+from structkit.commands.validate import ValidateCommand
+from structkit import __version__
+
+
+class StructMCPServer:
+    """FastMCP-based MCP Server for structkit tool operations."""
+
+    def __init__(self):
+        self.app = FastMCP("structkit-mcp-server", version=__version__)
+        self.logger = logging.getLogger(__name__)
+        self._register_tools()
+
+    # =====================
+    # Tool logic (transport-agnostic)
+    # =====================
+    def _list_structures_logic(self, structures_path: Optional[str] = None) -> str:
+        this_file = os.path.dirname(os.path.realpath(__file__))
+        contribs_path = os.path.join(this_file, "contribs")
+
+        paths_to_list = [contribs_path]
+        if structures_path:
+            paths_to_list = [structures_path, contribs_path]
+
+        all_structures = set()
+        for path in paths_to_list:
+            if os.path.exists(path):
+                for root, _, files in os.walk(path):
+                    for file in files:
+                        if file.endswith(".yaml"):
+                            rel = os.path.relpath(os.path.join(root, file), path)[:-5]
+                            if path != contribs_path:
+                                rel = f"+ {rel}"
+                            all_structures.add(rel)
+
+        sorted_list = sorted(all_structures)
+        result_text = "📃 Available structures:\n\n" + "\n".join([f" - {s}" for s in sorted_list])
+        result_text += "\n\nNote: Structures with '+' sign are custom structures"
+        return result_text
+
+    def _get_structure_info_logic(self, structure_name: Optional[str], structures_path: Optional[str] = None) -> str:
+        if not structure_name:
+            return "Error: structure_name is required"
+
+        # Resolve path
+        if structure_name.startswith("file://") and structure_name.endswith(".yaml"):
+            file_path = structure_name[7:]
+        else:
+            this_file = os.path.dirname(os.path.realpath(__file__))
+            base = structures_path or os.path.join(this_file, "contribs")
+            file_path = os.path.join(base, f"{structure_name}.yaml")
+
+        if not os.path.exists(file_path):
+            return f"❗ Structure not found: {file_path}"
+
+        with open(file_path, "r") as f:
+            config = yaml.safe_load(f) or {}
+
+        result_lines = [
+            "📒 Structure definition\n",
+            f"   📌 Name: {structure_name}\n",
+            f"   📌 Description: {config.get('description', 'No description')}\n",
+        ]
+
+        files = config.get("files", [])
+        if files:
+            result_lines.append("   📌 Files:\n")
+            for item in files:
+                for name in item.keys():
+                    result_lines.append(f"       - {name}\n")
+
+        folders = config.get("folders", [])
+        if folders:
+            result_lines.append("   📌 Folders:\n")
+            for item in folders:
+                if isinstance(item, dict):
+                    for folder, content in item.items():
+                        result_lines.append(f"       - {folder}\n")
+                        if isinstance(content, dict):
+                            # Support both 'struct' (config key) and 'structkit' (package name)
+                            structs = content.get("struct") or content.get("structkit")
+                            if isinstance(structs, list):
+                                result_lines.append("         • struct(s):\n")
+                                for s in structs:
+                                    result_lines.append(f"           - {s}\n")
+                            elif isinstance(structs, str):
+                                result_lines.append(f"         • struct: {structs}\n")
+                            if isinstance(content.get("with"), dict):
+                                with_items = " ".join([f"{k}={v}" for k, v in content["with"].items()])
+                                result_lines.append(f"         • with:{with_items}\n")
+                else:
+                    result_lines.append(f"       - {item}\n")
+
+        return "".join(result_lines)
+
+    def _generate_structure_logic(
+        self,
+        structure_definition: str,
+        base_path: str,
+        output: str = "files",
+        dry_run: bool = False,
+        mappings: Optional[Dict[str, str]] = None,
+        structures_path: Optional[str] = None,
+    ) -> str:
+        class Args:
+            pass
+        args = Args()
+        args.structure_definition = structure_definition
+        args.base_path = base_path
+        args.output = "console" if output == "console" else "file"
+        args.dry_run = dry_run
+        args.structures_path = structures_path
+        args.vars = None
+        args.mappings_file = None
+        args.backup = None
+        args.file_strategy = "overwrite"
+        args.global_system_prompt = None
+        args.non_interactive = True
+        args.input_store = "/tmp/structkit/input.json"
+        args.diff = False
+        args.log = "INFO"
+        args.config_file = None
+        args.log_file = None
+
+        # If mappings provided, convert to vars string consumed by GenerateCommand
+        if mappings:
+            args.vars = ",".join([f"{k}={v}" for k, v in mappings.items()])
+
+        if output == "console":
+            from io import StringIO
+            buf = StringIO()
+            old = sys.stdout
+            sys.stdout = buf
+            try:
+                # Create a dummy parser for GenerateCommand
+                import argparse
+                dummy_parser = argparse.ArgumentParser()
+                GenerateCommand(dummy_parser).execute(args)
+                text = buf.getvalue()
+                return text.strip() or "Structure generation completed successfully"
+            finally:
+                sys.stdout = old
+        else:
+            # Create a dummy parser for GenerateCommand
+            import argparse
+            dummy_parser = argparse.ArgumentParser()
+            GenerateCommand(dummy_parser).execute(args)
+            if dry_run:
+                return f"Dry run completed for structure '{structure_definition}' at '{base_path}'"
+            return f"Structure '{structure_definition}' generated successfully at '{base_path}'"
+
+    def _validate_structure_logic(self, yaml_file: Optional[str]) -> str:
+        if not yaml_file:
+            return "Error: yaml_file is required"
+
+        class Args:
+            pass
+        args = Args()
+        args.yaml_file = yaml_file
+        args.log = "INFO"
+        args.config_file = None
+        args.log_file = None
+
+        from io import StringIO
+        buf = StringIO()
+        old = sys.stdout
+        sys.stdout = buf
+        try:
+            # Create a dummy parser for ValidateCommand
+            import argparse
+            dummy_parser = argparse.ArgumentParser()
+            ValidateCommand(dummy_parser).execute(args)
+            text = buf.getvalue()
+            return text.strip() or f"✅ YAML file '{yaml_file}' is valid"
+        finally:
+            sys.stdout = old
+
+    # =====================
+    # FastMCP tool registration (maps to logic above)
+    # =====================
+    def _register_tools(self):
+        @self.app.tool(name="list_structures", description="List all available structure definitions")
+        async def list_structures(structures_path: Optional[str] = None) -> str:
+            self.logger.debug(f"MCP request: list_structures args={{'structures_path': {structures_path!r}}}")
+            result = self._list_structures_logic(structures_path)
+            preview = result if len(result) <= 1000 else result[:1000] + f"... [truncated {len(result)-1000} chars]"
+            self.logger.debug(f"MCP response: list_structures len={len(result)} preview=\n{preview}")
+            return result
+
+        @self.app.tool(name="get_structure_info", description="Get detailed information about a specific structure")
+        async def get_structure_info(structure_name: str, structures_path: Optional[str] = None) -> str:
+            self.logger.debug(
+                f"MCP request: get_structure_info args={{'structure_name': {structure_name!r}, 'structures_path': {structures_path!r}}}"
+            )
+            result = self._get_structure_info_logic(structure_name, structures_path)
+            preview = result if len(result) <= 1000 else result[:1000] + f"... [truncated {len(result)-1000} chars]"
+            self.logger.debug(f"MCP response: get_structure_info len={len(result)} preview=\n{preview}")
+            return result
+
+        @self.app.tool(name="generate_structure", description="Generate a project structure using specified definition and options")
+        async def generate_structure(
+            structure_definition: str,
+            base_path: str,
+            output: str = "files",
+            dry_run: bool = False,
+            mappings: Optional[Dict[str, str]] = None,
+            structures_path: Optional[str] = None,
+        ) -> str:
+            self.logger.debug(
+                "MCP request: generate_structure args=%s",
+                {
+                    "structure_definition": structure_definition,
+                    "base_path": base_path,
+                    "output": output,
+                    "dry_run": dry_run,
+                    "mappings": mappings,
+                    "structures_path": structures_path,
+                },
+            )
+            result = self._generate_structure_logic(
+                structure_definition,
+                base_path,
+                output,
+                dry_run,
+                mappings,
+                structures_path,
+            )
+            preview = result if len(result) <= 1000 else result[:1000] + f"... [truncated {len(result)-1000} chars]"
+            self.logger.debug(f"MCP response: generate_structure len={len(result)} preview=\n{preview}")
+            return result
+
+        @self.app.tool(name="validate_structure", description="Validate a structure configuration YAML file")
+        async def validate_structure(yaml_file: str) -> str:
+            self.logger.debug(f"MCP request: validate_structure args={{'yaml_file': {yaml_file!r}}}")
+            result = self._validate_structure_logic(yaml_file)
+            preview = result if len(result) <= 1000 else result[:1000] + f"... [truncated {len(result)-1000} chars]"
+            self.logger.debug(f"MCP response: validate_structure len={len(result)} preview=\n{preview}")
+            return result
+
+    async def run(
+        self,
+        transport: str = "stdio",
+        *,
+        show_banner: bool = True,
+        host: str | None = None,
+        port: int | None = None,
+        path: str | None = None,
+        log_level: str | None = None,
+        stateless_http: bool | None = None,
+        fastmcp_log_level: str | None = None,
+    ):
+        """Run the FastMCP server with the specified transport.
+
+        Note: FastMCP.run(...) is synchronous in fastmcp>=2.x, so we
+        offload it to a thread to avoid blocking the event loop.
+
+        Args:
+            transport: "stdio" | "http" | "sse"
+            show_banner: Whether to print the FastMCP banner
+            host: Host to bind for HTTP/SSE transports
+            port: Port to bind for HTTP/SSE transports
+            path: Endpoint path for HTTP/SSE transports
+            log_level: Log level for the HTTP server (uvicorn)
+            stateless_http: Whether to use stateless HTTP mode (HTTP only)
+            fastmcp_log_level: Log level for FastMCP internals (e.g., DEBUG, INFO)
+        """
+        loop = asyncio.get_running_loop()
+        def _run():
+            # Apply FastMCP-specific logger level if provided
+            if fastmcp_log_level:
+                try:
+                    logging.getLogger('fastmcp').setLevel(getattr(logging, fastmcp_log_level.upper()))
+                except Exception:
+                    logging.getLogger('fastmcp').setLevel(logging.DEBUG if str(fastmcp_log_level).upper() == 'DEBUG' else logging.INFO)
+            kwargs = {"show_banner": show_banner}
+            if transport in {"http", "sse"}:
+                if host is not None:
+                    kwargs["host"] = host
+                if port is not None:
+                    kwargs["port"] = port
+                if path is not None:
+                    kwargs["path"] = path
+                if log_level is not None:
+                    kwargs["log_level"] = log_level
+                if stateless_http is not None and transport == "http":
+                    kwargs["stateless_http"] = stateless_http
+                logging.getLogger(__name__).info(
+                    "Starting FastMCP %s server on http://%s:%s%s (uvicorn log_level=%s)",
+                    transport,
+                    kwargs.get("host", "127.0.0.1"),
+                    kwargs.get("port", 8000),
+                    kwargs.get("path", "/mcp"),
+                    kwargs.get("log_level", None),
+                )
+            else:
+                logging.getLogger(__name__).info("Starting FastMCP stdio server")
+            self.app.run(transport, **kwargs)
+        await loop.run_in_executor(None, _run)
+
+    # =====================
+    # Compatibility methods for testing (simulates MCP result structure)
+    # =====================
+    async def _handle_get_structure_info(self, params: Dict[str, Any]):
+        """Compatibility method for tests that expect MCP-style responses."""
+        structure_name = params.get('structure_name')
+        structures_path = params.get('structures_path')
+
+        result_text = self._get_structure_info_logic(structure_name, structures_path)
+
+        # Mock MCP response structure
+        class MockContent:
+            def __init__(self, text):
+                self.text = text
+
+        class MockResult:
+            def __init__(self, content):
+                self.content = content
+
+        return MockResult([MockContent(result_text)])
+
+
+async def main():
+    logging.basicConfig(level=logging.INFO)
+    server = StructMCPServer()
+    await server.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

structkit/model_wrapper.py

@@ -0,0 +1,47 @@
+import os
+import logging
+from dotenv import load_dotenv
+from pydantic_ai import Agent
+
+load_dotenv()
+
+class ModelWrapper:
+  """
+  Wraps model logic using pydantic-ai Agent, allowing use of multiple LLM providers.
+  """
+  def __init__(self, logger=None):
+    self.logger = logger or logging.getLogger(__name__)
+    self.model_name = os.getenv("AI_MODEL") or "openai:gpt-4.1"
+
+    # Set default API key if not provided to prevent startup crashes
+    if self.model_name.startswith("openai:") and not os.getenv("OPENAI_API_KEY"):
+        os.environ["OPENAI_API_KEY"] = "sk-default-placeholder-key"
+        self.logger.warning("OPENAI_API_KEY not set. Using placeholder. AI features may not work properly.")
+
+    self.agent = Agent(model=self.model_name)
+    self.logger.debug(f"Configured Agent with model: {self.model_name}")
+
+  def generate_content(self, system_prompt, user_prompt, dry_run=False):
+    if not self.agent:
+      self.logger.warning("No agent configured. Skipping content generation.")
+      return "No agent configured. Skipping content generation."
+    if dry_run:
+      self.logger.info("[DRY RUN] Would generate content using AI agent.")
+      return "[DRY RUN] Generating content using AI agent"
+
+    # Check if using placeholder API key
+    if os.getenv("OPENAI_API_KEY") == "sk-default-placeholder-key":
+      self.logger.warning("Using placeholder API key. Set OPENAI_API_KEY environment variable for AI features to work.")
+      return "AI generation skipped: Please set OPENAI_API_KEY environment variable."
+
+    prompt = f"{user_prompt}"
+    try:
+      self.agent.system_prompt = system_prompt
+      result = self.agent.run_sync(prompt)
+      return result.output
+    except Exception as e:
+      self.logger.error(f"AI agent generation failed: {e}")
+      # Provide more helpful error message for API key issues
+      if "api_key" in str(e).lower() or "unauthorized" in str(e).lower():
+        return "AI generation failed: Please check your OPENAI_API_KEY environment variable."
+      return f"AI agent generation failed: {e}"

structkit/template_renderer.py

@@ -0,0 +1,258 @@
+# FILE: template_renderer.py
+import logging
+import os
+import sys
+from jinja2 import Environment, meta
+from structkit.filters import (
+  get_latest_release,
+  slugify,
+  get_default_branch,
+  gen_uuid,
+  now_iso,
+  env as env_get,
+  read_file,
+  to_yaml,
+  from_yaml,
+  to_json,
+  from_json,
+)
+from structkit.input_store import InputStore
+from structkit.utils import get_current_repo
+
+class TemplateRenderer:
+    def __init__(self, config_variables, input_store, non_interactive, mappings=None):
+      self.config_variables = config_variables
+      self.non_interactive = non_interactive
+      self.mappings = mappings or {}
+
+      self.env = Environment(
+        trim_blocks=True,
+        block_start_string='{%@',
+        block_end_string='@%}',
+        variable_start_string='{{@',
+        variable_end_string='@}}',
+        comment_start_string='{#@',
+        comment_end_string='@#}'
+      )
+
+      self.logger = logging.getLogger(__name__)
+
+      custom_filters = {
+        'latest_release': get_latest_release,
+        'slugify': slugify,
+        'default_branch': get_default_branch,
+        'to_yaml': to_yaml,
+        'from_yaml': from_yaml,
+        'to_json': to_json,
+        'from_json': from_json,
+      }
+
+      globals = {
+        'current_repo': get_current_repo,
+        'uuid': gen_uuid,
+        'now': now_iso,
+        'env': env_get,
+        'read_file': read_file,
+      }
+
+      self.env.globals.update(globals)
+      self.env.filters.update(custom_filters)
+      self.input_store = InputStore(input_store)
+      self.input_store.load()
+      self.input_data = self.input_store.get_data()
+
+    # Get the config variables from the list and create a dictionary that has
+    # variable name and their default value
+    #
+    # Example:
+    # variables:
+    #   - session_name:
+    #       type: string
+    #       default: my_session
+    #   - project_name:
+    #       type: string
+    #       default: my_project
+    #       help: The name of the project
+    #
+    # Returns:
+    #   {'session_name': 'my_session', 'project_name': 'my_project'}
+    def get_defaults_from_config(self):
+      self.logger.debug(f"Config variables: {self.config_variables}")
+      defaults = {}
+      for item in self.config_variables:
+        for name, content in item.items():
+          # Explicit default value
+          if 'default' in content:
+            defaults[name] = content.get('default')
+          # Default from environment variable (env or default_from_env)
+          env_key = content.get('env') or content.get('default_from_env')
+          if env_key and os.environ.get(env_key) is not None:
+            defaults[name] = os.environ.get(env_key)
+      return defaults
+
+
+    def render_template(self, content, vars):
+      # Inject mappings into the template context
+      if self.mappings:
+        vars = vars.copy() if vars else {}
+        vars['mappings'] = self.mappings
+      template = self.env.from_string(content)
+      return template.render(vars)
+
+    def _get_variable_icon(self, var_name, var_type):
+      """Get contextual icon for variable based on name and type"""
+      var_lower = var_name.lower()
+
+      # Project/name related
+      if any(keyword in var_lower for keyword in ['project', 'name', 'app', 'title']):
+        return '🚀'
+      # Environment related
+      elif any(keyword in var_lower for keyword in ['env', 'environment', 'stage', 'deploy']):
+        return '🌍'
+      # Database related (check before URL to prioritize database_url)
+      elif any(keyword in var_lower for keyword in ['db', 'database', 'sql']):
+        return '🗄️'
+      # Port/network related
+      elif any(keyword in var_lower for keyword in ['port', 'url', 'host', 'endpoint']):
+        return '🔌'
+      # Boolean/toggle related
+      elif var_type == 'boolean' or any(keyword in var_lower for keyword in ['enable', 'disable', 'toggle', 'flag']):
+        return '⚡'
+      # Authentication/security
+      elif any(keyword in var_lower for keyword in ['token', 'key', 'secret', 'password', 'auth']):
+        return '🔐'
+      # Version/tag related
+      elif any(keyword in var_lower for keyword in ['version', 'tag', 'release']):
+        return '🏷️'
+      # Path/directory related
+      elif any(keyword in var_lower for keyword in ['path', 'dir', 'folder']):
+        return '📁'
+      # Default
+      else:
+        return '🔧'
+
+    def prompt_for_missing_vars(self, content, vars):
+      parsed_content = self.env.parse(content)
+      undeclared_variables = meta.find_undeclared_variables(parsed_content)
+      self.logger.debug(f"Undeclared variables: {undeclared_variables}")
+
+      # Build schema lookup
+      schema = {}
+      for item in (self.config_variables or []):
+        for name, conf in item.items():
+          schema[name] = conf or {}
+
+      # Prompt the user for any missing variables
+      # Suggest a default from the config if available
+      default_values = self.get_defaults_from_config()
+      self.logger.debug(f"Default values from config: {default_values}")
+
+      for var in undeclared_variables:
+        if var not in vars:
+          conf = schema.get(var, {})
+          required = conf.get('required', False)
+          default = self.input_data.get(var, default_values.get(var, ""))
+          if self.non_interactive:
+            if required and (default is None or default == ""):
+              raise ValueError(f"Missing required variable '{var}' in non-interactive mode")
+            user_input = default
+          else:
+            # Interactive prompt with enum support (choose by value or index)
+            enum = conf.get('enum')
+            var_type = conf.get('type', 'string')
+
+            # Get description if available (support both 'description' and 'help' fields)
+            description = conf.get('description') or conf.get('help')
+
+            # Get contextual icon
+            icon = self._get_variable_icon(var, var_type)
+
+            # ANSI color codes for formatting
+            BOLD = '\033[1m'
+            RESET = '\033[0m'
+
+            if enum:
+              # Build options list string like "(1) dev, (2) staging, (3) prod"
+              options = ", ".join([f"({i+1}) {val}" for i, val in enumerate(enum)])
+
+              if description:
+                print(f"{icon} {BOLD}{var}{RESET}: {description}")
+                print(f"   Options: {options}")
+                raw = input(f"   Enter value [{default}]: ") or default
+              else:
+                raw = input(f"{icon} {BOLD}{var}{RESET} [{default}] {options}: ") or default
+
+              raw = raw.strip()
+              if raw == "":
+                user_input = default
+              elif raw.isdigit() and 1 <= int(raw) <= len(enum):
+                user_input = enum[int(raw) - 1]
+              elif raw in enum:
+                user_input = raw
+              else:
+                # For invalid enum input, raise immediately instead of re-prompting
+                raise ValueError(f"Variable '{var}' must be one of {enum}, got: {raw}")
+            else:
+              if description:
+                print(f"{icon} {BOLD}{var}{RESET}: {description}")
+                user_input = input(f"   Enter value [{default}]: ") or default
+              else:
+                user_input = input(f"{icon} {BOLD}{var}{RESET} [{default}]: ") or default
+          # Coerce and validate according to schema
+          coerced = self._coerce_and_validate(var, user_input, conf)
+          self.input_store.set_value(var, coerced)
+          vars[var] = coerced
+      self.input_store.save()
+      return vars
+
+    def _coerce_and_validate(self, name, value, conf):
+      # Type coercion
+      vtype = (conf.get('type') or 'string').lower()
+      original = value
+      try:
+        if vtype == 'boolean' or vtype == 'bool':
+          if isinstance(value, bool):
+            coerced = value
+          elif isinstance(value, str):
+            coerced = value.strip().lower() in ['1', 'true', 'yes', 'y', 'on']
+          else:
+            coerced = bool(value)
+        elif vtype == 'number' or vtype == 'float':
+          coerced = float(value) if value != '' and value is not None else None
+        elif vtype == 'integer' or vtype == 'int':
+          coerced = int(value) if value not in (None, '') else None
+        else:
+          coerced = '' if value is None else str(value)
+      except Exception:
+        raise ValueError(f"Variable '{name}' could not be coerced to {vtype} (value: {original})")
+
+      # Enum validation
+      enum = conf.get('enum')
+      if enum is not None and coerced not in enum:
+        raise ValueError(f"Variable '{name}' must be one of {enum}, got: {coerced}")
+
+      # Regex validation (only for strings)
+      pattern = conf.get('regex') or conf.get('pattern')
+      if pattern and isinstance(coerced, str):
+        import re as _re
+        if _re.fullmatch(pattern, coerced) is None:
+          raise ValueError(f"Variable '{name}' does not match required pattern: {pattern}")
+
+      # Min/Max validation
+      def _as_num(x):
+        try:
+          return float(x)
+        except Exception:
+          return None
+      minv = conf.get('min')
+      maxv = conf.get('max')
+      if minv is not None:
+        cv = _as_num(coerced)
+        if cv is not None and cv < float(minv):
+          raise ValueError(f"Variable '{name}' must be >= {minv}, got {coerced}")
+      if maxv is not None:
+        cv = _as_num(coerced)
+        if cv is not None and cv > float(maxv):
+          raise ValueError(f"Variable '{name}' must be <= {maxv}, got {coerced}")
+
+      return coerced

structkit/utils.py

@@ -0,0 +1,36 @@
+import yaml
+import os
+import subprocess
+
+def read_config_file(file_path):
+    with open(file_path, 'r') as f:
+        return yaml.safe_load(f)
+
+def merge_configs(file_config, args):
+    args_dict = vars(args)
+    for key, value in file_config.items():
+        if key in args_dict and args_dict[key] is None:
+            args_dict[key] = value
+    return args_dict
+
+def get_current_repo():
+    try:
+        # Get the remote URL
+        remote_url = subprocess.check_output(['git', 'config', '--get', 'remote.origin.url'], text=True).strip()
+
+        # Handle different remote URL formats (HTTPS and SSH)
+        if remote_url.startswith("https://"):
+            # Extract "owner/repository" from HTTPS URL
+            owner_repo = remote_url.split("github.com/")[1].replace(".git", "")
+        elif remote_url.startswith("git@"):
+            # Extract "owner/repository" from SSH URL
+            owner_repo = remote_url.split(":")[1].replace(".git", "")
+        else:
+            return "Error: Not a GitHub repository"
+
+        return owner_repo
+    except subprocess.CalledProcessError:
+        return "Error: Not a Git repository or no remote URL set"
+
+
+project_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")