# Repository Overview

Welcome to this repository. This project appears to be a small Java application centered on currency data, conversion logic, and a simple user interface. The codebase is organized into a few focused packages rather than a large framework-driven stack, which should make it approachable for a new contributor. If you are coming in fresh, the main thing to understand is how data moves from the API layer, through conversion, and into the UI.

## Overview

This repository appears to implement a currency conversion feature set. Based on the available modules, it likely retrieves exchange-rate information, converts values between currencies, and presents the result through a user-facing UI. The structure suggests a straightforward layered design: one part talks to a rate source, one part performs conversion logic, and one part handles interaction with the user.

The codebase is intentionally compact, so the main learning curve is understanding the responsibilities of each package and how they connect. That makes it a good candidate for reading from the outside in: start with the UI, trace into the converter, then look at the API integration.

## Technology Stack

Detected from the repository files and imports:

- **Java** — the application is implemented in Java source files under `src/main/java`.
- **Maven** — `pom.xml` is present, so the project is built and managed with Maven.
- **Standard Java utilities** — no well-known frameworks were detected from import analysis, so this appears to rely mainly on the JDK and project-specific classes.

There are also resources under `src/main/resources`, including a `config.properties` file and icon assets, which suggests the application uses external configuration and packaged UI resources.

## Architecture

This repository appears to follow a simple layered architecture:

- **api** handles currency-rate access.
- **converter** transforms rate data into currency conversion results.
- **ui** presents the interaction layer and user inputs.

```mermaid
flowchart LR
  API["api"] --> CONVERTER["converter"]
  CONVERTER --> UI["ui"]
  UI --> CONVERTER
```

In practice, the API layer appears to be the source of exchange-rate data, the converter applies conversion rules, and the UI coordinates user interaction and display. The dependency direction suggests the UI should not need to know about external rate-source details directly.

## Module Guide

### `api`

This module appears to own the boundary for exchange-rate data. The key reference is `CurrencyRateAPI`, which likely encapsulates fetching or exposing current currency-rate information. If you need to understand where rates come from, this is the first place to read.

### `converter`

This module appears to contain the core business logic for currency conversion. The main class is `CurrencyConverter`, which likely takes source amounts and currency information and computes converted values. This is the most important module if you want to understand the actual conversion rules.

### `ui`

This module appears to provide the user-facing interaction layer. The main class is `UI`, with helper types such as `NumericFilter` and `CurrencyCode` defined in the same file. It likely handles input validation, currency selection, and the display of conversion results.

The broader package documentation suggests these modules form a small pipeline: API data flows into the converter, and the UI sits on top of that work to present it to the user.

## Getting Started

A new developer should probably read the code in this order:

1. **`src/main/java/com/github/blaxk3/ui/UI.java`** — start here to see the user flow and how the application is driven.
2. **`src/main/java/com/github/blaxk3/converter/CurrencyConverter.java`** — then inspect how amounts and currencies are transformed.
3. **`src/main/java/com/github/blaxk3/api/CurrencyRateAPI.java`** — finally look at how rate data is obtained or represented.

Recommended reading order by concept:

- **Entry point and interaction flow** — `UI`
- **Business logic** — `CurrencyConverter`
- **Data source / integration boundary** — `CurrencyRateAPI`

If you are trying to make a change, a useful rule of thumb is:

- Update **`ui`** for presentation and input behavior.
- Update **`converter`** for conversion rules or calculation logic.
- Update **`api`** for rate-source or integration changes.

For additional context, the top-level package documentation in `.codewiki/com/github/blaxk3.md` provides a useful high-level summary of how the three modules relate.