assayflux 0.1.0__tar.gz

assayflux-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 AssayFlux
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

assayflux-0.1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include README.md
+include LICENSE
+include RELEASE_NOTES_0.5.0.md
+include RELEASE_NOTES_0.6.0.md
+include RELEASE_NOTES_0.7.0.md
+recursive-include docs *.md
+recursive-include scripts *.sh
+recursive-include tests *.py
+
+include RELEASE_NOTES_0.1.0.md

assayflux-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: assayflux
+Version: 0.1.0
+Summary: A cross-platform developer toolkit for generating projects, checking language toolchains, running code, validating websites, and orchestrating native and Android builds.
+Author-email: Md Safarujjaman <assayflux@gmail.com>, Md Sahanujjaman <assayflux@gmail.com>
+Maintainer-email: AssayFlux Scientific Systems <company@assayflux.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.assayflux.org
+Project-URL: Official Website (.com), https://www.assayflux.com
+Project-URL: Organization, https://www.assayflux.org
+Project-URL: GitHub, https://github.com/AssayFlux
+Keywords: AssayFlux,AssayFlux Scientific Systems,Md Safarujjaman,Md Sahanujjaman,India,West Bengal,Kolkata,build-tool,project-generator,website,android,apk,aab,multi-language,Python,C++,R,TypeScript,Go,Rust,SQL,scientific-computing,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.1; extra == "dev"
+Dynamic: license-file
+
+# AssayFlux
+
+**Version:** 0.1.0  
+**Authors:** Md Safarujjaman and Md Sahanujjaman  
+**Company:** AssayFlux Scientific Systems · **Country:** India · **State:** West Bengal · **Region:** Kolkata  
+**Author email:** assayflux@gmail.com · **Company email:** company@assayflux.com  
+**GitHub:** [AssayFlux](https://github.com/AssayFlux)  
+**Official websites:** [assayflux.org](https://www.assayflux.org) · [assayflux.com](https://www.assayflux.com)
+
+**AssayFlux is a cross-platform developer toolkit for turning project ideas into organized, runnable software workspaces.** Its Python-powered CLI generates starter projects, checks language toolchains, plans tasks, runs supported code, validates website assets, packages source, and orchestrates Android APK/AAB builds when the required SDK and build tools are installed. It is designed to bring multiple development workflows under one consistent interface while preserving the role of each language's native runtime, compiler, and build system.
+
+AssayFlux does not translate arbitrary source code between languages. A reported successful build means the requested build command and artifact checks succeeded; it does not replace runtime testing on a device or deployment environment.
+
+## Project ownership and official links
+
+- Authors: **Md Safarujjaman** and **Md Sahanujjaman**
+- Author email: **assayflux@gmail.com**
+- Company: **AssayFlux Scientific Systems**
+- Company email: **company@assayflux.com**
+- Country: **India**
+- State: **West Bengal**
+- Region: **Kolkata**
+- GitHub: **AssayFlux** — https://github.com/AssayFlux
+- Official websites: https://www.assayflux.org and https://www.assayflux.com
+
+These details are included in package metadata and documentation where the packaging standards support them. PyPI does not provide dedicated author country, state, or region fields, so the location is documented here rather than represented as a verified package-index attribute.
+
+## Install
+
+```bash
+python -m pip install --upgrade assayflux
+assayflux --version
+assayflux doctor
+```
+
+For local development:
+
+```bash
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+## Quick start
+
+Create a starter website:
+
+```bash
+assayflux create MyWebsite --target website
+assayflux run --project-dir MyWebsite --target website
+```
+
+Open `http://127.0.0.1:8000` in your browser. In another terminal, inspect the plan and test the project:
+
+```bash
+assayflux plan MyWebsite
+assayflux test MyWebsite
+assayflux build MyWebsite
+```
+
+Build output is placed in `deliverables/MyWebsite/`; the editable project remains in `MyWebsite/`.
+
+## Wrap an existing static website into an Android APK project
+
+AssayFlux can create an Android WebView wrapper and bundle local HTML, CSS, JavaScript, images, and other static assets into the Android project:
+
+```bash
+assayflux wrap-web MyMobileSite --source ./path/to/website --root ./mobile-projects
+cd ./mobile-projects/MyMobileSite
+assayflux build . --android-artifacts apk
+```
+
+The `--source` directory must contain `index.html`; a project containing `web/index.html` is also accepted. Website files are copied into `app/src/main/assets/site/`. The generated wrapper uses AndroidX WebKit's `WebViewAssetLoader`, disables direct file access, and opens external navigation in the device browser.
+
+**Scope:** This wraps a static frontend. It does not automatically embed a Python/PHP backend, create a database server, add authentication, or integrate payment processing. Backend APIs need a separate deployment or explicit native integration. The generated Gradle project downloads its declared AndroidX WebKit dependency during a build, so the first build generally needs network access.
+
+## Generate other project types
+
+```bash
+assayflux new DataTool --target python
+assayflux new MultiTool --target python --target website --target backend
+assayflux new NativeDemo --target android
+```
+
+Supported starter targets: `website`, `html`, `css`, `backend`, `cli`, `python`, `r`, `c`, `cpp`, `javascript`, `typescript`, `java`, `kotlin`, `php`, `bash`, `go`, `rust`, `sql`, and `android`. Engine detection is capability discovery; it does not imply every target is compiled by the generic `build` command.
+
+## Scientific and multi-language starter workflows
+
+AssayFlux 0.1.0 includes R, TypeScript, Go, Rust, and SQLite SQL starter workflows. R runtime execution still requires R and Rscript to be installed. Generate an R analysis workspace with:
+
+```bash
+assayflux new ResearchAnalysis --target r
+assayflux doctor
+assayflux run --project-dir ResearchAnalysis --target r
+```
+
+The generated `src/analysis.R` is a minimal working starter, not a full statistical-analysis framework. R must be installed separately and `Rscript` must be available on `PATH`. Package installation and advanced R/Python interoperability are not performed automatically.
+
+Other added targets:
+
+```bash
+assayflux new TypeScriptDemo --target typescript  # requires tsc + Node.js
+assayflux new GoDemo --target go                   # requires Go
+assayflux new RustDemo --target rust               # requires rustc
+assayflux new SQLDemo --target sql                 # Python standard-library SQLite, in-memory
+assayflux run --project-dir SQLDemo --target sql
+assayflux validate-web ./web                      # checks index.html and local referenced assets
+```
+
+`validate-web` is a lightweight sanity check; it is not a full HTML validator or security audit. TypeScript, Go, Rust, and R targets need their respective toolchains for execution.
+
+## Toolchain setup and automatic requirements
+
+AssayFlux's core CLI is written using the Python standard library, so a basic install does not need a separate third-party Python runtime dependency. Install the optional development tools with `python -m pip install --upgrade "assayflux[dev]"` when you need to run tests or build/publish a release.
+
+**System toolchains are different from Python dependencies.** Java/JDK, Gradle, Android SDK/build-tools, Node.js, C/C++ compilers, PHP, and similar tools are OS-level programs with different installation methods, licenses, sizes, and permissions. `pip install assayflux` cannot safely and reliably install all of them on every Windows, macOS, Linux, Termux, and Colab environment. Run `assayflux doctor` to check what is available. For supported Android build environments, use the included setup guide/script; it installs the documented toolchain for its target environment and may download several gigabytes and request Android SDK license acceptance. Review scripts before running them and do not run them on systems where you lack administrator permission.
+
+## Android build requirements
+
+Android builds require a compatible JDK (17 recommended), Gradle compatible with Android Gradle Plugin 8.7.3, Android SDK platform 35 and build-tools 35.0.0, and `ANDROID_HOME` or `ANDROID_SDK_ROOT`. See [Google Colab Android setup](docs/GOOGLE_COLAB_ANDROID.md).
+
+```bash
+assayflux build . --android-artifacts apk    # debug APK
+assayflux build . --android-artifacts aab    # release AAB
+assayflux build . --android-artifacts both   # both
+```
+
+Release AAB signing is not configured automatically. Configure signing credentials securely before publishing. Test APKs on real devices or emulators.
+
+## CLI commands
+
+- `assayflux --version`, `assayflux info`
+- `assayflux engines` — show registered engines and detected tools
+- `assayflux doctor [--json]` — inspect local build prerequisites
+- `assayflux new NAME` / `assayflux create NAME` — generate a starter workspace
+- `assayflux wrap-web NAME --source DIR [--root DIR]` — bundle a static site into an Android WebView project
+- `assayflux validate-web [WEBSITE_DIR]` — check `index.html` and referenced local assets
+- `assayflux plan [PROJECT_DIR]` — print the task plan
+- `assayflux test [PROJECT_DIR]` — run project tests
+- `assayflux build [PROJECT_DIR] [--force] [--android-artifacts apk|aab|both|none]` — package source and run requested Android build tasks
+- `assayflux run --project-dir DIR --target TARGET` — run a supported target
+
+`--force` replaces only the existing delivery folder, not the editable project source. Review the destination before using it.
+
+## Delivery report
+
+`BUILD_REPORT.json` distinguishes `built` (requested Android artifact built and found), `source_packaged` (source snapshot packaged without a requested Android build), and `partial` (requested Android build was blocked or failed). Build stdout/stderr are retained under `logs/`; inspect them when a build fails.
+
+## Python API
+
+```python
+from assayflux import Project
+
+project = Project.create("ResearchPortal", root=".", targets=["website", "backend"])
+project.generate()
+result = project.build()
+print(result.report["status"])
+```
+
+## Security and limitations
+
+- Build, test, and run commands may execute project-local code. Do not run untrusted projects; AssayFlux is not a sandbox.
+- Generated backend code is a minimal starter, not a hardened internet-facing API.
+- Website-to-APK wrapping is for static frontends; server-side routes, local database services, login backends, and payments are not automatically ported.
+- Generic non-Android `build` packages source; it does not claim to compile every language target.
+- APK build success does not prove the app's full runtime behavior. Test the resulting app on a device/emulator.
+- Release signing and store publication require separate configuration and credentials.
+
+## Build and validate a release
+
+```bash
+python -m pip install --upgrade build twine
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+Review [the publishing checklist](docs/PUBLISHING_CHECKLIST.md) before releasing. PyPI publishing is a separate authenticated action; building a wheel does not publish it.
+
+## Runtime detection and setup (0.1.0)
+
+Use `assayflux runtimes` to check Python, R/Rscript, Java, Gradle, Android SDK manager, Node.js/npm, TypeScript, PHP, Go, Rust and C/C++ compilers. `assayflux setup` is detection-only unless you explicitly provide `--install --yes`; it then uses a supported OS package manager to install a baseline set of tools. Android SDK command-line tools, SDK platform/build-tools and licence acceptance may still require separate setup. See [`docs/RUNTIME_SETUP.md`](docs/RUNTIME_SETUP.md).

assayflux-0.1.0/README.md

@@ -0,0 +1,181 @@
+# AssayFlux
+
+**Version:** 0.1.0  
+**Authors:** Md Safarujjaman and Md Sahanujjaman  
+**Company:** AssayFlux Scientific Systems · **Country:** India · **State:** West Bengal · **Region:** Kolkata  
+**Author email:** assayflux@gmail.com · **Company email:** company@assayflux.com  
+**GitHub:** [AssayFlux](https://github.com/AssayFlux)  
+**Official websites:** [assayflux.org](https://www.assayflux.org) · [assayflux.com](https://www.assayflux.com)
+
+**AssayFlux is a cross-platform developer toolkit for turning project ideas into organized, runnable software workspaces.** Its Python-powered CLI generates starter projects, checks language toolchains, plans tasks, runs supported code, validates website assets, packages source, and orchestrates Android APK/AAB builds when the required SDK and build tools are installed. It is designed to bring multiple development workflows under one consistent interface while preserving the role of each language's native runtime, compiler, and build system.
+
+AssayFlux does not translate arbitrary source code between languages. A reported successful build means the requested build command and artifact checks succeeded; it does not replace runtime testing on a device or deployment environment.
+
+## Project ownership and official links
+
+- Authors: **Md Safarujjaman** and **Md Sahanujjaman**
+- Author email: **assayflux@gmail.com**
+- Company: **AssayFlux Scientific Systems**
+- Company email: **company@assayflux.com**
+- Country: **India**
+- State: **West Bengal**
+- Region: **Kolkata**
+- GitHub: **AssayFlux** — https://github.com/AssayFlux
+- Official websites: https://www.assayflux.org and https://www.assayflux.com
+
+These details are included in package metadata and documentation where the packaging standards support them. PyPI does not provide dedicated author country, state, or region fields, so the location is documented here rather than represented as a verified package-index attribute.
+
+## Install
+
+```bash
+python -m pip install --upgrade assayflux
+assayflux --version
+assayflux doctor
+```
+
+For local development:
+
+```bash
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+## Quick start
+
+Create a starter website:
+
+```bash
+assayflux create MyWebsite --target website
+assayflux run --project-dir MyWebsite --target website
+```
+
+Open `http://127.0.0.1:8000` in your browser. In another terminal, inspect the plan and test the project:
+
+```bash
+assayflux plan MyWebsite
+assayflux test MyWebsite
+assayflux build MyWebsite
+```
+
+Build output is placed in `deliverables/MyWebsite/`; the editable project remains in `MyWebsite/`.
+
+## Wrap an existing static website into an Android APK project
+
+AssayFlux can create an Android WebView wrapper and bundle local HTML, CSS, JavaScript, images, and other static assets into the Android project:
+
+```bash
+assayflux wrap-web MyMobileSite --source ./path/to/website --root ./mobile-projects
+cd ./mobile-projects/MyMobileSite
+assayflux build . --android-artifacts apk
+```
+
+The `--source` directory must contain `index.html`; a project containing `web/index.html` is also accepted. Website files are copied into `app/src/main/assets/site/`. The generated wrapper uses AndroidX WebKit's `WebViewAssetLoader`, disables direct file access, and opens external navigation in the device browser.
+
+**Scope:** This wraps a static frontend. It does not automatically embed a Python/PHP backend, create a database server, add authentication, or integrate payment processing. Backend APIs need a separate deployment or explicit native integration. The generated Gradle project downloads its declared AndroidX WebKit dependency during a build, so the first build generally needs network access.
+
+## Generate other project types
+
+```bash
+assayflux new DataTool --target python
+assayflux new MultiTool --target python --target website --target backend
+assayflux new NativeDemo --target android
+```
+
+Supported starter targets: `website`, `html`, `css`, `backend`, `cli`, `python`, `r`, `c`, `cpp`, `javascript`, `typescript`, `java`, `kotlin`, `php`, `bash`, `go`, `rust`, `sql`, and `android`. Engine detection is capability discovery; it does not imply every target is compiled by the generic `build` command.
+
+## Scientific and multi-language starter workflows
+
+AssayFlux 0.1.0 includes R, TypeScript, Go, Rust, and SQLite SQL starter workflows. R runtime execution still requires R and Rscript to be installed. Generate an R analysis workspace with:
+
+```bash
+assayflux new ResearchAnalysis --target r
+assayflux doctor
+assayflux run --project-dir ResearchAnalysis --target r
+```
+
+The generated `src/analysis.R` is a minimal working starter, not a full statistical-analysis framework. R must be installed separately and `Rscript` must be available on `PATH`. Package installation and advanced R/Python interoperability are not performed automatically.
+
+Other added targets:
+
+```bash
+assayflux new TypeScriptDemo --target typescript  # requires tsc + Node.js
+assayflux new GoDemo --target go                   # requires Go
+assayflux new RustDemo --target rust               # requires rustc
+assayflux new SQLDemo --target sql                 # Python standard-library SQLite, in-memory
+assayflux run --project-dir SQLDemo --target sql
+assayflux validate-web ./web                      # checks index.html and local referenced assets
+```
+
+`validate-web` is a lightweight sanity check; it is not a full HTML validator or security audit. TypeScript, Go, Rust, and R targets need their respective toolchains for execution.
+
+## Toolchain setup and automatic requirements
+
+AssayFlux's core CLI is written using the Python standard library, so a basic install does not need a separate third-party Python runtime dependency. Install the optional development tools with `python -m pip install --upgrade "assayflux[dev]"` when you need to run tests or build/publish a release.
+
+**System toolchains are different from Python dependencies.** Java/JDK, Gradle, Android SDK/build-tools, Node.js, C/C++ compilers, PHP, and similar tools are OS-level programs with different installation methods, licenses, sizes, and permissions. `pip install assayflux` cannot safely and reliably install all of them on every Windows, macOS, Linux, Termux, and Colab environment. Run `assayflux doctor` to check what is available. For supported Android build environments, use the included setup guide/script; it installs the documented toolchain for its target environment and may download several gigabytes and request Android SDK license acceptance. Review scripts before running them and do not run them on systems where you lack administrator permission.
+
+## Android build requirements
+
+Android builds require a compatible JDK (17 recommended), Gradle compatible with Android Gradle Plugin 8.7.3, Android SDK platform 35 and build-tools 35.0.0, and `ANDROID_HOME` or `ANDROID_SDK_ROOT`. See [Google Colab Android setup](docs/GOOGLE_COLAB_ANDROID.md).
+
+```bash
+assayflux build . --android-artifacts apk    # debug APK
+assayflux build . --android-artifacts aab    # release AAB
+assayflux build . --android-artifacts both   # both
+```
+
+Release AAB signing is not configured automatically. Configure signing credentials securely before publishing. Test APKs on real devices or emulators.
+
+## CLI commands
+
+- `assayflux --version`, `assayflux info`
+- `assayflux engines` — show registered engines and detected tools
+- `assayflux doctor [--json]` — inspect local build prerequisites
+- `assayflux new NAME` / `assayflux create NAME` — generate a starter workspace
+- `assayflux wrap-web NAME --source DIR [--root DIR]` — bundle a static site into an Android WebView project
+- `assayflux validate-web [WEBSITE_DIR]` — check `index.html` and referenced local assets
+- `assayflux plan [PROJECT_DIR]` — print the task plan
+- `assayflux test [PROJECT_DIR]` — run project tests
+- `assayflux build [PROJECT_DIR] [--force] [--android-artifacts apk|aab|both|none]` — package source and run requested Android build tasks
+- `assayflux run --project-dir DIR --target TARGET` — run a supported target
+
+`--force` replaces only the existing delivery folder, not the editable project source. Review the destination before using it.
+
+## Delivery report
+
+`BUILD_REPORT.json` distinguishes `built` (requested Android artifact built and found), `source_packaged` (source snapshot packaged without a requested Android build), and `partial` (requested Android build was blocked or failed). Build stdout/stderr are retained under `logs/`; inspect them when a build fails.
+
+## Python API
+
+```python
+from assayflux import Project
+
+project = Project.create("ResearchPortal", root=".", targets=["website", "backend"])
+project.generate()
+result = project.build()
+print(result.report["status"])
+```
+
+## Security and limitations
+
+- Build, test, and run commands may execute project-local code. Do not run untrusted projects; AssayFlux is not a sandbox.
+- Generated backend code is a minimal starter, not a hardened internet-facing API.
+- Website-to-APK wrapping is for static frontends; server-side routes, local database services, login backends, and payments are not automatically ported.
+- Generic non-Android `build` packages source; it does not claim to compile every language target.
+- APK build success does not prove the app's full runtime behavior. Test the resulting app on a device/emulator.
+- Release signing and store publication require separate configuration and credentials.
+
+## Build and validate a release
+
+```bash
+python -m pip install --upgrade build twine
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+Review [the publishing checklist](docs/PUBLISHING_CHECKLIST.md) before releasing. PyPI publishing is a separate authenticated action; building a wheel does not publish it.
+
+## Runtime detection and setup (0.1.0)
+
+Use `assayflux runtimes` to check Python, R/Rscript, Java, Gradle, Android SDK manager, Node.js/npm, TypeScript, PHP, Go, Rust and C/C++ compilers. `assayflux setup` is detection-only unless you explicitly provide `--install --yes`; it then uses a supported OS package manager to install a baseline set of tools. Android SDK command-line tools, SDK platform/build-tools and licence acceptance may still require separate setup. See [`docs/RUNTIME_SETUP.md`](docs/RUNTIME_SETUP.md).

assayflux-0.1.0/RELEASE_NOTES_0.1.0.md

@@ -0,0 +1,13 @@
+# AssayFlux 0.1.0
+
+- Added TypeScript, Go, Rust, and SQLite SQL starter targets and execution paths.
+- Added a dependency-free website entry-point/local-asset validator.
+- Improved engine registry and runtime diagnostics; registered languages still require their external toolchains.
+- Added regression tests for new templates, SQL execution, and website validation.
+
+## Limits
+- SQL uses an in-memory SQLite database; it is a starter workflow, not a production database service.
+- Website validation is a sanity check, not a full standards/security audit.
+- Android builds require a configured JDK, Gradle, Android SDK, and accepted licences.
+- TypeScript, Go, Rust, and R execution require their respective external toolchains.
+- This workflow does not publish to PyPI.

assayflux-0.1.0/RELEASE_NOTES_0.5.0.md

@@ -0,0 +1,26 @@
+# AssayFlux 0.5.0
+
+## Highlights
+
+- Added `assayflux create` as a friendly alias for `assayflux new`.
+- Added `assayflux wrap-web` to bundle an existing static website into an Android WebView project.
+- Fixed generated Android Gradle configuration to explicitly apply the Kotlin Android plugin and target Java/Kotlin 17.
+- Android build reports now distinguish a successful requested Android build (`built`) from source-only delivery (`source_packaged`) and incomplete Android builds (`partial`).
+- Requested APK/AAB output folders are cleared before building so stale binaries cannot be mistaken for newly generated artifacts.
+- Added tests for Kotlin build configuration, website asset bundling, and the new CLI workflows.
+- Expanded documentation for website-to-Android conversion and release validation.
+
+## Limitations
+
+- `wrap-web` packages static frontend assets; it does not port server-side backend code, databases, authentication servers, or payment services into Android.
+- Android build success still requires runtime testing on an emulator or physical device.
+- The release has not been published to PyPI by this archive-generation step. Publish only after review and authenticated release validation.
+
+
+## Project metadata update
+
+Package metadata now identifies author Md Safarujjaman, AssayFlux Scientific Systems, India, and official websites https://www.assayflux.org and https://www.assayflux.com. PyPI does not expose a dedicated author-country field; the country is included in the README/keywords.
+
+## Tool installation clarification
+
+The core CLI does not require extra runtime Python dependencies. Optional development dependencies are available through `assayflux[dev]`. Operating-system toolchains (JDK, Android SDK/build-tools, Gradle, Node.js, compilers, etc.) cannot be universally installed by pip; users should run `assayflux doctor` and follow the environment-specific setup guide.

assayflux-0.1.0/RELEASE_NOTES_0.6.0.md

@@ -0,0 +1,9 @@
+# AssayFlux 0.6.0 — Runtime Setup Preview
+
+- Added `assayflux runtimes` for runtime/toolchain detection (human-readable or JSON).
+- Added opt-in `assayflux setup` for baseline OS-package installation on supported Termux, Debian/Ubuntu, Fedora, Arch, macOS/Homebrew, and Windows/winget environments.
+- Kept installation opt-in: setup is detection-only by default; installation requires `--install --yes`.
+- Added documentation for Android APK/AAB prerequisites, SDK licensing, and cross-platform limitations.
+- Bumped package version to 0.6.0.
+
+Limitations: this is a runtime setup helper, not a universal bundler. The Android SDK is not shipped inside the PyPI package. SDK command-line tools, SDK packages, environment variables and licence acceptance may require separate steps. Availability of OS packages varies by platform and repository.

assayflux-0.1.0/RELEASE_NOTES_0.7.0.md

@@ -0,0 +1,16 @@
+# AssayFlux 0.7.0 — R Support and Project Metadata Update
+
+## Highlights
+
+- Added first-class R/Rscript runtime discovery in `assayflux runtimes` and `assayflux doctor`.
+- Registered an R engine and added the `r` project target.
+- Added a starter R analysis script and an `assayflux run --target r` execution path.
+- Updated package metadata and documentation for both named authors, author contact, company contact, organization, location details, GitHub, and the 0.7.0 release description.
+- Improved the package description to describe project generation, runtime/toolchain checks, code execution, website validation, and Android build orchestration without claiming universal compilation.
+
+## Important scope notes
+
+- R must be installed separately; AssayFlux does not bundle R or automatically install arbitrary R packages.
+- The R starter is a minimal runnable script, not a full statistical analysis suite.
+- Android builds still depend on a compatible JDK, Gradle configuration, Android SDK, and required dependencies. APK/AAB builds and device execution must be tested in the target environment.
+- The version bump does not itself mean a PyPI upload has occurred. Publish only after tests, distribution checks, and explicit release authorization.

assayflux-0.1.0/docs/ARCHITECTURE.md

@@ -0,0 +1,12 @@
+# Architecture
+
+- `project.py`: validates project specification and computes workspace/delivery paths.
+- `generator.py`: deterministic starter templates for supported targets.
+- `planner.py`: dependency-aware task plan serialization.
+- `engines/`: capability metadata for language/runtime tools, including Android APK and AAB tasks.
+- `relay.py`: capability-aware engine routing.
+- `builder.py`: snapshots source, invokes selected Android Gradle tasks, collects artifacts/logs, and writes `BUILD_REPORT.json`.
+- `doctor.py`: checks Python, language toolchains, Gradle, SDK manager, and SDK environment configuration.
+- `cli.py`: stable console interface.
+
+The project deliberately separates generation, execution, and delivery. A build report distinguishes source packaging from Android build success. The Android pipeline requires a configured external SDK/toolchain; it is not bundled in the Python wheel.

assayflux-0.1.0/docs/GOOGLE_COLAB_ANDROID.md

@@ -0,0 +1,105 @@
+# Build an APK/AAB in Google Colab
+
+This is the recommended first Android-build smoke test for the published AssayFlux package. Colab sessions are temporary; download artifacts before the session ends.
+
+## Cell 1 — Install AssayFlux
+
+```python
+%pip install --upgrade assayflux
+!assayflux --version
+!assayflux info
+!assayflux engines
+```
+
+If you are testing source before it is published, upload/extract the project ZIP and run `%pip install -e /content/AssayFlux[dev]` from its root instead.
+
+## Cell 2 — Install Android build tools
+
+Run in a Linux Colab runtime:
+
+```bash
+%%bash
+set -euo pipefail
+apt-get update -qq
+DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk unzip wget
+export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
+export PATH="$JAVA_HOME/bin:$PATH"
+mkdir -p /content/android-sdk/cmdline-tools
+cd /content
+wget -q -O commandlinetools.zip https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
+mkdir -p /content/cmdline-tools-unpack
+unzip -q -o commandlinetools.zip -d /content/cmdline-tools-unpack
+rm -rf /content/android-sdk/cmdline-tools/latest
+mv /content/cmdline-tools-unpack/cmdline-tools /content/android-sdk/cmdline-tools/latest
+export ANDROID_HOME=/content/android-sdk
+export ANDROID_SDK_ROOT="$ANDROID_HOME"
+export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$PATH"
+yes | sdkmanager --licenses >/dev/null
+sdkmanager "platform-tools" "platforms;android-35" "build-tools;35.0.0"
+cd /content
+wget -q -O gradle-8.9-bin.zip https://services.gradle.org/distributions/gradle-8.9-bin.zip
+unzip -q -o gradle-8.9-bin.zip -d /content
+/content/gradle-8.9/bin/gradle --version
+```
+
+## Cell 3 — Set variables and generate a project
+
+```python
+import os
+os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-17-openjdk-amd64"
+os.environ["ANDROID_HOME"] = "/content/android-sdk"
+os.environ["ANDROID_SDK_ROOT"] = "/content/android-sdk"
+os.environ["PATH"] = "/content/gradle-8.9/bin:/content/android-sdk/cmdline-tools/latest/bin:/content/android-sdk/platform-tools:" + os.environ["JAVA_HOME"] + "/bin:" + os.environ["PATH"]
+```
+
+```bash
+!assayflux doctor --json
+!assayflux new NativeDemo --root /content --target android
+```
+
+## Cell 4 — Build APK
+
+```bash
+!assayflux build /content/NativeDemo --android-artifacts apk
+```
+
+Expected output location after a successful build:
+
+`/content/deliverables/NativeDemo/artifacts/app-debug.apk`
+
+## Cell 5 — Build AAB separately
+
+The build command refuses to overwrite an existing delivery folder by default, so use a fresh project root/name for the AAB test or pass `--force` if you intend to replace that delivery folder.
+
+```bash
+!assayflux build /content/NativeDemo --android-artifacts aab --force
+```
+
+Expected output location after a successful build:
+
+`/content/deliverables/NativeDemo/artifacts/app-release.aab`
+
+## Cell 6 — Inspect report and download
+
+```python
+import json, os
+from pathlib import Path
+report = json.loads(Path('/content/deliverables/NativeDemo/BUILD_REPORT.json').read_text())
+print(json.dumps(report, indent=2))
+for f in Path('/content/deliverables/NativeDemo/artifacts').glob('*'):
+    print(f, f.stat().st_size, 'bytes')
+```
+
+```python
+from google.colab import files
+for f in Path('/content/deliverables/NativeDemo/artifacts').glob('*'):
+    files.download(str(f))
+```
+
+## Troubleshooting
+
+- If SDK packages fail to download, rerun the tool installation cell in a fresh runtime.
+- If `assayflux doctor` cannot see Gradle, re-run the environment setup cell. Colab shell variables set in a `%%bash` cell do not persist into Python cells; set `os.environ` in Cell 3.
+- If Gradle fails, inspect `logs/android-build.stderr.log` and `logs/android-build.stdout.log` inside the delivery folder.
+- A generated release AAB is not necessarily signed and is not automatically Play Store ready. Configure signing securely and test the APK on a real device before release.
+- The package is only published after a maintainer performs the PyPI/GitHub release steps; this document does not publish anything by itself.

assayflux-0.1.0/docs/PUBLISHING_CHECKLIST.md

@@ -0,0 +1,20 @@
+# Release checklist
+
+1. Review `pyproject.toml` package name, version, description, license, classifiers, and supported Python versions.
+2. Run `python -m pytest -q` and add regression tests for each changed feature.
+3. Build fresh artifacts with `python -m build` after removing stale `dist/` files.
+4. Validate artifacts with `python -m twine check dist/*` and install the wheel into a clean virtual environment for smoke tests.
+5. Inspect the wheel and source distribution to confirm that source, docs, and license are included and temporary artifacts are excluded.
+6. Publish only after explicit review using a configured PyPI Trusted Publisher or API token; never commit credentials.
+7. After publishing, test `python -m pip install --upgrade assayflux` in a clean environment and verify `assayflux --version` and core workflows.
+8. For Android releases, validate generated Gradle configuration, build the APK/AAB, and test the resulting application on an emulator/device. Configure release signing separately.
+
+
+## Author and website metadata
+
+Confirm authors Md Safarujjaman and Md Sahanujjaman, author email `assayflux@gmail.com`, company AssayFlux Scientific Systems, company email `company@assayflux.com`, and the official links `https://www.assayflux.org`, `https://www.assayflux.com`, and `https://github.com/AssayFlux`. Country India, state West Bengal, and region Kolkata are documented in the README because PyPI has no dedicated author-location metadata fields. Verify control of the listed domains and GitHub organization before release.
+
+
+## Colab token publishing notebook
+
+Use `AssayFlux_Colab_Test_Build_PyPI_0.1.0.ipynb` with `AssayFlux_Professional_0.1.0.zip`. It runs tests, builds a wheel and sdist, checks them with Twine, performs an isolated wheel-install smoke test, and offers a separate optional upload cell. The upload cell requires the exact release confirmation and prompts for a token without echoing it. Do not commit or save the token. Verify the release on PyPI after the upload command completes.