boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/config.py

@@ -0,0 +1,235 @@
+# pylint: disable=import-outside-toplevel,line-too-long,missing-docstring,too-many-branches,too-many-instance-attributes,too-many-statements,use-maxsplit-arg
+from __future__ import annotations
+import subprocess
+import re
+
+import functools
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass(frozen=True)
+class ProjectConfig:
+    github_repo: str | None = None
+    github_token_env: str = "GITHUB_TOKEN"
+    jules_api_url: str | None = None
+    core_dirs: List[str] = field(default_factory=lambda: ["src/layouts/", "src/components/"])
+    monolithic_pr_threshold: int = 3
+    base_branch: str = "origin/main"
+    vite_base_path: str = "/tech-dancer/"
+    gh_path: str = "gh"
+    max_diff_chars: int = 40000
+    content_scopes: Dict[str, str] = field(
+        default_factory=lambda: {
+            "resources": "content/resources/",
+            "posts": "content/posts/",
+            "blog": "content/blog/",
+            "studies": "content/studies/",
+        }
+    )
+    ai_synthesis_model: str = "gpt-4o-mini"
+    ai_review_model: str = "gpt-4o"
+    ai_vision_model: str = "gpt-4o"
+    ui_indicators: List[str] = field(
+        default_factory=lambda: [
+            "src/components",
+            "src/pages",
+            "src/layouts",
+            "src/index.css",
+            "tailwind",
+        ]
+    )
+    tailwind_indicators: List[str] = field(default_factory=lambda: ["px-", "py-", "mt-", "flex", "grid", "text-["])
+    audit_check_dirs: List[str] = field(
+        default_factory=lambda: [
+            "src/features",
+            "src/pages",
+            "src/components",
+            "src/layouts",
+            "src/App.tsx",
+        ]
+    )
+    cli_alias: str = "td-cli"
+    default_limit: int = 10
+    allowed_bots: List[str] = field(default_factory=lambda: ["github-actions[bot]"])
+    worktree_prefix: str = "bt-repair-"
+    pnpm_version: str = "10.28.2"
+    infra_file_paths: List[str] = field(
+        default_factory=lambda: [
+            "scripts/",
+            "boomtick-pkg/cli/",
+            ".github/",
+            "setup-agent.sh",
+            "Dockerfile",
+        ]
+    )
+    infra_feedback: str = (
+        "- **Infrastructure/Bootstrap Change:** Low-level script changes detected.\n"
+        "  - *Review focus:* Ensure idempotency, portability (avoid bashisms), and robust error handling (`set -e`, `set -u`).\n"
+        "  - *Verification:* If full system setup is risky, verify via dry-runs, `bash -n`, or log inspection. Document verification method in the PR.\n"
+    )
+    temp_file_patterns: List[str] = field(
+        default_factory=lambda: [
+            r".*\.tmp$",
+            r"^[^/]+\.py$",
+            r".*audit.*\.md$",
+            r".*dump.*\.json$",
+            r".*\.jsonl$",
+        ]
+    )
+    temp_file_feedback: str = (
+        "- **Stray/Temporary Files:** Suspicious files (scripts, logs, audits) detected. "
+        "Verify if these are intended to be committed.\n"
+    )
+    spec_sections: List[str] = field(
+        default_factory=lambda: [
+            "Problem Statement",
+            "Goal",
+            "Non-Goals",
+            "Proposed Approach",
+            "Alternatives Considered",
+            "Architectural Impact",
+            "Scope",
+            "UNDERSTAND THE ISSUE",
+            "DETERMINE APPROACH",
+            "SPECIFY SCOPE",
+            "DEFINITION OF DONE",
+        ]
+    )
+
+    @property
+    def base_branch_name(self) -> str:
+        """Returns the base branch name without the remote prefix (e.g., 'main' for 'origin/main')."""
+        if not self.base_branch:
+            return "main"
+        return self.base_branch.split("/")[-1]
+
+    @property
+    def context_builder_script(self) -> str:
+        """Returns the absolute path to the context builder script."""
+        from dev_tools.utils import resolve_resource_path
+
+        return resolve_resource_path("build-repo-context.py")
+
+
+@functools.lru_cache()
+def get_config(path: str | Path = "project_config.json") -> ProjectConfig:
+    """Returns a cached singleton instance of ProjectConfig."""
+    return load_project_config(path)
+
+
+@functools.lru_cache()
+def _detect_repo_name() -> str | None:
+    """Safely detects repository name from git remote."""
+    try:
+        res = subprocess.run(
+            ["git", "config", "--get", "remote.origin.url"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if res.returncode != 0:
+            return None
+        url = res.stdout.strip()
+        if not url:
+            return None
+        match = re.search(r"[:/]([^/]+/[^/.]+)(\.git)?$", url)
+        return match.group(1) if match else url
+    except Exception:
+        return None
+
+
+def load_project_config(path: str | Path = "project_config.json") -> ProjectConfig:
+    p = Path(path)
+
+    raw: Dict[str, Any] = {}
+    if p.exists():
+        try:
+            raw = json.loads(p.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, IOError):
+            pass
+    elif path != "project_config.json":
+        # If a specific path was requested but doesn't exist, return default
+        return ProjectConfig()
+    else:
+        # Check parent directories for project_config.json if not in CWD
+        # This helps when running from subdirectories
+        current = Path.cwd()
+        for parent in [current] + list(current.parents):
+            check_path = parent / "project_config.json"
+            if check_path.exists():
+                try:
+                    raw = json.loads(check_path.read_text(encoding="utf-8"))
+                    break
+                except (json.JSONDecodeError, IOError):
+                    pass
+
+    def get_list(key: str) -> Optional[List[str]]:
+        val = raw.get(key)
+        if val is None:
+            return None
+        if isinstance(val, str):
+            return [val]
+        if isinstance(val, list):
+            return [str(item) for item in val]
+        return None
+
+    def get_dict(key: str) -> Optional[Dict[str, str]]:
+        val = raw.get(key)
+        if isinstance(val, dict):
+            return {str(k): str(v) for k, v in val.items()}
+        return None
+
+    kwargs: Dict[str, Any] = {}
+    if "github_repo" in raw or "repo_name" in raw:
+        kwargs["github_repo"] = raw.get("github_repo") or raw.get("repo_name")
+    else:
+        kwargs["github_repo"] = _detect_repo_name() or "arii/tech-dancer"
+
+    if "vite_base_path" in raw:
+        kwargs["vite_base_path"] = raw["vite_base_path"]
+    if "gh_path" in raw:
+        kwargs["gh_path"] = raw["gh_path"]
+    if "github_token_env" in raw:
+        kwargs["github_token_env"] = raw["github_token_env"]
+    if "jules_api_url" in raw:
+        kwargs["jules_api_url"] = raw["jules_api_url"]
+    if "monolithic_pr_threshold" in raw:
+        kwargs["monolithic_pr_threshold"] = int(raw["monolithic_pr_threshold"])
+    if "base_branch" in raw:
+        kwargs["base_branch"] = raw["base_branch"]
+    if "max_diff_chars" in raw:
+        kwargs["max_diff_chars"] = int(raw["max_diff_chars"])
+    if "ai_synthesis_model" in raw:
+        kwargs["ai_synthesis_model"] = raw["ai_synthesis_model"]
+    if "ai_review_model" in raw:
+        kwargs["ai_review_model"] = raw["ai_review_model"]
+    if "ai_vision_model" in raw:
+        kwargs["ai_vision_model"] = raw["ai_vision_model"]
+    if "worktree_prefix" in raw:
+        kwargs["worktree_prefix"] = raw["worktree_prefix"]
+    if "pnpm_version" in raw:
+        kwargs["pnpm_version"] = raw["pnpm_version"]
+    if "temp_file_feedback" in raw:
+        kwargs["temp_file_feedback"] = raw["temp_file_feedback"]
+
+    for list_key in [
+        "core_dirs",
+        "ui_indicators",
+        "tailwind_indicators",
+        "audit_check_dirs",
+        "allowed_bots",
+        "spec_sections",
+        "temp_file_patterns",
+    ]:
+        val = get_list(list_key)
+        if val is not None:
+            kwargs[list_key] = val
+
+    content_scopes = get_dict("content_scopes")
+    if content_scopes is not None:
+        kwargs["content_scopes"] = content_scopes
+
+    return ProjectConfig(**kwargs)

dev_tools/constants.py

@@ -0,0 +1,14 @@
+"""Constants for dev_tools."""
+
+# Robust placeholder detection using regex to handle minor variants
+REVIEW_PLACEHOLDERS = [
+    r"<findings\s*/?>",
+    r"<summary\s*/?>",
+    r"<filename\s*/?>",
+    r"<feedback\s*/?>",
+    r"<Approved\s*\|\s*Approved\s*with\s*Minor\s*Changes\s*\|\s*Not\s*Approved>",
+    r"##\s+ANTI-AI-SLOP",
+    r"##\s+FINDINGS",
+    r"##\s+FINAL RECOMMENDATION",
+    r"<!--\s*td-review-manager-comment\s*-->",
+]

dev_tools/daemon.py

@@ -0,0 +1,146 @@
+# pylint: disable=arguments-differ,attribute-defined-outside-init,line-too-long,logging-fstring-interpolation,missing-docstring,too-few-public-methods
+import logging
+import sys
+from typing import Any, Dict, List, Optional
+
+from dev_tools.orchestrator import Orchestrator
+from dev_tools.services.github import GitHubClient
+from dev_tools.services.jules import JulesClient
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ExtendedJulesClient(JulesClient):
+    """JulesClient subclass with extended timeouts for daemon use."""
+
+    def get_messages(self, session_id: str, timeout: int = 30) -> List[Dict[str, Any]]:
+        # Set default timeout to 30s instead of the default 10s
+        return super().get_messages(session_id, timeout=timeout)
+
+
+class JulesFeedbackDaemon:
+    def __init__(self):
+        self.jules = ExtendedJulesClient()
+        self.github = GitHubClient()
+        self.orchestrator = Orchestrator()
+        # Ensure the orchestrator uses our extended client
+        self.orchestrator.initialize_jules(self.jules)
+
+    def run(self, limit: int = 10):
+        logger.info("Starting Jules Feedback Daemon")
+        try:
+            sessions = self.jules.list_sessions(pageSize=limit)
+            logger.info(f"Found {len(sessions)} sessions")
+        except Exception as e:
+            logger.error(f"Error fetching sessions: {e}")
+            sys.exit(1)
+
+        self._pr_cache: Dict[int, Any] = {}
+        self._session_to_pr_map: Dict[str, Any] = {}
+
+        # Batch pre-match sessions to PRs where possible to reduce API hits
+        self._pre_match_sessions_batch(sessions)
+
+        for session in sessions:
+            self._process_session(session)
+
+    def _pre_match_sessions_batch(self, sessions: List[Dict[str, Any]]):
+        """Batch search for multiple session IDs in one GitHub API call."""
+        if not sessions:
+            return
+
+        session_ids = []
+        for s in sessions:
+            sid = s.get("name", "").split("/")[-1]
+            if sid:
+                session_ids.append(sid)
+
+        if not session_ids:
+            return
+
+        # GitHub Search API query construction
+        # Example: (ID1 OR ID2 OR ID3) in:body,title state:open
+        id_query = " OR ".join([f'"{sid}"' for sid in session_ids])
+        full_query = f"({id_query}) in:body,title state:open"
+
+        try:
+            logger.info(f"Performing batch PR search for {len(session_ids)} session IDs")
+            found_prs = self.github.search_pull_requests(full_query, limit=50)
+
+            for pr in found_prs:
+                body = (pr.get("body") or "").lower()
+                title = (pr.get("title") or "").lower()
+                for sid in session_ids:
+                    if sid.lower() in body or sid.lower() in title:
+                        self._session_to_pr_map[sid] = pr
+                        # Cache the PR details as well
+                        self._pr_cache[pr["number"]] = pr
+        except Exception as e:
+            logger.warning(f"Batch PR search failed, will fallback to individual lookups: {e}")
+
+    def _get_pr_for_session(self, session: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Optimized PR lookup for a session."""
+        session_id = session.get("name", "").replace("sessions/", "")
+
+        # 0. Check batch pre-match results
+        if session_id in self._session_to_pr_map:
+            return self._session_to_pr_map[session_id]
+
+        # 1-3. Delegate to orchestrator logic
+        pr_num = self.orchestrator.get_pr_for_session(session)
+        if pr_num:
+            if pr_num not in self._pr_cache:
+                self._pr_cache[pr_num] = self.github.fetch_pr_details(pr_num)
+            return self._pr_cache[pr_num]
+
+        return None
+
+    def _process_session(self, session: Dict[str, Any]):
+        session_id = session.get("name", "").replace("sessions/", "")
+        if not session_id:
+            return
+
+        logger.info(f"Processing session {session_id}")
+        matched_pr = self._get_pr_for_session(session)
+
+        if not matched_pr:
+            logger.info(f"No matching PR found for session {session_id}")
+            return
+
+        try:
+            messages = self.jules.get_messages(session_id)
+        except Exception as e:
+            logger.error(f"Error getting messages for session {session_id}: {e}")
+            return
+
+        if not messages:
+            logger.info(f"No messages for session {session_id}")
+            return
+
+        logger.info(
+            f"Matched PR #{matched_pr['number']} ({matched_pr.get('headRefName')}, {matched_pr.get('title')}) for session {session_id}"
+        )
+
+        last_message = messages[-1]
+        if last_message.get("role") == "user":
+            logger.info(f"Last message from user, skipping feedback to avoid double-feedback for {session_id}")
+            return
+
+        if last_message.get("role") == "jules":
+            logger.info(f"Triggering feedback for session {session_id} matching PR #{matched_pr['number']}")
+            try:
+                # Use orchestrator.trigger_jules_feedback which executes CI validation logic
+                res = self.orchestrator.trigger_jules_feedback(session_id)
+                logger.info(f"Feedback triggered successfully: {res.get('status', 'unknown')}")
+            except Exception as e:
+                logger.error(f"Error triggering feedback for {session_id}: {e}")
+
+
+if __name__ == "__main__":
+    try:
+        daemon = JulesFeedbackDaemon()
+        daemon.run()
+    except Exception as e:
+        logger.error(f"Daemon crashed: {e}")
+        sys.exit(1)

dev_tools/dist/config.js

@@ -0,0 +1,108 @@
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({
+    path: path.resolve(__dirname, "../.env"),
+    quiet: true
+});
+function getGithubToken() {
+    if (process.env.GITHUB_TOKEN) {
+        return process.env.GITHUB_TOKEN;
+    }
+    try {
+        const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        if (token) {
+            return token;
+        }
+    }
+    catch (e) { }
+    return undefined;
+}
+let cachedDynamicConfig = null;
+/**
+ * Explicitly initializes dynamic configuration from the Python CLI.
+ * Should be called once during server startup.
+ */
+export function initializeConfig() {
+    if (cachedDynamicConfig !== null) {
+        return cachedDynamicConfig;
+    }
+    try {
+        // Attempt to load core properties from the Python CLI to avoid duplication
+        const cmd = `td-cli config view`;
+        const output = execSync(cmd, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        cachedDynamicConfig = JSON.parse(output);
+        return cachedDynamicConfig;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        const errorPrefix = `CRITICAL: Failed to load dynamic config from Python CLI. Ensure Python 3 is installed and boomtick-pkg/cli is in your PYTHONPATH. Details: ${message}`;
+        if (process.env.NODE_ENV === "development" || process.env.CI === "true") {
+            throw new Error(errorPrefix);
+        }
+        else {
+            console.warn(errorPrefix);
+        }
+        // Set an empty object to prevent repeated attempts if initialization fails in non-blocking mode
+        cachedDynamicConfig = {};
+    }
+    return cachedDynamicConfig;
+}
+function findRepoRoot() {
+    if (process.env.BOOMTICK_REPO_PATH) {
+        return process.env.BOOMTICK_REPO_PATH;
+    }
+    // Traverse up to find workspace.json or .git
+    let current = __dirname;
+    while (current !== path.parse(current).root) {
+        if (fs.existsSync(path.join(current, "workspace.json")) || fs.existsSync(path.join(current, ".git"))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    // Fallback to the monolithic relative path if discovery fails
+    return path.resolve(__dirname, "../../../");
+}
+export const config = {
+    get githubToken() { return getGithubToken(); },
+    get githubOwner() {
+        if (process.env.GITHUB_OWNER)
+            return process.env.GITHUB_OWNER;
+        const repoString = cachedDynamicConfig?.github_repo;
+        if (typeof repoString !== "string" || !repoString.includes("/")) {
+            throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
+        }
+        return repoString.split("/")[0];
+    },
+    get githubRepo() {
+        if (process.env.GITHUB_REPO)
+            return process.env.GITHUB_REPO;
+        const repoString = cachedDynamicConfig?.github_repo;
+        if (typeof repoString !== "string" || !repoString.includes("/")) {
+            throw new Error("GITHUB_REPO must be set via environment variable or project_config.json");
+        }
+        return repoString.split("/")[1];
+    },
+    get repoPath() {
+        return findRepoRoot();
+    },
+    get defaultBaseBranch() {
+        return process.env.DEFAULT_BASE_BRANCH || cachedDynamicConfig?.base_branch?.split("/").pop() || "main";
+    },
+    get viteBasePath() {
+        const path = process.env.VITE_BASE_PATH || cachedDynamicConfig?.vite_base_path;
+        if (!path) {
+            throw new Error("VITE_BASE_PATH must be set via environment variable or project_config.json");
+        }
+        return path;
+    },
+    get ghPath() {
+        return process.env.GH_PATH || cachedDynamicConfig?.gh_path || "gh";
+    }
+};

dev_tools/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { BoomtickMCPServer } from "./mcp/server.js";
+import { initializeConfig } from "./config.js";
+// Initialize configuration once at startup
+initializeConfig();
+const server = new BoomtickMCPServer();
+server.run().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

dev_tools/dist/lib/error_utils.js

@@ -0,0 +1,8 @@
+/**
+ * Sanitizes stderr from CLI commands to prevent implementation detail leakage
+ * in error messages returned to the AI agent.
+ */
+export function sanitizeError(stderr) {
+    // Take first line and truncate to 200 chars to balance detail vs security
+    return (stderr.split("\n")[0] || "Unknown error").slice(0, 200);
+}

dev_tools/dist/lib/git.js

@@ -0,0 +1,31 @@
+import { runCommand } from "./shell.js";
+import path from "path";
+import fs from "fs/promises";
+function validatePrNumber(value) {
+    const prNumber = Number(value);
+    if (!Number.isInteger(prNumber) || prNumber <= 0) {
+        throw new Error("Invalid PR number");
+    }
+    return prNumber;
+}
+export async function createWorktree(branch, prNumber) {
+    const safePrNumber = validatePrNumber(prNumber);
+    const workspaceRoot = "/tmp/boomtick-worktrees";
+    // nosemgrep
+    const worktreePath = path.join(workspaceRoot, `boomtick-mcp-rescue-${safePrNumber}`);
+    // Clean up if exists
+    try {
+        await fs.rm(worktreePath, { recursive: true, force: true });
+        await runCommand("git", ["worktree", "prune"]);
+    }
+    catch (e) { }
+    const result = await runCommand("git", ["worktree", "add", "-b", `repair-pr-${prNumber}-${Date.now()}`, worktreePath, branch]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to create worktree: ${result.stderr}`);
+    }
+    return worktreePath;
+}
+export async function removeWorktree(worktreePath) {
+    await runCommand("git", ["worktree", "remove", "--force", worktreePath]);
+    await runCommand("git", ["worktree", "prune"]);
+}

dev_tools/dist/lib/result.js

@@ -0,0 +1,21 @@
+export function createSuccessResult(data) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+export function createErrorResult(message) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: message,
+            },
+        ],
+        isError: true,
+    };
+}

dev_tools/dist/lib/shell.js

@@ -0,0 +1,91 @@
+import { spawn } from "child_process";
+import { config } from "../config.js";
+import path from "path";
+import fs from "fs";
+export const ALLOWED_COMMANDS = {
+    git: "git",
+    gh: "gh",
+    "td-cli": "td-cli",
+    pnpm: "pnpm",
+    ls: "ls",
+    rm: "rm",
+    mkdir: "mkdir",
+    cp: "cp",
+    python3: "python3"
+};
+export async function runCommand(cmd, args, options = {}) {
+    if (!(cmd in ALLOWED_COMMANDS)) {
+        throw new Error(`Command not allowed: ${cmd}`);
+    }
+    const safeCmd = cmd;
+    const start = Date.now();
+    const timeout = options.timeout || 60000;
+    // Resolve path for 'gh' or 'td-cli' if specified
+    let finalCmd = ALLOWED_COMMANDS[safeCmd];
+    if (safeCmd === "gh") {
+        finalCmd = config.ghPath;
+    }
+    else if (safeCmd === "td-cli") {
+        // If we have a repo-relative .venv, prioritize it
+        const venvBin = path.join(config.repoPath, ".venv", "bin", "td-cli");
+        const localVenvBin = path.join(process.cwd(), ".venv", "bin", "td-cli");
+        const parentVenvBin = path.join(config.repoPath, "..", ".venv", "bin", "td-cli");
+        // In standalone mode, config.repoPath is the boomtick-pkg root.
+        // We check common venv locations to ensure we call the isolated binary.
+        if (fs.existsSync(venvBin)) {
+            finalCmd = venvBin;
+        }
+        else if (fs.existsSync(localVenvBin)) {
+            finalCmd = localVenvBin;
+        }
+        else if (fs.existsSync(parentVenvBin)) {
+            finalCmd = parentVenvBin;
+        }
+    }
+    const env = {
+        ...process.env,
+        ...options.env,
+        GH_TOKEN: config.githubToken,
+        GITHUB_TOKEN: config.githubToken
+    };
+    return new Promise((resolve, reject) => {
+        // nosemgrep
+        const child = spawn(finalCmd, args, {
+            cwd: options.cwd || config.repoPath,
+            env
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Command timed out: ${cmd} ${args.join(" ")}`));
+        }, timeout);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const durationMs = Date.now() - start;
+            // Redact token from output
+            if (config.githubToken) {
+                const redact = (str) => str.replace(new RegExp(config.githubToken, "g"), "REDACTED");
+                stdout = redact(stdout);
+                stderr = redact(stderr);
+            }
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code,
+                durationMs,
+                command: `${cmd} ${args.join(" ")}`
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}

dev_tools/dist/lib/shell.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+import path from "path";
+// Simple test to verify environment and vitest setup
+describe("Basic Environment", () => {
+    it("should have a valid repo path", () => {
+        const repoPath = process.env.BOOMTICK_REPO_PATH || "/app";
+        expect(repoPath).toBeDefined();
+        expect(path.isAbsolute(repoPath)).toBe(true);
+    });
+});