lewishowles-cli-style 0.15.0__tar.gz

lewishowles_cli_style-0.15.0/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.npmrc
+dist/
+build/
+coverage/
+adapters/swift/.build/

lewishowles_cli_style-0.15.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lewis Howles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lewishowles_cli_style-0.15.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: lewishowles-cli-style
+Version: 0.15.0
+Summary: Python adapter for the shared cli-style binary.
+Project-URL: Repository, https://github.com/lewishowles/cli-style
+Project-URL: Issues, https://github.com/lewishowles/cli-style/issues
+Author: Lewis Howles
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# lewishowles-cli-style
+
+`lewishowles-cli-style` is a Python adapter for the shared `cli-style` command-line renderer. It lets Python programs use the same terminal output styles as the JavaScript package.
+
+## Install
+
+```sh
+python -m pip install lewishowles-cli-style
+```
+
+The package supports Python 3.9 and later. The installed distribution is named `lewishowles-cli-style`, and you import it as `cli_style`.
+
+Rendering happens in the separate `cli-style` binary, so that needs to be on your `PATH`. The [main readme](https://github.com/lewishowles/cli-style#install) covers the ways to install it.
+
+## Usage
+
+```python
+from cli_style import render
+
+print(render("status", {"type": "success", "label": "Build passed"}))
+```
+
+If the `cli-style` binary is not available, `render()` returns sorted plain `key: value` text by default. Pass `raise_on_missing=True` to raise `CliStyleNotFoundError` instead.
+
+## More information
+
+- [Repository](https://github.com/lewishowles/cli-style)
+- [Issue tracker](https://github.com/lewishowles/cli-style/issues)
+- [MIT licence](https://github.com/lewishowles/cli-style/blob/main/LICENSE)

lewishowles_cli_style-0.15.0/README.md

@@ -0,0 +1,29 @@
+# lewishowles-cli-style
+
+`lewishowles-cli-style` is a Python adapter for the shared `cli-style` command-line renderer. It lets Python programs use the same terminal output styles as the JavaScript package.
+
+## Install
+
+```sh
+python -m pip install lewishowles-cli-style
+```
+
+The package supports Python 3.9 and later. The installed distribution is named `lewishowles-cli-style`, and you import it as `cli_style`.
+
+Rendering happens in the separate `cli-style` binary, so that needs to be on your `PATH`. The [main readme](https://github.com/lewishowles/cli-style#install) covers the ways to install it.
+
+## Usage
+
+```python
+from cli_style import render
+
+print(render("status", {"type": "success", "label": "Build passed"}))
+```
+
+If the `cli-style` binary is not available, `render()` returns sorted plain `key: value` text by default. Pass `raise_on_missing=True` to raise `CliStyleNotFoundError` instead.
+
+## More information
+
+- [Repository](https://github.com/lewishowles/cli-style)
+- [Issue tracker](https://github.com/lewishowles/cli-style/issues)
+- [MIT licence](https://github.com/lewishowles/cli-style/blob/main/LICENSE)

lewishowles_cli_style-0.15.0/cli_style/__init__.py

@@ -0,0 +1,73 @@
+"""Public Python API for the cli-style adapter."""
+
+from ._wrappers import (
+	agent_transcript,
+	audit_finding,
+	bar_chart,
+	bullet_list,
+	chip,
+	command_result,
+	compact_data_table,
+	confirmation_result,
+	diagnostic_report,
+	diff_block,
+	divider,
+	empty_state,
+	error_block,
+	hint,
+	labelled_line,
+	next_step_block,
+	panel,
+	progress_bar,
+	row,
+	row_group,
+	sparkline,
+	span,
+	status,
+	step,
+	step_progress,
+	table,
+	task_summary,
+)
+from .core import (
+	CliStyleError,
+	CliStyleNotFoundError,
+	CliStyleRenderError,
+	render,
+	resolve_binary,
+)
+
+__all__ = [
+	"CliStyleError",
+	"CliStyleNotFoundError",
+	"CliStyleRenderError",
+	"agent_transcript",
+	"audit_finding",
+	"bar_chart",
+	"bullet_list",
+	"chip",
+	"command_result",
+	"compact_data_table",
+	"confirmation_result",
+	"diagnostic_report",
+	"diff_block",
+	"divider",
+	"empty_state",
+	"error_block",
+	"hint",
+	"labelled_line",
+	"next_step_block",
+	"panel",
+	"progress_bar",
+	"render",
+	"resolve_binary",
+	"row",
+	"row_group",
+	"sparkline",
+	"span",
+	"status",
+	"step",
+	"step_progress",
+	"table",
+	"task_summary",
+]

lewishowles_cli_style-0.15.0/cli_style/_wrappers.py

@@ -0,0 +1,503 @@
+# Generated by scripts/generate-adapters.js. Do not edit directly.
+
+from __future__ import annotations
+
+from typing import Any
+
+from .core import render
+
+def agent_transcript(
+	entries: list[dict[str, Any]] | None = None,
+	title: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return agent-transcript output; extra keyword arguments go to render()."""
+	data = {
+		"entries": [] if entries is None else entries,
+	}
+
+	if title is not None:
+		data["title"] = title
+
+	return render("agent-transcript", data, **kwargs)
+
+
+def audit_finding(
+	result: str,
+	finding: str,
+	location: str = "",
+	recommendation: str = "",
+	evidence: str = "",
+	reference: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return audit-finding output; extra keyword arguments go to render()."""
+	data = {
+		"result": result,
+		"finding": finding,
+		"location": location,
+		"recommendation": recommendation,
+		"evidence": [evidence] if evidence else [],
+		"references": [reference] if reference else [],
+	}
+
+	return render("audit-finding", data, **kwargs)
+
+
+def bar_chart(
+	rows: list[dict[str, Any]] | None = None,
+	bar_width: int | float | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return bar-chart output; extra keyword arguments go to render()."""
+	data = {
+		"rows": [] if rows is None else rows,
+	}
+
+	if bar_width is not None:
+		data["barWidth"] = bar_width
+
+	return render("bar-chart", data, **kwargs)
+
+
+def bullet_list(
+	items: list[dict[str, Any]],
+	**kwargs: Any,
+) -> str:
+	"""Return bullet-list output; extra keyword arguments go to render()."""
+	data = {
+		"items": items,
+	}
+
+	return render("bullet-list", data, **kwargs)
+
+
+def chip(
+	label: str,
+	tone: str = "neutral",
+	**kwargs: Any,
+) -> str:
+	"""Return chip output; extra keyword arguments go to render()."""
+	data = {
+		"label": label,
+		"tone": tone,
+	}
+
+	return render("chip", data, **kwargs)
+
+
+def command_result(
+	result: str,
+	summary: str,
+	command: str = "",
+	exit_code: int | float | None = None,
+	duration: str = "",
+	detail: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return command-result output; extra keyword arguments go to render()."""
+	data = {
+		"result": result,
+		"summary": summary,
+		"command": command,
+		"duration": duration,
+		"details": [detail] if detail else [],
+	}
+
+	if exit_code is not None:
+		data["exitCode"] = exit_code
+
+	return render("command-result", data, **kwargs)
+
+
+def compact_data_table(
+	columns: list[dict[str, Any]],
+	rows: list[dict[str, Any]],
+	summary: str = "",
+	title: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return compact-data-table output; extra keyword arguments go to render()."""
+	data = {
+		"columns": columns,
+		"rows": rows,
+		"summary": summary,
+	}
+
+	if title is not None:
+		data["title"] = title
+
+	return render("compact-data-table", data, **kwargs)
+
+
+def confirmation_result(
+	state: str,
+	action: str,
+	item: str = "",
+	detail: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return confirmation-result output; extra keyword arguments go to render()."""
+	data = {
+		"state": state,
+		"action": action,
+		"item": item,
+		"detail": detail,
+	}
+
+	return render("confirmation-result", data, **kwargs)
+
+
+def diagnostic_report(
+	title: str | None = None,
+	checks: list[dict[str, Any]] | None = None,
+	findings: list[dict[str, Any]] | None = None,
+	skipped_checks: list[dict[str, Any]] | None = None,
+	next_actions: list[str] | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return diagnostic-report output; extra keyword arguments go to render()."""
+	data = {
+		"checks": [] if checks is None else checks,
+		"findings": [] if findings is None else findings,
+		"skippedChecks": [] if skipped_checks is None else skipped_checks,
+		"nextActions": [] if next_actions is None else next_actions,
+	}
+
+	if title is not None:
+		data["title"] = title
+
+	return render("diagnostic-report", data, **kwargs)
+
+
+def diff_block(
+	lines: list[dict[str, Any]] | None = None,
+	path: str = "",
+	title: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return diff-block output; extra keyword arguments go to render()."""
+	data = {
+		"path": path,
+	}
+
+	if lines is not None:
+		data["lines"] = lines
+	if title is not None:
+		data["title"] = title
+
+	return render("diff-block", data, **kwargs)
+
+
+def divider(
+	label: str = "",
+	divider_width: int | float | None = None,
+	divider_colour: str | None = None,
+	label_colour: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return divider output; extra keyword arguments go to render()."""
+	data = {
+		"label": label,
+	}
+
+	if divider_width is not None:
+		data["dividerWidth"] = divider_width
+	if divider_colour is not None:
+		data["dividerColour"] = divider_colour
+	if label_colour is not None:
+		data["labelColour"] = label_colour
+
+	return render("divider", data, **kwargs)
+
+
+def empty_state(
+	title: str = "No results",
+	detail: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return empty-state output; extra keyword arguments go to render()."""
+	data = {
+		"title": title,
+		"detail": detail,
+	}
+
+	return render("empty-state", data, **kwargs)
+
+
+def error_block(
+	title: str = "Failed",
+	lines: list[str] | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return error-block output; extra keyword arguments go to render()."""
+	data = {
+		"title": title,
+		"lines": [] if lines is None else lines,
+	}
+
+	return render("error-block", data, **kwargs)
+
+
+def hint(
+	message: str,
+	**kwargs: Any,
+) -> str:
+	"""Return hint output; extra keyword arguments go to render()."""
+	data = {
+		"message": message,
+	}
+
+	return render("hint", data, **kwargs)
+
+
+def labelled_line(
+	label: str = "",
+	message: str = "",
+	icon: str = "",
+	tone: str = "info",
+	wrap: bool = True,
+	wrap_width: int | float | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return labelled-line output; extra keyword arguments go to render()."""
+	data = {
+		"label": label,
+		"message": message,
+		"icon": icon,
+		"tone": tone,
+		"wrap": wrap,
+	}
+
+	if wrap_width is not None:
+		data["wrapWidth"] = wrap_width
+
+	return render("labelled-line", data, **kwargs)
+
+
+def next_step_block(
+	next_step: str,
+	reason: str = "",
+	command: str = "",
+	alternative: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return next-step-block output; extra keyword arguments go to render()."""
+	data = {
+		"next": next_step,
+		"reason": reason,
+		"commands": [command] if command else [],
+		"alternatives": [alternative] if alternative else [],
+	}
+
+	return render("next-step-block", data, **kwargs)
+
+
+def panel(
+	lines: list[str] | None = None,
+	title: str | None = None,
+	tone: str = "info",
+	panel_width: int | float | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return panel output; extra keyword arguments go to render()."""
+	data = {
+		"lines": [] if lines is None else lines,
+		"tone": tone,
+	}
+
+	if title is not None:
+		data["title"] = title
+	if panel_width is not None:
+		data["panelWidth"] = panel_width
+
+	return render("panel", data, **kwargs)
+
+
+def progress_bar(
+	max: int | float = 100,
+	value: int | float = 0,
+	bar_width: int | float | None = None,
+	tone: str = "success",
+	**kwargs: Any,
+) -> str:
+	"""Return progress-bar output; extra keyword arguments go to render()."""
+	data = {
+		"max": max,
+		"value": value,
+		"tone": tone,
+	}
+
+	if bar_width is not None:
+		data["barWidth"] = bar_width
+
+	return render("progress-bar", data, **kwargs)
+
+
+def row(
+	label: str,
+	value: str,
+	result: str = "",
+	label_width: int | float | None = None,
+	label_colour: str | None = None,
+	value_colour: str | None = None,
+	separator: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return row output; extra keyword arguments go to render()."""
+	data = {
+		"label": label,
+		"value": value,
+		"result": result,
+	}
+
+	if label_width is not None:
+		data["labelWidth"] = label_width
+	if label_colour is not None:
+		data["labelColour"] = label_colour
+	if value_colour is not None:
+		data["valueColour"] = value_colour
+	if separator is not None:
+		data["separator"] = separator
+
+	return render("row", data, **kwargs)
+
+
+def row_group(
+	rows: list[dict[str, Any]],
+	label_width: int | float | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return row-group output; extra keyword arguments go to render()."""
+	data = {
+		"rows": rows,
+	}
+
+	if label_width is not None:
+		data["labelWidth"] = label_width
+
+	return render("row-group", data, **kwargs)
+
+
+def sparkline(
+	values: list[int | float] | None = None,
+	width: int | float | None = None,
+	label: str | None = None,
+	tone: str = "success",
+	**kwargs: Any,
+) -> str:
+	"""Return sparkline output; extra keyword arguments go to render()."""
+	data = {
+		"values": [] if values is None else values,
+		"tone": tone,
+	}
+
+	if width is not None:
+		data["width"] = width
+	if label is not None:
+		data["label"] = label
+
+	return render("sparkline", data, **kwargs)
+
+
+def span(
+	value: str,
+	tone: str = "info",
+	weight: str | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return span output; extra keyword arguments go to render()."""
+	data = {
+		"value": value,
+		"tone": tone,
+	}
+
+	if weight is not None:
+		data["weight"] = weight
+
+	return render("span", data, **kwargs)
+
+
+def status(
+	type: str,
+	label: str = "",
+	detail: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return status output; extra keyword arguments go to render()."""
+	data = {
+		"type": type,
+		"label": label,
+		"detail": detail,
+	}
+
+	return render("status", data, **kwargs)
+
+
+def step(
+	label: str = "",
+	state: str = "pending",
+	**kwargs: Any,
+) -> str:
+	"""Return step output; extra keyword arguments go to render()."""
+	data = {
+		"label": label,
+		"state": state,
+	}
+
+	return render("step", data, **kwargs)
+
+
+def step_progress(
+	current: int | float = 0,
+	steps: list[str] | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return step-progress output; extra keyword arguments go to render()."""
+	data = {
+		"current": current,
+		"steps": [] if steps is None else steps,
+	}
+
+	return render("step-progress", data, **kwargs)
+
+
+def table(
+	columns: list[dict[str, Any]],
+	rows: list[dict[str, Any]],
+	unicode: bool | None = None,
+	width: int | float | None = None,
+	**kwargs: Any,
+) -> str:
+	"""Return table output; extra keyword arguments go to render()."""
+	data = {
+		"columns": columns,
+		"rows": rows,
+	}
+
+	if unicode is not None:
+		data["unicode"] = unicode
+	if width is not None:
+		data["width"] = width
+
+	return render("table", data, **kwargs)
+
+
+def task_summary(
+	result: str,
+	task: str,
+	summary: str = "",
+	completed: str = "",
+	remaining: str = "",
+	**kwargs: Any,
+) -> str:
+	"""Return task-summary output; extra keyword arguments go to render()."""
+	data = {
+		"result": result,
+		"task": task,
+		"summary": summary,
+		"completed": [completed] if completed else [],
+		"remaining": [remaining] if remaining else [],
+	}
+
+	return render("task-summary", data, **kwargs)

lewishowles_cli_style-0.15.0/cli_style/core.py

@@ -0,0 +1,136 @@
+"""Run the shared cli-style binary from Python."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Sequence
+
+
+class CliStyleError(RuntimeError):
+	"""Base error for cli-style adapter failures."""
+
+
+class CliStyleNotFoundError(CliStyleError):
+	"""Raised when the cli-style binary cannot be found."""
+
+
+class CliStyleRenderError(CliStyleError):
+	"""Raised when cli-style rejects a render request."""
+
+
+def resolve_subprocess_environment() -> dict[str, str]:
+	"""Resolve the child environment while preserving caller controls."""
+	environment = os.environ.copy()
+
+	if (
+		sys.stdout.isatty()
+		and "FORCE_COLOR" not in environment
+		and "NO_COLOR" not in environment
+	):
+		environment["FORCE_COLOR"] = "1"
+
+	return environment
+
+
+def render(
+	renderer: str,
+	data: dict[str, Any],
+	*,
+	binary: str = "cli-style",
+	profile: str | None = None,
+	width: int | None = None,
+	plain: bool = False,
+	no_colour: bool = False,
+	no_unicode: bool = False,
+	extra_args: Sequence[str] | None = None,
+	raise_on_missing: bool = False,
+) -> str:
+	"""Render JSON-serialisable data through ``cli-style render``.
+
+	When the binary cannot be found, return a plain-text rendering of the data
+	instead, unless ``raise_on_missing`` is set.
+
+	:param renderer: Stable renderer name accepted by the cli-style binary.
+	:param data: JSON-serialisable renderer input.
+	:param binary: Binary path or command name.
+	:param profile: Optional output profile.
+	:param width: Optional terminal width.
+	:param plain: Disable terminal colour and Unicode output.
+	:param no_colour: Disable terminal colour output.
+	:param no_unicode: Disable Unicode output.
+	:param extra_args: Additional flags passed to the binary.
+	:param raise_on_missing: Raise ``CliStyleNotFoundError`` when the binary
+		cannot be found, instead of returning plain text.
+	"""
+	if not isinstance(renderer, str) or renderer == "":
+		raise ValueError("renderer must be a non-empty string")
+
+	if not isinstance(data, dict):
+		raise TypeError("data must be a dict")
+
+	try:
+		resolved_binary = resolve_binary(binary)
+	except CliStyleNotFoundError:
+		if raise_on_missing:
+			raise
+
+		# Sort the keys so the lines match the Swift adapter, which has no key order to keep.
+		return "\n".join(f"{key}: {value}" for key, value in sorted(data.items(), key=lambda item: str(item[0])))
+
+	command = [resolved_binary, "render", renderer]
+
+	if profile is not None:
+		command.extend(["--profile", profile])
+
+	if width is not None:
+		command.extend(["--width", str(width)])
+
+	if plain:
+		command.append("--plain")
+
+	if no_colour:
+		command.append("--no-colour")
+
+	if no_unicode:
+		command.append("--no-unicode")
+
+	if extra_args is not None:
+		command.extend(extra_args)
+
+	result = subprocess.run(
+		command,
+		capture_output=True,
+		check=False,
+		env=resolve_subprocess_environment(),
+		input=json.dumps(data),
+		text=True,
+	)
+
+	if result.returncode != 0:
+		message = result.stderr.strip() or f"cli-style render failed with exit code {result.returncode}"
+		raise CliStyleRenderError(message)
+
+	return result.stdout.rstrip("\n")
+
+
+def resolve_binary(binary: str) -> str:
+	"""Resolve a cli-style command name or executable path."""
+	if "/" in binary:
+		path = Path(binary)
+
+		if path.is_file() and os.access(path, os.X_OK):
+			return str(path)
+
+		raise CliStyleNotFoundError(f"cli-style binary not found: {binary}")
+
+	resolved = shutil.which(binary)
+
+	if resolved is None:
+		raise CliStyleNotFoundError(f"cli-style binary not found: {binary}")
+
+	return resolved

lewishowles_cli_style-0.15.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "lewishowles-cli-style"
+version = "0.15.0"
+description = "Python adapter for the shared cli-style binary."
+authors = [{ name = "Lewis Howles" }]
+license = { text = "MIT" }
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+classifiers = [
+	"License :: OSI Approved :: MIT License",
+	"Programming Language :: Python :: 3",
+	"Programming Language :: Python :: 3 :: Only",
+	"Programming Language :: Python :: 3.9",
+	"Programming Language :: Python :: 3.10",
+	"Programming Language :: Python :: 3.11",
+	"Programming Language :: Python :: 3.12",
+	"Programming Language :: Python :: 3.13",
+	"Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Repository = "https://github.com/lewishowles/cli-style"
+Issues = "https://github.com/lewishowles/cli-style/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["cli_style"]