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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artificial-intelligence-usage
-Version: 0.0.4
+Version: 0.0.5
 Summary: Analyze usage of artificial intelligence tool.
 Author: Kaizten Analytics
 License-Expression: LicenseRef-Proprietary
@@ -8,11 +8,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: langid==1.1.6
 
 # Artificial Intelligence Usage
 
 `artificial-intelligence-usage` analyzes local Codex session rollouts and prints a summary of the
-latest session followed by daily session, turn, token, and rate-limit usage.
+latest session followed by daily and per-session prompt, token, and rate-limit usage.
 
 ## Behavior
 
@@ -22,6 +23,19 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 - 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.
+- Breaks applied prompts down into Normal, Plan, and Goal counts. Goal counts
+  include automatic goal continuations, while background tasks such as guardian
+  reviews are excluded.
+- Shows a second table with one row per session, including its start time,
+  session name (up to 10 characters), first-prompt preview (up to 20
+  characters), GitHub repository, usage, and language.
+- Reads session names from `~/.codex/session_index.jsonl`. Missing names and
+  prompts display as `Unknown`.
+- For goal-only sessions, reads the goal objective from
+  `~/.codex/goals_1.sqlite` for the prompt preview and reports its language as
+  `Unknown`.
+- Uses `langid`, restricted to English and Spanish, for prompt language
+  detection. Sessions without a detectable user prompt show `Unknown`.
 - Shows the remaining five-hour and weekly allowance recorded in each day's
   last session.
 - Ignores malformed JSON lines and incomplete status events.
@@ -31,6 +45,7 @@ The tool only reads local session files and does not modify them.
 ## Requirements
 
 - Python 3.10 or newer
+- `langid` 1.1.6 (installed automatically with the package)
 
 ## Building
 

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

@@ -1,7 +1,7 @@
 # Artificial Intelligence Usage
 
 `artificial-intelligence-usage` analyzes local Codex session rollouts and prints a summary of the
-latest session followed by daily session, turn, token, and rate-limit usage.
+latest session followed by daily and per-session prompt, token, and rate-limit usage.
 
 ## Behavior
 
@@ -11,6 +11,19 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 - 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.
+- Breaks applied prompts down into Normal, Plan, and Goal counts. Goal counts
+  include automatic goal continuations, while background tasks such as guardian
+  reviews are excluded.
+- Shows a second table with one row per session, including its start time,
+  session name (up to 10 characters), first-prompt preview (up to 20
+  characters), GitHub repository, usage, and language.
+- Reads session names from `~/.codex/session_index.jsonl`. Missing names and
+  prompts display as `Unknown`.
+- For goal-only sessions, reads the goal objective from
+  `~/.codex/goals_1.sqlite` for the prompt preview and reports its language as
+  `Unknown`.
+- Uses `langid`, restricted to English and Spanish, for prompt language
+  detection. Sessions without a detectable user prompt show `Unknown`.
 - Shows the remaining five-hour and weekly allowance recorded in each day's
   last session.
 - Ignores malformed JSON lines and incomplete status events.
@@ -20,6 +33,7 @@ The tool only reads local session files and does not modify them.
 ## Requirements
 
 - Python 3.10 or newer
+- `langid` 1.1.6 (installed automatically with the package)
 
 ## Building
 

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

@@ -4,12 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "artificial-intelligence-usage"
-version = "0.0.4"
+version = "0.0.5"
 description = "Analyze usage of artificial intelligence tool."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "LicenseRef-Proprietary"
 authors = [{ name = "Kaizten Analytics" }]
+dependencies = ["langid==1.1.6"]
 classifiers = [
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artificial-intelligence-usage
-Version: 0.0.4
+Version: 0.0.5
 Summary: Analyze usage of artificial intelligence tool.
 Author: Kaizten Analytics
 License-Expression: LicenseRef-Proprietary
@@ -8,11 +8,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: langid==1.1.6
 
 # Artificial Intelligence Usage
 
 `artificial-intelligence-usage` analyzes local Codex session rollouts and prints a summary of the
-latest session followed by daily session, turn, token, and rate-limit usage.
+latest session followed by daily and per-session prompt, token, and rate-limit usage.
 
 ## Behavior
 
@@ -22,6 +23,19 @@ latest session followed by daily session, turn, token, and rate-limit usage.
 - 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.
+- Breaks applied prompts down into Normal, Plan, and Goal counts. Goal counts
+  include automatic goal continuations, while background tasks such as guardian
+  reviews are excluded.
+- Shows a second table with one row per session, including its start time,
+  session name (up to 10 characters), first-prompt preview (up to 20
+  characters), GitHub repository, usage, and language.
+- Reads session names from `~/.codex/session_index.jsonl`. Missing names and
+  prompts display as `Unknown`.
+- For goal-only sessions, reads the goal objective from
+  `~/.codex/goals_1.sqlite` for the prompt preview and reports its language as
+  `Unknown`.
+- Uses `langid`, restricted to English and Spanish, for prompt language
+  detection. Sessions without a detectable user prompt show `Unknown`.
 - Shows the remaining five-hour and weekly allowance recorded in each day's
   last session.
 - Ignores malformed JSON lines and incomplete status events.
@@ -31,6 +45,7 @@ The tool only reads local session files and does not modify them.
 ## Requirements
 
 - Python 3.10 or newer
+- `langid` 1.1.6 (installed automatically with the package)
 
 ## Building
 

{artificial_intelligence_usage-0.0.4 → artificial_intelligence_usage-0.0.5}/src/artificial_intelligence_usage.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/artificial_intelligence_usage.egg-info/PKG-INFO
 src/artificial_intelligence_usage.egg-info/SOURCES.txt
 src/artificial_intelligence_usage.egg-info/dependency_links.txt
 src/artificial_intelligence_usage.egg-info/entry_points.txt
+src/artificial_intelligence_usage.egg-info/requires.txt
 src/artificial_intelligence_usage.egg-info/top_level.txt
 tests/test_artificial_intelligence_usage.py
 tests/test_publish_pypi.py

artificial_intelligence_usage-0.0.5/src/artificial_intelligence_usage.egg-info/requires.txt

@@ -0,0 +1 @@
+langid==1.1.6

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

@@ -5,16 +5,46 @@ from __future__ import annotations
 
 import argparse
 import json
+import re
 import shutil
+import sqlite3
 import subprocess
 from collections import Counter, defaultdict
+from dataclasses import dataclass
 from datetime import date, datetime, timedelta
 from pathlib import Path
 from typing import Any
 
+import langid
+
 
 DEFAULT_DAYS = 14
 SUPPORTED_TOOLS = (("Codex", "codex"), ("Claude", "claude"))
+INTERNAL_USER_TEXT_TAGS = {
+    "codex_internal_context",
+    "environment_context",
+    "goal",
+    "goals",
+    "guardian_tool_descriptions",
+    "turn_aborted",
+}
+
+langid.set_languages(["en", "es"])
+
+
+@dataclass(frozen=True)
+class SessionAnalysis:
+    """Usage information extracted from one Codex session."""
+
+    turns: int
+    tokens: int
+    normal_prompts: int
+    plan_prompts: int
+    goal_prompts: int
+    repository: str
+    language: str
+    session_id: str | None
+    first_prompt: str | None
 
 
 def positive_int(value: str) -> int:
@@ -263,10 +293,170 @@ def print_status(session_file: Path | None) -> None:
     print()
 
 
-def analyze_session(session_file: Path) -> tuple[int, int]:
-    """Return ``(user_turns, total_tokens)`` for one Codex session."""
+def prompt_type(payload: dict[str, Any]) -> str | None:
+    """Return the prompt type for a task-started payload, if applicable."""
+    attribution = payload.get("turn_attribution")
+    if isinstance(attribution, dict):
+        trigger = attribution.get("turn_trigger")
+    elif isinstance(attribution, str):
+        trigger = attribution
+    else:
+        trigger = None
+
+    if trigger == "goal":
+        return "goal"
+
+    if trigger not in (None, "user"):
+        return None
+
+    mode = payload.get("collaboration_mode_kind")
+    if mode == "plan":
+        return "plan"
+    if mode in (None, "default"):
+        return "normal"
+
+    return None
+
+
+def github_repository(repository_url: Any) -> str:
+    """Return ``owner/repository`` for a GitHub remote URL."""
+    if not isinstance(repository_url, str):
+        return "Unknown"
+
+    match = re.match(
+        r"^(?:https?://|ssh://git@|git@)github\.com[/:]"
+        r"(?P<owner>[^/]+)/(?P<repository>[^/#]+)/?$",
+        repository_url.strip(),
+        re.IGNORECASE,
+    )
+    if match is None:
+        return "Unknown"
+
+    repository = match.group("repository").removesuffix(".git")
+    return f"{match.group('owner')}/{repository}"
+
+
+def is_internal_user_text(text: str) -> bool:
+    """Return whether user-role text contains Codex-injected context."""
+    match = re.match(r"^\s*<([A-Za-z0-9_-]+)(?:\s|>)", text)
+    return match is not None and match.group(1) in INTERNAL_USER_TEXT_TAGS
+
+
+def user_prompt_text(payload: dict[str, Any]) -> str | None:
+    """Return real user-authored text from a user-message payload."""
+    content = payload.get("content")
+    if not isinstance(content, list):
+        return None
+
+    parts = []
+    for item in content:
+        if not isinstance(item, dict) or item.get("type") != "input_text":
+            continue
+
+        text = item.get("text")
+        if (
+            isinstance(text, str)
+            and text.strip()
+            and not is_internal_user_text(text)
+        ):
+            parts.append(text.strip())
+
+    return "\n".join(parts) or None
+
+
+def detect_language(prompt: str | None) -> str:
+    """Classify a prompt as English or Spanish."""
+    if prompt is None:
+        return "Unknown"
+
+    language_code, _confidence = langid.classify(prompt)
+    return {"en": "English", "es": "Spanish"}.get(language_code, "Unknown")
+
+
+def compact_text(value: str | None, maximum_length: int) -> str:
+    """Normalize whitespace and truncate display text."""
+    if not isinstance(value, str):
+        return "Unknown"
+
+    normalized = " ".join(value.split())
+    return normalized[:maximum_length] or "Unknown"
+
+
+def read_session_names(session_index_file: Path) -> dict[str, str]:
+    """Return the latest indexed name for each Codex session."""
+    names: dict[str, str] = {}
+
+    try:
+        with session_index_file.open("r", encoding="utf-8") as file_handle:
+            for line in file_handle:
+                try:
+                    entry = json.loads(line)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    continue
+
+                session_id = entry.get("id")
+                thread_name = entry.get("thread_name")
+                if (
+                    isinstance(session_id, str)
+                    and session_id
+                    and isinstance(thread_name, str)
+                    and thread_name.strip()
+                ):
+                    names[session_id] = thread_name
+    except (OSError, UnicodeError):
+        pass
+
+    return names
+
+
+def read_goal_objectives(goals_database: Path) -> dict[str, str]:
+    """Return goal objectives keyed by their Codex thread ID."""
+    if not goals_database.is_file():
+        return {}
+
+    connection: sqlite3.Connection | None = None
+    try:
+        database_uri = f"{goals_database.resolve().as_uri()}?mode=ro"
+        connection = sqlite3.connect(database_uri, uri=True)
+        rows = connection.execute(
+            "SELECT thread_id, objective FROM thread_goals"
+        ).fetchall()
+    except (OSError, sqlite3.Error):
+        return {}
+    finally:
+        if connection is not None:
+            connection.close()
+
+    return {
+        thread_id: objective
+        for thread_id, objective in rows
+        if isinstance(thread_id, str)
+        and thread_id
+        and isinstance(objective, str)
+        and objective.strip()
+    }
+
+
+def session_start_time(session_file: Path) -> str:
+    """Return the session start time encoded in a rollout filename."""
+    match = re.match(
+        r"^rollout-\d{4}-\d{2}-\d{2}T(\d{2})-(\d{2})-(\d{2})-",
+        session_file.name,
+    )
+    if match is None:
+        return "Unknown"
+
+    return ":".join(match.groups())
+
+
+def analyze_session(session_file: Path) -> SessionAnalysis:
+    """Return usage information extracted from one Codex session."""
     turns = 0
     total_tokens = 0
+    prompt_counts: Counter[str] = Counter()
+    repository = "Unknown"
+    session_id = None
+    first_prompt = None
 
     with session_file.open("r", encoding="utf-8") as file_handle:
         for line in file_handle:
@@ -277,12 +467,29 @@ def analyze_session(session_file: Path) -> tuple[int, int]:
 
             payload = event.get("payload") or {}
 
+            if event.get("type") == "session_meta":
+                candidate_session_id = payload.get("id") or payload.get("session_id")
+                if isinstance(candidate_session_id, str) and candidate_session_id:
+                    session_id = candidate_session_id
+                git = payload.get("git") or {}
+                repository = github_repository(git.get("repository_url"))
+
+            if (
+                event.get("type") == "event_msg"
+                and payload.get("type") == "task_started"
+            ):
+                category = prompt_type(payload)
+                if category is not None:
+                    prompt_counts[category] += 1
+
             if (
                 event.get("type") == "response_item"
                 and payload.get("type") == "message"
                 and payload.get("role") == "user"
             ):
                 turns += 1
+                if first_prompt is None:
+                    first_prompt = user_prompt_text(payload)
 
             if (
                 event.get("type") == "event_msg"
@@ -295,7 +502,17 @@ def analyze_session(session_file: Path) -> tuple[int, int]:
                 if isinstance(value, (int, float)):
                     total_tokens = max(total_tokens, int(value))
 
-    return turns, total_tokens
+    return SessionAnalysis(
+        turns=turns,
+        tokens=total_tokens,
+        normal_prompts=prompt_counts["normal"],
+        plan_prompts=prompt_counts["plan"],
+        goal_prompts=prompt_counts["goal"],
+        repository=repository,
+        language=detect_language(first_prompt),
+        session_id=session_id,
+        first_prompt=first_prompt,
+    )
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -315,6 +532,8 @@ def run_report(
     days: int,
     today: date | None = None,
     tool_versions: dict[str, str] | None = None,
+    session_index_file: Path | None = None,
+    goals_database: Path | None = None,
 ) -> int:
     """Analyze sessions and print the status and daily usage report."""
     current_day = today or date.today()
@@ -322,12 +541,24 @@ def run_report(
     session_counts: Counter[str] = Counter()
     turn_counts: defaultdict[str, list[int]] = defaultdict(list)
     token_counts: Counter[str] = Counter()
+    normal_prompt_counts: Counter[str] = Counter()
+    plan_prompt_counts: Counter[str] = Counter()
+    goal_prompt_counts: Counter[str] = Counter()
     last_session_by_date: dict[str, Path] = {}
+    session_rows: list[tuple[str, Path, SessionAnalysis]] = []
 
     if tool_versions is None:
         tool_versions = detect_installed_tool_versions()
     print_installed_tool_versions(tool_versions)
 
+    codex_dir = sessions_dir.parent
+    session_names = read_session_names(
+        session_index_file or codex_dir / "session_index.jsonl"
+    )
+    goal_objectives = read_goal_objectives(
+        goals_database or codex_dir / "goals_1.sqlite"
+    )
+
     all_session_files = list(sessions_dir.glob("*/*/*/rollout-*.jsonl"))
     latest_session = (
         max(all_session_files, key=lambda path: path.stat().st_mtime)
@@ -349,10 +580,14 @@ def run_report(
         if not first_day <= session_date <= current_day:
             continue
 
-        turns, tokens = analyze_session(session_file)
+        analysis = analyze_session(session_file)
         session_counts[date_label] += 1
-        turn_counts[date_label].append(turns)
-        token_counts[date_label] += tokens
+        turn_counts[date_label].append(analysis.turns)
+        token_counts[date_label] += analysis.tokens
+        normal_prompt_counts[date_label] += analysis.normal_prompts
+        plan_prompt_counts[date_label] += analysis.plan_prompts
+        goal_prompt_counts[date_label] += analysis.goal_prompts
+        session_rows.append((date_label, session_file, analysis))
 
         previous_last = last_session_by_date.get(date_label)
         if previous_last is None or session_file.name > previous_last.name:
@@ -362,16 +597,20 @@ def run_report(
         print(f"No Codex sessions found in the last {days} days in {sessions_dir}")
         return 0
 
-    print(
+    header = (
         f"{'Date':<12} "
         f"{'Sessions':>8} "
         f"{'Turns':>8} "
         f"{'Avg turns':>10} "
+        f"{'Normal':>8} "
+        f"{'Plan':>8} "
+        f"{'Goal':>8} "
         f"{'Tokens':>15} "
         f"{'5h last session':>17} "
         f"{'Weekly last session':>20}"
     )
-    print("-" * 96)
+    print(header)
+    print("-" * len(header))
 
     for date_label in sorted(session_counts):
         sessions = session_counts[date_label]
@@ -385,6 +624,9 @@ def run_report(
             f"{sessions:>8} "
             f"{total_turns:>8} "
             f"{avg_turns:>10.1f} "
+            f"{normal_prompt_counts[date_label]:>8} "
+            f"{plan_prompt_counts[date_label]:>8} "
+            f"{goal_prompt_counts[date_label]:>8} "
             f"{tokens:>15,} "
             f"{five_hour:>17} "
             f"{weekly:>20}"
@@ -393,18 +635,74 @@ def run_report(
     total_sessions = sum(session_counts.values())
     total_turns = sum(sum(turns) for turns in turn_counts.values())
     total_tokens = sum(token_counts.values())
+    total_normal_prompts = sum(normal_prompt_counts.values())
+    total_plan_prompts = sum(plan_prompt_counts.values())
+    total_goal_prompts = sum(goal_prompt_counts.values())
     overall_average = total_turns / total_sessions
 
-    print("-" * 96)
+    print("-" * len(header))
     print(
         f"{'Total':<12} "
         f"{total_sessions:>8} "
         f"{total_turns:>8} "
         f"{overall_average:>10.1f} "
+        f"{total_normal_prompts:>8} "
+        f"{total_plan_prompts:>8} "
+        f"{total_goal_prompts:>8} "
         f"{total_tokens:>15,} "
         f"{'-':>17} "
         f"{'-':>20}"
     )
+
+    print()
+    print("Sessions")
+    repository_width = max(
+        len("Repository"),
+        *(len(analysis.repository) for _date, _path, analysis in session_rows),
+    )
+    session_header = (
+        f"{'Date':<12} "
+        f"{'Start':<8} "
+        f"{'Repository':<{repository_width}} "
+        f"{'Name':<10} "
+        f"{'First prompt':<20} "
+        f"{'Turns':>8} "
+        f"{'Normal':>8} "
+        f"{'Plan':>8} "
+        f"{'Goal':>8} "
+        f"{'Language':<8} "
+        f"{'Tokens':>15} "
+        f"{'5h last session':>17} "
+        f"{'Weekly last session':>20}"
+    )
+    print(session_header)
+    print("-" * len(session_header))
+
+    for date_label, session_file, analysis in sorted(
+        session_rows, key=lambda row: (row[0], row[1].name)
+    ):
+        five_hour, weekly = session_rate_limits(session_file)
+        session_name = compact_text(session_names.get(analysis.session_id), 10)
+        first_prompt = analysis.first_prompt
+        if first_prompt is None and analysis.goal_prompts:
+            first_prompt = goal_objectives.get(analysis.session_id)
+        prompt_preview = compact_text(first_prompt, 20)
+        print(
+            f"{date_label:<12} "
+            f"{session_start_time(session_file):<8} "
+            f"{analysis.repository:<{repository_width}} "
+            f"{session_name:<10} "
+            f"{prompt_preview:<20} "
+            f"{analysis.turns:>8} "
+            f"{analysis.normal_prompts:>8} "
+            f"{analysis.plan_prompts:>8} "
+            f"{analysis.goal_prompts:>8} "
+            f"{analysis.language:<8} "
+            f"{analysis.tokens:>15,} "
+            f"{five_hour:>17} "
+            f"{weekly:>20}"
+        )
+
     return 0