ArtinKit 0.1.0__tar.gz

artinkit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artin Karimian
+
+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.

artinkit-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: ArtinKit
+Version: 0.1.0
+Summary: Lightweight Python utilities with secure defaults and zero mandatory third-party dependencies.
+Author: Artin Karimian
+License-Expression: MIT
+Keywords: utilities,toolkit,json,files,text,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# ArtinKit
+
+Lightweight Python utilities with secure defaults and **zero mandatory third-party runtime dependencies**.
+
+> ArtinKit is a general-purpose utility toolkit, not a bundled AI model.
+
+## Features
+
+- Text helpers: whitespace normalization, word counting, safe truncation, and slug creation.
+- File helpers: UTF-8 reads/writes, directory creation, file listing, and file sizes.
+- JSON storage: Unicode-friendly JSON load/save with clear error behavior.
+- Validation helpers: safe checks for common strings and numeric values.
+- Logging helper: create a consistently configured standard-library logger.
+- CLI: inspect files and normalize text from a terminal.
+- Automated tests, security scanning, and build verification.
+
+## Install online
+
+After the first release is published on PyPI:
+
+```bash
+python -m pip install ArtinKit
+```
+
+The package name on package indexes is case-insensitive; import it as `artinkit`.
+
+## Install offline
+
+Download the prebuilt wheel from this repository's release/files section or obtain the wheel from the project maintainer, then install it without internet:
+
+```bash
+python -m pip install --no-index --no-deps ArtinKit-0.1.0-py3-none-any.whl
+```
+
+ArtinKit has no mandatory third-party runtime dependencies. See [OFFLINE_INSTALL.md](OFFLINE_INSTALL.md) for full offline installation instructions.
+
+## Quick start
+
+```python
+from artinkit import text, files, jsonstore
+
+print(text.normalize_whitespace("  Hello   ArtinKit  "))
+print(text.slugify("ArtinKit Utilities"))
+
+files.write_text("hello.txt", "Hello from ArtinKit", create_parents=True)
+jsonstore.save_json("settings.json", {"language": "fa", "ready": True})
+settings = jsonstore.load_json("settings.json")
+print(settings)
+```
+
+## CLI
+
+```bash
+artinkit normalize "  Hello    world  "
+artinkit file-info README.md
+```
+
+## Security notes
+
+- No network access or subprocess execution is performed by the core package.
+- File operations target paths explicitly supplied by the caller.
+- JSON loading does not execute code.
+- Avoid passing untrusted paths to file-writing functions when your application has broader filesystem permissions.
+- Security scans and tests run in GitHub Actions. Publishing is separated into a protected job that uses PyPI Trusted Publishing.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

artinkit-0.1.0/README.md

@@ -0,0 +1,77 @@
+# ArtinKit
+
+Lightweight Python utilities with secure defaults and **zero mandatory third-party runtime dependencies**.
+
+> ArtinKit is a general-purpose utility toolkit, not a bundled AI model.
+
+## Features
+
+- Text helpers: whitespace normalization, word counting, safe truncation, and slug creation.
+- File helpers: UTF-8 reads/writes, directory creation, file listing, and file sizes.
+- JSON storage: Unicode-friendly JSON load/save with clear error behavior.
+- Validation helpers: safe checks for common strings and numeric values.
+- Logging helper: create a consistently configured standard-library logger.
+- CLI: inspect files and normalize text from a terminal.
+- Automated tests, security scanning, and build verification.
+
+## Install online
+
+After the first release is published on PyPI:
+
+```bash
+python -m pip install ArtinKit
+```
+
+The package name on package indexes is case-insensitive; import it as `artinkit`.
+
+## Install offline
+
+Download the prebuilt wheel from this repository's release/files section or obtain the wheel from the project maintainer, then install it without internet:
+
+```bash
+python -m pip install --no-index --no-deps ArtinKit-0.1.0-py3-none-any.whl
+```
+
+ArtinKit has no mandatory third-party runtime dependencies. See [OFFLINE_INSTALL.md](OFFLINE_INSTALL.md) for full offline installation instructions.
+
+## Quick start
+
+```python
+from artinkit import text, files, jsonstore
+
+print(text.normalize_whitespace("  Hello   ArtinKit  "))
+print(text.slugify("ArtinKit Utilities"))
+
+files.write_text("hello.txt", "Hello from ArtinKit", create_parents=True)
+jsonstore.save_json("settings.json", {"language": "fa", "ready": True})
+settings = jsonstore.load_json("settings.json")
+print(settings)
+```
+
+## CLI
+
+```bash
+artinkit normalize "  Hello    world  "
+artinkit file-info README.md
+```
+
+## Security notes
+
+- No network access or subprocess execution is performed by the core package.
+- File operations target paths explicitly supplied by the caller.
+- JSON loading does not execute code.
+- Avoid passing untrusted paths to file-writing functions when your application has broader filesystem permissions.
+- Security scans and tests run in GitHub Actions. Publishing is separated into a protected job that uses PyPI Trusted Publishing.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

artinkit-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ArtinKit"
+version = "0.1.0"
+description = "Lightweight Python utilities with secure defaults and zero mandatory third-party dependencies."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "Artin Karimian" }
+]
+keywords = ["utilities", "toolkit", "json", "files", "text", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["build>=1.2", "pytest>=8", "bandit>=1.7", "twine>=5"]
+
+[project.scripts]
+artinkit = "artinkit.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.bandit]
+exclude_dirs = ["tests"]

artinkit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

artinkit-0.1.0/src/ArtinKit.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: ArtinKit
+Version: 0.1.0
+Summary: Lightweight Python utilities with secure defaults and zero mandatory third-party dependencies.
+Author: Artin Karimian
+License-Expression: MIT
+Keywords: utilities,toolkit,json,files,text,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# ArtinKit
+
+Lightweight Python utilities with secure defaults and **zero mandatory third-party runtime dependencies**.
+
+> ArtinKit is a general-purpose utility toolkit, not a bundled AI model.
+
+## Features
+
+- Text helpers: whitespace normalization, word counting, safe truncation, and slug creation.
+- File helpers: UTF-8 reads/writes, directory creation, file listing, and file sizes.
+- JSON storage: Unicode-friendly JSON load/save with clear error behavior.
+- Validation helpers: safe checks for common strings and numeric values.
+- Logging helper: create a consistently configured standard-library logger.
+- CLI: inspect files and normalize text from a terminal.
+- Automated tests, security scanning, and build verification.
+
+## Install online
+
+After the first release is published on PyPI:
+
+```bash
+python -m pip install ArtinKit
+```
+
+The package name on package indexes is case-insensitive; import it as `artinkit`.
+
+## Install offline
+
+Download the prebuilt wheel from this repository's release/files section or obtain the wheel from the project maintainer, then install it without internet:
+
+```bash
+python -m pip install --no-index --no-deps ArtinKit-0.1.0-py3-none-any.whl
+```
+
+ArtinKit has no mandatory third-party runtime dependencies. See [OFFLINE_INSTALL.md](OFFLINE_INSTALL.md) for full offline installation instructions.
+
+## Quick start
+
+```python
+from artinkit import text, files, jsonstore
+
+print(text.normalize_whitespace("  Hello   ArtinKit  "))
+print(text.slugify("ArtinKit Utilities"))
+
+files.write_text("hello.txt", "Hello from ArtinKit", create_parents=True)
+jsonstore.save_json("settings.json", {"language": "fa", "ready": True})
+settings = jsonstore.load_json("settings.json")
+print(settings)
+```
+
+## CLI
+
+```bash
+artinkit normalize "  Hello    world  "
+artinkit file-info README.md
+```
+
+## Security notes
+
+- No network access or subprocess execution is performed by the core package.
+- File operations target paths explicitly supplied by the caller.
+- JSON loading does not execute code.
+- Avoid passing untrusted paths to file-writing functions when your application has broader filesystem permissions.
+- Security scans and tests run in GitHub Actions. Publishing is separated into a protected job that uses PyPI Trusted Publishing.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

artinkit-0.1.0/src/ArtinKit.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/ArtinKit.egg-info/PKG-INFO
+src/ArtinKit.egg-info/SOURCES.txt
+src/ArtinKit.egg-info/dependency_links.txt
+src/ArtinKit.egg-info/entry_points.txt
+src/ArtinKit.egg-info/requires.txt
+src/ArtinKit.egg-info/top_level.txt
+src/artinkit/__init__.py
+src/artinkit/cli.py
+src/artinkit/files.py
+src/artinkit/jsonstore.py
+src/artinkit/logging_utils.py
+src/artinkit/text.py
+src/artinkit/validation.py
+tests/test_core.py

artinkit-0.1.0/src/ArtinKit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

artinkit-0.1.0/src/ArtinKit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+artinkit = artinkit.cli:main

artinkit-0.1.0/src/ArtinKit.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+build>=1.2
+pytest>=8
+bandit>=1.7
+twine>=5

artinkit-0.1.0/src/ArtinKit.egg-info/top_level.txt

@@ -0,0 +1 @@
+artinkit

artinkit-0.1.0/src/artinkit/__init__.py

@@ -0,0 +1,8 @@
+"""ArtinKit: lightweight Python utilities with secure defaults."""
+
+from . import files, jsonstore, text, validation
+from .logging_utils import get_logger
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__", "files", "jsonstore", "text", "validation", "get_logger"]

artinkit-0.1.0/src/artinkit/cli.py

@@ -0,0 +1,40 @@
+"""Command-line entry point for ArtinKit."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from . import files, text
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="artinkit", description="Lightweight Python utilities")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    normalize = subparsers.add_parser("normalize", help="collapse whitespace in text")
+    normalize.add_argument("text", help="text to normalize")
+
+    info = subparsers.add_parser("file-info", help="show basic information about a file")
+    info.add_argument("path", help="path to an existing file")
+
+    return parser
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    if args.command == "normalize":
+        print(text.normalize_whitespace(args.text))
+        return 0
+    if args.command == "file-info":
+        path = Path(args.path)
+        if not path.is_file():
+            raise SystemExit(f"Not a file: {path}")
+        print(f"Path: {path}")
+        print(f"Size: {files.file_size(path)} bytes")
+        return 0
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

artinkit-0.1.0/src/artinkit/files.py

@@ -0,0 +1,51 @@
+"""Explicit-path filesystem helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def read_text(path: str | Path, encoding: str = "utf-8") -> str:
+    """Read a text file using UTF-8 by default."""
+    return Path(path).read_text(encoding=encoding)
+
+
+def write_text(
+    path: str | Path,
+    content: str,
+    *,
+    encoding: str = "utf-8",
+    create_parents: bool = False,
+) -> Path:
+    """Write text to an explicit path and return the resulting Path."""
+    if not isinstance(content, str):
+        raise TypeError("content must be a string")
+    target = Path(path)
+    if create_parents:
+        target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding=encoding)
+    return target
+
+
+def ensure_dir(path: str | Path) -> Path:
+    """Create a directory and its parents if needed."""
+    target = Path(path)
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def list_files(path: str | Path, *, recursive: bool = False) -> list[Path]:
+    """List regular files in a directory, sorted by path."""
+    root = Path(path)
+    if not root.is_dir():
+        raise NotADirectoryError(str(root))
+    iterator = root.rglob("*") if recursive else root.iterdir()
+    return sorted((item for item in iterator if item.is_file()), key=lambda item: str(item))
+
+
+def file_size(path: str | Path) -> int:
+    """Return file size in bytes."""
+    target = Path(path)
+    if not target.is_file():
+        raise FileNotFoundError(str(target))
+    return target.stat().st_size

artinkit-0.1.0/src/artinkit/jsonstore.py

@@ -0,0 +1,32 @@
+"""Simple JSON file storage using only the standard library."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_json(path: str | Path) -> Any:
+    """Load JSON from a UTF-8 file."""
+    with Path(path).open("r", encoding="utf-8") as stream:
+        return json.load(stream)
+
+
+def save_json(
+    path: str | Path,
+    data: Any,
+    *,
+    indent: int = 2,
+    create_parents: bool = False,
+) -> Path:
+    """Save JSON as UTF-8, preserving non-ASCII characters."""
+    if isinstance(indent, bool) or not isinstance(indent, int) or indent < 0:
+        raise ValueError("indent must be a non-negative integer")
+    target = Path(path)
+    if create_parents:
+        target.parent.mkdir(parents=True, exist_ok=True)
+    with target.open("w", encoding="utf-8", newline="\n") as stream:
+        json.dump(data, stream, ensure_ascii=False, indent=indent, allow_nan=False)
+        stream.write("\n")
+    return target

artinkit-0.1.0/src/artinkit/logging_utils.py

@@ -0,0 +1,14 @@
+"""Logging configuration helpers."""
+
+from __future__ import annotations
+
+import logging
+
+
+def get_logger(name: str = "artinkit", *, level: int = logging.INFO) -> logging.Logger:
+    """Return a named logger without configuring the application's root logger."""
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError("name must be a non-empty string")
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    return logger

artinkit-0.1.0/src/artinkit/text.py

@@ -0,0 +1,51 @@
+"""Small, dependency-free text helpers."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+
+def normalize_whitespace(value: str) -> str:
+    """Collapse all whitespace runs into one ASCII space and trim edges."""
+    _require_string(value, "value")
+    return " ".join(value.split())
+
+
+def word_count(value: str) -> int:
+    """Count whitespace-separated words."""
+    _require_string(value, "value")
+    return len(value.split())
+
+
+def truncate(value: str, max_length: int, suffix: str = "...") -> str:
+    """Truncate text to at most max_length characters, including the suffix."""
+    _require_string(value, "value")
+    _require_string(suffix, "suffix")
+    if isinstance(max_length, bool) or not isinstance(max_length, int):
+        raise TypeError("max_length must be an integer")
+    if max_length < 0:
+        raise ValueError("max_length must be >= 0")
+    if len(value) <= max_length:
+        return value
+    if max_length == 0:
+        return ""
+    if max_length <= len(suffix):
+        return value[:max_length]
+    return value[: max_length - len(suffix)] + suffix
+
+
+def slugify(value: str, separator: str = "-") -> str:
+    """Create a simple lowercase ASCII slug from text."""
+    _require_string(value, "value")
+    _require_string(separator, "separator")
+    if not separator or any(ch.isalnum() for ch in separator):
+        raise ValueError("separator must be non-empty and contain no alphanumeric characters")
+    normalized = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode("ascii")
+    parts = re.findall(r"[a-zA-Z0-9]+", normalized.lower())
+    return separator.join(parts)
+
+
+def _require_string(value: str, name: str) -> None:
+    if not isinstance(value, str):
+        raise TypeError(f"{name} must be a string")

artinkit-0.1.0/src/artinkit/validation.py

@@ -0,0 +1,33 @@
+"""Small, predictable validation helpers."""
+
+from __future__ import annotations
+
+import math
+import re
+
+
+def is_non_empty_string(value: object) -> bool:
+    """Return True when value is a string containing non-whitespace text."""
+    return isinstance(value, str) and bool(value.strip())
+
+
+def is_integer(value: object) -> bool:
+    """Return True for integers but not booleans."""
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def is_finite_number(value: object) -> bool:
+    """Return True for finite integers/floats, excluding booleans."""
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        return False
+    try:
+        return math.isfinite(value)
+    except OverflowError:
+        return False
+
+
+def matches_pattern(value: str, pattern: str) -> bool:
+    """Return whether an entire string matches a regular expression."""
+    if not isinstance(value, str) or not isinstance(pattern, str):
+        raise TypeError("value and pattern must be strings")
+    return re.fullmatch(pattern, value) is not None

artinkit-0.1.0/tests/test_core.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import pytest
+
+from artinkit import files, jsonstore, text, validation
+
+
+def test_normalize_whitespace_and_word_count():
+    assert text.normalize_whitespace("  hello\t world \n") == "hello world"
+    assert text.word_count("one two three") == 3
+    assert text.word_count("   ") == 0
+
+
+def test_slugify():
+    assert text.slugify("ArtinKit Utilities!") == "artinkit-utilities"
+    assert text.slugify("A B", separator="_") == "a_b"
+
+
+def test_truncate_respects_limit():
+    assert text.truncate("abcdef", 4) == "a..."
+    assert text.truncate("abcdef", 2) == "ab"
+    assert text.truncate("abc", 4) == "abc"
+    assert text.truncate("abc", 0) == ""
+
+
+def test_text_validation():
+    with pytest.raises(TypeError):
+        text.normalize_whitespace(42)  # type: ignore[arg-type]
+    with pytest.raises(ValueError):
+        text.truncate("abc", -1)
+
+
+def test_write_read_and_create_parent(tmp_path):
+    target = files.write_text(tmp_path / "nested" / "hello.txt", "سلام", create_parents=True)
+    assert files.read_text(target) == "سلام"
+    assert files.file_size(target) > 0
+
+
+def test_list_files_and_ensure_dir(tmp_path):
+    folder = files.ensure_dir(tmp_path / "data")
+    (folder / "a.txt").write_text("a", encoding="utf-8")
+    (folder / "b.txt").write_text("b", encoding="utf-8")
+    (folder / "nested").mkdir()
+    (folder / "nested" / "c.txt").write_text("c", encoding="utf-8")
+    assert [p.name for p in files.list_files(folder)] == ["a.txt", "b.txt"]
+    assert len(files.list_files(folder, recursive=True)) == 3
+
+
+def test_json_roundtrip_preserves_unicode(tmp_path):
+    target = tmp_path / "config.json"
+    data = {"language": "فارسی", "enabled": True, "items": [1, 2]}
+    jsonstore.save_json(target, data)
+    assert jsonstore.load_json(target) == data
+    assert "فارسی" in target.read_text(encoding="utf-8")
+
+
+def test_json_rejects_nan(tmp_path):
+    with pytest.raises(ValueError):
+        jsonstore.save_json(tmp_path / "bad.json", {"x": float("nan")})
+
+
+def test_json_indent_validation(tmp_path):
+    with pytest.raises(ValueError):
+        jsonstore.save_json(tmp_path / "bad.json", {}, indent=-1)
+
+
+def test_validation_helpers():
+    assert validation.is_non_empty_string(" hi ")
+    assert not validation.is_non_empty_string("  ")
+    assert validation.is_integer(2)
+    assert not validation.is_integer(True)
+    assert validation.is_finite_number(1.5)
+    assert not validation.is_finite_number(float("inf"))
+    assert validation.matches_pattern("ABC-123", r"[A-Z]{3}-\d{3}")
+
+
+def test_cli_normalize(capsys, monkeypatch):
+    from artinkit import cli
+    monkeypatch.setattr("sys.argv", ["artinkit", "normalize", "  hello   world "])
+    assert cli.main() == 0
+    assert capsys.readouterr().out.strip() == "hello world"