charisma-cli 0.1.2__tar.gz

charisma_cli-0.1.2/.gitignore

@@ -0,0 +1,134 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build outputs
+dist/
+build/
+*.log
+
+# Local pipeline secrets (do not commit)
+.env.pipeline
+
+# Database
+*.sqlite
+*.db
+
+# Test coverage
+coverage/
+.nyc_output/
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+
+# Confluence sync metadata (optional - can be committed)
+# .amazonq/knowledge-base/.confluence-sync.json
+
+# Nuxt build outputs
+.nuxt/
+.output/
+dist/
+
+# Python cache
+*.pyc
+*/__pycache__/
+
+# Python virtual environments
+.venv/
+venv/
+
+# Hypothesys cache
+.hypothesis/
+
+# Kiro hooks (auto-generated)
+.kiro/hooks/
+.kiro/settings/*
+.kiro/settings/mcp.json
+
+# Kiro spec config (local)
+.kiro/specs/**/.config.kiro
+
+# Coverage
+.coverage
+
+# AWS SAM build artifacts
+.aws-sam/
+
+# Zip files in repo root (test artifacts, allure exports, etc.)
+*.zip
+
+# Playwright test results
+frontend/test-results/
+frontend/playwright-report/
+frontend/e2e-results/
+test-results/
+
+# E2E auth state (contains secrets)
+frontend/e2e/.auth/
+
+# E2E test environment (contains secrets)
+frontend/.env.e2e
+
+
+test-reporting.code-workspace
+
+
+.vscode/extensions.json
+Aurora.session.sql
+Charisma DB.session.sql
+
+
+# API integration test setup scripts (contains sensitive token generation)
+backend/api_integration_test_setup_scripts/
+
+# Local test/debug scripts
+scripts/test-ingestion-token.py
+
+# vs code settings
+.vscode/settings.json
+backend/integration_test_report.xml
+backend/unit_test_report.xml
+frontend/app/pages/proto.vue
+scripts/connect-aurora.ps1
+
+# mock test result files
+test-data-junit-debug*
+
+# scripts for creating mock data
+scripts/ingest-test-run/*
+
+# --- ltm-power ---
+ltm/*
+ltm/store/*.jsonl
+ltm/runtime/*
+ltm/reports/*
+ltm/snapshots/*
+.kiro/steering/ltm-memory-format.md
+.kiro/steering/ltm-operations.md
+backend/coverage.json
+*/__pycache__/*
+allure-results/*

charisma_cli-0.1.2/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: charisma-cli
+Version: 0.1.2
+Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
+Author: Charisma Team
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: click<9.0,>=8.0
+Requires-Dist: httpx<1.0,>=0.24
+Requires-Dist: watchdog<5.0,>=3.0
+Provides-Extra: dev
+Requires-Dist: hypothesis; extra == 'dev'
+Requires-Dist: pytest<10.0,>=7.0; extra == 'dev'
+Requires-Dist: respx; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# charisma-cli
+
+CLI tool that watches an `allure-results` directory during test execution and streams results + attachments to the Charisma ingestion API in real time.
+
+## Installation
+
+```bash
+pip install charisma-cli
+```
+
+No token, no index URL — works on any laptop and in any CI. The package is published to public PyPI; the Charisma repo itself stays private (only this client wheel is public).
+
+For local development from a checkout of the repo:
+
+```bash
+pip install -e packages/charisma-cli
+```
+
+<details>
+<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
+
+Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
+
+```bash
+pip install charisma-cli \
+  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
+```
+
+</details>
+
+## Publishing (maintainers)
+
+Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
+
+> Trusted publishing (OIDC) is not used because this repo runs on **GitHub Enterprise Server**, whose OIDC issuer PyPI does not trust. A stored API token is required instead.
+
+One-time setup (done once by a PyPI project owner):
+
+1. Sign in to [PyPI](https://pypi.org) with the team-owned account (2FA enabled).
+2. Go to **Account settings → API tokens → Add API token**. Scope it to the `charisma-cli` project once the project exists; for the very first publish use an account-scoped token, then re-scope it to the project afterward.
+3. Copy the token (starts with `pypi-`).
+4. In the GitHub Enterprise repo, add it as an Actions secret named **`PYPI_API_TOKEN`** (org-level secret recommended so both packages share it).
+5. Bump `version` in `pyproject.toml` and merge — the workflow builds and publishes on the next release.
+
+Rotate the token periodically and store it in the team secret manager.
+
+## Usage
+
+```bash
+export CHARISMA_ENDPOINT=https://charisma.company.com
+export CHARISMA_TOKEN=<your-service-token>
+export CHARISMA_PROJECT_ID=my-project
+
+charismactl watch --results allure-results -- uv run pytest -n 4 tests/
+```
+
+## Environment Variables
+
+| Variable              | Required | Description                                        |
+| --------------------- | -------- | -------------------------------------------------- |
+| `CHARISMA_ENDPOINT`   | Yes      | Base URL of the Charisma API                       |
+| `CHARISMA_TOKEN`      | Yes      | Service or CI bearer token                         |
+| `CHARISMA_PROJECT_ID` | Yes      | Project alias for result routing                   |
+| `CHARISMA_RESULTS`    | No       | Path to allure-results (default: `allure-results`) |
+
+## Flags
+
+| Flag             | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `--results PATH` | Allure results directory (overrides env var) |
+| `--project ID`   | Project alias (overrides env var)            |
+| `--silent`       | Don't fail pipeline if upload errors occur   |
+| `--skip-too-big` | Skip result files larger than 2MB            |

charisma_cli-0.1.2/README.md

@@ -0,0 +1,73 @@
+# charisma-cli
+
+CLI tool that watches an `allure-results` directory during test execution and streams results + attachments to the Charisma ingestion API in real time.
+
+## Installation
+
+```bash
+pip install charisma-cli
+```
+
+No token, no index URL — works on any laptop and in any CI. The package is published to public PyPI; the Charisma repo itself stays private (only this client wheel is public).
+
+For local development from a checkout of the repo:
+
+```bash
+pip install -e packages/charisma-cli
+```
+
+<details>
+<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
+
+Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
+
+```bash
+pip install charisma-cli \
+  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
+```
+
+</details>
+
+## Publishing (maintainers)
+
+Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
+
+> Trusted publishing (OIDC) is not used because this repo runs on **GitHub Enterprise Server**, whose OIDC issuer PyPI does not trust. A stored API token is required instead.
+
+One-time setup (done once by a PyPI project owner):
+
+1. Sign in to [PyPI](https://pypi.org) with the team-owned account (2FA enabled).
+2. Go to **Account settings → API tokens → Add API token**. Scope it to the `charisma-cli` project once the project exists; for the very first publish use an account-scoped token, then re-scope it to the project afterward.
+3. Copy the token (starts with `pypi-`).
+4. In the GitHub Enterprise repo, add it as an Actions secret named **`PYPI_API_TOKEN`** (org-level secret recommended so both packages share it).
+5. Bump `version` in `pyproject.toml` and merge — the workflow builds and publishes on the next release.
+
+Rotate the token periodically and store it in the team secret manager.
+
+## Usage
+
+```bash
+export CHARISMA_ENDPOINT=https://charisma.company.com
+export CHARISMA_TOKEN=<your-service-token>
+export CHARISMA_PROJECT_ID=my-project
+
+charismactl watch --results allure-results -- uv run pytest -n 4 tests/
+```
+
+## Environment Variables
+
+| Variable              | Required | Description                                        |
+| --------------------- | -------- | -------------------------------------------------- |
+| `CHARISMA_ENDPOINT`   | Yes      | Base URL of the Charisma API                       |
+| `CHARISMA_TOKEN`      | Yes      | Service or CI bearer token                         |
+| `CHARISMA_PROJECT_ID` | Yes      | Project alias for result routing                   |
+| `CHARISMA_RESULTS`    | No       | Path to allure-results (default: `allure-results`) |
+
+## Flags
+
+| Flag             | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `--results PATH` | Allure results directory (overrides env var) |
+| `--project ID`   | Project alias (overrides env var)            |
+| `--silent`       | Don't fail pipeline if upload errors occur   |
+| `--skip-too-big` | Skip result files larger than 2MB            |

charisma_cli-0.1.2/pyproject.toml

@@ -0,0 +1,54 @@
+# Build: hatchling
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "charisma-cli"
+version = "0.1.2"
+description = "CLI tool that watches allure-results and streams test results + attachments to Charisma."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Charisma Team" },
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "click>=8.0,<9.0",
+    "httpx>=0.24,<1.0",
+    "watchdog>=3.0,<5.0",
+]
+
+[project.scripts]
+charismactl = "charisma_cli.main:cli"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0,<10.0",
+    "respx",
+    "hypothesis",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/charisma_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]

charisma_cli-0.1.2/src/charisma_cli/__init__.py

@@ -0,0 +1,3 @@
+"""charisma-cli: Stream allure results to Charisma in real time."""
+
+__version__ = "0.1.2"

charisma_cli-0.1.2/src/charisma_cli/config.py

@@ -0,0 +1,86 @@
+"""Configuration dataclass with env var + CLI flag resolution."""
+
+import os
+from dataclasses import dataclass
+
+import click
+
+
+@dataclass
+class Config:
+    """Resolved configuration for charismactl.
+
+    Fields are populated via from_env() which merges CLI flag overrides
+    with environment variable fallbacks.
+    """
+
+    endpoint: str
+    token: str
+    project: str
+    results_dir: str
+    silent: bool
+    skip_too_big: bool
+    drain_timeout: int
+    build_id: str | None
+    commit_sha: str | None
+    branch: str | None
+
+    @classmethod
+    def from_env(
+        cls,
+        *,
+        endpoint: str | None = None,
+        token: str | None = None,
+        project: str | None = None,
+        results: str | None = None,
+        silent: bool = False,
+        skip_too_big: bool = False,
+        drain_timeout: int = 30,
+    ) -> "Config":
+        """Build Config by resolving CLI flags over environment variables.
+
+        Resolution order: CLI flag (if not None) > env var > default.
+
+        Args:
+            endpoint: --endpoint flag override
+            token: --token flag override
+            project: --project flag override
+            results: --results flag override
+            silent: --silent flag
+            skip_too_big: --skip-too-big flag
+            drain_timeout: drain timeout in seconds
+
+        Returns:
+            Fully resolved Config instance.
+
+        Raises:
+            click.UsageError: If required fields (endpoint, token) are missing.
+        """
+        resolved_endpoint = (endpoint or os.getenv("CHARISMA_ENDPOINT", "")).strip()
+        resolved_token = (token or os.getenv("CHARISMA_TOKEN", "")).strip()
+        resolved_project = (project or os.getenv("CHARISMA_PROJECT_ID", "")).strip()
+        resolved_results = results or os.getenv("CHARISMA_RESULTS", "allure-results")
+
+        if not resolved_endpoint:
+            raise click.UsageError(
+                "Missing required configuration: endpoint. "
+                "Set CHARISMA_ENDPOINT or pass --endpoint."
+            )
+        if not resolved_token:
+            raise click.UsageError(
+                "Missing required configuration: token. "
+                "Set CHARISMA_TOKEN or pass --token."
+            )
+
+        return cls(
+            endpoint=resolved_endpoint,
+            token=resolved_token,
+            project=resolved_project,
+            results_dir=resolved_results,
+            silent=silent,
+            skip_too_big=skip_too_big,
+            drain_timeout=drain_timeout,
+            build_id=os.getenv("BUILD_ID"),
+            commit_sha=os.getenv("COMMIT_SHA"),
+            branch=os.getenv("BRANCH"),
+        )

charisma_cli-0.1.2/src/charisma_cli/main.py

@@ -0,0 +1,206 @@
+"""CLI entry point for charismactl."""
+
+import signal
+import sys
+from pathlib import Path
+from queue import PriorityQueue
+
+import click
+
+from charisma_cli import __version__
+from charisma_cli.config import Config
+from charisma_cli.models import FileEvent
+from charisma_cli.subprocess_mgr import SubprocessManager
+from charisma_cli.uploader import Uploader
+from charisma_cli.watcher import ResultsWatcher, classify_file
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="charismactl")
+def cli() -> None:
+    """Stream allure test results to Charisma in real time."""
+
+
+def _resolve_config(
+    endpoint: str | None,
+    token: str | None,
+    project: str,
+    results: str,
+    silent: bool,
+    skip_too_big: bool,
+) -> Config:
+    """Resolve CLI config from flags + env vars. Re-raises UsageError on failure."""
+    return Config.from_env(
+        endpoint=endpoint,
+        token=token,
+        project=project,
+        results=results,
+        silent=silent,
+        skip_too_big=skip_too_big,
+    )
+
+
+def _open_launch_or_exit(uploader: Uploader, config: Config) -> str:
+    """Open a launch, handling failure based on silent mode.
+
+    Returns:
+        The launch ID on success.
+
+    Exits:
+        sys.exit(1) if non-silent and launch open fails.
+        Returns empty string if silent and launch fails (caller must handle).
+    """
+    launch_id = uploader.open_launch()
+    if launch_id is None:
+        if config.silent:
+            return ""
+        click.echo("Error: Failed to open launch. Exiting.", err=True)
+        sys.exit(1)
+    return launch_id
+
+
+def _print_summary(uploader: Uploader) -> None:
+    """Print the upload summary to stdout."""
+    summary = uploader.summary
+    click.echo(
+        f"Summary: results_sent={summary.results_sent}, "
+        f"results_failed={summary.results_failed}, "
+        f"attachments_sent={summary.attachments_sent}, "
+        f"attachments_skipped={summary.attachments_skipped}, "
+        f"containers_sent={summary.containers_sent}"
+    )
+
+
+@cli.command()
+@click.option("--endpoint", envvar="CHARISMA_ENDPOINT", default=None, help="Charisma API endpoint.")
+@click.option("--token", envvar="CHARISMA_TOKEN", default=None, help="Bearer token.")
+@click.option("--results", envvar="CHARISMA_RESULTS", default="allure-results", help="Allure results directory.")
+@click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
+@click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
+@click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
+@click.argument("command", nargs=-1, required=True)
+def watch(
+    endpoint: str | None,
+    token: str | None,
+    results: str,
+    project: str,
+    silent: bool,
+    skip_too_big: bool,
+    command: tuple[str, ...],
+) -> None:
+    """Watch allure-results and stream to Charisma while running COMMAND.
+
+    Usage: charismactl watch --project my-project -- pytest -n 4 tests/
+    """
+    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big)
+
+    queue: PriorityQueue[FileEvent] = PriorityQueue()
+    uploader = Uploader(config, queue)
+    uploader.configure_logging()
+
+    # Open launch (Uploader owns the client)
+    launch_id = _open_launch_or_exit(uploader, config)
+    if not launch_id:
+        # Silent degradation — run subprocess without uploads
+        mgr = SubprocessManager()
+        mgr.spawn(command)
+        sys.exit(mgr.wait())
+
+    # Start watcher + uploader consumer
+    watcher = ResultsWatcher(config.results_dir, queue, config)
+    watcher.start()
+    uploader.start()
+
+    # Spawn subprocess with signal forwarding
+    mgr = SubprocessManager()
+
+    def _forward_signal(sig: int, _frame: object) -> None:
+        mgr.forward_signal(sig)
+
+    try:
+        signal.signal(signal.SIGTERM, _forward_signal)
+    except (OSError, ValueError):
+        pass
+    try:
+        signal.signal(signal.SIGINT, _forward_signal)
+    except (OSError, ValueError):
+        pass
+
+    mgr.spawn(command)
+    exit_code = mgr.wait()
+
+    # After subprocess exits (crash or normal): flush debouncing files and scan
+    # for anything the watcher missed entirely. This prevents data loss when
+    # parallel test workers write results in bursts just before crash.
+    watcher.flush_pending()
+    watcher.final_scan()
+
+    # Drain and close — stop watcher AFTER drain so all files are processed
+    uploader.drain(timeout=config.drain_timeout)
+    watcher.stop()
+    uploader.stop()
+
+    uploader.ensure_client()
+    uploader.close_launch()
+    if uploader._client is not None:
+        uploader._client.close()
+        uploader._client = None
+
+    _print_summary(uploader)
+    sys.exit(exit_code)
+
+
+@cli.command()
+@click.option("--endpoint", envvar="CHARISMA_ENDPOINT", default=None, help="Charisma API endpoint.")
+@click.option("--token", envvar="CHARISMA_TOKEN", default=None, help="Bearer token.")
+@click.option("--results", envvar="CHARISMA_RESULTS", default="allure-results", help="Allure results directory.")
+@click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
+@click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
+@click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
+def upload(
+    endpoint: str | None,
+    token: str | None,
+    results: str,
+    project: str,
+    silent: bool,
+    skip_too_big: bool,
+) -> None:
+    """Upload completed allure-results to Charisma (post-execution).
+
+    Usage: charismactl upload --project my-project --results allure-results
+    """
+    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big)
+
+    queue: PriorityQueue[FileEvent] = PriorityQueue()
+    uploader = Uploader(config, queue)
+    uploader.configure_logging()
+
+    # Open launch
+    launch_id = _open_launch_or_exit(uploader, config)
+    if not launch_id:
+        click.echo("Warning: Failed to open launch. No results uploaded.", err=True)
+        sys.exit(0)
+
+    # Scan existing results directory
+    results_path = Path(config.results_dir)
+    if not results_path.exists():
+        click.echo(f"Error: Results directory '{config.results_dir}' does not exist.", err=True)
+        sys.exit(1)
+
+    for filepath in sorted(results_path.iterdir()):
+        if filepath.is_file():
+            category = classify_file(filepath.name)
+            if category is not None:
+                queue.put(FileEvent(path=filepath, category=category))
+
+    # Process and drain
+    uploader.start()
+    uploader.drain(timeout=config.drain_timeout)
+    uploader.stop()
+
+    # Close launch
+    uploader.ensure_client()
+    uploader.close_launch()
+    uploader.stop()
+
+    _print_summary(uploader)