kctl-glpi 0.2.0__tar.gz

kctl_glpi-0.2.0/.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local

kctl_glpi-0.2.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: kctl-glpi
+Version: 0.2.0
+Summary: Kodemeio GLPI CLI - manage GLPI IT Service Management platform
+Author-email: Kodemeio <dev@kodeme.io>
+License-Expression: MIT
+Keywords: asset-management,cli,glpi,helpdesk,itsm,kodemeio
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: kctl-lib>=0.7.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.14.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.35.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# kctl-glpi
+
+GLPI IT asset management CLI for Kodemeio infrastructure.

kctl_glpi-0.2.0/README.md

@@ -0,0 +1,3 @@
+# kctl-glpi
+
+GLPI IT asset management CLI for Kodemeio infrastructure.

kctl_glpi-0.2.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "kctl-glpi"
+version = "0.2.0"
+description = "Kodemeio GLPI CLI - manage GLPI IT Service Management platform"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Kodemeio", email = "dev@kodeme.io" }]
+keywords = ["glpi", "itsm", "helpdesk", "asset-management", "cli", "kodemeio"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Systems Administration",
+]
+dependencies = [
+    "kctl-lib>=0.7.0",
+    "httpx>=0.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.0",
+    "pytest-httpx>=0.35.0",
+    "ruff>=0.9.0",
+    "mypy>=1.14.0",
+    "types-PyYAML>=6.0.0",
+]
+
+[project.scripts]
+kctl-glpi = "kctl_glpi.cli:_run"
+
+[tool.uv.sources]
+kctl-lib = { workspace = true }
+
+[project.entry-points."kctl_glpi.plugins"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kctl_glpi"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP", "B", "SIM"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

kctl_glpi-0.2.0/src/kctl_glpi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

kctl_glpi-0.2.0/src/kctl_glpi/__main__.py

@@ -0,0 +1,3 @@
+from kctl_glpi.cli import _run
+
+_run()

kctl_glpi-0.2.0/src/kctl_glpi/cli.py

@@ -0,0 +1,138 @@
+"""Main CLI entry point for kctl-glpi."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+from kctl_glpi import __version__
+from kctl_glpi.commands.assets import app as assets_app
+from kctl_glpi.commands.config_cmd import app as config_app
+from kctl_glpi.commands.dashboard import app as dashboard_app
+from kctl_glpi.commands.doctor_cmd import app as doctor_app
+from kctl_glpi.commands.entities import app as entities_app
+from kctl_glpi.commands.health import app as health_app
+from kctl_glpi.commands.plugins_cmd import app as plugins_app
+from kctl_glpi.commands.search_cmd import app as search_app
+from kctl_glpi.commands.skill_cmd import app as skill_app
+from kctl_glpi.commands.tickets import app as tickets_app
+from kctl_glpi.commands.users import app as users_app
+from kctl_glpi.core.callbacks import AppContext
+from kctl_glpi.core.plugins import discover_and_load_plugins
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-glpi {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-glpi",
+    help="Kodemeio GLPI CLI - manage your GLPI IT Service Management platform.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    format: Annotated[str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit header row in CSV output")] = False,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    app_token: Annotated[str | None, typer.Option("--app-token", help="App-Token override")] = None,
+    user_token: Annotated[str | None, typer.Option("--user-token", help="User token override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio GLPI CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        format=format,
+        no_header=no_header,
+        url_override=url,
+        app_token_override=app_token,
+        user_token_override=user_token,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-glpi", __version__)
+
+
+# Register all command groups
+app.add_typer(tickets_app, name="tickets")
+app.add_typer(assets_app, name="assets")
+app.add_typer(users_app, name="users")
+app.add_typer(entities_app, name="entities")
+app.add_typer(search_app, name="search")
+app.add_typer(plugins_app, name="plugins")
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(config_app, name="config")
+app.add_typer(doctor_app, name="doctor")
+app.add_typer(skill_app, name="skill", hidden=True)
+
+# Load third-party plugins via entry points
+discover_and_load_plugins(app)
+add_tui_command(app, service_key="glpi", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-glpi."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-glpi", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-glpi")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-glpi", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-glpi", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_glpi-0.2.0/src/kctl_glpi/commands/assets.py

@@ -0,0 +1,220 @@
+"""Asset management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib.exceptions import KctlError
+
+from kctl_glpi.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage GLPI assets (computers).")
+
+
+@app.command("list")
+def list_assets(
+    ctx: typer.Context,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Max results")] = 50,
+    name_filter: Annotated[str | None, typer.Option("--name", "-n", help="Filter by name (contains)")] = None,
+) -> None:
+    """List computers/assets with optional filters."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    criteria: list[dict] = []
+    if name_filter:
+        criteria.append({"field": 1, "searchtype": "contains", "value": name_filter})
+
+    try:
+        result = c.search("Computer", criteria=criteria or None, params={"range": f"0-{limit - 1}"})
+        assets = result.get("data", [])
+    except KctlError as e:
+        out.error(f"Failed to list assets: {e}")
+        raise typer.Exit(1) from e
+
+    if not assets:
+        out.info("No assets found")
+        return
+
+    rows: list[list[str]] = []
+    for a in assets:
+        rows.append(
+            [
+                str(a.get("2", a.get("id", ""))),  # ID
+                str(a.get("1", "")),  # Name
+                str(a.get("4", "")),  # Type
+                str(a.get("5", "")),  # Serial
+                str(a.get("31", "")),  # Status
+                str(a.get("70", "")),  # User
+            ]
+        )
+
+    out.table(
+        f"Computers ({len(assets)})",
+        [("ID", "cyan"), ("Name", ""), ("Type", ""), ("Serial", "dim"), ("Status", ""), ("User", "")],
+        rows,
+        data_for_json=assets,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    asset_id: Annotated[int, typer.Argument(help="Computer/asset ID")],
+) -> None:
+    """Get asset details by ID."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    try:
+        asset = c.get_item("Computer", asset_id)
+    except KctlError as e:
+        out.error(f"Failed to get asset {asset_id}: {e}")
+        raise typer.Exit(1) from e
+
+    if not asset:
+        out.error(f"Asset {asset_id} not found")
+        raise typer.Exit(1)
+
+    sections: list[tuple[str, list[tuple[str, str]]]] = [
+        (
+            f"Computer #{asset.get('id', asset_id)}",
+            [
+                ("Name", asset.get("name", "")),
+                ("Serial", asset.get("serial", "")),
+                ("OTH Number", asset.get("otherserial", "")),
+                ("Type", str(asset.get("computertypes_id", ""))),
+                ("Model", str(asset.get("computermodels_id", ""))),
+                ("Manufacturer", str(asset.get("manufacturers_id", ""))),
+                ("Status", str(asset.get("states_id", ""))),
+                ("Location", str(asset.get("locations_id", ""))),
+                ("User", str(asset.get("users_id", ""))),
+                ("Group", str(asset.get("groups_id", ""))),
+                ("Entity", str(asset.get("entities_id", ""))),
+                ("Date Created", asset.get("date_creation", "")),
+                ("Date Modified", asset.get("date_mod", "")),
+                ("Comment", (asset.get("comment", "") or "")[:300]),
+            ],
+        )
+    ]
+
+    out.detail(f"Computer #{asset_id}", sections, data_for_json=asset)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Option("--name", "-n", help="Computer name")],
+    serial: Annotated[str | None, typer.Option("--serial", "-s", help="Serial number")] = None,
+    computer_type: Annotated[int | None, typer.Option("--type", help="Computer type ID")] = None,
+    status: Annotated[int | None, typer.Option("--status", help="Status ID")] = None,
+    location: Annotated[int | None, typer.Option("--location", help="Location ID")] = None,
+    user: Annotated[int | None, typer.Option("--user", help="User ID")] = None,
+    comment: Annotated[str | None, typer.Option("--comment", help="Comment")] = None,
+) -> None:
+    """Create a new computer/asset."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    data: dict = {"name": name}
+    if serial is not None:
+        data["serial"] = serial
+    if computer_type is not None:
+        data["computertypes_id"] = computer_type
+    if status is not None:
+        data["states_id"] = status
+    if location is not None:
+        data["locations_id"] = location
+    if user is not None:
+        data["users_id"] = user
+    if comment is not None:
+        data["comment"] = comment
+
+    try:
+        result = c.create_item("Computer", data)
+        out.success(f"Computer created: {result}")
+    except KctlError as e:
+        out.error(f"Failed to create computer: {e}")
+        raise typer.Exit(1) from e
+
+    if out.json_mode:
+        out.raw_json(result)
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    asset_id: Annotated[int, typer.Argument(help="Computer/asset ID")],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="New name")] = None,
+    serial: Annotated[str | None, typer.Option("--serial", "-s", help="New serial number")] = None,
+    status: Annotated[int | None, typer.Option("--status", help="New status ID")] = None,
+    location: Annotated[int | None, typer.Option("--location", help="New location ID")] = None,
+    user: Annotated[int | None, typer.Option("--user", help="New user ID")] = None,
+    comment: Annotated[str | None, typer.Option("--comment", help="New comment")] = None,
+) -> None:
+    """Update a computer/asset."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    data: dict = {}
+    if name is not None:
+        data["name"] = name
+    if serial is not None:
+        data["serial"] = serial
+    if status is not None:
+        data["states_id"] = status
+    if location is not None:
+        data["locations_id"] = location
+    if user is not None:
+        data["users_id"] = user
+    if comment is not None:
+        data["comment"] = comment
+
+    if not data:
+        out.error("No fields to update. Use --name, --serial, --status, etc.")
+        raise typer.Exit(1)
+
+    try:
+        result = c.update_item("Computer", asset_id, data)
+        out.success(f"Computer {asset_id} updated")
+    except KctlError as e:
+        out.error(f"Failed to update computer {asset_id}: {e}")
+        raise typer.Exit(1) from e
+
+    if out.json_mode:
+        out.raw_json(result)
+
+
+@app.command()
+def types(ctx: typer.Context) -> None:
+    """List available computer types."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    try:
+        items = c.get_items("ComputerType")
+    except KctlError as e:
+        out.error(f"Failed to list computer types: {e}")
+        raise typer.Exit(1) from e
+
+    if not items:
+        out.info("No computer types found")
+        return
+
+    rows: list[list[str]] = []
+    for item in items:
+        rows.append(
+            [
+                str(item.get("id", "")),
+                item.get("name", ""),
+                item.get("comment", "") or "",
+            ]
+        )
+
+    out.table(
+        "Computer Types",
+        [("ID", "cyan"), ("Name", ""), ("Comment", "dim")],
+        rows,
+        data_for_json=items,
+    )