artificial-intelligence-usage 0.0.2__tar.gz → 0.0.4__tar.gz

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artificial-intelligence-usage
-Version: 0.0.2
+Version: 0.0.4
 Summary: Analyze usage of artificial intelligence tool.
 Author: Kaizten Analytics
 License-Expression: LicenseRef-Proprietary
@@ -17,7 +17,8 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 ## Behavior
 
 - Reads rollout files below `~/.codex/sessions`.
-- Reports when the Codex or Claude CLI is not available on `PATH`.
+- Shows the installed Codex and Claude CLI versions when those commands are
+  available.
 - Shows status details from the most recently modified session.
 - Reports sessions from the last 14 calendar days by default, including today.
 - Counts user turns and cumulative tokens for each session.

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/README.md

@@ -6,7 +6,8 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 ## Behavior
 
 - Reads rollout files below `~/.codex/sessions`.
-- Reports when the Codex or Claude CLI is not available on `PATH`.
+- Shows the installed Codex and Claude CLI versions when those commands are
+  available.
 - Shows status details from the most recently modified session.
 - Reports sessions from the last 14 calendar days by default, including today.
 - Counts user turns and cumulative tokens for each session.

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "artificial-intelligence-usage"
-version = "0.0.2"
+version = "0.0.4"
 description = "Analyze usage of artificial intelligence tool."
 readme = "README.md"
 requires-python = ">=3.10"

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/src/artificial_intelligence_usage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artificial-intelligence-usage
-Version: 0.0.2
+Version: 0.0.4
 Summary: Analyze usage of artificial intelligence tool.
 Author: Kaizten Analytics
 License-Expression: LicenseRef-Proprietary
@@ -17,7 +17,8 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 ## Behavior
 
 - Reads rollout files below `~/.codex/sessions`.
-- Reports when the Codex or Claude CLI is not available on `PATH`.
+- Shows the installed Codex and Claude CLI versions when those commands are
+  available.
 - Shows status details from the most recently modified session.
 - Reports sessions from the last 14 calendar days by default, including today.
 - Counts user turns and cumulative tokens for each session.

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/src/artificial_intelligence_usage.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
-"""Analyze recent Codex sessions and report usage information."""
+"""Analyze recent sessions of artificial intelligence tools (Codex, Claude, etc.) and report usage information."""
 
 from __future__ import annotations
 
 import argparse
 import json
 import shutil
+import subprocess
 from collections import Counter, defaultdict
 from datetime import date, datetime, timedelta
 from pathlib import Path
@@ -13,13 +14,7 @@ from typing import Any
 
 
 DEFAULT_DAYS = 14
-
-
-def print_unavailable_tools() -> None:
-    """Print a message for each supported AI CLI that is not on PATH."""
-    for command, name in (("codex", "Codex"), ("claude", "Claude")):
-        if shutil.which(command) is None:
-            print(f"{name} is not available.")
+SUPPORTED_TOOLS = (("Codex", "codex"), ("Claude", "claude"))
 
 
 def positive_int(value: str) -> int:
@@ -35,6 +30,53 @@ def positive_int(value: str) -> int:
     return number
 
 
+def installed_tool_version(command: str) -> str | None:
+    """Return an installed command's version output, or ``None`` if absent."""
+    executable = shutil.which(command)
+    if executable is None:
+        return None
+
+    try:
+        result = subprocess.run(
+            [executable, "--version"],
+            capture_output=True,
+            check=False,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return "unknown"
+
+    output = result.stdout.strip() or result.stderr.strip()
+    if not output:
+        return "unknown"
+
+    return " ".join(output.splitlines()[0].split())
+
+
+def detect_installed_tool_versions() -> dict[str, str]:
+    """Return versions for the supported AI command-line tools that exist."""
+    versions = {}
+    for name, command in SUPPORTED_TOOLS:
+        version = installed_tool_version(command)
+        if version is not None:
+            versions[name] = version
+    return versions
+
+
+def print_installed_tool_versions(versions: dict[str, str]) -> None:
+    """Print installed AI command-line tool versions when any are present."""
+    if not versions:
+        return
+
+    print("Installed AI tools")
+    print("-" * 57)
+    for name, _command in SUPPORTED_TOOLS:
+        if name in versions:
+            print(f"{name + ':':<16} {versions[name]}")
+    print()
+
+
 def format_timestamp(value: str | int | float | None) -> str:
     """Format an ISO or Unix timestamp in the local timezone."""
     try:
@@ -268,7 +310,12 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def run_report(sessions_dir: Path, days: int, today: date | None = None) -> int:
+def run_report(
+    sessions_dir: Path,
+    days: int,
+    today: date | None = None,
+    tool_versions: dict[str, str] | None = None,
+) -> int:
     """Analyze sessions and print the status and daily usage report."""
     current_day = today or date.today()
     first_day = current_day - timedelta(days=days - 1)
@@ -277,6 +324,10 @@ def run_report(sessions_dir: Path, days: int, today: date | None = None) -> int:
     token_counts: Counter[str] = Counter()
     last_session_by_date: dict[str, Path] = {}
 
+    if tool_versions is None:
+        tool_versions = detect_installed_tool_versions()
+    print_installed_tool_versions(tool_versions)
+
     all_session_files = list(sessions_dir.glob("*/*/*/rollout-*.jsonl"))
     latest_session = (
         max(all_session_files, key=lambda path: path.stat().st_mtime)
@@ -360,7 +411,6 @@ def run_report(sessions_dir: Path, days: int, today: date | None = None) -> int:
 def main(argv: list[str] | None = None) -> int:
     """Run the artificial-intelligence-usage command."""
     args = build_parser().parse_args(argv)
-    print_unavailable_tools()
     return run_report(Path.home() / ".codex" / "sessions", args.days)
 
 

{artificial_intelligence_usage-0.0.2 → artificial_intelligence_usage-0.0.4}/tests/test_artificial_intelligence_usage.py

@@ -73,6 +73,63 @@ class ArtificialIntelligenceUsageTests(unittest.TestCase):
         with self.assertRaisesRegex(Exception, "must be an integer"):
             artificial_intelligence_usage.positive_int("nope")
 
+    def test_installed_tool_version_returns_none_when_command_is_absent(self):
+        with patch.object(
+            artificial_intelligence_usage.shutil, "which", return_value=None
+        ):
+            self.assertIsNone(
+                artificial_intelligence_usage.installed_tool_version("codex")
+            )
+
+    def test_installed_tool_version_reads_version_from_command(self):
+        completed = artificial_intelligence_usage.subprocess.CompletedProcess(
+            args=["/tools/codex", "--version"],
+            returncode=0,
+            stdout="codex-cli 1.2.3\n",
+            stderr="",
+        )
+        with (
+            patch.object(
+                artificial_intelligence_usage.shutil,
+                "which",
+                return_value="/tools/codex",
+            ),
+            patch.object(
+                artificial_intelligence_usage.subprocess,
+                "run",
+                return_value=completed,
+            ) as run,
+        ):
+            version = artificial_intelligence_usage.installed_tool_version("codex")
+
+        self.assertEqual(version, "codex-cli 1.2.3")
+        run.assert_called_once_with(
+            ["/tools/codex", "--version"],
+            capture_output=True,
+            check=False,
+            text=True,
+            timeout=5,
+        )
+
+    def test_report_includes_installed_codex_and_claude_versions(self):
+        with tempfile.TemporaryDirectory() as directory:
+            output = io.StringIO()
+            with contextlib.redirect_stdout(output):
+                artificial_intelligence_usage.run_report(
+                    Path(directory),
+                    days=14,
+                    today=date(2026, 10, 4),
+                    tool_versions={
+                        "Codex": "codex-cli 1.2.3",
+                        "Claude": "2.0.1 (Claude Code)",
+                    },
+                )
+
+        report = output.getvalue()
+        self.assertIn("Installed AI tools", report)
+        self.assertIn("Codex:           codex-cli 1.2.3", report)
+        self.assertIn("Claude:          2.0.1 (Claude Code)", report)
+
     def test_analyze_session_ignores_malformed_lines_and_uses_maximum_tokens(self):
         with tempfile.TemporaryDirectory() as directory:
             session_file = Path(directory) / "rollout-test.jsonl"
@@ -118,7 +175,10 @@ class ArtificialIntelligenceUsageTests(unittest.TestCase):
             output = io.StringIO()
             with contextlib.redirect_stdout(output):
                 result = artificial_intelligence_usage.run_report(
-                    Path(directory), days=14, today=date(2026, 10, 4)
+                    Path(directory),
+                    days=14,
+                    today=date(2026, 10, 4),
+                    tool_versions={},
                 )
 
         self.assertEqual(result, 0)
@@ -170,7 +230,10 @@ class ArtificialIntelligenceUsageTests(unittest.TestCase):
             output = io.StringIO()
             with contextlib.redirect_stdout(output):
                 result = artificial_intelligence_usage.run_report(
-                    sessions_dir, days=2, today=date(2026, 10, 4)
+                    sessions_dir,
+                    days=2,
+                    today=date(2026, 10, 4),
+                    tool_versions={},
                 )
 
         report = output.getvalue()
@@ -184,40 +247,14 @@ class ArtificialIntelligenceUsageTests(unittest.TestCase):
     def test_main_can_be_called_repeatedly(self):
         with patch.object(
             artificial_intelligence_usage, "run_report", return_value=0
-        ) as run_report, patch.object(
-            artificial_intelligence_usage, "print_unavailable_tools"
-        ) as print_unavailable_tools:
+        ) as run_report:
             self.assertEqual(artificial_intelligence_usage.main(["--days", "3"]), 0)
             self.assertEqual(artificial_intelligence_usage.main(["--days", "5"]), 0)
 
         self.assertEqual(run_report.call_count, 2)
-        self.assertEqual(print_unavailable_tools.call_count, 2)
         self.assertEqual(run_report.call_args_list[0].args[1], 3)
         self.assertEqual(run_report.call_args_list[1].args[1], 5)
 
-    def test_unavailable_tools_prints_a_message_for_codex_and_claude(self):
-        output = io.StringIO()
-        with patch.object(
-            artificial_intelligence_usage.shutil, "which", return_value=None
-        ), contextlib.redirect_stdout(output):
-            artificial_intelligence_usage.print_unavailable_tools()
-
-        self.assertEqual(
-            output.getvalue(),
-            "Codex is not available.\nClaude is not available.\n",
-        )
-
-    def test_unavailable_tools_does_not_print_for_installed_commands(self):
-        output = io.StringIO()
-        with patch.object(
-            artificial_intelligence_usage.shutil,
-            "which",
-            side_effect=lambda command: f"/usr/bin/{command}",
-        ), contextlib.redirect_stdout(output):
-            artificial_intelligence_usage.print_unavailable_tools()
-
-        self.assertEqual(output.getvalue(), "")
-
 
 if __name__ == "__main__":
     unittest.main()