← All components
Published module

Basics

The foundation layer beneath the Tom stack: a minimal-dependency utility package plus a CLI/tooling framework, surrounded by focused extensions for console, network, crypto, chat, and code-generation support.

10 modules
12.8k loc · 935 tests · 13.0k test LOC
0 released 7 published 1 in works 2 not started

Basics is the bottom of the Tom architecture. It pairs two foundations — `tom_basics`, the minimal-dependency utility floor (UUID-tracked exceptions and core helpers), and `tom_build_base`, the declarative CLI framework that Tom's build tools are built on — with a set of narrow extensions.

The extensions add capabilities without pulling weight into the floor: platform and console output (`tom_basics_console`), HTTP retry and server discovery (`tom_basics_network`), cryptography (`tom_crypto`), a unified chat API (`tom_chattools`), and code-generation helpers (`tom_analyzer_shared`, `tom_markdown_merge`, `tom_package_scanner`).

Everything above — `tom_core_kernel`, the Flutter and server cores, and the build CLIs — rests on this layer. It carries no business logic; it supplies the shared utilities and tooling primitives the rest of Tom assumes.

Foundation

tom_basics Published

tom_basics · v1.0.0
595 loc · 6 tests · 50 test LOC
The minimal-dependency base of the Tom stack: core utilities and a UUID-tracked base exception with stack-trace support that the whole framework builds on.
Published

tom_basics role: foundation

tom_basics · v1.0.0

`tom_basics` is the utility floor at the bottom of every Tom application. It keeps its dependency surface as small as possible so that everything above — `tom_core_kernel`, the Flutter and server cores, and the build tools — can rest on it without inheriting weight. Its central type is `TomBaseException`, a base exception carrying a UUID, an error key, parameters, and stack-trace support, giving the framework a uniform, traceable error model. The other utilities here are the small, shared helpers the rest of Tom assumes are always present.

LOC
595
Tests
6
Test LOC
50
2 docs · 1 API

tom_basics_network Published

tom_basics_network · v1.0.1
299 loc · 12 tests · 100 test LOC
Network extension of `tom_basics`: HTTP retry with configurable exponential backoff and network-based server discovery for distributed Tom applications.
Published

tom_basics_network role: extension

tom_basics_network · v1.0.1

`tom_basics_network` adds the networking primitives Tom applications reuse rather than reimplement. Its HTTP retry layer applies configurable exponential backoff, attempt limits, and retry conditions via `RetryConfig`, hardening calls against transient failures. It also provides network-based server discovery for distributed Tom deployments, letting components locate peers without hard-coded addresses.

LOC
299
Tests
12
Test LOC
100
2 docs · 1 API

tom_crypto Published

tom_crypto · v1.0.1
588 loc · 9 tests · 97 test LOC
Cryptographic building blocks for Tom: JWT tokens, Argon2 password hashing, and RSA encryption, signing, and key management for secure authentication and data protection.
Published

tom_crypto role: extension

tom_crypto · v1.0.1

`tom_crypto` collects the cryptographic primitives Tom's authentication and security code relies on. It issues and verifies JWT tokens with HMAC or RSA signing and encrypted payloads, and hashes passwords with Argon2 for secure storage. For asymmetric work it provides RSA encryption with OAEP padding, digital signatures, and key management — generation plus PEM parsing and encoding in PKCS#1 and PKCS#8. Together these give the framework a consistent set of crypto operations to build identity and security features on.

LOC
588
Tests
9
Test LOC
97
3 docs · 1 API
Tool foundation

tom_build_base Published

tom_build_base · v2.6.21
9.1k loc · 754 tests · 11.1k test LOC
The CLI and tooling framework Tom's build tools are built on: declarative tool, command, and option definitions with workspace traversal, pipelines, and configuration loading.
Published

tom_build_base role: foundation

tom_build_base · v2.6.21

`tom_build_base` is the foundation under Tom's command-line build tools. Tools declare themselves as immutable `ToolDefinition`, `CommandDefinition`, and `OptionDefinition` data, and the framework handles help generation, project and git traversal, and folder-nature detection. Multi-command tools gain pipelines, runtime macros, and persistent defines automatically, plus declarative wiring of nested external tool binaries. It also reads `buildkit.yaml` configuration, runs external processes, and renders console Markdown. Build tools such as buildkit, testkit, and the code-generation CLIs are thin users of this framework, which keeps their behaviour and help output uniform across the workspace.

LOC
9.1k
Tests
754
Test LOC
11.1k
8 docs · 1 API

tom_basics_console Published

tom_basics_console · v1.0.0
79 loc · 0 tests · 0 test LOC
Standalone-platform extension of `tom_basics`: platform detection, Markdown-formatted console output, and an IO-based HTTP client for command-line and desktop Dart applications.
Published

tom_basics_console role: extension

tom_basics_console · v1.0.0

`tom_basics_console` extends the utility floor for standalone Dart programs that run outside the browser. It adds platform detection across desktop, mobile, web, and individual operating systems, Markdown-rendered console output, and an IO-based HTTP client. It re-exports all of `tom_basics`, so a console or desktop tool can depend on this single package and get both the base utilities and the standalone-only capabilities together.

LOC
79
Tests
0
Test LOC
0
2 docs · 1 API

tom_analyzer_shared Published

tom_analyzer_shared · v0.1.0
1.0k loc · 82 tests · 1.1k test LOC
Caching infrastructure that builds and reuses binary analyzer summaries so Tom's code generators skip rescanning stable dependencies on every run.
Published

tom_analyzer_shared role: extension

tom_analyzer_shared · v0.1.0

`tom_analyzer_shared` gives Tom's code generators a shared summary cache. For a project with a resolved `pubspec.lock`, it resolves dependencies, decides which are cacheable, and builds binary analyzer summaries for the SDK and each stable package in dependency order. Summaries are stored under the workspace and handed back so callers can feed them to the analyzer and skip re-analysing unchanged packages from source. Extracted from the reflection generator, it is now the common cache reused by reflection, d4rt bridges, and other generators.

LOC
1.0k
Tests
82
Test LOC
1.1k
2 docs · 1 API
Specific-purpose libraries

tom_chattools Published

tom_chattools · v1.0.2
688 loc · 6 tests · 43 test LOC
A platform-agnostic chat abstraction for sending and receiving messages, with a unified message model and a Telegram implementation behind a single `ChatAPI` interface.
Published

tom_chattools role: extension

tom_chattools · v1.0.2

`tom_chattools` gives Tom one interface for talking to messaging platforms. The abstract `ChatAPI` and unified `ChatMessage`, `ChatSender`, and `ChatResponse` types let calling code send and receive messages without binding to a specific service. Concrete platforms are selected through `ChatAPI.connect()`, with Telegram supported today via the Bot API and real-time updates delivered through an `onMessage` stream. The factory pattern leaves room for additional platforms behind the same contract.

LOC
688
Tests
6
Test LOC
43
2 docs · 1 API

tom_markdown_merge Not started

tom_markdown_merge · v1.0.0
67 loc · 19 tests · 188 test LOC
Lets a generator refresh designated regions of a Markdown file on every run without clobbering hand-authored prose, using managed, override, and preserved free-text regions.
Not started

tom_markdown_merge role: extension

tom_markdown_merge · v1.0.0

`tom_markdown_merge` solves the problem of regenerating Markdown that also contains hand-written text. A document is split into insert-marker regions delimited by HTML comments: managed regions the generator may refresh, override regions the author owns and that are never rewritten, and free text preserved verbatim in document order. It is built on `tom_doc_specs`' insert-marker engine rather than a custom parser, so parsing stays AST-based and shared with the rest of the Tom toolchain. This merge machinery underpins the framework's managed-then- curated content fields.

LOC
67
Tests
19
Test LOC
188
2 docs · 1 API

tom_package_scanner In the works

tom_package_scanner · v1.0.0
407 loc · 47 tests · 418 test LOC
Scans a workspace's framework repos and, for each Dart package, derives its publication status, license token, version, description, and external links into a `PackageInfo`.
In the works

tom_package_scanner role: extension

tom_package_scanner · v1.0.0

`tom_package_scanner` walks a workspace's framework repositories and, for each Dart package, derives a `PackageInfo`: its four-state publication status, license token, version, description, and external links. Discovery is one level deep — the direct child folders carrying a `pubspec.yaml` — and results are sorted for diff-friendly output. Built on `tom_build_base`'s folder-nature detection and extracted from the website's module generator, it is the single scanner that both the module-index generator and the status-report generator share.

LOC
407
Tests
47
Test LOC
418
2 docs · 1 API
Key generator for development certificates

tom_tools Not started

tom_tools · v1.0.1
20 loc · 0 tests · 0 test LOC
A sample command-line application scaffold with a `bin/` entrypoint, library code, and an example unit test.
Not started

tom_tools role: extension

tom_tools · v1.0.1

A sample command-line application scaffold with a `bin/` entrypoint, library code, and an example unit test.

LOC
20
Tests
0
Test LOC
0
2 docs · 0 API
License 
# License

See each folder/package for its specific license.