Skip to content
CAI
Software that uses CAICheck a score

mdabir1203/Modular-Rust-Learning

48.3

Weak · 8 November 2026

2.9k

lines of production code

Rust

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Module00 CLI application with greeting functionality

Introduces a new Rust-based CLI module (Module00) that provides a simple greeting feature. The module includes a \cli.rs\ file that defines a \greet\_user\ function to print a welcome message to the console, and a \main.rs\ file that orchestrates the application flow, calling both the module's greeting and a local greeting function. The implementation includes basic error handling for I/O operations and unit tests to verify the greeting logic.

Module00 · high confidence

Add Rust-based authentication server with JWT support

The auth\_server module now includes a complete Rust implementation for an authentication server using the Warp framework. It provides a login endpoint that issues JSON Web Tokens (JWT) and a protected endpoint that validates these tokens. The code is organized into modular components for JWT handling, request handling, and server routing, accompanied by unit tests for the login and protected routes.

_Module02/auth\server · high confidence

Add Todo List Application with Unit Tests

Introduced a new Rust-based Todo List application in Module01/Todo, providing core functionality to add, display, and mark to-do items as completed. The implementation includes a command-line interface for user interaction and a comprehensive set of unit tests covering item creation, status updates, and input parsing.

Module01/Todo · high confidence

Add in-memory cache and console logging utilities

Introduces a new caching component that provides an in-memory cache implementation with a generic strategy pattern, allowing different cache backends to be swapped in. Additionally, adds a console logging utility that uses a strategy pattern to support pluggable logging implementations, currently defaulting to printing messages to the console.

Module05/cachecomponent, Module05/consolelog · high confidence

Add number guessing game with error handling and tests

A new number guessing game application has been added to the Module01/error module. The program generates a random secret number and allows the user to guess it, providing feedback on whether the guess is too small, too big, or correct. The implementation includes robust error handling for invalid user input, colored console output for better user experience, and unit tests for the core comparison logic.

Module01/error · high confidence

Added Actix Web service for fetching GitHub repository information

A new Rust-based web service has been introduced in the Module02/gitCheck directory, built with Actix Web to retrieve GitHub repository details. The implementation includes a main server entry point that binds to 127.0.0.1:5500, a handler that queries the GitHub API for a given owner and repository, and a data model for the response. The project also includes a README with installation and usage instructions, as well as unit tests for the handler and main application.

Module02/gitCheck · high confidence

Added Rusty the Chatbot: a command-line Rust application with JSON-based responses

Users can now run a simple command-line chatbot named 'Rusty' built in Rust. The application reads predefined responses from a JSON file (chatbot\_responses.json) and interacts with users via stdin/stdout, supporting an infinite loop until the user types 'exit'. The change includes the main Rust source code, the JSON response data, and associated IDE configuration files.

Module02/Chatbot · high confidence

Added a basic in-memory key-value store for keyword-to-URL mapping

The data vault module now includes a new Rust implementation of a search engine key-value store. This adds a \SearchEngineKV\ struct that manages a HashMap of keywords to lists of URLs, supporting insert, retrieve, and remove operations. Additionally, a \colors\ module was added to provide ANSI escape codes for terminal text styling, enabling colored output in the application.

_Module03/data\vault · high confidence

Added new modules for authentication, data structures, and generic traits

Added a Rust-based authentication module (Module02/Auth) implementing JWT-based login, token generation, and protected route handling using the warp framework. Added a B-Tree map implementation (Module07/btreemap) with node management and configuration. Added a value tree implementation (Module07/valuetree) with similar B-Tree structures and comprehensive unit tests. Added a banking module (Module08/banking) with database integration using sqlx and axum routing. Added a Rust backend module (Module09/rust\_backend) with user models, authentication middleware, and nginx configuration. Added a tokenizer module (Module09/tokenize) for advanced text tokenization with context awareness. Added generic trait examples (Module10/generic) demonstrating advanced traits, associated types, and higher-kinded types.

(repo-wide) · high confidence

Added password-protected data vault with save and load functionality

Introduced a new Rust-based data vault component that allows users to securely save and load sensitive information using password-based encryption. The implementation includes password strength validation, Argon2 hashing for secure storage, and error handling for invalid passwords or file formats. Users can now protect their data with a strong password before saving, and must provide the correct password to load the vault.

_Module03/data\_vault\exx · high confidence

Added project governance, safety, and development tooling files

The repository now includes essential documentation and configuration files to support community contribution and project maintenance. A \.gitignore\ file has been added to exclude build artifacts, IDE files, and generated content. A \clean.sh\ script is now available to automate the removal of Cargo build artifacts and lock files across all subdirectories. Additionally, the project has introduced standard governance documents: a \LICENSE\ (MIT), a \README.md\ explaining the modular learning approach, a \CODE\_OF\_CONDUCT.md\ based on the Contributor Covenant, a \CONTRIBUTING.md\ guide for developers, and a \SECURITY.md\ outlining vulnerability reporting procedures. Finally, a \colors.rs\ file was added, providing a comprehensive set of Tailwind CSS color constants for terminal output styling.

(repo-wide) · high confidence

New Actix Web server with static file serving and WebSocket test page

The Web1 module now includes a complete Rust-based web server built with Actix Web. Users can run the server locally on port 8080, which serves a welcome message at the root path and provides a custom 404 error page. The project also includes a test.html page that demonstrates WebSocket connectivity to port 7878, along with a unit test to verify the root route returns a 200 OK status.

Module02/Web1 · high confidence

New Actix Web server with static pages and API endpoints

The Web2 module now includes a complete Rust-based web server using the Actix framework. This adds a new HTTP server that serves static HTML pages (a custom 404 error page and a blog-style page for Medium posts) and provides API endpoints for greeting users, echoing JSON data, and handling basic routing. The server listens on port 5500 and includes unit tests for the main routes.

Module02/Web2 · high confidence

Removals

Removed RetroSpy project and its dependencies

The RetroSpy directory and all its associated files, including the \.babelrc\ configuration and the entire \node\_modules\ directory (containing dependencies like \@ampproject/remapping\ and various CLI tools), have been deleted. This removes the RetroSpy project from the codebase.

RetroSpy · high confidence

Test coverage

Added test assets and configuration for Module09

Added a new \.env\ file for environment configuration, a \Dockerfile\ for containerizing the Rust backend, and multiple SVG files in the \media/texts\ directory containing glyph definitions for rendering text as vector graphics.

Module09 · high confidence

Dependencies

Removed Babel and Node.js dependencies from RetroSpy

The RetroSpy project has removed its \node\_modules\ directory, deleting the \@babel\ and \@ampproject/remapping\ packages and their associated metadata files. This indicates a shift away from using Babel for JavaScript transpilation or build processes within this specific project context.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 47 → 48 (+0.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 98 → 98 (+0.0)
  • Architecture 99 → 99 (+0.0)
  • Maturity 45 → 55 (+10.1)
  • Readiness 42 → 42 (+0.0)
  • Security 43 → 43 (+0.0)
  • Domain Modelling 100 → 100 (+0.0)
  • Accessibility 48 → 48 (+0.0)
  • Performance 91 → 91 (+0.0)

Resolved (3)

  • Naming inconsistency between public API and internal implementation. The public BTree uses 'search' while the internal Node also uses 'search'. While this might be intentional, 'search' is often ambiguous in key-value stores (does it return the value or a boolean existence check?). More critically, if BTree delegates to Node, the naming is consistent, but the return type of BTree.search is V (the value), which implies it panics or returns a default on missing keys, whereas 'search' often implies an Option/Result return. However, the primary inconsistency is between BTree.insert and Node.insert signatures.
  • Signature mismatch between public API and internal method. BTree.insert does not take a 'degree' parameter, but Node.insert does. This suggests that BTree.insert must internally pass the degree, but the public API hides this implementation detail (which is good), yet the internal Node API exposes it. This is not a direct inconsistency in the public surface, but it indicates a lack of encapsulation in the Node type's public-facing methods if Node is exposed or if the API is meant to be uniform.
  • Vague and inconsistent naming in utility module. 'optimize_memory_usage' is a high-level goal, not an operation. 'reuse_buffers' is an implementation detail. 'handle_large_data' is too generic. These functions lack clear, distinct purposes in their names, making it hard to understand what each does without reading the body. They may overlap in functionality (e.g., optimizing memory might involve reusing buffers).

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

mdabir1203/Modular-Rust-Learning was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 521a0c5744dce0d579da08cf74180468768c4424 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.