O1 update

.gitignore

@@ -1,3 +1,7 @@
+# Temporarily exclude these files from aide to make the token size manageable
+#account/
+#order-processor/
+
 ### How to update
 # This is copied from OpenHFT/.gitignore
 # update the original and run OpenHFT/update_gitignore.sh

README.adoc

@@ -1,12 +1,57 @@
-= Chronicle-Queue-Demo
-Peter Lawrey
-:imagesdir: images
+= Chronicle Queue Demo - README
+:toc:
+:toclevels: 3
 
-This is a tutorial demonstrating the usage of Chronicle Queue with simple demo programs.
+This repository demonstrates the usage of Chronicle Queue (and related Chronicle libraries) through multiple examples, including an order processor, event routing, and more. Below is a quick start and pointers to further documentation.
+
+== Quick Start
+
+.Basic Steps
+----
+git clone https://github.com/OpenHFT/Chronicle-Queue-Demo.git
+cd Chronicle-Queue-Demo
+mvn clean install
+----
+
+To run a simple example, like the hello-world module:
+
+----
+cd hello-world
+mvn install exec:java@RecordInputToConsoleMain
+----
+
+== Documentation
+
+The project’s documentation is consolidated in five AsciiDoc files:
+
+1. xref:architecture.adoc[Architecture]
+2. xref:usage-and-tests.adoc[Usage & Tests]
+3. xref:reference.adoc[Reference, Style & Glossary]
+4. xref:account/README.adoc[Account Management System (AMS)]
+5. xref:order-processor/README.adoc[Order Processor]
+
+Refer to them for details on architecture, usage instructions, testing approaches, style guides, and advanced references.
+
+== Repository Overview
+
+The modules in this repository include:
+
+* **account**: An Account Management System (AMS) example using Chronicle Queue event-driven logic.
+* **benchmarks**: Scripts and classes demonstrating throughput/latency benchmarks (e.g., LatencyDistributionMain, ThroughputMain).
+* **event-routing**: Showcases how messages can be routed via Chronicle Queues with interfaces like `ViaIn`, `ViaOut`.
+* **hello-world**: A simple introduction to an event-driven microservice using Chronicle Queue (input, exclamation addition, output).
+* **md-pipeline**: A Market Data pipeline example with aggregator, strategy, and an exchange simulator.
+* **message-history-demo**: Demonstrates Chronicle’s `MessageHistory` in bridging or event processing scenarios.
+* **messages-with-text**: An example of writing/reading textual content with minimal garbage creation.
+* **order-processor**: A submodule that acts as a simple OMS (Order Management System), referencing FIX 4.2 concepts.
+
+For deeper details on each, see xref:architecture.adoc[Architecture].
 
 == Order Processor
 
-image::Two-hop-latency.PNG[]
+This is a tutorial demonstrating the usage of Chronicle Queue with simple demo programs.
+
+image::images/Two-hop-latency.png[]
 
 You can find the source code for the order processor example https://github.com/OpenHFT/Chronicle-Queue-Demo/tree/master/order-processor[here].
 
@@ -18,13 +63,13 @@ This allows you to install Linux packages that aren't already on Windows.
 When this asks you which packages you want to install, search for and add `git`.
 This is under `Development` and you need to click `skip` so it says to `install`.
 
-image::gitpack.png[]
+image::images/gitpack.png[]
 
 Open IntelliJ or your favorite https://en.wikipedia.org/wiki/Integrated_development_environment[Integrated Development Environment (IDE)]. If you haven't installed an IDE, we recommend https://www.jetbrains.com/idea/download/#section=windows[IntelliJ], which we'll use for this tutorial.
 
 In IntelliJ, select `Get from VCS` to clone the Chronicle Queue Sample code.
 
-image::homegit.png[]
+image::images/homegit.png[]
 
 Then, copy the following URL into the `Git Repository URL` field and remember the `Parent Directory`. Click `Clone` to get the code.
 
@@ -33,11 +78,11 @@ Then, copy the following URL into the `Git Repository URL` field and remember th
 https://github.com/OpenHFT/Chronicle-Queue-Demo.git
 ----
 
-image::Clone.PNG[]
+image::images/Clone.png[]
 
 If you close the project, you can reopen it by going to `File -> Open`. You'll find the repository in the directory where you saved it.
 
-image::directory.PNG[]
+image::images/directory.png[]
 
 Now you're ready to run the example programs! You can start with https://github.com/OpenHFT/Chronicle-Queue-Demo/tree/master/simple-input[Simple Input].
 

account.ad

@@ -0,0 +1,63 @@
+= Project Summary
+
+== Overview
+
+The project is an Account Management System (AMS) leveraging the Chronicle libraries for high-performance, low-latency event-driven operations. It emphasizes documentation-driven development with AI integration for streamlined engineering. The AMS manages account creation, transfers, and state snapshots through a comprehensive suite of YAML-based tests, detailed functional requirements, and a modular architecture.
+
+== Key Features
+
+* **Low-Latency and High-Throughput**: Designed for operations with microsecond-level latencies and over 1M messages per second throughput.
+* **Event-Driven Design**: Utilizes Chronicle Queue for durable message persistence and asynchronous operations.
+* **Rich Documentation**: Implements AsciiDoc for capturing requirements, workflows, and style guides to align development with AI tools.
+* **Testing Framework**: YAML-driven scenarios test various operations, including edge cases and invalid inputs, ensuring robust functionality.
+
+== Functional Components
+
+=== Documentation
+* **AIDE Glossary**: Defines project-specific terminology, such as AIDE (Artificial Intelligence Development Environment) and tokens/line ratios.
+* **Style Guide**: Enforces British English conventions and standardizes coding/documentation practices.
+* **Workflow**: Outlines iterative development—document, test, code, review, and repeat—keeping code and requirements synchronized.
+
+=== Code
+* **Core Classes**:
+* `AccountManagerImpl`: Orchestrates incoming events and delegates logic to `AccountService`.
+* `AccountService`: Validates accounts, manages balances, and processes transfers.
+* DTOs (e.g., `CreateAccount`, `Transfer`): Represent operations with fluent setter methods for chaining.
+* **Utilities**:
+* `LogsAccountManagerOut`: A mock implementation for testing event outputs.
+* `ErrorListener`: Handles JVM-level errors gracefully.
+
+=== Testing
+* **Parameterized Tests**: YAML scenarios validate the AMS against predefined inputs and outputs.
+* **Coverage**:
+* Account creation, transfers, checkpoints.
+* Edge cases, including invalid currencies, missing fields, and insufficient funds.
+* Performance benchmarks using JLBH for latency testing.
+
+=== Benchmark Results
+Demonstrated latencies:
+
+* Shared Memory: ~1.5 µs
+* TCP: ~20 µs
+* End-to-End Variance: Minimal under high load conditions.
+
+== Directories and Files
+
+All directories here are under `account` directory
+
+=== Code
+* `src/main/java`: Implementation of AMS.
+* `AccountManagerImpl.java`: Main orchestration logic.
+* `AccountService.java`: Domain operations.
+
+=== Tests
+* `src/test/java`: Unit and integration tests.
+* YAML files: Input (`in.yaml`), expected output (`out.yaml`), and setup (`_setup.yaml`) configurations.
+
+=== Utilities
+* `list_files_asciidoc.sh`: Script to generate directory content summaries.
+* `benchmark-results.txt`: Performance insights.
+
+== Summary
+
+The AMS is a modular, high-performance system underpinned by comprehensive documentation, rigorous testing, and cutting-edge Chronicle technologies. This structure ensures maintainability, scalability, and alignment with evolving requirements.