agentix-cli 0.1.1__tar.gz → 0.2.0__tar.gz

agentix_cli-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.9", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv pip install -e ".[dev]"
+
+      - name: Lint
+        run: uv run ruff check src/ tests/
+
+      - name: Test
+        run: uv run pytest tests/ -v --tb=short
+
+  build:
+    name: Build package
+    runs-on: ubuntu-latest
+    needs: [test]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Build
+        run: uv build
+
+      - name: Verify package
+        run: ls -la dist/

{agentix_cli-0.1.1 → agentix_cli-0.2.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: agentix-cli
-Version: 0.1.1
-Summary: A CLI tool for [description TBD]
+Version: 0.2.0
+Summary: Unified CLI and SDK for Jira, Confluence, and Jenkins
 Project-URL: Homepage, https://github.com/saggl/agentix
 Project-URL: Repository, https://github.com/saggl/agentix.git
 Project-URL: Issues, https://github.com/saggl/agentix/issues
@@ -18,6 +18,16 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+Requires-Dist: tabulate>=0.9
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: tomli>=1.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: responses>=0.23; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # agentix

{agentix_cli-0.1.1 → agentix_cli-0.2.0}/pyproject.toml

@@ -3,12 +3,17 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
-dev = []
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "responses>=0.23",
+    "ruff>=0.4",
+]
 
 [project]
 name = "agentix-cli"
-version = "0.1.1"
-description = "A CLI tool for [description TBD]"
+version = "0.2.0"
+description = "Unified CLI and SDK for Jira, Confluence, and Jenkins"
 readme = "README.md"
 requires-python = ">=3.9"
 license = {text = "MIT"}
@@ -26,7 +31,21 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-dependencies = []
+dependencies = [
+    "click>=8.0",
+    "requests>=2.28",
+    "tomli>=1.0; python_version < '3.11'",
+    "tomli-w>=1.0",
+    "tabulate>=0.9",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "responses>=0.23",
+    "ruff>=0.4",
+]
 
 [project.scripts]
 agentix = "agentix.__main__:main"

{agentix_cli-0.1.1 → agentix_cli-0.2.0}/src/agentix/__init__.py

@@ -1,3 +1,3 @@
 """agentix - A CLI tool"""
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

agentix_cli-0.2.0/src/agentix/cli.py

@@ -0,0 +1,76 @@
+"""Root CLI for agentix."""
+
+import logging
+import sys
+
+import click
+
+from agentix import __version__
+from agentix.config.commands import config_group
+from agentix.config.manager import ConfigManager
+from agentix.core.exceptions import AgentixError
+from agentix.core.output import OutputFormatter
+from agentix.confluence.commands import confluence_group
+from agentix.jenkins.commands import jenkins_group
+from agentix.jira.commands import jira_group
+
+
+@click.group()
+@click.option(
+    "--profile",
+    default=None,
+    envvar="AGENTIX_DEFAULT_PROFILE",
+    help="Config profile to use.",
+)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["json", "table"]),
+    default=None,
+    help="Output format (default: json).",
+)
+@click.option("--verbose", is_flag=True, help="Enable verbose logging.")
+@click.version_option(version=__version__, prog_name="agentix")
+@click.pass_context
+def cli(ctx, profile, output_format, verbose):
+    """agentix — Unified CLI for Jira, Confluence, and Jenkins."""
+    ctx.ensure_object(dict)
+
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG, stream=sys.stderr)
+
+    config_manager = ConfigManager()
+    resolved_format = (
+        output_format
+        or config_manager.config.defaults.format
+        or "json"
+    )
+
+    ctx.obj["profile"] = profile
+    ctx.obj["config_manager"] = config_manager
+    ctx.obj["formatter"] = OutputFormatter(resolved_format)
+
+
+# Register subgroups
+cli.add_command(config_group)
+cli.add_command(jira_group)
+cli.add_command(confluence_group)
+cli.add_command(jenkins_group)
+
+
+def main():
+    """Entry point for the agentix CLI."""
+    try:
+        cli(standalone_mode=False)
+    except AgentixError as e:
+        formatter = OutputFormatter("json")
+        formatter.error(e)
+        sys.exit(e.exit_code)
+    except click.exceptions.Abort:
+        sys.exit(130)
+    except click.exceptions.Exit as e:
+        sys.exit(e.exit_code)
+
+
+if __name__ == "__main__":
+    main()

agentix_cli-0.2.0/src/agentix/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration management for agentix."""

agentix_cli-0.2.0/src/agentix/config/commands.py

@@ -0,0 +1,180 @@
+"""CLI commands for agentix config management."""
+
+import json
+
+import click
+import requests
+from requests.auth import HTTPBasicAuth
+
+from agentix.config.models import (
+    ConfluenceConfig,
+    JenkinsConfig,
+    JiraConfig,
+)
+
+
+@click.group("config")
+def config_group():
+    """Manage agentix configuration."""
+    pass
+
+
+@config_group.command()
+@click.pass_context
+def init(ctx):
+    """Interactive setup wizard."""
+    cm = ctx.obj["config_manager"]
+    config = cm.config
+
+    profile_name = click.prompt("Profile name", default="default")
+    profile = config.get_profile(profile_name)
+
+    # Jira
+    if click.confirm("Configure Jira?", default=True):
+        profile.jira = _setup_jira()
+
+    # Confluence
+    if click.confirm("Configure Confluence?", default=True):
+        profile.confluence = _setup_confluence(profile.jira)
+
+    # Jenkins
+    if click.confirm("Configure Jenkins?", default=False):
+        profile.jenkins = _setup_jenkins()
+
+    config.default_profile = profile_name
+    config.profiles[profile_name] = profile
+    cm.save(config)
+
+    formatter = ctx.obj["formatter"]
+    formatter.success(f"Configuration saved to {cm.config_path}")
+
+
+def _setup_jira() -> JiraConfig:
+    base_url = click.prompt("Jira base URL (e.g., https://company.atlassian.net)")
+    email = click.prompt("Jira email")
+    api_token = click.prompt("Jira API token", hide_input=True)
+
+    # Validate
+    click.echo("Validating credentials... ", nl=False)
+    try:
+        resp = requests.get(
+            f"{base_url.rstrip('/')}/rest/api/3/myself",
+            auth=HTTPBasicAuth(email, api_token),
+            timeout=10,
+        )
+        if resp.ok:
+            user = resp.json()
+            click.echo(f"OK (authenticated as {user.get('displayName', email)})")
+        else:
+            click.echo(f"Warning: got HTTP {resp.status_code} — credentials may be invalid")
+    except requests.RequestException as e:
+        click.echo(f"Warning: could not validate — {e}")
+
+    return JiraConfig(base_url=base_url.rstrip("/"), email=email, api_token=api_token)
+
+
+def _setup_confluence(jira_config: JiraConfig) -> ConfluenceConfig:
+    default_url = ""
+    default_email = ""
+    default_token = ""
+
+    if jira_config.base_url:
+        default_url = jira_config.base_url.rstrip("/") + "/wiki"
+        default_email = jira_config.email
+        default_token = jira_config.api_token
+
+    base_url = click.prompt(
+        "Confluence base URL", default=default_url or None
+    )
+    email = click.prompt("Confluence email", default=default_email or None)
+    api_token = click.prompt(
+        "Confluence API token (same as Jira for Atlassian Cloud)",
+        default=default_token or None,
+        hide_input=True,
+    )
+
+    return ConfluenceConfig(
+        base_url=base_url.rstrip("/"), email=email, api_token=api_token
+    )
+
+
+def _setup_jenkins() -> JenkinsConfig:
+    base_url = click.prompt("Jenkins base URL (e.g., https://jenkins.company.com)")
+    username = click.prompt("Jenkins username")
+    api_token = click.prompt("Jenkins API token", hide_input=True)
+
+    # Validate
+    click.echo("Validating credentials... ", nl=False)
+    try:
+        resp = requests.get(
+            f"{base_url.rstrip('/')}/api/json",
+            auth=HTTPBasicAuth(username, api_token),
+            timeout=10,
+        )
+        if resp.ok:
+            click.echo("OK")
+        else:
+            click.echo(f"Warning: got HTTP {resp.status_code}")
+    except requests.RequestException as e:
+        click.echo(f"Warning: could not validate — {e}")
+
+    return JenkinsConfig(
+        base_url=base_url.rstrip("/"), username=username, api_token=api_token
+    )
+
+
+@config_group.command()
+@click.argument("key")
+@click.argument("value")
+@click.pass_context
+def set(ctx, key, value):
+    """Set a config value (e.g., agentix config set profiles.work.jira.base_url https://...)."""
+    cm = ctx.obj["config_manager"]
+    cm.set_value(key, value)
+    ctx.obj["formatter"].success(f"Set {key} = {value}")
+
+
+@config_group.command()
+@click.argument("key")
+@click.pass_context
+def get(ctx, key):
+    """Get a config value."""
+    cm = ctx.obj["config_manager"]
+    try:
+        value = cm.get_value(key)
+    except Exception as e:
+        ctx.obj["formatter"].error(e)
+        ctx.exit(2)
+        return
+    formatter = ctx.obj["formatter"]
+    if isinstance(value, dict):
+        formatter.output(value)
+    else:
+        if formatter.fmt == "json":
+            print(json.dumps({"key": key, "value": value}))
+        else:
+            print(value)
+
+
+@config_group.command()
+@click.pass_context
+def show(ctx):
+    """Show full config with tokens masked."""
+    cm = ctx.obj["config_manager"]
+    if not cm.exists():
+        click.echo("No configuration found. Run 'agentix config init' to create one.")
+        ctx.exit(2)
+        return
+    ctx.obj["formatter"].output(cm.mask_tokens())
+
+
+@config_group.command()
+@click.pass_context
+def path(ctx):
+    """Print config file path."""
+    cm = ctx.obj["config_manager"]
+    formatter = ctx.obj["formatter"]
+    if formatter.fmt == "json":
+        print(json.dumps({"path": str(cm.config_path), "exists": cm.exists()}))
+    else:
+        print(cm.config_path)

agentix_cli-0.2.0/src/agentix/config/manager.py

@@ -0,0 +1,109 @@
+"""Configuration manager for agentix."""
+
+import os
+import stat
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+import tomli_w
+
+from agentix.core.exceptions import ConfigError
+
+from .models import AgentixConfig, get_config_path
+
+
+class ConfigManager:
+    """Load, save, and query agentix configuration."""
+
+    def __init__(self, config_path: Optional[Path] = None):
+        self.config_path = config_path or get_config_path()
+        self._config: Optional[AgentixConfig] = None
+
+    @property
+    def config(self) -> AgentixConfig:
+        if self._config is None:
+            self._config = self.load()
+        return self._config
+
+    def exists(self) -> bool:
+        return self.config_path.exists()
+
+    def load(self) -> AgentixConfig:
+        if not self.config_path.exists():
+            return AgentixConfig()
+        try:
+            data = tomllib.loads(self.config_path.read_text(encoding="utf-8"))
+            return AgentixConfig.from_dict(data)
+        except Exception as e:
+            raise ConfigError(
+                f"Failed to load config from {self.config_path}: {e}"
+            ) from e
+
+    def save(self, config: Optional[AgentixConfig] = None) -> None:
+        cfg = config or self.config
+        config_dir = self.config_path.parent
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Set restrictive permissions on directory
+        if sys.platform != "win32":
+            os.chmod(config_dir, stat.S_IRWXU)
+
+        self.config_path.write_text(
+            tomli_w.dumps(cfg.to_dict()), encoding="utf-8"
+        )
+
+        # Set restrictive permissions on file
+        if sys.platform != "win32":
+            os.chmod(self.config_path, stat.S_IRUSR | stat.S_IWUSR)
+
+        self._config = cfg
+
+    def get_value(self, key: str) -> Any:
+        """Get a config value by dotted key path (e.g., 'profiles.work.jira.base_url')."""
+        parts = key.split(".")
+        data = self.config.to_dict()
+        for part in parts:
+            if isinstance(data, dict) and part in data:
+                data = data[part]
+            else:
+                raise ConfigError(f"Config key not found: {key}")
+        return data
+
+    def set_value(self, key: str, value: str) -> None:
+        """Set a config value by dotted key path."""
+        parts = key.split(".")
+        data = self.config.to_dict()
+
+        # Navigate to parent
+        current = data
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+        current[parts[-1]] = value
+
+        self._config = AgentixConfig.from_dict(data)
+        self.save()
+
+    def mask_tokens(self) -> dict:
+        """Return config dict with tokens/secrets masked."""
+        data = self.config.to_dict()
+        secret_keys = {"api_token", "token", "password", "secret"}
+
+        def _mask(d: Any) -> Any:
+            if isinstance(d, dict):
+                return {
+                    k: ("***" if k in secret_keys and v else _mask(v))
+                    for k, v in d.items()
+                }
+            if isinstance(d, list):
+                return [_mask(i) for i in d]
+            return d
+
+        return _mask(data)

agentix_cli-0.2.0/src/agentix/config/models.py

@@ -0,0 +1,105 @@
+"""Configuration data models for agentix."""
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class JiraConfig:
+    base_url: str = ""
+    email: str = ""
+    api_token: str = ""
+
+
+@dataclass
+class ConfluenceConfig:
+    base_url: str = ""
+    email: str = ""
+    api_token: str = ""
+
+
+@dataclass
+class JenkinsConfig:
+    base_url: str = ""
+    username: str = ""
+    api_token: str = ""
+
+
+@dataclass
+class Profile:
+    jira: JiraConfig = field(default_factory=JiraConfig)
+    confluence: ConfluenceConfig = field(default_factory=ConfluenceConfig)
+    jenkins: JenkinsConfig = field(default_factory=JenkinsConfig)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Profile":
+        return cls(
+            jira=JiraConfig(**data.get("jira", {})),
+            confluence=ConfluenceConfig(**data.get("confluence", {})),
+            jenkins=JenkinsConfig(**data.get("jenkins", {})),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {}
+        for service_name in ("jira", "confluence", "jenkins"):
+            cfg = getattr(self, service_name)
+            d = {k: v for k, v in cfg.__dict__.items() if v}
+            if d:
+                result[service_name] = d
+        return result
+
+
+@dataclass
+class Defaults:
+    format: str = "json"
+
+
+@dataclass
+class AgentixConfig:
+    default_profile: str = "default"
+    defaults: Defaults = field(default_factory=Defaults)
+    profiles: Dict[str, Profile] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AgentixConfig":
+        profiles = {}
+        for name, pdata in data.get("profiles", {}).items():
+            profiles[name] = Profile.from_dict(pdata)
+        return cls(
+            default_profile=data.get("default_profile", "default"),
+            defaults=Defaults(**data.get("defaults", {})),
+            profiles=profiles,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {"default_profile": self.default_profile}
+        defaults_dict = {k: v for k, v in self.defaults.__dict__.items() if v}
+        if defaults_dict:
+            result["defaults"] = defaults_dict
+        if self.profiles:
+            result["profiles"] = {
+                name: p.to_dict() for name, p in self.profiles.items()
+            }
+        return result
+
+    def get_profile(self, name: Optional[str] = None) -> Profile:
+        profile_name = name or self.default_profile
+        if profile_name not in self.profiles:
+            self.profiles[profile_name] = Profile()
+        return self.profiles[profile_name]
+
+
+def get_config_dir() -> Path:
+    """Return the platform-appropriate config directory."""
+    if sys.platform == "win32":
+        base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+    else:
+        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return base / "agentix"
+
+
+def get_config_path() -> Path:
+    return get_config_dir() / "config.toml"

agentix_cli-0.2.0/src/agentix/confluence/__init__.py

@@ -0,0 +1 @@
+"""Confluence integration for agentix."""