bob-dev 0.1.0__py3-none-any.whl

bob_dev/cli.py

@@ -0,0 +1,293 @@
+"""cli.py
+
+Entry point for the BOB Dev CLI tool.
+
+Workflow
+--------
+1. Fetch a Jira task by ID (title, description, fix versions).
+2. Read the project's Markdown documentation and build an LLM context string.
+3. Ask an LLM (GROK or OpenAI) to convert the acceptance criteria into a
+   Claude Code prompt, enriched with project context and framework info.
+4. Analyse the generated prompt for ambiguities and security concerns.
+5. Pass the final prompt to the Claude Code CLI for implementation.
+
+Usage
+-----
+    bob-dev --task_id PROJ-123 --path /path/to/repo
+    bob-dev --configure
+
+Environment variables (.env next to this file or exported):
+    GROK_API_KEY    – xAI / GROK secret key
+    OPENAI_API_KEY  – OpenAI secret key
+    AGENT           – "GROK" (default) or "OPENAI"
+    JIRA_URL        – https://your-org.atlassian.net
+    JIRA_EMAIL      – Atlassian account e-mail
+    JIRA_API_TOKEN  – Atlassian API token
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import argparse
+import asyncio
+from pathlib import Path
+
+from InquirerPy import inquirer
+from dotenv import load_dotenv
+
+from .helpers.terminal import (
+    BOLD,
+    RESET,
+    print_error,
+    print_info,
+    print_step,
+    print_success,
+    print_warn,
+    run_subprocess,
+    run_with_spinner,
+)
+from .helpers.jira_helper import get_jira_task
+from .helpers.llm_helper import analyse_prompt, llm_model, prompt_claude_code
+from .helpers.project_helper import build_md_context, identify_framework
+from .helpers.config_helper import check_configuration, update_env_file
+
+# ---------------------------------------------------------------------------
+# Module-level configuration
+# ---------------------------------------------------------------------------
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+load_dotenv(SCRIPT_DIR / ".env")
+
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+GROK_API_KEY   = os.environ.get("GROK_API_KEY", "")
+AGENT          = os.environ.get("AGENT", "GROK").upper()   # "GROK" or "OPENAI"
+
+JIRA_URL       = os.environ.get("JIRA_URL", "")
+JIRA_EMAIL     = os.environ.get("JIRA_EMAIL", "")
+JIRA_API_TOKEN = os.environ.get("JIRA_API_TOKEN", "")
+
+REPO_BASE_PATH  = Path("./")   # Overridden by --path at runtime.
+CLAUDE_CODE_CMD = "claude"     # Must be on $PATH.
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Parse CLI arguments and orchestrate the four-step workflow."""
+
+    parser = argparse.ArgumentParser(
+        prog="bob-dev",
+        description="BOB Dev – AI-assisted developer workflow tool.",
+    )
+    parser.add_argument(
+        "--task_id", type=str,
+        help="Jira task ID to process (e.g. PROJ-123).",
+    )
+    parser.add_argument(
+        "--path", type=str, default="./",
+        help="Path to the target project repository (default: current directory).",
+    )
+    parser.add_argument(
+        "--agent", type=str, choices=["GROK", "OPENAI"], default=AGENT,
+        help="LLM backend to use (default: GROK).",
+    )
+    parser.add_argument(
+        "--configure", action="store_true",
+        help="Run interactive setup to save API keys to .env.",
+    )
+    args = parser.parse_args()
+
+    # ── Interactive configuration wizard ────────────────────────────────────
+    if args.configure:
+        _run_configure()
+        sys.exit(0)
+
+    # ── Require task_id for normal workflow ──────────────────────────────────
+    if not args.task_id:
+        print_error("Jira task ID is required. Use --task_id PROJ-123.")
+        sys.exit(1)
+
+    task_id = args.task_id.strip().upper()
+    agent   = args.agent.upper()
+
+    # ── Validate credentials before making any API calls ────────────────────
+    if not all([JIRA_URL, JIRA_EMAIL, JIRA_API_TOKEN]):
+        print_error("Jira credentials are not configured. Run `bob-dev --configure`.")
+        sys.exit(1)
+
+    if agent == "GROK" and not GROK_API_KEY:
+        print_error("GROK_API_KEY is not set. Run `bob-dev --configure`.")
+        sys.exit(1)
+
+    if agent == "OPENAI" and not OPENAI_API_KEY:
+        print_error("OPENAI_API_KEY is not set. Run `bob-dev --configure`.")
+        sys.exit(1)
+
+    # ── Resolve and validate the repository path ─────────────────────────────
+    global REPO_BASE_PATH
+    REPO_BASE_PATH = Path(args.path).resolve()
+
+    if not REPO_BASE_PATH.exists() or not REPO_BASE_PATH.is_dir():
+        print_error(f"Invalid project path: {REPO_BASE_PATH}")
+        sys.exit(1)
+
+    print_info(f"Project path  : {REPO_BASE_PATH}")
+    print_info(f"Jira task ID  : {task_id}")
+    print_info(f"LLM backend   : {agent} ({llm_model(agent)})")
+    print()
+
+    # ── Step 1 – Fetch Jira task ─────────────────────────────────────────────
+    print_step("[1/4]", f"Fetching Jira task {task_id} …")
+
+    task = asyncio.run(run_with_spinner(
+        get_jira_task,
+        task_id, JIRA_URL, JIRA_EMAIL, JIRA_API_TOKEN,
+        label="Fetching Jira task",
+    ))
+
+    print_success(f"Title         : {task['title']}")
+    print_success(f"Fix versions  : {', '.join(task['fix_versions']) or 'N/A'}")
+    print()
+
+    acceptance_criteria = task["description"]
+    if not acceptance_criteria.strip():
+        print_error("The Jira task has no description / acceptance criteria.")
+        sys.exit(1)
+
+    # ── Step 2 – Read project docs & generate prompt ─────────────────────────
+    print_step("[2/4]", f"Generating Claude Code prompt via {agent} ({llm_model(agent)}) …")
+
+    # Collect Markdown context (blocking I/O) inside the spinner thread.
+    md_context = asyncio.run(run_with_spinner(
+        build_md_context, REPO_BASE_PATH,
+        label="Reading project docs",
+    ))
+
+    # Framework detection is fast – no spinner needed.
+    try:
+        framework = identify_framework(md_context)
+        print_success(f"Detected framework : {framework}")
+    except ValueError as exc:
+        print_warn(str(exc))
+        framework = "the project"
+
+    prompt_md = asyncio.run(run_with_spinner(
+        prompt_claude_code,
+        acceptance_criteria, md_context, framework,
+        agent, GROK_API_KEY, OPENAI_API_KEY,
+        label="Generating prompt",
+        task_meta=task,
+    ))
+
+    if not prompt_md.strip():
+        print_error("Failed to generate a prompt for Claude Code.")
+        sys.exit(1)
+
+    print_success("Prompt generated.")
+    print()
+
+    # ── Step 3 – Analyse the prompt ──────────────────────────────────────────
+    print_step("[3/4]", "Analysing the prompt for issues …")
+
+    analysis = asyncio.run(run_with_spinner(
+        analyse_prompt,
+        prompt_md, acceptance_criteria,
+        agent, GROK_API_KEY, OPENAI_API_KEY,
+        label="Analysing prompt",
+    ))
+
+    print(f"\n{BOLD}── Prompt Analysis {'─' * 50}{RESET}")
+    print(analysis)
+    print("─" * 68 + "\n")
+
+    # ── Confirm before handing off to Claude Code ────────────────────────────
+    answer = input("Proceed and send prompt to Claude Code? [y/N] ").strip().lower()
+    if answer != "y":
+        prompt_file = SCRIPT_DIR / f"claude_prompt-{task_id}.md"
+        prompt_file.write_text(prompt_md, encoding="utf-8")
+        print_info(f"Aborted. Prompt saved to {prompt_file}")
+        sys.exit(0)
+
+    # ── Step 4 – Pass prompt to Claude Code ──────────────────────────────────
+    print_step("[4/4]", "Passing prompt to Claude Code …")
+    print()
+    asyncio.run(_pass_to_claude_code(prompt_md, task_id))
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+async def _pass_to_claude_code(prompt_md: str, task_id: str) -> None:
+    """Write the prompt to a temp file, then run Claude Code non-interactively."""
+
+    # Persist the prompt so the user can review it regardless of outcome.
+    prompt_file = SCRIPT_DIR / "tmp" / f"claude_prompt_{task_id}.md"
+    prompt_file.parent.mkdir(parents=True, exist_ok=True)
+    prompt_file.write_text(prompt_md, encoding="utf-8")
+    print_info(f"Prompt saved to: {prompt_file}")
+
+    cmd = [CLAUDE_CODE_CMD, "--dangerously-skip-permissions", "--print", prompt_md]
+    print_info(f"Running: {' '.join(cmd[:2])} <prompt>")
+    print()
+
+    returncode, _, _ = await run_subprocess(cmd, REPO_BASE_PATH)
+
+    if returncode != 0:
+        print_warn(f"Claude Code exited with code {returncode}")
+
+
+def _run_configure() -> None:
+    """Interactive wizard to write API keys and Jira credentials to .env."""
+    env_path = SCRIPT_DIR / ".env"
+    print_step("[CONFIGURE]", "Running initial configuration …")
+
+    # Choose the LLM backend.
+    system_choice = inquirer.select(
+        message="Select the default LLM backend:",
+        choices=["GROK", "OPENAI"],
+    ).execute()
+
+    # Collect the appropriate API key.
+    print(f"Enter your {system_choice} API key:")
+    api_key = input("> ").strip()
+    env_key = "GROK_API_KEY" if system_choice == "GROK" else "OPENAI_API_KEY"
+    update_env_file(env_key, api_key, env_path)
+    print_success(f"{system_choice} API key saved.")
+
+    # Jira credentials.
+    print("\nJira configuration:")
+    jira_url   = input("JIRA_URL   (e.g. https://your-org.atlassian.net): ").strip()
+    jira_email = input("JIRA_EMAIL (your Atlassian account e-mail)       : ").strip()
+    jira_token = input("JIRA_API_TOKEN (Atlassian API token)              : ").strip()
+
+    for key, val in [
+        ("JIRA_URL",       jira_url),
+        ("JIRA_EMAIL",     jira_email),
+        ("JIRA_API_TOKEN", jira_token),
+    ]:
+        update_env_file(key, val, env_path)
+
+    print_success("Jira configuration saved.")
+
+    # Claude Code API key.
+    print("\nClaude Code API key:")
+    claude_key = input("CLAUDE_API_KEY: ").strip()
+    update_env_file("CLAUDE_API_KEY", claude_key, env_path)
+    print_success("Claude Code configuration saved.")
+
+    # Optional: verify all keys immediately.
+    answer = input("\nVerify all keys now? [y/N] ").strip().lower()
+    if answer == "y":
+        check_configuration(
+            agent          = os.environ.get("AGENT", "GROK").upper(),
+            grok_api_key   = os.environ.get("GROK_API_KEY", ""),
+            openai_api_key = os.environ.get("OPENAI_API_KEY", ""),
+            jira_url       = jira_url,
+            jira_email     = jira_email,
+            jira_api_token = jira_token,
+            claude_cmd     = CLAUDE_CODE_CMD,
+        )

bob_dev/constants/frameworks.py

@@ -0,0 +1,28 @@
+AVAILABLE_FRAMEWORKS = [
+    "Django REST Framework",
+    "Flask",
+    "FastAPI",
+    "Express.js",
+    "Spring Boot",
+    "Ruby on Rails",
+    "Laravel",
+    "ASP.NET Core",
+    "Symfony",
+    "CakePHP",
+    "CodeIgniter",
+    "Angular",
+    "React",
+    "Vue.js",
+    "Svelte",
+    "Next.js",
+    "Nuxt.js",
+    "Flutter",
+    "React Native",
+    "Ionic",
+    "Xamarin",
+    "Electron",
+    "NestJS",
+    "AdonisJS",
+    "Hadoop",
+    "Spark",
+]

bob_dev/helpers/__init__.py

@@ -0,0 +1 @@
+# helpers package – utility modules for bob_dev

bob_dev/helpers/config_helper.py

@@ -0,0 +1,107 @@
+"""config_helper.py
+
+Configuration utilities for bob_dev:
+  - Write / update key-value pairs in the .env file.
+  - Validate all external service credentials and print coloured results.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from .terminal import print_error, print_success, print_info
+
+
+# ---------------------------------------------------------------------------
+# .env management
+# ---------------------------------------------------------------------------
+
+def update_env_file(key: str, value: str, env_path: Path) -> None:
+    """Write or update *key=value* in *env_path* and apply it to os.environ.
+
+    If the key already exists in the file it is updated in place; otherwise
+    a new line is appended.  The updated file is also re-loaded via dotenv.
+    """
+    lines: list[str] = []
+    if env_path.exists():
+        lines = env_path.read_text(encoding="utf-8").splitlines()
+
+    updated = False
+    for i, line in enumerate(lines):
+        if line.startswith(f"{key}="):
+            lines[i] = f"{key}={value}"
+            updated  = True
+            break
+
+    if not updated:
+        lines.append(f"{key}={value}")
+
+    env_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    os.environ[key] = value
+    load_dotenv(env_path)
+
+
+# ---------------------------------------------------------------------------
+# Configuration verification
+# ---------------------------------------------------------------------------
+
+def check_configuration(
+    agent: str,
+    grok_api_key: str,
+    openai_api_key: str,
+    jira_url: str,
+    jira_email: str,
+    jira_api_token: str,
+    claude_cmd: str,
+) -> None:
+    """Validate all API keys and the Claude Code CLI, printing coloured results.
+
+    Each check is independent: a failure in one does not stop the others.
+    """
+    # ── LLM API key ───────────────────────────────────────────────────────
+    print_info(f"Checking {agent} API key …")
+    try:
+        from .llm_helper import build_llm_client, llm_model
+
+        client   = build_llm_client(agent, grok_api_key, openai_api_key)
+        model    = llm_model(agent)
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "system", "content": "Say: API key OK"}],
+            temperature=0,
+        )
+        reply = response.choices[0].message.content or ""
+        print_success(f"{agent} API key working. Response: {reply}")
+    except Exception as exc:
+        print_error(f"Failed to connect to {agent} API: {exc}")
+
+    # ── Jira credentials ──────────────────────────────────────────────────
+    print_info("Checking Jira credentials …")
+    try:
+        from atlassian import Jira
+
+        jira = Jira(url=jira_url, username=jira_email, password=jira_api_token, cloud=True)
+        user = jira.myself()
+        print_success(f"Jira credentials OK. Authenticated as: {user.get('displayName')}")
+    except Exception as exc:
+        print_error(f"Failed to connect to Jira: {exc}")
+
+    # ── Claude Code CLI ───────────────────────────────────────────────────
+    print_info(f"Checking Claude Code CLI ({claude_cmd}) …")
+    try:
+        result = subprocess.run(
+            [claude_cmd, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            print_success(f"Claude Code CLI OK. Version: {result.stdout.strip()}")
+        else:
+            print_error(f"Claude Code CLI error: {result.stderr.strip()}")
+    except Exception as exc:
+        print_error(f"Failed to run Claude Code CLI: {exc}")

bob_dev/helpers/jira_helper.py

@@ -0,0 +1,75 @@
+"""jira_helper.py
+
+Jira integration utilities for bob_dev:
+  - Fetch a Jira issue and normalise its fields into a plain dict.
+  - Parse Atlassian Document Format (ADF) nodes into plain text.
+"""
+
+from __future__ import annotations
+
+from atlassian import Jira
+
+
+def get_jira_task(
+    task_id: str,
+    jira_url: str,
+    jira_email: str,
+    jira_token: str,
+) -> dict:
+    """Connect to Jira Cloud and return normalised fields for *task_id*.
+
+    Returns a dict with keys:
+        task_id      (str)
+        title        (str)
+        description  (str – plain text extracted from ADF or raw string)
+        fix_versions (list[str])
+    """
+    jira = Jira(
+        url=jira_url,
+        username=jira_email,
+        password=jira_token,
+        cloud=True,
+    )
+
+    issue  = jira.issue(task_id)
+    fields = issue.get("fields", {})
+
+    title: str        = fields.get("summary", "")
+    fix_versions: list[str] = [v["name"] for v in fields.get("fixVersions", [])]
+
+    # The description field may be Atlassian Document Format (dict) or plain text.
+    raw_description = fields.get("description") or ""
+    description = (
+        _adf_to_text(raw_description)
+        if isinstance(raw_description, dict)
+        else str(raw_description)
+    )
+
+    return {
+        "task_id":      task_id,
+        "title":        title,
+        "description":  description,
+        "fix_versions": fix_versions,
+    }
+
+
+def _adf_to_text(node: dict, _depth: int = 0) -> str:
+    """Recursively extract plain text from an Atlassian Document Format node.
+
+    ADF is a nested JSON tree.  This function walks the tree and joins
+    text leaves with appropriate line-break separators based on node type.
+    """
+    node_type = node.get("type", "")
+    text      = node.get("text", "")
+    children  = node.get("content", [])
+
+    parts: list[str] = []
+    if text:
+        parts.append(text)
+    for child in children:
+        parts.append(_adf_to_text(child, _depth + 1))
+
+    # Block-level nodes get a newline separator; inline nodes do not.
+    block_types = {"paragraph", "heading", "listItem", "bulletList", "orderedList"}
+    separator   = "\n" if node_type in block_types else ""
+    return separator.join(parts)

bob_dev/helpers/llm_helper.py

@@ -0,0 +1,187 @@
+"""llm_helper.py
+
+LLM integration for bob_dev:
+  - Build an OpenAI-compatible client for GROK or OpenAI backends.
+  - Return the appropriate model name for a given backend.
+  - Generate a Claude Code prompt from Jira acceptance criteria.
+  - Analyse a generated prompt for gaps and security concerns.
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+from openai import OpenAI
+
+
+# ---------------------------------------------------------------------------
+# Client & model helpers
+# ---------------------------------------------------------------------------
+
+def build_llm_client(agent: str, grok_api_key: str, openai_api_key: str) -> OpenAI:
+    """Return an OpenAI-compatible client for *agent* ("GROK" or "OPENAI").
+
+    Raises EnvironmentError if the required API key is missing.
+    """
+    if agent == "GROK":
+        if not grok_api_key:
+            raise EnvironmentError("GROK_API_KEY is not set in .env")
+        return OpenAI(api_key=grok_api_key, base_url="https://api.x.ai/v1")
+
+    # Default: OpenAI
+    if not openai_api_key:
+        raise EnvironmentError("OPENAI_API_KEY is not set in .env")
+    return OpenAI(api_key=openai_api_key)
+
+
+def llm_model(agent: str) -> str:
+    """Return the model identifier for the given *agent* backend."""
+    return "grok-3" if agent == "GROK" else "gpt-4o"
+
+
+# ---------------------------------------------------------------------------
+# Prompt generation
+# ---------------------------------------------------------------------------
+
+def prompt_claude_code(
+    acceptance_criteria: str,
+    md_context: str,
+    project_framework: str,
+    agent: str,
+    grok_api_key: str,
+    openai_api_key: str,
+    task_meta: dict | None = None,
+) -> str:
+    """Ask the LLM to convert *acceptance_criteria* into a Claude Code prompt.
+
+    Parameters
+    ----------
+    acceptance_criteria:
+        Raw description text from the Jira task.
+    md_context:
+        Pre-built string of project Markdown files + summarised README.
+    project_framework:
+        Detected framework name (e.g. "Django REST Framework").
+    agent:
+        "GROK" or "OPENAI".
+    grok_api_key / openai_api_key:
+        API keys; the unused one may be an empty string.
+    task_meta:
+        Optional dict with 'task_id', 'title', 'fix_versions' for context.
+
+    Returns
+    -------
+    str
+        Markdown-formatted prompt ready to be fed to Claude Code.
+    """
+    client = build_llm_client(agent, grok_api_key, openai_api_key)
+    model  = llm_model(agent)
+
+    # Build optional task-metadata block injected into the user message.
+    meta_block = ""
+    if task_meta:
+        versions   = ", ".join(task_meta.get("fix_versions", [])) or "N/A"
+        meta_block = textwrap.dedent(f"""
+            ## Task Metadata
+            - **ID:** {task_meta.get('task_id', '')}
+            - **Title:** {task_meta.get('title', '')}
+            - **Fix Versions:** {versions}
+        """)
+
+    system_prompt = textwrap.dedent(f"""
+        You are a senior software engineer working on a {project_framework} project.
+        Your job is to convert a Jira acceptance criteria description into a precise,
+        actionable prompt for Claude Code – an AI coding assistant that implements
+        features directly in the codebase.
+
+        The prompt you produce must:
+        1.  Be formatted in **Markdown**.
+        2.  Have a clear "## Objective" section summarising what needs to be built.
+        3.  Have a "## Context" section referencing relevant {project_framework} apps
+            and models from the provided project docs.
+        4.  Have an "## Implementation Steps" section with numbered, concrete steps.
+        5.  Have a "## Test Scenarios" section with specific unit / integration tests
+            (use {project_framework} TestCase / DRF APITestCase conventions).
+        6.  Have an "## Acceptance Criteria" section restating the original criteria
+            as a dev-friendly checklist.
+        7.  Prevent N+1 queries and other common {project_framework} performance pitfalls.
+        8.  NOT assume information absent from the acceptance criteria or project docs.
+        9.  Be concise – avoid unnecessary prose.
+        10. NOT invent API contracts or schemas that contradict the existing docs.
+        11. NOT include any instructions about commits, PRs, or GitHub interactions.
+    """).strip()
+
+    user_message = textwrap.dedent(f"""
+        ## Project Documentation
+
+        {md_context}
+
+        ---
+
+        {meta_block}
+
+        ## Acceptance Criteria (from Jira)
+
+        {acceptance_criteria}
+
+        ---
+
+        Convert the acceptance criteria above into a Claude Code prompt.
+    """).strip()
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user",   "content": user_message},
+        ],
+        temperature=0.3,
+    )
+
+    return response.choices[0].message.content or ""
+
+
+# ---------------------------------------------------------------------------
+# Prompt analysis
+# ---------------------------------------------------------------------------
+
+def analyse_prompt(
+    prompt_md: str,
+    acceptance_criteria: str,
+    agent: str,
+    grok_api_key: str,
+    openai_api_key: str,
+) -> str:
+    """Ask the LLM to review *prompt_md* for ambiguities and security concerns.
+
+    Returns a short bullet-point analysis string (max ~300 words).
+    """
+    client = build_llm_client(agent, grok_api_key, openai_api_key)
+    model  = llm_model(agent)
+
+    system_prompt = textwrap.dedent("""
+        You are a senior tech lead reviewing a prompt for an AI coding assistant.
+        Identify:
+        - Ambiguities or missing information that could cause wrong implementation.
+        - Security concerns (missing auth checks, data exposure, injection risks).
+        - Whether the test scenarios adequately cover the acceptance criteria.
+        - Suggested improvements if needed.
+
+        Be concise. Use bullet points. Max 300 words.
+    """).strip()
+
+    user_message = (
+        f"## Original Acceptance Criteria\n\n{acceptance_criteria}\n\n"
+        f"## Generated Claude Code Prompt\n\n{prompt_md}"
+    )
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user",   "content": user_message},
+        ],
+        temperature=0.2,
+    )
+
+    return response.choices[0].message.content or ""

bob_dev/helpers/project_helper.py

@@ -0,0 +1,101 @@
+"""project_helper.py
+
+Project context utilities for bob_dev:
+  - Collect Markdown files from the repository for LLM context.
+  - Summarise README.md content.
+  - Detect the primary framework used in the project.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from summa.summarizer import summarize
+
+from ..constants.frameworks import AVAILABLE_FRAMEWORKS
+
+
+# ---------------------------------------------------------------------------
+# Markdown context collection
+# ---------------------------------------------------------------------------
+
+def collect_md_context(
+    root: Path,
+    max_files: int = 30,
+    max_chars: int = 40_000,
+) -> str:
+    """Walk *root* and return concatenated content of Markdown files.
+
+    Files are sorted alphabetically and capped at *max_files* / *max_chars*
+    to keep the LLM context window manageable.
+    """
+    md_files = sorted(root.rglob("*.md"))[:max_files]
+    parts: list[str] = []
+    total = 0
+
+    for md in md_files:
+        try:
+            text = md.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+
+        relative = md.relative_to(root)
+        chunk    = f"### {relative}\n\n{text}\n\n"
+
+        if total + len(chunk) > max_chars:
+            break
+
+        parts.append(chunk)
+        total += len(chunk)
+
+    return "".join(parts)
+
+
+def read_readme(repo_path: Path) -> str:
+    """Return the content of README.md (case-insensitive) at *repo_path*.
+
+    Returns an empty string if no README file is found.
+    """
+    for name in ("README.md", "readme.md", "Readme.md"):
+        path = repo_path / name
+        if path.exists() and path.is_file():
+            try:
+                return path.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                pass
+    return ""
+
+
+def build_md_context(repo_path: Path) -> str:
+    """Build a combined context string for LLM consumption.
+
+    Combines a summarised README (up to 300 words) with the full
+    Markdown context collected from the repository.
+    """
+    readme_raw     = read_readme(repo_path)
+    readme_summary = summarize(readme_raw, words=300) if readme_raw.strip() else ""
+    md_context     = collect_md_context(repo_path)
+
+    return "# README:\n" + readme_summary + "\n\n# Context:\n" + md_context
+
+
+# ---------------------------------------------------------------------------
+# Framework detection
+# ---------------------------------------------------------------------------
+
+def identify_framework(combined_text: str) -> str:
+    """Detect the primary framework from *combined_text* (README + MD context).
+
+    Iterates over the known frameworks list and returns the first match.
+
+    Raises ValueError if no framework is detected.
+    """
+    lower = combined_text.lower()
+    for framework in AVAILABLE_FRAMEWORKS:
+        if framework.lower() in lower:
+            return framework
+
+    raise ValueError(
+        "Could not detect the project framework from the documentation. "
+        "Ensure your README.md or Markdown files mention the framework name."
+    )

bob_dev/helpers/terminal.py

@@ -0,0 +1,134 @@
+"""terminal.py
+
+Terminal output utilities for bob_dev:
+  - ANSI color constants
+  - Typed print helpers (error = red, success = green, plain for everything else)
+  - Async spinner with ASCII desert-car animation
+  - Async subprocess runner with the same animation
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# ANSI color codes
+# ---------------------------------------------------------------------------
+
+RED    = "\033[91m"
+GREEN  = "\033[92m"
+YELLOW = "\033[93m"
+BOLD   = "\033[1m"
+RESET  = "\033[0m"
+
+# ---------------------------------------------------------------------------
+# Print helpers
+# ---------------------------------------------------------------------------
+
+def print_error(msg: str) -> None:
+    """Print a red error line prefixed with [✗]."""
+    print(f"{RED}[✗] {msg}{RESET}")
+
+
+def print_success(msg: str) -> None:
+    """Print a green success line prefixed with [✓]."""
+    print(f"{GREEN}[✓] {msg}{RESET}")
+
+
+def print_info(msg: str) -> None:
+    """Print a plain informational line (no colour)."""
+    print(f"[i] {msg}")
+
+
+def print_warn(msg: str) -> None:
+    """Print a plain warning line (no colour)."""
+    print(f"[!] {msg}")
+
+
+def print_step(step: str, msg: str) -> None:
+    """Print a bold step label (e.g. '[1/4]') followed by a plain message."""
+    print(f"{BOLD}{step}{RESET} {msg}")
+
+
+# ---------------------------------------------------------------------------
+# ASCII desert-car animation helpers
+# ---------------------------------------------------------------------------
+
+# The landscape string is scrolled left one character per frame.
+_DESERT = ". . ● . . o . . ● " * 2  # Repeated to ensure it's long enough for smooth scrolling
+# Four frames of wheel animation for the car body.ƒ
+_CAR_FRAMES = ["O", "O", "ᗧ", "ᗧ"]
+
+
+def _render_car_frame(i: int, label: str, elapsed: float) -> str:
+    """Build the single-line spinner string for frame index *i*."""
+    offset    = i % len(_DESERT)
+    landscape = (_DESERT[offset:] + _DESERT[:offset])[:6]
+    car       = _CAR_FRAMES[i % len(_CAR_FRAMES)]
+    return f"\r  {YELLOW}{car}{RESET} {landscape}(tokens) - {label}... ({elapsed:.1f}s)"
+
+
+# ---------------------------------------------------------------------------
+# Async spinner wrappers
+# ---------------------------------------------------------------------------
+
+async def run_with_spinner(func, *args, label: str = "Processing", **kwargs):
+    """Run a blocking *func* in a thread while showing the car animation.
+
+    Any extra *args* / *kwargs* are forwarded directly to *func*.
+    The keyword argument *label* controls the text shown next to the animation
+    and is consumed by this function (not forwarded).
+
+    Returns whatever *func* returns.
+    """
+    # Schedule the blocking call without awaiting it immediately.
+    task = asyncio.create_task(asyncio.to_thread(func, *args, **kwargs))
+
+    start_time = time.time()
+    i = 0
+    while not task.done():
+        elapsed = time.time() - start_time
+        print(_render_car_frame(i, label, elapsed), end="", flush=True)
+        i += 1
+        await asyncio.sleep(0.12)
+
+    # Clear the animation line.
+    print("\r" + " " * 70 + "\r", end="", flush=True)
+    return task.result()
+
+
+async def run_subprocess(cmd: list[str], cwd: Path) -> tuple[int, str, str]:
+    """Run *cmd* as an async subprocess under *cwd* with the car animation.
+
+    Streams stdout and stderr to the terminal once the process finishes.
+
+    Returns:
+        (returncode, stdout, stderr)
+    """
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=str(cwd),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    start_time = time.time()
+    i = 0
+    while proc.returncode is None:
+        elapsed = time.time() - start_time
+        print(_render_car_frame(i, "Running claude", elapsed), end="", flush=True)
+        i += 1
+        await asyncio.sleep(0.12)
+
+    # Clear the animation line.
+    print("\r" + " " * 70 + "\r", end="", flush=True)
+
+    stdout, stderr = await proc.communicate()
+    if stdout:
+        print(stdout.decode())
+    if stderr:
+        print(stderr.decode())
+
+    return proc.returncode, stdout.decode(), stderr.decode()

bob_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: bob-dev
+Version: 0.1.0
+Summary: An AI developer to write code for you
+Author-email: Samuel Pereira dos Santos <samuelsantosdev@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# BOB Dev
+
+**BOB Dev** is an AI-powered developer workflow CLI that bridges a task requirements, your codebase, and Claude Code.
+
+![BOB-Dev Banner](https://github.com/samuelsantosdev/bob-dev/blob/main/assets/banner.png)
+
+Given a Jira task ID it will:
+
+1. **Fetch** the task title, description, and fix versions from Jira.
+2. **Read** your project's Markdown documentation to build rich LLM context.
+3. **Generate** a precise Claude Code prompt (via GROK or OpenAI), including project-framework context, implementation steps, and test scenarios.
+4. **Analyse** the prompt for ambiguities and security concerns.
+5. **Execute** the prompt with the Claude Code CLI (optional – you can review first).
+
+---
+
+## Requirements
+
+- Python 3.11+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and available on `$PATH` as `claude`
+- A Jira Cloud account with an [API token](https://id.atlassian.com/manage-profile/security/api-tokens)
+- An [xAI / GROK](https://console.x.ai/) **or** [OpenAI](https://platform.openai.com/) API key
+
+---
+
+## Installation
+
+```bash
+pip install bob-dev
+```
+
+---
+
+## Configuration
+
+Run the interactive setup wizard the first time:
+
+```bash
+bob-dev --configure
+```
+
+This will prompt for your API keys, Jira credentials, and Claude Code API key.
+
+---
+
+## Usage
+
+```bash
+bob-dev --task_id PROJ-123 --path /path/to/your/repo
+```
+
+| Flag | Description |
+|------|-------------|
+| `--task_id` | Jira task ID to process (required for normal workflow) |
+| `--path` | Path to the target repository (default: current directory) |
+| `--agent` | LLM backend: `GROK` or `OPENAI` (default: value of `AGENT` in `.env`) |
+| `--configure` | Run the interactive configuration wizard |
+
+---
+
+## Project structure
+
+```
+src/bob_dev/
+├── cli.py                  # Entry point & main workflow orchestration
+├── helpers/
+│   ├── terminal.py         # ANSI colours, print helpers, spinner animation
+│   ├── jira_helper.py      # Jira API connection + ADF-to-text parsing
+│   ├── llm_helper.py       # LLM client, model selection, prompt generation
+│   ├── project_helper.py   # Markdown context collection + framework detection
+│   └── config_helper.py    # .env management + credential validation
+└── constants/
+    └── frameworks.py       # Known framework names used for auto-detection
+```
+
+---
+
+## Colour conventions
+
+| Colour | Meaning |
+|--------|---------|
+| Red    | Errors that stop execution |
+| Green  | Success messages |
+| Plain  | Informational / default output |
+
+---
+
+## License
+
+MIT

bob_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bob_dev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bob_dev/cli.py,sha256=g8azCAJI0wTrlAhwQFeITpUuIGQIyU9MEK2uJGXOqNM,11093
+bob_dev/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bob_dev/constants/frameworks.py,sha256=Zcp1lqAY4re4CjO-0DLEpU4mD71UWCaxCMZjjAs3S5o,447
+bob_dev/helpers/__init__.py,sha256=4txLltQKoBei__spwrfAwRBVgN2rZWnN_LfImCPe4dg,50
+bob_dev/helpers/config_helper.py,sha256=fr7d1-M6AwzxyEgyuyZEzgte2fEwW_gxEiuhN8yFbfI,3988
+bob_dev/helpers/jira_helper.py,sha256=97M2MZ62NQSnSnOq_vgfHppIR2mOb0bjkzTO23_cuDU,2208
+bob_dev/helpers/llm_helper.py,sha256=-zPPhkrOgkMBSPqi5YHfY1whafbwBJ-4HPIPN7QpNec,6495
+bob_dev/helpers/project_helper.py,sha256=MRG6BL9DqrrDoEIPdAsNolD8rq1cUxiWDKxQn5MlIlw,3083
+bob_dev/helpers/terminal.py,sha256=dWwhSinvctk3J3Il6l3Ky-KN5tfAf8ptSP5b-UG_SJk,4340
+bob_dev-0.1.0.dist-info/licenses/LICENSE,sha256=mGS4YZDhM8Mb5BWvEXa_1u9ctDyhaAeFvy182Rkkv8U,744
+bob_dev-0.1.0.dist-info/METADATA,sha256=wMokinb5mmv3gzTXinkHpvQlBx_1kGEjlqvpzWmVPJM,2975
+bob_dev-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bob_dev-0.1.0.dist-info/entry_points.txt,sha256=3XHdjzhLETqYvM5xmiuIvxxB0i9d3RkjlJ4uLeNrzKA,45
+bob_dev-0.1.0.dist-info/top_level.txt,sha256=nbfFtA2C9OUmLV6EbTHCoOOWIDhNnnd4tcmzL01-j4w,17
+bob_dev-0.1.0.dist-info/RECORD,,

bob_dev-0.1.0.dist-info/WHEEL

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

bob_dev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bob-dev = bob_dev.cli:main

bob_dev-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+PRIVATE LICENSE
+
+Copyright (c) 2024. All rights reserved.
+
+This project and all its contents, including but not limited to source code, documentation, 
+and other materials, are proprietary and confidential. Unauthorized copying, distribution, 
+modification, or use of this material is strictly prohibited without express written permission 
+from the copyright holder.
+
+RESTRICTIONS:
+- This software is provided for authorized use only
+- Copying, modifying, or distributing the software is prohibited
+- Reverse engineering or decompiling is strictly forbidden
+- Commercial use is not permitted without explicit authorization
+- No warranties or guarantees are provided
+
+For permission or licensing inquiries, please contact the copyright holder.

bob_dev-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+bob_dev