codeplain 0.3.0__tar.gz → 0.3.1__tar.gz

codeplain-0.3.1/.claude/settings.json

@@ -0,0 +1,27 @@
+{
+    "includeCoAuthoredBy": false,
+    "attribution": { "commit": "", "pr": "" },
+    "permissions": {
+        "allow": [
+            "Read",
+            "Bash(pytest *)",
+            "Bash(black *)",
+            "Bash(isort *)",
+            "Bash(flake8 *)",
+            "Bash(mypy *)",
+            "Bash(coverage *)",
+            "Bash(git status*)",
+            "Bash(git diff*)",
+            "Bash(git log*)",
+            "Bash(ls *)",
+            "Bash(cat *)",
+            "Bash(grep *)",
+            "Bash(find *)",
+            "Bash(head *)",
+            "Bash(tail *)",
+            "Bash(conda *)",
+            "Bash(.venv/bin/python *)",
+            "Bash(python plain2code.py *)"
+        ]
+    }
+}

codeplain-0.3.1/.github/workflows/e2e.yml

@@ -0,0 +1,62 @@
+# .github/workflows/e2e.yml
+name: E2E
+
+on:
+  schedule:
+    - cron: '0 5 * * 1-5'   # weekday nights to catch API drift
+  workflow_dispatch:
+
+jobs:
+  e2e-linux:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - run: pip install pytest
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build E2E image (cached)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: tests/e2e/Dockerfile
+          tags: codeplain-e2e:latest
+          load: true
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Run E2E tests
+        env:
+          CODEPLAIN_API_KEY: ${{ secrets.CODEPLAIN_API_KEY }}
+        run: pytest tests/e2e/ -v --tb=short
+
+      - name: Upload generated outputs on failure
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-outputs-linux
+          path: /tmp/pytest-of-runner/**/container_work*/**
+
+  e2e-windows:
+    runs-on: windows-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - run: pip install pytest
+
+      - name: Run E2E tests
+        env:
+          CODEPLAIN_API_KEY: ${{ secrets.CODEPLAIN_API_KEY }}
+        run: pytest tests/e2e/ -v --tb=short

codeplain-0.3.1/CLAUDE.md

@@ -0,0 +1,238 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+This is **codeplain**, a Python CLI tool that renders code from `***plain` specification files using the Codeplain API. The tool acts as a client that:
+1. Parses `***plain` spec files (a domain-specific language for software specifications)
+2. Sends specs to the Codeplain API (LLM-based code generation service)
+3. Manages an iterative state-machine-driven render process with testing and refactoring cycles
+4. Outputs generated code to a build folder
+
+The codebase serves two audiences:
+- **End users**: developers who write `***plain` specs and run `plain2code.py` to generate code
+- **Internal devs**: maintaining the renderer itself (this codebase)
+
+### Related Repository: plain2code_rest_api
+
+This repository has a sibling repository **`plain2code_rest_api`** which contains the backend API service that this client communicates with. The two repositories are typically cloned as siblings:
+
+```
+parent-directory/
+├── codeplain/              # This repository (client)
+└── plain2code_rest_api/    # Backend API service
+```
+
+**When to work across both repositories:**
+- API contract changes (request/response formats)
+- Adding new endpoints or modifying existing ones
+- Debugging communication issues between client and server
+- End-to-end feature development that requires both client and server changes
+
+When working on features that span both repositories, coordinate changes carefully to maintain backward compatibility or plan coordinated deployments.
+
+## Development Setup
+
+### Prerequisites
+- Python 3.11+
+- `CODEPLAIN_API_KEY` environment variable set
+
+### Installation
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+### Git Hooks
+A pre-push hook runs automatically on `git push` and executes:
+- Black formatting check
+- isort import sorting check  
+- Flake8 linting
+- Mypy type checking
+- Full test suite with coverage
+
+Hook is located at `.git/hooks/pre-push`.
+
+## Common Commands
+
+### Running the Tool
+```bash
+# Basic usage - render a .plain file
+python plain2code.py path/to/file.plain
+
+# Display account status (user info, credits, API key label)
+python plain2code.py --status
+
+# Dry run (parse and validate .plain files without rendering code)
+# This parses the spec files, resolves imports/requires, but doesn't generate code
+python plain2code.py path/to/file.plain --dry-run
+
+# Enable file logging (writes to codeplain.log in same dir as .plain file)
+python plain2code.py path/to/file.plain --log-to-file
+
+# Headless mode (no TUI, logs to file only)
+python plain2code.py path/to/file.plain --headless
+
+# Render specific functionality range
+python plain2code.py file.plain --render-range 1,3  # Render functionalities 1-3
+python plain2code.py file.plain --render-from 2     # Resume from functionality 2
+
+# Run with examples
+cd examples/example_hello_world_python
+python ../../plain2code.py hello_world_python.plain
+cd build && python hello_world.py
+```
+
+### Testing
+```bash
+# Run all tests
+pytest tests/ -v
+
+# Run specific test file
+pytest tests/test_plain_modules.py -v
+
+# Run specific test
+pytest tests/test_plain_modules.py::test_get_next_frid_within_same_module -v
+
+# Run with coverage
+coverage run -m pytest tests/ -v
+coverage report
+coverage html  # Generates htmlcov/index.html
+```
+
+### Code Quality
+```bash
+# Format code
+black .
+
+# Sort imports
+isort .
+
+# Lint
+flake8 .
+
+# Type check
+mypy . --check-untyped-defs
+
+# Run all checks (same as pre-push hook)
+black . --check && isort . --check-only && flake8 . && mypy . --check-untyped-defs && coverage run -m pytest tests/ -v && coverage report
+```
+
+## Architecture
+
+### High-Level Flow
+1. **Entry Point** (`plain2code.py`): CLI argument parsing, logging setup, TUI initialization
+2. **Module Loading** (`plain_modules.py`, `plain_file.py`): Parse `.plain` files into `PlainModule` objects with dependency trees
+3. **Rendering Orchestration** (`module_renderer.py`): Coordinates render process across modules
+4. **State Machine** (`render_machine/`): Hierarchical state machine drives the render lifecycle
+5. **API Communication** (`codeplain_REST_api.py`): HTTP client for Codeplain API
+6. **Code Generation** (`render_machine/code_renderer.py`): Main code renderer class that orchestrates the code generation workflow using a hierarchical state machine
+7. **TUI** (`tui/`): Textual-based terminal UI showing render progress
+8. **CLI Output** (`cli_output/`): Non-interactive terminal output formatting for status, dry-run, and render summaries
+
+### Key Concepts
+
+**Plain Modules**: A `.plain` file can `import` other `.plain` files, creating a module dependency tree. The renderer processes required modules first (depth-first), then the top module.
+
+**Functionalities (FRIDs)**: Each functional requirement in a `.plain` file has a unique ID (FRID). The renderer processes them sequentially. State is checkpointed after each FRID.
+
+**Render State Machine** (`render_machine/states.py`): Hierarchical FSM with states like:
+- `IMPLEMENTING_FRID` → `PROCESSING_UNIT_TESTS` → `REFACTORING_CODE` → `PROCESSING_CONFORMANCE_TESTS`
+- Transitions handled by triggers in `render_machine/triggers.py`
+- Config in `render_machine/state_machine_config.py`
+
+**Memory Management** (`memory_management.py`): Tracks previously rendered code to provide context to the LLM for incremental changes. Uses git commits to persist checkpoints.
+
+**Partial Rendering** (`partial_rendering.py`): Detects when specs or code changed and determines the optimal starting point to resume rendering (avoids full re-renders).
+
+**Event Bus** (`event_bus.py`): Pub/sub for UI updates. Events defined in `plain2code_events.py` (e.g., `LogMessageEmitted`, `RenderCompleted`).
+
+### Directory Structure
+
+- `plain2code.py` - Main CLI entry point
+- `plain2code_arguments.py` - CLI argument parsing and validation
+- `plain2code_utils.py` - Pure utility functions (duration formatting, ambiguity messages)
+- `plain_modules.py` - Module dependency resolution
+- `plain_file.py` - `.plain` file parser
+- `plain_spec.py` - Spec extraction and FRID utilities
+- `module_renderer.py` - Orchestrates render for a module
+- `render_machine/` - State machine implementation
+  - `code_renderer.py` - Generates code via templates
+  - `states.py` - State name constants
+  - `triggers.py` - State transition logic
+  - `render_context.py` - Shared context across states
+  - `conformance_tests.py` - Test generation and execution
+- `tui/` - Interactive terminal UI (Textual framework)
+  - `plain2code_tui.py` - Main TUI app
+  - `components.py` - Custom UI widgets
+- `cli_output/` - Non-interactive CLI output formatting
+  - `status.py` - Status display (`--status` flag)
+  - `dry_run.py` - Dry run output (`--dry-run` flag)
+  - `render_summary.py` - Render completion summary
+- `codeplain_REST_api.py` - API client
+- `memory_management.py` - Context tracking
+- `git_utils.py` - Git operations for checkpointing
+- `file_utils.py` - File I/O utilities
+- `concept_utils.py` - Concept validation (***plain language feature)
+- `plain2code_logger.py` - Custom logging with elapsed time timestamps
+- `plain2code_console.py` - Rich console wrapper with custom styles
+- `plain2code_state.py` - Runtime state (render ID, counters, timing)
+- `standard_template_library/` - Built-in code templates
+- `examples/` - Sample `.plain` projects
+
+### Testing Architecture
+
+Tests are in `tests/` and cover:
+- `test_plain_modules.py` - Module loading, dependency resolution, metadata
+- `test_plainfileparser.py` - `.plain` syntax parsing
+- `test_partial_rendering.py` - Render resumption logic
+- `test_git_utils.py` - Git checkpoint/restore operations
+- `test_imports.py`, `test_requires.py` - Module dependency resolution
+
+No integration tests hit the actual Codeplain API (would require API key + network). Testing focuses on parser, state management, and file operations.
+
+### Logging
+
+Two logging modes:
+1. **Console (TUI)**: Logs displayed in TUI with relative timestamps `[HH:MM:SS]` (elapsed since render start, accounts for pauses)
+2. **File**: Same format as TUI, written to `codeplain.log` in the `.plain` file's directory
+
+`ElapsedTimeFormatter` (in `plain2code_logger.py`) uses `RunState` to calculate elapsed time. Format: `[HH:MM:SS] LEVEL logger_name: message`
+
+## Important Notes
+
+### Plain Specification Language
+- `***plain` is a Markdown-like DSL for software specs
+- Docs at https://www.plainlang.org/docs/
+- Parser handles sections: definitions, functional specs, implementation reqs, test reqs, acceptance tests
+- Concepts (domain terms) validated across modules via `concept_utils.py`
+
+### Code Generation Process
+- Templates in `standard_template_library/` use Liquid2 syntax
+- Template search order: (1) `.plain` file dir, (2) `--template-dir`, (3) built-in standard lib
+- Generated code written to `build/` (configurable via `--build-folder`)
+- Each FRID render produces a git commit in build folder for rollback capability
+
+### Configuration
+- `config.yaml` can be placed in `.plain` file dir or CWD
+- Specifies test scripts, template dirs, build paths
+- CLI args override config file values
+
+### Running Plain2Code from Another Directory
+The tool can be run from any directory by providing an absolute or relative path to the `.plain` file. All paths (build folder, log file, templates) are resolved relative to the `.plain` file's directory, not the current working directory, unless explicitly overridden via CLI arguments.
+
+### Windows Support
+Windows users must use WSL (Windows Subsystem for Linux). The codebase has some platform-specific script handling (`.ps1` for Windows, `.sh` for Unix).
+
+### CRITICAL: No User-Specific Paths in Version Control
+**Never commit files containing user-specific absolute paths** (e.g., `/Users/username/...`, `/home/username/...`, `C:\Users\...`) to version-controlled files like:
+- `.claude/settings.json` - Use relative paths (`.venv/bin/python`) instead of absolute paths
+- `config.yaml` or any config files
+- Any documentation or scripts
+
+User-specific paths should only exist in:
+- `.claude/settings.local.json` (gitignored)
+- Personal `.env` files (gitignored)
+- User's global `~/.claude/settings.json`

{codeplain-0.3.0 → codeplain-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.3.0
+Version: 0.3.1
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console
@@ -11,17 +11,17 @@ Requires-Python: ==3.11
 Requires-Dist: gitpython==3.1.50
 Requires-Dist: mistletoe==1.3.0
 Requires-Dist: networkx==3.6.1
-Requires-Dist: python-frontmatter==1.1.0
+Requires-Dist: python-frontmatter==1.3.0
 Requires-Dist: python-liquid2==0.3.0
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: requests==2.34.0
-Requires-Dist: rich==14.2.0
+Requires-Dist: rich==15.0.0
 Requires-Dist: textual>=7.5.0
 Requires-Dist: tiktoken==0.12.0
 Requires-Dist: transitions==0.9.3
 Provides-Extra: dev
 Requires-Dist: black==26.3.1; extra == 'dev'
-Requires-Dist: flake8==7.0.0; extra == 'dev'
+Requires-Dist: flake8==7.3.0; extra == 'dev'
 Requires-Dist: isort==5.13.2; extra == 'dev'
 Requires-Dist: mypy==1.11.2; extra == 'dev'
 Requires-Dist: pytest==8.3.5; extra == 'dev'
@@ -105,6 +105,31 @@ After completing the installation steps above, you can immediately test the syst
    python hello_world.py
    ```
 
+## Releasing
+
+Releases are built and published with [uv](https://docs.astral.sh/uv/). The version is read from `_version.py`.
+
+1. Bump the version in `_version.py` and commit/tag (`git tag v<version>`).
+2. Build the distributions:
+   ```bash
+   uv build
+   ```
+   This produces `dist/codeplain-<version>-py3-none-any.whl` and `dist/codeplain-<version>.tar.gz`.
+3. (Optional) Smoke-test the wheel:
+   ```bash
+   uv run --with dist/codeplain-<version>-py3-none-any.whl --no-project -- codeplain --status
+   ```
+4. (Optional) Publish to TestPyPI first:
+   ```bash
+   uv publish --publish-url https://test.pypi.org/legacy/ dist/codeplain-<version>*
+   ```
+5. Publish to PyPI:
+   ```bash
+   uv publish dist/codeplain-<version>*
+   ```
+   Authenticate with `UV_PUBLISH_TOKEN=pypi-...` (recommended), `--token pypi-...`, or `--username __token__ --password pypi-...`.
+6. Push the tag: `git push origin v<version>`.
+
 ## Additional Resources
 
 ### Examples and Sample Projects

{codeplain-0.3.0 → codeplain-0.3.1}/README.md

@@ -76,6 +76,31 @@ After completing the installation steps above, you can immediately test the syst
    python hello_world.py
    ```
 
+## Releasing
+
+Releases are built and published with [uv](https://docs.astral.sh/uv/). The version is read from `_version.py`.
+
+1. Bump the version in `_version.py` and commit/tag (`git tag v<version>`).
+2. Build the distributions:
+   ```bash
+   uv build
+   ```
+   This produces `dist/codeplain-<version>-py3-none-any.whl` and `dist/codeplain-<version>.tar.gz`.
+3. (Optional) Smoke-test the wheel:
+   ```bash
+   uv run --with dist/codeplain-<version>-py3-none-any.whl --no-project -- codeplain --status
+   ```
+4. (Optional) Publish to TestPyPI first:
+   ```bash
+   uv publish --publish-url https://test.pypi.org/legacy/ dist/codeplain-<version>*
+   ```
+5. Publish to PyPI:
+   ```bash
+   uv publish dist/codeplain-<version>*
+   ```
+   Authenticate with `UV_PUBLISH_TOKEN=pypi-...` (recommended), `--token pypi-...`, or `--username __token__ --password pypi-...`.
+6. Push the tag: `git push origin v<version>`.
+
 ## Additional Resources
 
 ### Examples and Sample Projects

codeplain-0.3.1/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

codeplain-0.3.1/cli_output/__init__.py

@@ -0,0 +1,7 @@
+"""CLI output formatting for non-interactive display."""
+
+from cli_output.dry_run import print_dry_run_output
+from cli_output.render_summary import print_exit_summary
+from cli_output.status import print_status
+
+__all__ = ["print_dry_run_output", "print_exit_summary", "print_status"]

codeplain-0.3.1/cli_output/dry_run.py

@@ -0,0 +1,35 @@
+"""Dry run output display for --dry-run flag."""
+
+from typing import Optional
+
+import plain_spec
+from plain2code_console import console
+
+
+def print_dry_run_output(plain_source_tree: dict, render_range: Optional[list[str]]):
+    """Print dry run output showing what would be rendered."""
+    frid = plain_spec.get_first_frid(plain_source_tree)
+
+    while frid is not None:
+        is_inside_range = render_range is None or frid in render_range
+
+        if is_inside_range:
+            specifications, _ = plain_spec.get_specifications_for_frid(plain_source_tree, frid)
+            functional_requirement_text = specifications[plain_spec.FUNCTIONAL_REQUIREMENTS][-1]
+            console.info(
+                "-------------------------------------\n"
+                f"Rendering functionality {frid}:\n"
+                f"{functional_requirement_text}\n"
+                "-------------------------------------\n"
+            )
+            if plain_spec.ACCEPTANCE_TESTS in specifications:
+                for i, acceptance_test in enumerate(specifications[plain_spec.ACCEPTANCE_TESTS], 1):
+                    console.info(f"Generating acceptance test #{i}:\n\n{acceptance_test}\n")
+        else:
+            console.info(
+                "-------------------------------------\n"
+                f"Skipping rendering iteration: {frid}\n"
+                "-------------------------------------"
+            )
+
+        frid = plain_spec.get_next_frid(plain_source_tree, frid)

codeplain-0.3.1/cli_output/render_summary.py

@@ -0,0 +1,27 @@
+"""Render completion summary display."""
+
+from typing import Optional
+
+from plain2code_console import console
+from plain2code_state import RunState
+from plain2code_utils import format_duration_hms
+
+
+def print_exit_summary(
+    run_state: RunState,
+    spec_filename: str,
+    error_message: Optional[str] = None,
+) -> None:
+    """Print render outcome after the TUI exits (terminal restored)."""
+    console.quiet = False
+
+    msg = "\n[#79FC96]✓ rendering completed\n\n" if run_state.render_succeeded else "[#FF6B6B]✗ rendering failed\n\n"
+    msg += f"  [#8E8F91]render id:\t\t\t[#FFFFFF]{run_state.render_id}\n"
+    msg += f"  [#8E8F91]input file:\t\t\t[#FFFFFF]{spec_filename}\n"
+    msg += f"  [#8E8F91]generated code folder:\t[#FFFFFF]{run_state.render_generated_code_path or '-'}\n\n"
+    msg += f"[#8E8F91]functionalities  [#FFFFFF]{run_state.rendered_functionalities}  [#8E8F91]used credits  [#FFFFFF]{run_state.rendered_functionalities}  [#8E8F91]render time  [#FFFFFF]{format_duration_hms(run_state.render_time_accumulated)}\n"
+    console.print(msg)
+
+    if not run_state.render_succeeded and error_message:
+        console.error(error_message)
+    console.quiet = True

codeplain-0.3.1/cli_output/status.py

@@ -0,0 +1,160 @@
+"""Status display for --status flag."""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+import codeplain_REST_api as codeplain_api
+from plain2code_console import console
+
+
+def _create_progress_bar(remaining: int, total: int, width: int = 30) -> str:
+    """Create a Unicode progress bar."""
+    if total == 0:
+        filled = 0
+    else:
+        filled = int((remaining / total) * width)
+
+    empty = width - filled
+    return "█" * filled + "░" * empty
+
+
+def _display_credit_line(plan_credits: dict) -> None:
+    """Display a plan credit line with progress bar."""
+    plan_type = plan_credits["type"]
+    remaining = plan_credits["remaining"]
+    total = plan_credits["total"]
+    period_end = plan_credits["period_end"]
+
+    # Parse ISO-8601 timestamp and format as "Jun 1, 2026"
+    # Handle both with and without timezone info
+    dt_str = period_end.replace("Z", "+00:00")
+    dt = datetime.fromisoformat(dt_str)
+    # If naive datetime, assume UTC
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    formatted_date = dt.strftime("%b %-d, %Y")
+
+    # Check if expired
+    now = datetime.now(timezone.utc)
+    is_expired = dt < now
+
+    # Create progress bar (30 chars wide)
+    bar = _create_progress_bar(remaining, total, width=30)
+
+    # Format plan type label
+    plan_label = "Free trial" if plan_type == "free" else plan_type.upper() + " plan"
+
+    if is_expired:
+        console.print(f"    {plan_label:10} {bar}   expired {formatted_date}")
+    else:
+        console.print(f"    {plan_label:10} {bar}   {remaining:2} of {total} remaining    expires {formatted_date}")
+
+
+def _display_purchased_credit_line(bucket: dict) -> None:
+    """Display a purchased credit line with progress bar."""
+    remaining = bucket["remaining"]
+    total = bucket["total"]
+    expiry_date = bucket["expiry_date"]
+
+    # Parse ISO-8601 timestamp and handle both with and without timezone info
+    dt_str = expiry_date.replace("Z", "+00:00")
+    dt = datetime.fromisoformat(dt_str)
+    # If naive datetime, assume UTC
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    formatted_date = dt.strftime("%b %-d, %Y")
+
+    # Check if expired
+    now = datetime.now(timezone.utc)
+    is_expired = dt < now
+
+    bar = _create_progress_bar(remaining, total, width=30)
+
+    if is_expired:
+        console.print(f"    Purchased  {bar}   expired {formatted_date}")
+    else:
+        console.print(f"    Purchased  {bar}   {remaining:2} of {total} remaining    expires {formatted_date}")
+
+
+def _display_status_message(plan_credits: Optional[dict], purchased_credits: list) -> None:
+    """Display appropriate status message based on credit state."""
+    has_remaining = False
+
+    # Check if plan credits have remaining balance and are not expired
+    if plan_credits:
+        remaining = plan_credits["remaining"]
+        dt_str = plan_credits["period_end"].replace("Z", "+00:00")
+        period_end = datetime.fromisoformat(dt_str)
+        # If naive datetime, assume UTC
+        if period_end.tzinfo is None:
+            period_end = period_end.replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
+
+        if remaining > 0 and period_end > now:
+            has_remaining = True
+
+    # Check if any purchased credits have remaining balance and not expired
+    for bucket in purchased_credits:
+        dt_str = bucket["expiry_date"].replace("Z", "+00:00")
+        expiry_date = datetime.fromisoformat(dt_str)
+        # If naive datetime, assume UTC
+        if expiry_date.tzinfo is None:
+            expiry_date = expiry_date.replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
+
+        if bucket["remaining"] > 0 and expiry_date > now:
+            has_remaining = True
+            break
+
+    if not has_remaining:
+        console.print("\nNo rendering credits remaining. Upgrade to continue rendering.")
+
+
+def print_status(api_key: str, api_url: str, client_version: str) -> None:
+    """Display account status including user info and rendering credits."""
+    codeplainAPI = codeplain_api.CodeplainAPI(api_key, console)
+    codeplainAPI.api_url = api_url
+
+    # First check client version
+    version_check = codeplainAPI.connection_check(client_version)
+    client_version_valid = version_check.get("client_version_valid", False)
+    min_version = version_check.get("min_client_version", "unknown")
+
+    response = codeplainAPI.status()
+
+    user = response["user"]
+    api_key_label = response["api_key_label"]
+    org_owner = response.get("organization_owner_email")
+    plan_credits = response.get("plan_credits")
+    purchased_credits = response.get("purchased_credits", [])
+
+    # Display header information
+    if client_version_valid:
+        console.print(f"Version: {client_version}")
+    else:
+        from plain2code_console import Plain2CodeConsole
+
+        console.print(
+            f"Version: {client_version} (outdated — minimum required: {min_version})",
+            style=Plain2CodeConsole.ERROR_STYLE,
+        )
+        console.print("To update, run: uv tool upgrade codeplain\n", style=Plain2CodeConsole.ERROR_STYLE)
+    console.print(f"Name: {user['first_name']} {user['last_name']}")
+    console.print(f"User email: {user['email']}")
+    console.print(f"Organization owner: {org_owner or 'N/A'}")
+    console.print(f"API key label: {api_key_label}\n")
+
+    # Display rendering credits section
+    console.print("Rendering credits:")
+
+    # Display plan credits (free trial or subscription)
+    if plan_credits:
+        _display_credit_line(plan_credits)
+
+    # Display purchased credits
+    for bucket in purchased_credits:
+        _display_purchased_credit_line(bucket)
+
+    # Display status messages and management link
+    _display_status_message(plan_credits, purchased_credits)
+    console.print("\nTo manage your plan navigate to https://platform.codeplain.ai/plans")

{codeplain-0.3.0 → codeplain-0.3.1}/codeplain_REST_api.py

@@ -161,6 +161,14 @@ class CodeplainAPI:
         }
         return self.post_request(endpoint_url, headers, payload, None, num_retries=0, silent=True)
 
+    def status(self):
+        endpoint_url = f"{self.api_url}/status"
+        headers = {"Content-Type": "application/json"}
+        payload = {
+            "api_key": self.api_key,
+        }
+        return self.post_request(endpoint_url, headers, payload, None, num_retries=0, silent=True)
+
     def render_functional_requirement(
         self,
         frid: str,