yardx 0.1.2__py3-none-any.whl

yard/console/console_ui.py

@@ -0,0 +1,14 @@
+from rich.console import Console
+
+
+
+console = Console()
+
+def success(message: str) -> None:
+    console.print(f"[green]✓{message}[/green]")
+
+def info(message: str) -> None:
+    console.print(f"[cyan]{message}[/cyan]")
+
+def error(message: str) -> None:
+    console.print(f"[red]{message}[/red]")

yard/console/error.py

@@ -0,0 +1,12 @@
+from rich import print as rprint
+from rich.panel import Panel
+
+
+def command_error(cmd):
+    rprint("[yellow]Usage:[/yellow] yard [PROMPT]")
+    rprint(Panel(renderable=f"No such '{cmd}' command",
+                 title="Error",
+                 title_align="left",
+                 border_style="red"
+                 ))
+    

yard/console/help_oargs.py

@@ -0,0 +1,58 @@
+from rich.panel import Panel
+from rich import print as rprint
+
+
+def custom_help():
+    rprint("[bold yellow]Usage:[/bold yellow] [cyan]yard[/cyan] [white]<prompt>[/white]\n")
+
+    rprint(
+        Panel(
+            renderable=(
+                "[bold cyan]PROMPT[/bold cyan]\n"
+                "Describe the task you want the agent to perform.\n\n"
+                "[dim]The agent analyzes your request and generates the required project files automatically.[/dim]"
+            ),
+            title="Arguments",
+            title_align="left",
+            border_style="dim"
+        )
+    )
+
+    rprint(
+        Panel(
+            renderable=(
+                "[bold cyan]--help[/bold cyan]      [white]Show this message and exit[/white]\n" \
+                "[bold cyan]-h[/bold cyan]          [white]Show this message and exit[/white]"
+            ),
+            title="Options",
+            title_align="left",
+            border_style="dim"
+        )
+    )
+
+    rprint(
+        Panel(
+            renderable=(
+                "[white]Supported Tasks[/white]\n\n"
+                "• Create Dockerfile\n"
+                "• Create .dockerignore\n"
+            ),
+            title="Capabilities",
+            title_align="left",
+            border_style="yellow"
+        )
+    )
+
+    rprint(
+        Panel(
+            renderable=(
+                '[bold yellow]yard[/bold yellow] '
+                '[cyan]"Create a Dockerfile for main.py"[/cyan]\n\n'
+                '[bold yellow]yard[/bold yellow] '
+                '[cyan]"Create a .dockerignore file and add the files and folders that should be ignored"[/cyan]'
+            ),
+            title="Examples",
+            title_align="left",
+            border_style="white"
+        )
+    )

yard/helper/depfile.py

@@ -0,0 +1,66 @@
+import re
+from pathlib import Path
+from yard.console.console_ui import console, success
+
+
+def find_dep_file(start=None):
+    if start is None:
+        current_root = Path(__file__).resolve()
+    else:
+        current_root = Path(start).resolve()
+    
+    
+    project_root = [current_root] + list(current_root.parents)
+
+    for parent in project_root:
+
+        with console.status(
+                "[cyan]Resolving dependencies[cyan]"
+            ):
+            # Search for pyproject.toml file in the root directory
+            if (parent / "pyproject.toml").exists():
+
+                success("Dependencies resolved")
+
+                with Path.open(parent/"pyproject.toml") as f:
+                    config = f.read()
+
+                    with console.status(
+                        "[cyan]Detecting Python environment[/cyan]"
+                    ):
+                        match = re.search(r'requires-python\s*=\s*"((?:<=|>=|==|<|>|=)\s*([0-9.]+))"', config)
+                        if match:
+                            version = match.group(1)
+
+                            success(f"Detected Python {version}")
+
+                            return "pyproject.toml", version
+
+            # Search for requirements.txt file in the root directory
+            elif (parent / "requirements.txt").exists():
+
+                success("✓ Dependencies resolved")
+
+                with console.status(
+                        "[cyan]Detecting Python environment[/cyan]"
+                    ):
+                    for venv_name in [".venv", "venv", "env"]:
+                        # Searching python version in the venv
+                        cfg = parent / venv_name / "pyvenv.cfg"
+                        if cfg.exists():
+                            text = cfg.read_text()
+
+                            match = re.search(r"version\s*=\s*([0-9.]+)", text)
+                            if match:
+                                version = match.group(1)
+
+                                success(f"Detected Python {version}")
+
+                                return "requirements.txt", version
+                
+    return None, None
+        
+
+
+if __name__ == "__main__":
+   print(find_dep_file())

yard/intent_agent.py

@@ -0,0 +1,79 @@
+import asyncio
+import os
+from dotenv import load_dotenv
+import json
+import typer
+
+from openai import AsyncOpenAI
+
+from yard.prompt.intent_prompt import SYSTEM_PROMPT
+from yard.schema.intent_schema import INTENT_TOOLS
+
+from yard.logger_config import get_logger
+
+logger = get_logger(__name__)
+
+load_dotenv()
+
+
+def get_openai_client():
+    api_key = os.environ.get("OPENAI_API_KEY")
+
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is not set")
+
+    return AsyncOpenAI(
+        api_key=api_key,
+        timeout=60
+    )
+
+
+async def intent_identifier(intent):
+
+    client = get_openai_client()
+    
+    messages = [{
+                    "role": "system", 
+                    "content": SYSTEM_PROMPT
+                },
+                {
+                    "role": "user", 
+                    "content": intent
+                }]
+    
+    response = await client.chat.completions.create(
+        model="gpt-4.1-nano",
+        messages=messages,
+        tools=INTENT_TOOLS,
+        tool_choice="auto"
+)
+    
+    messages = response.choices[0].message
+
+    if messages.tool_calls:
+        tool_call = messages.tool_calls[0]
+
+        task_name = tool_call.function.name 
+
+        arguments = json.loads(
+            tool_call.function.arguments
+        )
+
+            
+        if task_name == "non_docker_request":
+            logger.info("Task is not related to Docker")
+            return {
+                "success" : False,
+                "task" : task_name,
+                "data" : arguments
+            }
+
+        logger.info(f"Task {task_name} Indentified")   
+        return {
+            "success": True,
+            "task": task_name,
+            "data": arguments
+        }
+
+if __name__ == "__main__":
+    print(asyncio.run(intent_identifier("Create a dockerfile for modelai.py from src directory")))

yard/logger_config.py

@@ -0,0 +1,16 @@
+import logging
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
+    handlers=[
+        logging.FileHandler("app.log"),
+    ]
+)
+
+
+def get_logger(name):
+    return logging.getLogger(name)
+
+

yard/prompt/agent_prompt.py

@@ -0,0 +1,3 @@
+SYSTEM_PROMPT = """
+You are an experienced and highly skilled DevOps Engineer specializing in Docker containerization for Python-based backend applications.
+"""

yard/prompt/intent_prompt.py

@@ -0,0 +1,77 @@
+SYSTEM_PROMPT = """
+You are an intent extracting engine. Your job is to convert the user's message into structured JSON.
+
+Rules:
+- Understand the user's message correctly.
+- Identify the filename with the .py suffix in the user's message.
+- STRICTLY user intent must be related to Docker ONLY.
+- If the user request is related to Docker or DevOps:
+  - Return results ONLY through `tool_calls`.
+  - `message.content` MUST remain completely empty.
+  - Strictly follow the provided tool schema.
+  - Do not change the schema structure.
+  - Do not rename fields.
+- If the user request is NOT related to Docker, containers, DevOps, deployment, infrastructure, CI/CD, orchestration, or Docker ecosystem tasks:
+  - Return the `non_docker_request` tool
+- Do NOT write any Docker-related files (such as "Dockerfile", "compose.yaml", or "dockerignore") as values for the "file" key in the JSON schema.
+
+DOCKERIGNORE RULES:
+- STRICTLY do NOT use `\n`, escaped newline characters, or unnecessary backslashes in `.dockerignore`.
+- Write entries as clean plain lines only.
+- Do not serialize file contents using escaped strings.
+- Preserve raw formatting for all generated files.
+
+#Examples
+
+##Example - 1:
+INPUT: 
+Create a two dockerfiles: one for main.py and another for engine.py in src folder"
+
+OUTPUT:
+{
+    "tasks" : "create_dockerfile",
+    "runnable" : [{
+        "file" : "main.py",
+        "folder" : null
+      },
+      {
+        "file" : "engine.py",
+        "folder" : "src"
+      }
+    ]
+}
+
+##Example - 2:
+INPUT:
+Create a .dockerignore file and add all necessary Python project files and folders that should be ignored, including the src/engine.py file and src/tests folder.
+
+OUTPUT: 
+{   "task" : "create_dockerignore",
+    "ignored" : [
+            ".env",
+            ".env_local",
+            ".python_version",
+            "venv/",
+            ".venv/",
+            "__pycache__/",
+            ".mypy_cache",
+            ".ruff_cache",
+            ".git",
+            "build",
+            "src/engine.py",
+            "src/tests"
+            ]
+}
+
+##Example - 3:
+INPUT: 
+Create a python file and write hello world script
+
+OUTPUT:
+{
+  "task" : "non_docker_request",
+  "message" : I am a specialized Docker DevOps Engineer. Provide tasks related to Docker.
+
+}
+
+"""

yard/prompt/tasks/dockerfile_prompt.py

@@ -0,0 +1,21 @@
+from yard.prompt.tasks.examples.dockerfile_example import EXAMPLE_TEMPLATES
+
+
+
+def prompt(intent, dep_file, version):
+    return f"""Generate a Dockerfile based on the following project intent: `{intent}`.
+Use '{dep_file}' as the dependency file.
+Use Python version '{version}'.
+
+RULES:
+- Generate ONLY valid Dockerfile content and Docker-related instructions that strictly follow the structure and format of the provided example template.
+- Do NOT include explanations, markdown, notes, headings, or additional text outside the required Docker output.
+- If generating more that one Dockerfile, name each file using the format `Dockerfile.<filename>`.
+- If the dependency file is `requirements.txt`, use `pip` as the package manager.
+- If the dependency file is `pyproject.toml`, use `uv sync` to install and synchronize dependencies.
+- Do not assume or invent the Python version. Use only the Python version explicitly provided by the user. 
+
+EXAMPLES:
+`{EXAMPLE_TEMPLATES}'
+        
+"""

yard/prompt/tasks/examples/dockerfile_example.py

@@ -0,0 +1,161 @@
+EXAMPLE_TEMPLATES = """
+#Example-1:
+INPUT: 
+Generate a Dockerfile based on the following project intent: 
+`{
+    "task":"create_dockerfile",
+                 "runnable":[
+                        {
+                          "file":"modelai.py",
+                          "folder":"src"
+                        },
+                        {
+                          "file": "main.py",
+                          "folder" : null
+                        }
+                ]
+}`.
+Use 'pyproject.toml' as the dependency file.
+Use Python version '=> 3.13'.
+
+Output: 
+    `{'dockerfiles' : [{
+            'dockerfile_name' : 'Dockerfile.modelai',
+            'dockerfile_instructions' : '
+                                         FROM python:3.13-slim
+
+                                         # Prevents Python from creating .pyc files
+                                         # Ensures logs are shown immediately in Docker
+                                         # Makes uv use the system Python inside the container
+                                         PYTHONDONETWRITEBYTECODE=1 \
+                                         PYTHONUNBUFFERED=1 \
+                                         UV_SYSTEM_PYTHON=1
+                                         
+                                         # Set working directory
+                                         WORKDIR /app 
+
+                                         # Install uv package manager
+                                         RUN pip install -no-cache-dir uv
+
+                                         # Copy dependency files
+                                         COPY pyproject.toml uv.lock ./
+
+                                         # Install project dependencies
+                                         RUN uv sync --frozen --no-dev --no-cache
+                                         
+                                         # Copy application source code
+                                         COPY src/ ./src/
+                                         
+                                         # Start the application
+                                         CMD ["uv", "run", "-m", "src.modelai"] '
+
+            },
+            {
+               'dockerfile_name' : 'Dockerfile.main',
+                'dockerfile_instructions' : '
+                                         FROM python:3.13-slim
+
+                                         # Prevents Python from creating .pyc files
+                                         # Ensures logs are shown immediately in Docker
+                                         # Makes uv use the system Python inside the container
+                                         PYTHONDONETWRITEBYTECODE=1 \
+                                         PYTHONUNBUFFERED=1 \
+                                         UV_SYSTEM_PYTHON=1
+                                         
+                                         # Set working directory
+                                         WORKDIR /app 
+
+                                         # Install uv package manager
+                                         RUN pip install -no-cache-dir uv
+
+                                         # Copy dependency files
+                                         COPY pyproject.toml uv.lock* ./
+
+                                         # Install project dependencies
+                                         RUN uv sync --frozen --no-dev --no-cache
+                                         
+                                         # Copy application source code
+                                         COPY . .
+                                         
+                                         # Start the application
+                                         CMD ["uv", "run", "main.py"] ' 
+            
+            }]  }`
+
+            
+##Example - 2:
+INPUT: 
+Generate a Dockerfile based on the following project intent: 
+`{
+    "task":"create_dockerfile",
+                 "runnable":[
+                        {
+                          "file":"main.py",
+                          "folder": null
+                        },
+                        {
+                          "file": "app.py",
+                          "folder" : app
+                        }
+                ]
+}`.
+Use 'requirements.txt' as the dependency file.
+Use Python version '=> 3.13'.
+
+
+OUTPUT:
+`{ 'dockerfiles': [
+                {
+                    'dockerfile_name' : 'Dockerfile.main',
+                    'docker_instructions': '
+                                             FROM python:3.13-slim
+
+                                             # Prevents Python from creating .pyc files
+                                             # Ensures logs are shown immediately in Docker
+                                             ENV PYTHONDONTWRITEBYTECODE=1 \
+                                             PYTHONUNBUFFERED=1
+
+                                            # Set working directory
+                                            WORKDIR / app
+
+                                            # Copy project files
+                                            COPY requirements.txt .
+
+                                            # Install dependencies
+                                            RUN pip install --no-cache-dir -r requirements.txt
+
+                                            # Copy application source code
+                                            COPY . .
+
+                                            # Run main.py
+                                            CMD ["python", "main.py"] '
+                },
+                {
+                    'dockerfile_name' : 'Dockerfile.app',
+                    'docker_instructions': '
+                                            FROM python:3.13-slim
+
+                                            # Prevents Python from creating .pyc files
+                                            # Ensures logs are shown immediately in Docker
+                                            ENV PYTHONDONTWRITEBYTECODE=1 \
+                                                PYTHONUNBUFFERED=1
+
+                                            # Set working directory
+                                            WORKDIR /app
+
+                                            # Copy dependency file
+                                            COPY requirements.txt .
+
+                                            # Install project dependencies
+                                            RUN pip install --no-cache-dir -r requirements.txt
+
+                                            # Copy application source code
+                                            COPY app/ ./app/
+
+                                            # Start the application
+                                            CMD["python", "-m", "app.app"]
+                
+                }]}`
+
+
+"""

yard/schema/intent_schema.py

@@ -0,0 +1,87 @@
+INTENT_TOOLS = [
+  {
+      "type" : "function",
+      "function" : {
+          "name" : "create_dockerfile",
+          "description": "Extract creating dockerfile tasks with files and folders",
+          "strict" : True,
+          "parameters" : {
+              "type" : "object",
+              "properties" : {
+                  "task" : {
+                      "type" : "string",
+                      "enum" : ["create_dockerfile"]
+                  },
+                  "runnable" : {
+                      "type" : "array",
+                      "items" : {
+                          "type" : "object",
+                          "properties" : {
+                              "file" : {
+                                  "type" : ["string", "null"]
+                              },
+                              "folder" : {
+                                  "type" : ["string", "null"]
+                              }
+                          },
+                          "required" : ["file", "folder"],
+                          "additionalProperties" : False
+                      }
+                  }
+              },
+              "required" : [
+                  "task",
+                  "runnable"
+              ],
+              "additionalProperties" : False
+          }
+      }
+  },
+  {
+        "type" : "function",
+        "function": {
+            "name" : "create_dockerignore",
+            "description" : "Extract files and folders to ignore and Create a .dockerignore file",
+            "strict" : True,
+            "parameters" : {
+                "type" : "object",
+                "properties" : {
+                    "task" : {
+                        "type" : "string",
+                        "enum" : ["create_dockerignore"]
+                    },
+                    "ignored": {
+                        "type" : "array",
+                        "items" : {
+                            "type" : "string"
+                        },
+                        "description" : "ingored files and folders"
+                    } 
+                },
+                "required" : ["task","ignored"],
+                "additionalProperties" : False
+            }
+        }
+    },
+    {
+    "type": "function",
+    "function": {
+        "name": "non_docker_request",
+        "description": "Use this when the request is not related to Docker or DevOps",
+        "strict": True,
+        "parameters": {
+        "type": "object",
+        "properties": {
+            "message": {
+            "type": "string",
+            "enum": [
+                "I am a specialized Docker DevOps Engineer. Provide tasks related to Docker."
+            ]
+            }
+        },
+        "required": ["message"],
+        "additionalProperties": False
+        }
+    }
+    }
+]

yard/schema/yard_schema.py

@@ -0,0 +1,32 @@
+TOOLS = [
+    {
+        "type" : "function",
+        "function" : {
+            "name" : "create_dockerfile",
+            "description" : "Create a Dockerfile using given information",
+            "parameters" : {
+                "type" : "object",
+                "properties" : {
+                    "dockerfiles" : {
+                        "type" : "array",
+                        "items" : {
+                            "type" : "object",
+                            "properties" : {
+                                "dockerfile_name" : {
+                                    "type" : "string"
+                                },
+                                "dockerfile_instructions" : {
+                                    "type" : "string"
+                                }
+                            },
+                            "required" : ["dockerfile_name", "dockerfile_instructions"],
+                            "additionalProperties" : False
+                        }
+                    }
+                },
+                "required" : ["dockerfiles"],
+                "additionalProperties" : False
+            }
+        }
+    }
+]

yard/tools/create_dockerfile.py

@@ -0,0 +1,40 @@
+import asyncio
+import json
+from yard.logger_config import get_logger
+from yard.yard_agent import yard_devops
+from yard.helper.depfile import find_dep_file
+from yard.console.console_ui import console, success
+from yard.prompt.tasks.dockerfile_prompt import prompt
+
+logger = get_logger(__name__)
+
+
+async def create_dockerfile(intent):
+    
+    dep_filename, version = find_dep_file()
+
+    prompts = prompt(intent, dep_filename, version)
+
+    with console.status(
+        "[cyan]Generating Dockerfile[/cyan]"
+    ):
+        logger.info("Dispatching request to yard agent")
+
+        output = await yard_devops(prompts)
+
+        logger.info(json.dumps(output, indent=2))
+
+        
+        for doc in output["dockerfiles"]:
+
+            logger.info(f"creating {doc["dockerfile_name"]} and writing instructions")
+            success(f"Writing Docker instructions for {doc["dockerfile_name"]}")
+
+            with open(doc["dockerfile_name"], "w") as file:
+                file.write(doc["dockerfile_instructions"])
+
+                success(f"Wrote {doc['dockerfile_name']}")
+                logger.info(f"{doc["dockerfile_name"]} created successfully")
+
+if __name__ == "__main__":
+    asyncio.run(create_dockerfile("""{"intent":"create_dockerfile","runnable_file":[{"file":"modelai.py","folder":"src"}],"mode":"development","response":null}"""))

yard/tools/docker_ignore_file.py

@@ -0,0 +1,26 @@
+import json
+from pathlib import Path
+from yard.console.console_ui import success
+from yard.logger_config import get_logger
+
+
+logger = get_logger(__name__)
+
+
+
+
+async def dockerignore_file(intent):
+
+    logger.info(json.dumps(intent, indent=2))
+    success(f"Adding ignored files and folders")
+
+    files = intent["ignored"]
+
+    logger.info("Adding ignored files and folders")
+    success(f"Adding ignored files and folders")
+    for file in files:
+      with open(".dockerignore", "a+") as f:
+         f.write(f"{file}\n")
+
+    success(".dockerignore file created")
+    logger.info("dockerignore file created")

yard/yard_agent.py

@@ -0,0 +1,89 @@
+import os
+import sys
+import json
+from logging import WARNING
+from dotenv import load_dotenv
+import typer
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential,
+    retry_if_exception_type,
+    before_sleep_log
+)
+from openai import AsyncOpenAI
+from openai import (
+    APIConnectionError,
+    APITimeoutError,
+    RateLimitError,
+    InternalServerError,
+)
+
+from yard.logger_config import get_logger
+from yard.prompt.agent_prompt import SYSTEM_PROMPT
+from yard.schema.yard_schema import TOOLS
+from yard.console.console_ui import error
+
+
+
+logger = get_logger(__name__)
+load_dotenv()
+
+
+
+@retry(
+        retry=retry_if_exception_type((
+            APIConnectionError,
+            APITimeoutError,
+            RateLimitError,
+            InternalServerError,
+        )),
+        wait=wait_random_exponential(
+            multiplier=1,
+            max=60,
+        ),
+        stop=stop_after_attempt(8),
+        before_sleep=before_sleep_log(
+            logger,
+            WARNING
+        ),
+        reraise=True
+)
+async def yard_devops(intent):
+    
+    client = AsyncOpenAI(timeout=60)
+
+    messages = [{
+        "role": "system",
+        "content": SYSTEM_PROMPT
+    },
+    {
+        "role": "user",
+        "content": intent
+    }]
+
+    logger.info("Send OpenAI request")
+    response = await client.chat.completions.create(
+        model="gpt-5.4",
+        messages=messages,
+        tools=TOOLS,
+        tool_choice="auto"
+            
+    )
+
+    logger.info("OpenAI response received")
+    message = response.choices[0].message
+
+    if message.tool_calls:
+        content = message.tool_calls[0]
+
+        output = json.loads(
+            content.function.arguments
+            )
+
+        logger.info("Tool call parsed successfully")
+        return output
+    
+    return None
+

yard/yard_cli.py

@@ -0,0 +1,103 @@
+import sys
+import asyncio
+import typer
+from typer import Typer, Option, Argument
+from typer.core import TyperGroup
+from yard.intent_agent import intent_identifier
+
+from yard.console.help_oargs import custom_help
+from yard.console.console_ui import console, info, success
+from yard.console.error import command_error
+from yard.logger_config import get_logger
+
+
+
+from yard.tools.create_dockerfile import create_dockerfile
+from yard.tools.docker_ignore_file import dockerignore_file
+
+
+logger = get_logger(__name__)
+
+VERSION = "0.1.2"
+
+
+class CustomGroup(TyperGroup):
+    def get_command(self, ctx, cmd_name):
+        rv = super().get_command(ctx, cmd_name)
+
+        if rv is not None:
+            return rv
+        
+        command_error(cmd_name)
+
+        raise typer.Exit(code=1)
+
+
+app = Typer(cls=CustomGroup, 
+            # Typer stops decorating exceptions
+            pretty_exceptions_enable=False,
+            context_settings={
+            # To prevent using the typer's default behaviour of "--help" or '-h'
+            "help_option_names" : []
+            }
+        )
+
+@app.callback(invoke_without_command=True)
+def yard_agent(
+    prompt: str = Argument(""), 
+    help: bool = Option(
+        False,
+        "--help",
+        "-h",
+        is_eager=True,
+    ),
+    version: bool = Option(
+        False,
+        "--version",
+        "-v",
+        is_eager=True,
+    ),
+):  
+    with console.status(
+        "[cyan]Analyzing request[/cyan]"
+    ):
+        if help:
+            custom_help()
+            raise typer.Exit()
+        
+        if len(sys.argv) < 2:
+            custom_help()
+            raise typer.Exit()
+        
+        if version:
+            print(VERSION)
+            raise typer.Exit()
+        try:
+            logger.info("Sending the user message to intent agent")
+
+            result = asyncio.run(intent_identifier(prompt))
+
+        except RuntimeError as e:
+            print("OPENAI_API_KET is not set")
+            raise typer.Exit(code=1)
+
+    if result["success"] is True:
+
+        intent = result["data"]
+
+        if result["data"]["task"] == "create_dockerfile":
+
+            success(f"Prepared {result['data']['task']} tasks")
+            logger.info("Sending the dockerfile intent to create_dockerfile function")
+
+            asyncio.run(create_dockerfile(intent))
+
+        elif result["data"]["task"] == "create_dockerignore":
+
+            success(f"Prepared {result['data']['task']} tasks")
+            logger.info("Sending the ignored files to dockerignore_file function")
+
+            asyncio.run(dockerignore_file(intent))
+    else:
+        logger.info(f"{result["data"]["message"]}")
+        info(result["data"]["message"])

yardx-0.1.2.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: yardx
+Version: 0.1.2
+Summary: Terminal based AI agent for Docker
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=2.33.0
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: tenacity>=9.1.4
+Requires-Dist: typer>=0.25.1
+Dynamic: license-file
+
+# Yard for Docker
+
+Yard is a terminal-based AI agent for Docker. In this first version, it helps developers quickly generate Dockerfiles for Python projects directly from the terminal.
+
+## Status
+
+v1 — under active development.
+
+## What it does
+
+- Generates one or more Dockerfiles and a `.dockerignore` file from a simple command
+- Detects the Python version from project metadata
+- Helps package Python applications for Docker quickly from the terminal
+
+## Install
+
+```bash
+pipx install yard
+```
+
+## Setup
+
+Yard currently uses OpenAI models.
+
+### Windows PowerShell
+
+```powershell
+$env:OPENAI_API_KEY="your_api_key"
+```
+
+### Linux/macOS
+
+```bash
+export OPENAI_API_KEY="your_api_key"
+```
+
+## Example
+
+```bash
+yard "create a dockerfile for this main.py file"
+```
+
+## Privacy
+
+- This project does not send raw files, scripts, or `.env` variables to the AI
+- No data is used for training AI models
+- Yard only reads `pyproject.toml` or `pyvenv.cfg` files to detect the Python version
+
+## License
+
+MIT

yardx-0.1.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+yard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yard/intent_agent.py,sha256=nHo4dWpt3udV-RytygcI_exBg2BZtFqFBoV91XLsq4g,1903
+yard/logger_config.py,sha256=OLwSDimCbTuHJTdmwuXdC7MLQiN7TkCutJk01Hq43d0,269
+yard/yard_agent.py,sha256=MmGj-hzj_CXZOo_GQ-n_JD_9WN57J164j5deK9E4ZGM,1901
+yard/yard_cli.py,sha256=q6XnMFIJJMSQBN6zFYNEvnefxYd_9UNtRxP0oALHhbw,2772
+yard/console/console_ui.py,sha256=k2sjKwV5vB0bRdhgPh4R5Dca-eGuggCq8RjOyyI0t-k,309
+yard/console/error.py,sha256=8BcXFEvsEFVRp0zY1t8UBBYRcnwuyUEAvRbFTN1J-Mo,336
+yard/console/help_oargs.py,sha256=3qETBRqek5_djPFayG30D1qpzKQSu8xgQFy8j1OJim4,1805
+yard/helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yard/helper/depfile.py,sha256=ob6b0WvlJtFho1nkJyaQTJyA_Y2-AauaHaALzjVD3z4,2257
+yard/prompt/agent_prompt.py,sha256=uOw1QcdDuclTBwPgZTNUHpgiRpoUL1LcAdZn1gyinaY,162
+yard/prompt/intent_prompt.py,sha256=UPRT4x4yxdV4nfbXAr5LmPZE5jkTrNvdSOv2FnQ1p0I,2343
+yard/prompt/tasks/dockerfile_prompt.py,sha256=sxB2jy1KCbJlCIFuSWrCZUeC2f8Q-TNzFFnaZBcTue0,1008
+yard/prompt/tasks/examples/dockerfile_example.py,sha256=1-TnJHh4nA4BKMfcg_zGlaKm0iSwauo9glrxRFCi3aA,7001
+yard/schema/intent_schema.py,sha256=31ckh6N5eCn_HK5379bx9TXPhEpAVWFnnYFgo3SjsTY,2861
+yard/schema/yard_schema.py,sha256=nr4148mz0aYXjGSrvYcOhYTSj7mO0sfYnWbzCblYe8Q,1184
+yard/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yard/tools/create_dockerfile.py,sha256=8H38K9wUy_djWcwYMbbnhMf448W_eIvBKt9XLas4ZNs,1376
+yard/tools/docker_ignore_file.py,sha256=ObeNKsg3utH1ohvXsMD57FnNhctHIVHVk69bFupQKpQ,635
+yardx-0.1.2.dist-info/licenses/LICENSE,sha256=x4Uaun97gEUWc_XpgEt98cwb4h6OTuAaZoo2-aqAFeE,1093
+yardx-0.1.2.dist-info/METADATA,sha256=Yk-3zU7LxvhrAdx4k40j_dYTUyaAtonUnMZuC08P_dA,1393
+yardx-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+yardx-0.1.2.dist-info/entry_points.txt,sha256=6pYNx-t6Tsni9NdSX_M_B0esiDK2aMLvsWO7njl62AM,43
+yardx-0.1.2.dist-info/top_level.txt,sha256=GWIEw9vsBE5H6Ztm6mlO6JWemS-HcmFLvvqIs5LfPeE,5
+yardx-0.1.2.dist-info/RECORD,,

yardx-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

yardx-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+yard = yard.yard_cli:app

yardx-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arul Dhanasekar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yardx-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+yard