# Getting Started

## What This Project Does

This repository is a small Java codebase that looks more like a pattern catalog than a full application. It contains a few standalone classes that demonstrate field declarations, comment conventions, and inline metadata examples. There is no obvious runtime entry point in the indexed files, so new engineers should approach it as source to read and extend rather than an app to boot.

## Recommended Reading Order

Start with the existing wiki pages and then move into the code itself:

1. **[`overview.md`](../overview.md)** — high-level summary of the repository and its current structure.
2. **[`root.md`](../root.md)** — the only other documented wiki page; use it to confirm the top-level module view.
3. **Source files under `src/main/java`** — read the classes in the order below to understand the coding patterns.

For the code, read these files in sequence:

1. **[`Mixed.java`](../../src/main/java/Mixed.java)** — simplest baseline example.
2. **[`PatternA.java`](../../src/main/java/PatternA.java)** — shows the comment-delimited field block pattern.
3. **[`PatternB.java`](../../src/main/java/PatternB.java)** — shows the field map pattern and inline annotations.

## Key Entry Points

The repository does not expose highly referenced classes beyond the three small Java examples, so these are the key entry points to understand first:

- **[`Mixed`](../../src/main/java/Mixed.java)** — minimal class with two string fields and mixed comment usage.
- **[`PatternA`](../../src/main/java/PatternA.java)** — demonstrates the `ANK-0001` add block around a single field.
- **[`PatternB`](../../src/main/java/PatternB.java)** — demonstrates the `FIELD_MAP` structure for storing paired metadata.

If you only have a few minutes, read these classes in that order.

## Project Structure

The repository is organized as a single root module with a very small Java source set:

- **`src/main/java/`** — contains the Java example classes.
- **`.codewiki/`** — generated documentation for the repository.
- **`overview.md`** and **`root.md`** — top-level wiki pages that describe the repo and module view.

At the moment, the source tree is intentionally flat: each Java file stands on its own and does not appear to depend on the others.

## Configuration

No build tool, framework, or application configuration files are visible in the indexed files. That means there is currently nothing obvious to tune for runtime behavior, dependency injection, or test execution.

If you add more code later, look for these common config files first:

- **`pom.xml`** or **`build.gradle`** — dependency and build configuration
- **`application.yml` / `application.properties`** — runtime settings if a framework is introduced
- **`.editorconfig`** or **`spotless` / `checkstyle` configs** — formatting and style rules

## Common Patterns

A few conventions show up across the codebase:

- **Small, standalone classes** — each file is a self-contained example.
- **Private field-first design** — the visible classes mostly define private state only.
- **Inline comments as metadata** — comments are used to annotate meaning in English and Japanese.
- **Delimited change blocks** — `PatternA` uses `// ANK-0001 ADD START` and `// ANK-0001 ADD END` to mark an inserted section.
- **Array-based mapping** — `PatternB` stores field/type pairs in a two-dimensional string array.

When editing this codebase, preserve the existing comment style and keep changes small and local unless you are intentionally introducing a new pattern.

## Suggested Next Step

After this guide, open the three source files directly and compare the patterns side by side. That will give you the quickest mental model for how this repository is structured and how new code should fit into it.