25 independent Rust CLI tools · one focused workspace · built around NEXUS-Q Core

Explore the tools · Install · User guide · Architecture

---

What is NEXUS-Q Tools?

NEXUS-Q Tools is a collection of small, independent command-line utilities written in Rust. Each tool has one clear job and can be installed on its own with Cargo. Together, they cover local diagnostics, file and manifest workflows, documentation checks, integrity, signatures, backups, and developer productivity.

This repository is separate from the NEXUS-Q engine. Where an operation is already provided by the public nexusq-core API, the tools use that API instead of maintaining a second implementation. The tools complement the engine; they do not replace Core, SentinelFlow, or Nuvora.

Part of the NEXUS-Q ecosystem

NEXUS-Q Tools is a companion project in the NEXUS-Q ecosystem, built to extend the developer workflows around the main engine. The cryptographic and security foundations belong to the NEXUS-Q project: these tools integrate with its public nexusq-core API instead of presenting a separate or competing cryptographic engine.

• Main project: NEXUS-Q — source repository
• Project website: nexus-q.link
• Core library: nexusq-core on crates.io
• Companion tools: NEXUS-Q Tools repository

NEXUS-Q provides the underlying engine and Core APIs; NEXUS-Q Tools provides focused, independently installable utilities that make selected capabilities and everyday development tasks easier to use. The tools are complementary utilities, not a replacement for the main project.

The project today: 25 published binary crates, all at 0.1.0, with direct package links below. The repository is designed as a Cargo workspace, while every command remains an independently installable crate.

Why use it?

• Pick only what you need. Every tool is a standalone Cargo package; there is no mandatory suite installer.
• Small, explicit commands. Utilities focus on one task and expose their own CLI interface.
• Core-backed operations. Supported hashing, Ed25519 signing, password-based encryption, secure randomness, and engine workflows use public NEXUS-Q Core APIs.
• Safety-conscious defaults. Most inspection commands are read-only. Commands that create outputs use explicit destinations and documented safeguards.
• Local-first workflows. Most tools operate on local files and metadata without network access.
• Documented limits. Security, compatibility, memory use, and trust boundaries are described rather than hidden behind broad claims.

Tools catalog

All packages below are published on crates.io as independent binaries at version 0.1.0. Select a tool to open its package page or install command.

Diagnostics and environment

Tool	What it does	Install
nq-about	Shows suite and NEXUS-Q Core information.	cargo install nq-about
nq-doctor	Checks the local development environment and available tools.	cargo install nq-doctor
nq-env	Summarizes OS/runtime information with conservative environment-variable redaction.	cargo install nq-env
nq-cache-report	Reports common cache/build-directory sizes without deleting anything.	cargo install nq-cache-report
nq-git-audit	Summarizes repository and working-tree status without changing Git state.	cargo install nq-git-audit

Files, JSON, logs, and reports

Tool	What it does	Install
nq-hash	Calculates file SHA-256 hashes through NEXUS-Q Core.	cargo install nq-hash
nq-config-check	Validates JSON configuration objects and required top-level fields.	cargo install nq-config-check
nq-json-check	Checks JSON syntax in files or standard input.	cargo install nq-json-check
nq-log-view	Filters text logs by level, substring, and ISO-date prefix.	cargo install nq-log-view
nq-report	Assembles Markdown diagnostic reports from named text-file sections.	cargo install nq-report
nq-diff	Compares two file-manifest inventories and summarizes changes.	cargo install nq-diff

Manifests, archives, and workspaces

Tool	What it does	Install
nq-manifest	Creates deterministic inventories of regular files, sizes, and Core hashes.	cargo install nq-manifest
nq-bundle	Creates ZIP bundles with a Core SHA-256 content manifest.	cargo install nq-bundle
nq-verify-bundle	Verifies bundle structure and content without extracting archive entries.	cargo install nq-verify-bundle
nq-workspace	Creates and validates a minimal Rust CLI starter structure.	cargo install nq-workspace
nq-test-runner	Runs explicitly configured program/argument arrays without shell interpretation.	cargo install nq-test-runner

Integrity, security, and supply-chain metadata

Tool	What it does	Install
nq-seal	Creates and verifies SHA-256 integrity manifests.	cargo install nq-seal
nq-vault	Manages a local content-addressed artifact store using Core SHA-256. It is not encrypted storage.	cargo install nq-vault
nq-sign	Generates Ed25519 keys and creates/verifies detached signatures through Core.	cargo install nq-sign
nq-policy	Evaluates manifest metadata against explicit JSON policy rules.	cargo install nq-policy
nq-supply-chain	Reports Cargo.lock package, dependency, source, and checksum metadata offline.	cargo install nq-supply-chain
nq-secure-backup	Creates, verifies, and restores encrypted local backups using Core cryptography.	cargo install nq-secure-backup

Documentation and integration

Tool	What it does	Install
nq-release-notes	Extracts the latest or a selected Markdown changelog section.	cargo install nq-release-notes
nq-doc-audit	Checks Markdown documents for broken relative file links and required headings.	cargo install nq-doc-audit
nq-integrate	Runs an isolated integration diagnostic against public NEXUS-Q Core APIs.	cargo install nq-integrate

See the complete crates.io index for all package links and registry verification details, and the CLI reference for command contracts.

Installation

Install an individual tool

Install Rust and Cargo, then install only the commands you want:

cargo install nq-hash
cargo install nq-doctor
cargo install nq-secure-backup

Verify an installed command:

nq-hash --help
nq-hash --version

Cargo normally places executables in ~/.cargo/bin. Ensure that directory is on your PATH. To update or remove a tool:

cargo install nq-hash
cargo uninstall nq-hash

The published packages are version 0.1.0. See Installation for source builds, Termux notes, and troubleshooting.

Build the workspace from source

git clone https://github.com/lecodev-26/nexus-qtools.git
cd nexus-qtools
cargo build --workspace
cargo test --workspace
cargo fmt --all --check

For an environment with dependencies already cached, add --offline to the Cargo build/test commands. Initial dependency resolution may require network access.

Quick start

Hash a file:

nq-hash ./release.tar.gz

Inspect the local environment:

nq-doctor
nq-env

Create and inspect a file manifest:

nq-manifest ./project > manifest.json
nq-policy ./policy.json ./manifest.json

The policy command evaluates manifest metadata only; it does not open or hash the listed artifact files.

Create and verify an integrity seal:

nq-seal ./release-seal.json ./release.tar.gz
nq-seal --verify ./release-seal.json ./release-directory

Create and verify an encrypted backup:

chmod 600 ./backup-password.txt
nq-secure-backup create ./project ./project.nqsb --password-file ./backup-password.txt
nq-secure-backup verify ./project.nqsb --password-file ./backup-password.txt

Review the User Guide for more workflows and the CLI Reference for exact arguments and exit statuses.

Architecture

nexusq-tools/
├── crates/
│   ├── nq-about/
│   ├── nq-hash/
│   ├── nq-sign/
│   ├── nq-secure-backup/
│   └── ...                 # 25 independent binary crates
├── docs/                   # Architecture, guides, security, roadmap, references
├── assets/                 # Project identity assets
├── .github/                # CI and contribution templates
├── Cargo.toml              # Workspace definition
└── README.md

Each crate owns its CLI and tests. Fifteen crates use the exact published dependency nexusq-core = "=4.1.2" for supported engine and cryptographic operations. The remaining tools provide local parsing, reporting, filesystem, process, or documentation workflows. No developer-specific local Core path is required.

For the detailed dependency map and per-tool boundaries, see Architecture.

Security model and limitations

Security-sensitive functionality is intentionally explicit:

• Cryptography is delegated to NEXUS-Q Core. The tools do not maintain a parallel implementation of Core-backed cryptographic primitives.
• Read-only is the default, not a universal promise. Some commands create bundles, signatures, vault objects, manifests, backups, or restored directories. Review destinations and command help first.
• A hash is not a signature. A digest or integrity manifest does not prove authorship or protect the manifest from replacement.
• A signature is not identity proof. nq-sign verifies against the public key supplied by the operator; key trust must be established independently.
• The local vault is not encrypted. nq-vault stores content-addressed objects and follows normal filesystem permissions.
• The test runner is not a sandbox. Configured programs execute with the caller's permissions; review every command before running it.
• Supply-chain inventory is not vulnerability scanning. nq-supply-chain reads Cargo.lock metadata and does not query advisories or authenticate publishers.
• Some archive workflows buffer data in memory. Read the documented limits before processing large inputs.

No independent third-party security audit has been completed. This project does not claim a security certification, formal verification, FIPS validation, or suitability for every threat model. Read the Security Model and Security Policy before using security-sensitive workflows.

Compatibility

The workspace has been developed and tested in Termux on Android. This is not a complete device/ABI compatibility guarantee. Windows, macOS, and Linux have not been comprehensively verified as a project-wide matrix, and no formal minimum supported Rust version (MSRV) is declared. See Compatibility.

Documentation

Document	Description
Installation	Cargo installation, source builds, Termux, updates, and troubleshooting.
User Guide	Practical workflows and examples.
CLI Reference	Per-command arguments, behavior, and limitations.
Architecture	Workspace structure and NEXUS-Q Core integration.
Security Model	Trust boundaries, cryptography, and operational limitations.
Compatibility	Verified platforms and compatibility caveats.
FAQ	Common questions.
Crates.io Index	Direct links to all 25 published packages.
Roadmap	Implemented work, deferred items, and proposals.
Tool Ideas	Full catalogue of 37 implemented/deferred/proposed ideas.
Workflow	Development and verification process.

Contributing

Contributions and focused bug reports are welcome. Before proposing a change, read CONTRIBUTING.md, Architecture, and the Roadmap. Keep tools modular, dependencies minimal, tests reproducible, and safety boundaries documented. Do not assume that a roadmap proposal is approved for implementation.

• Contributing guide
• Code of Conduct
• Support
• Security Policy

License

This project is distributed under the MIT License. See CITATION.cff for citation metadata.

---

NEXUS-Q Tools
_{Small tools. Useful work. Built to complement NEXUS-Q Core.
GitHub · crates.io · NEXUS-Q}