assayflux 0.4.0__tar.gz

assayflux-0.4.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.4.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: assayflux
+Version: 0.4.0
+Summary: Python-driven multi-language project generation, testing, and build orchestration
+Author: AssayFlux contributors
+License-Expression: MIT
+Keywords: build-tool,project-generator,android,apk,aab,multi-language
+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
+
+**AssayFlux is a Python-based multi-language project generator and build orchestrator.** It creates starter workspaces, plans tasks, detects local toolchains, runs supported project targets, packages source into a separate delivery folder, and can orchestrate Android debug APK and release AAB builds when a compatible toolchain is configured.
+
+AssayFlux is a project toolkit, not a new programming language and not a transpiler: it does not translate arbitrary source code between languages.
+
+## Requirements
+
+- Python 3.10 or newer
+- Optional per-target toolchains: Node.js, C/C++ compiler, JDK, Kotlin compiler, PHP, Bash
+- Android builds: JDK 17, Gradle 8.9 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`
+
+## Install for development
+
+```bash
+python -m pip install -e '.[dev]'
+python -m pytest -q
+assayflux --version
+assayflux info
+assayflux engines
+assayflux doctor
+```
+
+## Quick start
+
+```bash
+assayflux new ResearchSite --target website --target backend --feature offline_database
+cd ResearchSite
+assayflux plan
+assayflux test
+assayflux build
+assayflux run --target backend
+```
+
+Open `http://127.0.0.1:8080/api/health` for the generated local backend while it is running. The starter backend binds to loopback only. The website can be served using `assayflux run --target website` and then opened at `http://127.0.0.1:8000`.
+
+## Supported targets
+
+`website`, `html`, `css`, `backend`, `cli`, `python`, `c`, `cpp`, `javascript`, `java`, `kotlin`, `php`, `bash`, `android`.
+
+```bash
+assayflux new NativeDemo --target android
+cd NativeDemo
+assayflux build --android-artifacts apk    # debug APK
+assayflux build --android-artifacts aab    # release AAB
+assayflux build --android-artifacts both   # both outputs
+```
+
+APK and AAB are separate build tasks and can be requested independently. Android build failures or missing tools are recorded honestly in `BUILD_REPORT.json`; a source delivery is not described as a successful Android build when binaries are missing. Read [docs/GOOGLE_COLAB_ANDROID.md](docs/GOOGLE_COLAB_ANDROID.md) to test builds in Google Colab.
+
+## Delivery structure
+
+```text
+workspace/
+  ResearchSite/                   # Editable project
+    .assayflux/project.json
+    .assayflux/plan.json
+    web/                          # if website target selected
+    backend_app.py                # if backend target selected
+    tests/
+  deliverables/ResearchSite/
+    source/                       # Source snapshot
+    artifacts/                    # Produced APK/AAB or other build artifacts
+    logs/                         # Android build stdout/stderr
+    BUILD_REPORT.json             # Machine-readable status
+    DELIVERY_README.md
+```
+
+`assayflux build` will not overwrite an existing delivery folder unless `--force` is explicitly passed. `--force` only replaces the delivery folder, not the editable source workspace.
+
+## Commands
+
+- `assayflux info`, `assayflux --version`
+- `assayflux engines` — engine capabilities/tool detection
+- `assayflux doctor [--json]` — toolchain diagnostics
+- `assayflux new NAME [--root DIR] [--target TARGET] [--feature FEATURE]`
+- `assayflux plan [PROJECT_DIR]`
+- `assayflux test [PROJECT_DIR]`
+- `assayflux build [PROJECT_DIR] [--force] [--android-artifacts apk|aab|both|none]`
+- `assayflux run --project-dir DIR --target TARGET`
+
+## Python API
+
+```python
+from assayflux import Project
+
+project = Project.create("ResearchPortal", root=".", targets=["website", "backend"], features=["offline_database", "data_analysis"])
+project.generate()
+result = project.build()
+print(result.delivery_dir)
+```
+
+## Security and limitations
+
+- Build/test/run commands can execute generated or project-local code. Do not run untrusted projects; this is not a sandbox.
+- Generated backend starter code is a minimal example, not a hardened internet-facing API. Keep it on loopback unless you add authentication, TLS, rate limits, and deployment hardening.
+- Android release AAB signing is not configured automatically. Configure signing secrets securely and test on devices before store release.
+- Non-Android `build` currently snapshots source and reports packaging; it does not claim to compile every language target. Use `run` and that target's toolchain to compile/run supported examples.
+- The normalized PyPI endpoint for `assayflux` returned not-found during the preparation check, but PyPI name availability must still be confirmed while creating the project under your own account. Also, this package uses the Python import namespace `assayflux`; do not install it in the same environment as your older, separate AssayFlux interpreter package if that package also uses the same import namespace. Configure a Trusted Publisher or API token. A ZIP/build check cannot publish the package for you.
+
+## Release build
+
+```bash
+python -m pip install --upgrade build twine
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+For GitHub Actions publishing, configure PyPI Trusted Publishing for the repository and workflow `.github/workflows/publish.yml`, then create a GitHub Release matching the version in `pyproject.toml`.
+
+## Google Colab release workflow
+
+Use `AssayFlux_Colab_Full_Test_then_PyPI.ipynb` to test the source, build fresh distributions, validate the wheel and source archive, test the built wheel in isolation, and only then optionally publish to real PyPI. This workflow skips TestPyPI and requires an explicit production-publish confirmation.

assayflux-0.4.0/README.md

@@ -0,0 +1,114 @@
+# AssayFlux
+
+**AssayFlux is a Python-based multi-language project generator and build orchestrator.** It creates starter workspaces, plans tasks, detects local toolchains, runs supported project targets, packages source into a separate delivery folder, and can orchestrate Android debug APK and release AAB builds when a compatible toolchain is configured.
+
+AssayFlux is a project toolkit, not a new programming language and not a transpiler: it does not translate arbitrary source code between languages.
+
+## Requirements
+
+- Python 3.10 or newer
+- Optional per-target toolchains: Node.js, C/C++ compiler, JDK, Kotlin compiler, PHP, Bash
+- Android builds: JDK 17, Gradle 8.9 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`
+
+## Install for development
+
+```bash
+python -m pip install -e '.[dev]'
+python -m pytest -q
+assayflux --version
+assayflux info
+assayflux engines
+assayflux doctor
+```
+
+## Quick start
+
+```bash
+assayflux new ResearchSite --target website --target backend --feature offline_database
+cd ResearchSite
+assayflux plan
+assayflux test
+assayflux build
+assayflux run --target backend
+```
+
+Open `http://127.0.0.1:8080/api/health` for the generated local backend while it is running. The starter backend binds to loopback only. The website can be served using `assayflux run --target website` and then opened at `http://127.0.0.1:8000`.
+
+## Supported targets
+
+`website`, `html`, `css`, `backend`, `cli`, `python`, `c`, `cpp`, `javascript`, `java`, `kotlin`, `php`, `bash`, `android`.
+
+```bash
+assayflux new NativeDemo --target android
+cd NativeDemo
+assayflux build --android-artifacts apk    # debug APK
+assayflux build --android-artifacts aab    # release AAB
+assayflux build --android-artifacts both   # both outputs
+```
+
+APK and AAB are separate build tasks and can be requested independently. Android build failures or missing tools are recorded honestly in `BUILD_REPORT.json`; a source delivery is not described as a successful Android build when binaries are missing. Read [docs/GOOGLE_COLAB_ANDROID.md](docs/GOOGLE_COLAB_ANDROID.md) to test builds in Google Colab.
+
+## Delivery structure
+
+```text
+workspace/
+  ResearchSite/                   # Editable project
+    .assayflux/project.json
+    .assayflux/plan.json
+    web/                          # if website target selected
+    backend_app.py                # if backend target selected
+    tests/
+  deliverables/ResearchSite/
+    source/                       # Source snapshot
+    artifacts/                    # Produced APK/AAB or other build artifacts
+    logs/                         # Android build stdout/stderr
+    BUILD_REPORT.json             # Machine-readable status
+    DELIVERY_README.md
+```
+
+`assayflux build` will not overwrite an existing delivery folder unless `--force` is explicitly passed. `--force` only replaces the delivery folder, not the editable source workspace.
+
+## Commands
+
+- `assayflux info`, `assayflux --version`
+- `assayflux engines` — engine capabilities/tool detection
+- `assayflux doctor [--json]` — toolchain diagnostics
+- `assayflux new NAME [--root DIR] [--target TARGET] [--feature FEATURE]`
+- `assayflux plan [PROJECT_DIR]`
+- `assayflux test [PROJECT_DIR]`
+- `assayflux build [PROJECT_DIR] [--force] [--android-artifacts apk|aab|both|none]`
+- `assayflux run --project-dir DIR --target TARGET`
+
+## Python API
+
+```python
+from assayflux import Project
+
+project = Project.create("ResearchPortal", root=".", targets=["website", "backend"], features=["offline_database", "data_analysis"])
+project.generate()
+result = project.build()
+print(result.delivery_dir)
+```
+
+## Security and limitations
+
+- Build/test/run commands can execute generated or project-local code. Do not run untrusted projects; this is not a sandbox.
+- Generated backend starter code is a minimal example, not a hardened internet-facing API. Keep it on loopback unless you add authentication, TLS, rate limits, and deployment hardening.
+- Android release AAB signing is not configured automatically. Configure signing secrets securely and test on devices before store release.
+- Non-Android `build` currently snapshots source and reports packaging; it does not claim to compile every language target. Use `run` and that target's toolchain to compile/run supported examples.
+- The normalized PyPI endpoint for `assayflux` returned not-found during the preparation check, but PyPI name availability must still be confirmed while creating the project under your own account. Also, this package uses the Python import namespace `assayflux`; do not install it in the same environment as your older, separate AssayFlux interpreter package if that package also uses the same import namespace. Configure a Trusted Publisher or API token. A ZIP/build check cannot publish the package for you.
+
+## Release build
+
+```bash
+python -m pip install --upgrade build twine
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+For GitHub Actions publishing, configure PyPI Trusted Publishing for the repository and workflow `.github/workflows/publish.yml`, then create a GitHub Release matching the version in `pyproject.toml`.
+
+## Google Colab release workflow
+
+Use `AssayFlux_Colab_Full_Test_then_PyPI.ipynb` to test the source, build fresh distributions, validate the wheel and source archive, test the built wheel in isolation, and only then optionally publish to real PyPI. This workflow skips TestPyPI and requires an explicit production-publish confirmation.

assayflux-0.4.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "assayflux"
+version = "0.4.0"
+description = "Python-driven multi-language project generation, testing, and build orchestration"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "AssayFlux contributors"}]
+keywords = ["build-tool", "project-generator", "android", "apk", "aab", "multi-language"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Build Tools",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "build>=1.2", "twine>=5.1"]
+
+[project.scripts]
+assayflux = "assayflux.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+addopts = "-ra"

assayflux-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

assayflux-0.4.0/src/assayflux/__init__.py

@@ -0,0 +1,5 @@
+"""AssayFlux: multi-language project generation and build orchestration."""
+from .errors import AssayFluxError, BuildError, ProjectNameError, ProjectPathError
+from .project import Project, VALID_TARGETS
+__version__ = "0.4.0"
+__all__ = ["Project", "VALID_TARGETS", "AssayFluxError", "BuildError", "ProjectNameError", "ProjectPathError", "__version__"]

assayflux-0.4.0/src/assayflux/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+raise SystemExit(main())

assayflux-0.4.0/src/assayflux/builder.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+import json, os, shutil, subprocess, sys, time
+from pathlib import Path
+from .errors import BuildError, ProjectPathError
+from . import __version__
+
+def find_project(path):
+    path = Path(path).expanduser().resolve()
+    if (path / ".assayflux" / "project.json").is_file(): return path
+    raise BuildError(f"{path} is not an AssayFlux project (missing .assayflux/project.json).")
+
+def load_metadata(path):
+    project_dir = find_project(path)
+    try: data = json.loads((project_dir / ".assayflux/project.json").read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc: raise BuildError(f"Cannot read project metadata: {exc}") from exc
+    if not isinstance(data, dict) or not isinstance(data.get("name"), str): raise BuildError("Project metadata is malformed.")
+    return data
+
+def _android_toolchain(source):
+    wrapper = source / ("gradlew.bat" if os.name == "nt" else "gradlew")
+    gradle = str(wrapper) if wrapper.is_file() else shutil.which("gradle")
+    sdk = os.environ.get("ANDROID_HOME") or os.environ.get("ANDROID_SDK_ROOT")
+    java = shutil.which("java")
+    missing = []
+    if not gradle: missing.append("Gradle executable or Gradle wrapper")
+    if not java: missing.append("Java runtime (JDK 17 recommended for Android Gradle Plugin 8.7.3)")
+    if not sdk or not Path(sdk).expanduser().is_dir(): missing.append("Android SDK configured through ANDROID_HOME or ANDROID_SDK_ROOT")
+    if missing: return None, "Missing Android build requirements: " + "; ".join(missing) + ". See docs/GOOGLE_COLAB_ANDROID.md."
+    return gradle, None
+
+def build_project(project, force=False, android_artifacts="both"):
+    if android_artifacts not in {"apk", "aab", "both", "none"}: raise BuildError("android_artifacts must be apk, aab, both, or none")
+    source = find_project(project.directory)
+    delivery = project.delivery_directory
+    expected_parent = project.root / "deliverables"
+    if delivery.parent != expected_parent or delivery == source: raise ProjectPathError("Unsafe delivery path refused.")
+    if delivery.exists() or delivery.is_symlink():
+        if not force: raise ProjectPathError(f"Delivery folder exists: {delivery}. Use --force to replace it.")
+        if delivery.is_symlink() or not delivery.is_dir(): raise ProjectPathError("Refusing to replace a non-directory or symlink delivery path.")
+        shutil.rmtree(delivery)
+    delivery.mkdir(parents=True)
+    snapshot = delivery / "source" / project.name
+    snapshot.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, snapshot, ignore=shutil.ignore_patterns("__pycache__", ".pytest_cache", "*.pyc", "data.sqlite3", "build", ".gradle", ".venv", "venv"))
+    artifacts = delivery / "artifacts"; artifacts.mkdir()
+    logs = delivery / "logs"; logs.mkdir()
+    android = {"status": "not_requested", "requested": android_artifacts, "apk": [], "aab": [], "message": "Android target not selected."}
+    if "android" in project.targets and android_artifacts != "none":
+        gradle, reason = _android_toolchain(source)
+        if reason:
+            android = {"status": "blocked", "requested": android_artifacts, "apk": [], "aab": [], "message": reason}
+        else:
+            tasks = []
+            if android_artifacts in ("apk", "both"): tasks.append(":app:assembleDebug")
+            if android_artifacts in ("aab", "both"): tasks.append(":app:bundleRelease")
+            cmd = [gradle, "--no-daemon", *tasks]
+            try:
+                result = subprocess.run(cmd, cwd=source, capture_output=True, text=True, timeout=1800, check=False)
+                (logs / "android-build.stdout.log").write_text(result.stdout or "", encoding="utf-8")
+                (logs / "android-build.stderr.log").write_text(result.stderr or "", encoding="utf-8")
+                apk_paths = sorted((source / "app/build/outputs/apk").rglob("*.apk")) if (source / "app/build/outputs/apk").exists() and android_artifacts in ("apk", "both") else []
+                aab_paths = sorted((source / "app/build/outputs/bundle").rglob("*.aab")) if (source / "app/build/outputs/bundle").exists() and android_artifacts in ("aab", "both") else []
+                copied_apk, copied_aab = [], []
+                for paths, target in ((apk_paths, copied_apk), (aab_paths, copied_aab)):
+                    for i, item in enumerate(paths):
+                        filename = item.name if not (artifacts / item.name).exists() else f"{item.stem}-{i+1}{item.suffix}"
+                        shutil.copy2(item, artifacts / filename); target.append(filename)
+                expected = bool(copied_apk) if android_artifacts == "apk" else bool(copied_aab) if android_artifacts == "aab" else bool(copied_apk) and bool(copied_aab)
+                okay = result.returncode == 0 and expected
+                android = {"status": "built" if okay else "failed", "requested": android_artifacts, "command": cmd, "returncode": result.returncode,
+                           "apk": copied_apk, "aab": copied_aab, "stdout_tail": (result.stdout or "")[-4000:], "stderr_tail": (result.stderr or "")[-4000:],
+                           "message": "Requested artifact checks passed." if okay else "Build command failed or requested artifacts were not produced. Review logs/."}
+            except subprocess.TimeoutExpired as exc:
+                android = {"status": "failed", "requested": android_artifacts, "apk": [], "aab": [], "message": "Android build timed out after 30 minutes.", "stdout_tail": str(exc.stdout or "")[-4000:], "stderr_tail": str(exc.stderr or "")[-4000:]}
+            except OSError as exc:
+                android = {"status": "failed", "requested": android_artifacts, "apk": [], "aab": [], "message": f"Could not start Android build: {exc}"}
+    elif "android" in project.targets:
+        android = {"status": "skipped", "requested": android_artifacts, "apk": [], "aab": [], "message": "Android build explicitly skipped."}
+    report = {"schema_version": 1, "product": "AssayFlux", "version": __version__, "project": project.name,
+              "created_at_epoch": int(time.time()), "source_directory": str(source), "delivery_directory": str(delivery),
+              "targets": project.targets, "status": "source_packaged", "checks": {"metadata": True, "source_snapshot": True},
+              "android_build": android, "limitations": ["Non-Android targets are packaged as source; use the corresponding run command or language-specific toolchain to compile/test them.",
+              "Release AAB signing is not configured automatically. Review app identity, permissions, privacy policy, and store requirements before release."]}
+    if android["status"] in ("failed", "blocked"): report["status"] = "partial"
+    (delivery / "BUILD_REPORT.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
+    (delivery / "DELIVERY_README.md").write_text(f"# {project.name} delivery\n\n`source/{project.name}/` is the source snapshot. `artifacts/` contains produced binaries. `logs/` contains build logs. Check `BUILD_REPORT.json`; a `partial` status means requested Android build did not complete.\n", encoding="utf-8")
+    return type("BuildResult", (), {"delivery_dir": delivery, "report": report, "success": report["status"] == "source_packaged"})()
+
+def run_tests(project_dir):
+    project_dir = find_project(project_dir); tests = project_dir / "tests"
+    if not tests.is_dir(): return {"status": "no_tests", "returncode": 0, "stdout": "No tests directory.", "stderr": ""}
+    try: result = subprocess.run([sys.executable, "-m", "pytest", "-q", str(tests)], cwd=project_dir, capture_output=True, text=True, timeout=180, check=False)
+    except (OSError, subprocess.TimeoutExpired) as exc: return {"status": "failed", "returncode": 1, "stdout": "", "stderr": str(exc)}
+    return {"status": "passed" if result.returncode == 0 else "failed", "returncode": result.returncode, "stdout": result.stdout, "stderr": result.stderr}
+
+def run_target(project_dir, target):
+    project_dir = find_project(project_dir)
+    commands = {"backend": [sys.executable, "backend_app.py"], "python": [sys.executable, "app.py"], "cli": [sys.executable, "app.py"], "javascript": ["node", "src/main.js"], "php": ["php", "src/main.php"], "bash": ["bash", "src/main.sh"]}
+    if target in ("website", "html"):
+        web = project_dir / "web"
+        if not web.is_dir(): raise BuildError("No web/ folder in this project.")
+        return subprocess.Popen([sys.executable, "-m", "http.server", "8000", "--directory", str(web)], cwd=project_dir)
+    if target in ("c", "cpp"):
+        compiler = shutil.which("clang" if target == "c" else "clang++") or shutil.which("gcc" if target == "c" else "g++")
+        if not compiler: raise BuildError(f"No {target.upper()} compiler found; install clang or gcc/g++.")
+        source = project_dir / ("src/main.c" if target == "c" else "src/main.cpp")
+        if not source.is_file(): raise BuildError(f"Expected source file missing: {source}")
+        binary = project_dir / "build" / ("main.exe" if os.name == "nt" else "main"); binary.parent.mkdir(parents=True, exist_ok=True)
+        result = subprocess.run([compiler, str(source), "-o", str(binary)], cwd=project_dir, capture_output=True, text=True, timeout=120, check=False)
+        if result.returncode: raise BuildError(result.stderr or "Compilation failed.")
+        return subprocess.run([str(binary)], cwd=project_dir, capture_output=True, text=True, timeout=30, check=False)
+    if target == "java":
+        javac, java = shutil.which("javac"), shutil.which("java")
+        if not javac or not java: raise BuildError("JDK not found; install a compatible JDK.")
+        source=project_dir/"src/Main.java"; out=project_dir/"build/java"; out.mkdir(parents=True,exist_ok=True)
+        result=subprocess.run([javac,"-d",str(out),str(source)],cwd=project_dir,capture_output=True,text=True,timeout=120,check=False)
+        if result.returncode: raise BuildError(result.stderr or "Java compilation failed.")
+        return subprocess.run([java,"-cp",str(out),"Main"],cwd=project_dir,capture_output=True,text=True,timeout=30,check=False)
+    if target == "kotlin":
+        compiler, java=shutil.which("kotlinc"),shutil.which("java")
+        if not compiler or not java: raise BuildError("Kotlin compiler and Java runtime are required.")
+        out=project_dir/"build/main.jar"; out.parent.mkdir(parents=True,exist_ok=True)
+        result=subprocess.run([compiler,str(project_dir/"src/main.kt"),"-include-runtime","-d",str(out)],cwd=project_dir,capture_output=True,text=True,timeout=180,check=False)
+        if result.returncode: raise BuildError(result.stderr or "Kotlin compilation failed.")
+        return subprocess.run([java,"-jar",str(out)],cwd=project_dir,capture_output=True,text=True,timeout=30,check=False)
+    if target == "android": raise BuildError("Android is built with `assayflux build --android-artifacts apk|aab|both`, not `run`.")
+    if target not in commands: raise BuildError(f"Run target {target!r} is not supported.")
+    exe=shutil.which(commands[target][0])
+    if not exe: raise BuildError(f"Required tool {commands[target][0]!r} is not installed.")
+    path = project_dir / commands[target][1] if len(commands[target]) > 1 else None
+    if path is not None and not path.is_file(): raise BuildError(f"Expected source file missing: {path}")
+    return subprocess.run([exe,*commands[target][1:]],cwd=project_dir,capture_output=True,text=True,timeout=120,check=False)

assayflux-0.4.0/src/assayflux/cli.py

@@ -0,0 +1,67 @@
+import argparse, json, sys
+from . import __version__, VALID_TARGETS
+from .project import Project
+from .errors import AssayFluxError
+from .generator import generate_project
+from .builder import find_project, load_metadata, build_project, run_tests, run_target
+from .planner import create_plan
+from .relay import Relay
+from .doctor import diagnostics
+
+def project_from_dir(path):
+    directory = find_project(path); meta = load_metadata(directory)
+    return Project.create(meta["name"], root=directory.parent, targets=meta.get("targets", ["website"]), features=meta.get("features", []))
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="assayflux", description="AssayFlux multi-language project toolkit")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subs = parser.add_subparsers(dest="command", required=True)
+    subs.add_parser("info", help="Show product and version information")
+    subs.add_parser("engines", help="List engines and tool availability")
+    doctor = subs.add_parser("doctor", help="Check local tools"); doctor.add_argument("--json", action="store_true", dest="as_json")
+    new = subs.add_parser("new", help="Generate a project workspace"); new.add_argument("name"); new.add_argument("--root", default=".")
+    new.add_argument("--target", action="append", choices=sorted(VALID_TARGETS)); new.add_argument("--feature", action="append", default=[])
+    for name in ("plan", "build", "test"):
+        cmd = subs.add_parser(name); cmd.add_argument("project_dir", nargs="?", default=".")
+        if name == "build":
+            cmd.add_argument("--force", action="store_true", help="Replace existing delivery folder")
+            cmd.add_argument("--android-artifacts", choices=("apk", "aab", "both", "none"), default="both", help="Choose Android outputs")
+    run = subs.add_parser("run", help="Run a generated project target"); run.add_argument("--project-dir", default=".")
+    run.add_argument("--target", required=True, choices=sorted(VALID_TARGETS - {"css"}))
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "info": print(f"AssayFlux {__version__}\nPython-driven multi-language project generation, testing, and build orchestration.")
+        elif args.command == "engines": print(json.dumps(Relay().engines_report(), indent=2))
+        elif args.command == "doctor":
+            rows = diagnostics()
+            if args.as_json: print(json.dumps(rows, indent=2))
+            else:
+                for row in rows: print(f"{'OK' if row['available'] else '--'}  {row['tool']}: {row['path']}")
+        elif args.command == "new":
+            project = Project.create(args.name, root=args.root, targets=args.target or ["website"], features=args.feature)
+            print(f"Created project: {generate_project(project)}"); print(f"Delivery folder: {project.delivery_directory}")
+        elif args.command == "plan": print(json.dumps(create_plan(project_from_dir(args.project_dir)), indent=2))
+        elif args.command == "build":
+            result = build_project(project_from_dir(args.project_dir), force=args.force, android_artifacts=args.android_artifacts)
+            print(f"Delivery package: {result.delivery_dir}"); print(f"Report: {result.delivery_dir/'BUILD_REPORT.json'}"); print(f"Build status: {result.report['status']}")
+            if not result.success: print("Warning: requested build did not fully succeed; inspect BUILD_REPORT.json and logs/.", file=sys.stderr); return 1
+        elif args.command == "test":
+            result = run_tests(args.project_dir)
+            if result["stdout"]: print(result["stdout"], end="")
+            if result["stderr"]: print(result["stderr"], file=sys.stderr, end="")
+            print(f"Test status: {result['status']}"); return result["returncode"]
+        elif args.command == "run":
+            result = run_target(args.project_dir, args.target)
+            if hasattr(result, "poll"):
+                print(f"Started {args.target}. Stop with Ctrl+C.")
+                try: result.wait()
+                except KeyboardInterrupt: result.terminate(); return 130
+            else:
+                if result.stdout: print(result.stdout, end="")
+                if result.stderr: print(result.stderr, file=sys.stderr, end="")
+                return result.returncode
+        return 0
+    except (AssayFluxError, OSError, ValueError, TimeoutError, json.JSONDecodeError) as exc:
+        print(f"assayflux: error: {exc}", file=sys.stderr); return 2
+
+if __name__ == "__main__": raise SystemExit(main())

assayflux-0.4.0/src/assayflux/doctor.py

@@ -0,0 +1,18 @@
+import os, shutil, sys
+from pathlib import Path
+
+TOOLS = {
+    "C compiler": ("clang", "gcc"), "C++ compiler": ("clang++", "g++"),
+    "Node.js": ("node", "nodejs"), "Java compiler": ("javac",), "Java runtime": ("java",),
+    "Kotlin compiler": ("kotlinc",), "PHP": ("php",), "Bash": ("bash",), "Gradle": ("gradle",),
+    "Android SDK manager": ("sdkmanager",),
+}
+def diagnostics():
+    rows = [{"tool": "Python", "path": sys.executable, "available": True}]
+    for label, names in TOOLS.items():
+        path = next((shutil.which(n) for n in names if shutil.which(n)), None)
+        rows.append({"tool": label, "path": path or "not found", "available": bool(path)})
+    sdk = os.environ.get("ANDROID_HOME") or os.environ.get("ANDROID_SDK_ROOT")
+    sdk_path = Path(sdk).expanduser() if sdk else None
+    rows.append({"tool": "Android SDK", "path": str(sdk_path) if sdk_path and sdk_path.is_dir() else "ANDROID_HOME/ANDROID_SDK_ROOT not configured or path missing", "available": bool(sdk_path and sdk_path.is_dir())})
+    return rows

assayflux-0.4.0/src/assayflux/engines/__init__.py

@@ -0,0 +1,17 @@
+from .base import Engine
+
+ENGINE_REGISTRY = {
+    "python": Engine("python", "Python", "Generate and run Python", ("python", "python3")),
+    "c": Engine("c", "C", "Compile C sources", ("clang", "gcc")),
+    "cpp": Engine("cpp", "C++", "Compile C++ sources", ("clang++", "g++")),
+    "html": Engine("html", "HTML", "Generate static website files"),
+    "css": Engine("css", "CSS", "Generate stylesheets"),
+    "javascript": Engine("javascript", "JavaScript", "Generate/run JavaScript", ("node", "nodejs")),
+    "java": Engine("java", "Java", "Compile/run Java", ("javac", "java")),
+    "kotlin": Engine("kotlin", "Kotlin", "Compile/run Kotlin", ("kotlinc", "java")),
+    "php": Engine("php", "PHP", "Run PHP scripts", ("php",)),
+    "bash": Engine("bash", "Bash", "Run shell scripts", ("bash",)),
+    "android": Engine("android", "Android", "Generate Android project and orchestrate builds", ("gradle",)),
+    "android-apk": Engine("android-apk", "Android APK", "Build Android debug APK", ("gradle",)),
+    "android-aab": Engine("android-aab", "Android App Bundle", "Build Android release AAB", ("gradle",)),
+}

assayflux-0.4.0/src/assayflux/engines/base.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+import shutil
+import subprocess
+
+@dataclass(frozen=True)
+class Engine:
+    name: str
+    language: str
+    purpose: str
+    tools: tuple = ()
+
+    def executable(self):
+        for name in self.tools:
+            found = shutil.which(name)
+            if found:
+                return found
+        return None
+
+    def describe(self):
+        exe = self.executable()
+        return {"name": self.name, "language": self.language, "purpose": self.purpose,
+                "tools": list(self.tools), "available": bool(exe) if self.tools else True,
+                "executable": exe}
+
+    def run(self, args, cwd, timeout=30):
+        return subprocess.run(args, cwd=cwd, capture_output=True, text=True, timeout=timeout, check=False)

assayflux-0.4.0/src/assayflux/errors.py

@@ -0,0 +1,11 @@
+class AssayFluxError(Exception):
+    """Base error."""
+
+class ProjectNameError(AssayFluxError):
+    """Invalid project name."""
+
+class ProjectPathError(AssayFluxError):
+    """Invalid project path or destination."""
+
+class BuildError(AssayFluxError):
+    """Build/test/run operation failed."""

assayflux-0.4.0/src/assayflux/generator.py

@@ -0,0 +1,173 @@
+import json
+import re
+import shutil
+from pathlib import Path
+from .errors import ProjectPathError
+from .planner import create_plan
+
+def write_file(root, relative, content):
+    path = root / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content.strip() + "\n", encoding="utf-8")
+
+def generate_project(project):
+    dest = project.directory
+    if dest.exists():
+        raise ProjectPathError(f"Project already exists: {dest}. Choose another name or move it.")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.mkdir()
+    try:
+        meta = {"schema_version": 1, "product": "AssayFlux", **project.describe(), "status": "generated"}
+        write_file(dest, ".assayflux/project.json", json.dumps(meta, indent=2))
+        write_file(dest, ".assayflux/plan.json", json.dumps(create_plan(project), indent=2))
+        write_file(dest, ".gitignore", "__pycache__/\n*.py[cod]\n.env\n.venv/\ndata.sqlite3\nbuild/\n.gradle/\n")
+        write_file(dest, "README.md", f"""# {project.name}
+
+Generated by AssayFlux.
+
+Targets: {', '.join(project.targets)}
+Features: {', '.join(project.features) or 'None specified'}
+
+Run `assayflux plan`, `assayflux build`, and `assayflux test` from this directory.
+Build output is saved separately under `../deliverables/{project.name}/`.
+""")
+        if "website" in project.targets or "html" in project.targets:
+            write_file(dest, "web/index.html", f"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{project.name}</title><link rel="stylesheet" href="style.css"></head>
+<body><main class="card"><p class="brand">ASSAYFLUX</p><h1>{project.name}</h1>
+<p>Your project workspace has been generated successfully.</p><button id="check">Test interface</button>
+<p id="status" role="status">Ready.</p></main><script src="app.js"></script></body></html>""")
+            write_file(dest, "web/style.css", """
+:root{font-family:system-ui,sans-serif;color:#172033;background:#f2f5fa}
+*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;place-items:center;padding:1rem}
+.card{width:min(100%,42rem);padding:clamp(1.5rem,5vw,3rem);background:#fff;border-radius:1.25rem;box-shadow:0 1rem 3rem #14243a18}
+.brand{font-size:.75rem;letter-spacing:.13em;font-weight:700;color:#315da8}
+h1{font-size:clamp(2rem,8vw,4rem);margin:.5rem 0}button{border:0;border-radius:.7rem;padding:.8rem 1rem;background:#234c9a;color:#fff;font:inherit}
+""")
+            write_file(dest, "web/app.js", """
+document.querySelector("#check")?.addEventListener("click",()=>{
+  document.querySelector("#status").textContent="Interface test passed.";
+});
+""")
+        if "css" in project.targets:
+            write_file(dest, "src/style.css", ":root{font-family:system-ui,sans-serif;color:#172033;background:#f2f5fa}\n*{box-sizing:border-box}\n")
+        if "backend" in project.targets:
+            write_file(dest, "backend_app.py", """
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+import json, sqlite3
+
+DB = Path(__file__).with_name("data.sqlite3")
+def init_db():
+    with sqlite3.connect(DB) as con:
+        con.execute("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT NOT NULL, created_at TEXT DEFAULT CURRENT_TIMESTAMP)")
+class Handler(BaseHTTPRequestHandler):
+    def send_json(self, status, data):
+        body=json.dumps(data).encode()
+        self.send_response(status); self.send_header("Content-Type","application/json; charset=utf-8")
+        self.send_header("Content-Length",str(len(body))); self.end_headers(); self.wfile.write(body)
+    def do_GET(self):
+        if self.path == "/api/health":
+            self.send_json(200, {"ok":True,"service":"AssayFlux starter backend"})
+        elif self.path == "/api/notes":
+            with sqlite3.connect(DB) as con:
+                rows=con.execute("SELECT id,text,created_at FROM notes ORDER BY id DESC").fetchall()
+            self.send_json(200, {"items":[{"id":r[0],"text":r[1],"created_at":r[2]} for r in rows]})
+        else: self.send_json(404, {"error":"not_found"})
+    def do_POST(self):
+        if self.path != "/api/notes":
+            self.send_json(404, {"error":"not_found"}); return
+        try:
+            size=int(self.headers.get("Content-Length","0"))
+            if size < 1 or size > 65536: raise ValueError("invalid body size")
+            data=json.loads(self.rfile.read(size))
+            text=data.get("text") if isinstance(data,dict) else None
+            if not isinstance(text,str) or not text.strip() or len(text)>2000: raise ValueError("text must be 1-2000 characters")
+            with sqlite3.connect(DB) as con:
+                cur=con.execute("INSERT INTO notes(text) VALUES (?)",(text.strip(),))
+                record_id=cur.lastrowid
+            self.send_json(201, {"id":record_id,"text":text.strip()})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json(400, {"error":str(exc)})
+    def log_message(self, fmt, *args): print("%s - %s"%(self.address_string(),fmt%args))
+if __name__=="__main__":
+    init_db(); server=ThreadingHTTPServer(("127.0.0.1",8080),Handler)
+    print("Backend running at http://127.0.0.1:8080/api/health")
+    try: server.serve_forever()
+    except KeyboardInterrupt: pass
+    finally: server.server_close()
+""")
+        if "cli" in project.targets or "python" in project.targets:
+            write_file(dest, "app.py", """
+def main():
+    print("Application initialized successfully.")
+if __name__ == "__main__":
+    main()
+""")
+        if "c" in project.targets:
+            write_file(dest, "src/main.c", '#include <stdio.h>\nint main(void) { puts("Hello from C"); return 0; }')
+        if "cpp" in project.targets:
+            write_file(dest, "src/main.cpp", '#include <iostream>\nint main() { std::cout << "Hello from C++\\n"; return 0; }')
+        if "javascript" in project.targets:
+            write_file(dest, "src/main.js", 'console.log("Hello from JavaScript");')
+        if "java" in project.targets:
+            write_file(dest, "src/Main.java", 'public class Main { public static void main(String[] args) { System.out.println("Hello from Java"); } }')
+        if "kotlin" in project.targets:
+            write_file(dest, "src/main.kt", 'fun main() { println("Hello from Kotlin") }')
+        if "php" in project.targets:
+            write_file(dest, "src/main.php", '<?php echo "Hello from PHP" . PHP_EOL;')
+        if "bash" in project.targets:
+            write_file(dest, "src/main.sh", '#!/usr/bin/env bash\nset -euo pipefail\necho "Hello from Bash"')
+        if "android" in project.targets:
+            package_suffix = re.sub(r"[^a-z0-9]", "", project.name.lower())
+            package_id = "org.assayflux." + (package_suffix or "app")
+            write_file(dest, "settings.gradle.kts", f'''pluginManagement {{ repositories {{ google(); mavenCentral(); gradlePluginPortal() }} }}
+dependencyResolutionManagement {{ repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS); repositories {{ google(); mavenCentral() }} }}
+rootProject.name = "{project.name}"
+include(":app")''')
+            write_file(dest, "build.gradle.kts", 'plugins { id("com.android.application") version "8.7.3" apply false }')
+            write_file(dest, "gradle.properties", "org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8\nandroid.useAndroidX=true\n")
+            write_file(dest, "app/build.gradle.kts", f'''plugins {{ id("com.android.application") }}
+
+android {{
+    namespace = "{package_id}"
+    compileSdk = 35
+    defaultConfig {{ applicationId = "{package_id}"; minSdk = 23; targetSdk = 35; versionCode = 1; versionName = "1.0.0" }}
+    buildTypes {{ release {{ isMinifyEnabled = false }} }}
+}}
+
+// Release signing can be configured here using environment-backed credentials.''')
+            write_file(dest, "app/src/main/AndroidManifest.xml", f'''<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"><application android:label="{project.name}" android:theme="@android:style/Theme.Material.Light.NoActionBar" android:allowBackup="false" android:supportsRtl="true"><activity android:name="{package_id}.MainActivity" android:exported="true"><intent-filter><action android:name="android.intent.action.MAIN"/><category android:name="android.intent.category.LAUNCHER"/></intent-filter></activity></application></manifest>''')
+            write_file(dest, "app/src/main/java/" + package_id.replace(".", "/") + "/MainActivity.kt", f'''package {package_id}
+
+import android.app.Activity
+import android.os.Bundle
+import android.graphics.Color
+import android.view.Gravity
+import android.widget.TextView
+import android.widget.LinearLayout
+
+class MainActivity : Activity() {{
+    override fun onCreate(savedInstanceState: Bundle?) {{
+        super.onCreate(savedInstanceState)
+        val layout = LinearLayout(this).apply {{ orientation = LinearLayout.VERTICAL; gravity = Gravity.CENTER; setPadding(32, 32, 32, 32); setBackgroundColor(Color.rgb(244,247,252)) }}
+        val title = TextView(this).apply {{ text = "{project.name}"; textSize = 30f; setTextColor(Color.rgb(25,45,80)); gravity = Gravity.CENTER }}
+        val detail = TextView(this).apply {{ text = "Built with AssayFlux"; textSize = 16f; gravity = Gravity.CENTER; setPadding(0,24,0,0) }}
+        layout.addView(title); layout.addView(detail); setContentView(layout)
+    }}
+}}''')
+            write_file(dest, "ANDROID_BUILD.md", """# Android build instructions\n\nThis target generates a native Android Gradle project. Building requires a compatible JDK, Android SDK (platform 35 and build-tools), and Gradle 8.9+ available on PATH.\n\n- Debug APK: `gradle --no-daemon :app:assembleDebug`\n- Release AAB: `gradle --no-daemon :app:bundleRelease`\n\nThe generated release bundle is not guaranteed to be signed. Configure release signing securely before publishing to Google Play. Test the output on a real device and verify application ID, permissions, privacy policy, and Play requirements.\n""")
+        write_file(dest, "tests/test_generated_project.py", """
+from pathlib import Path
+def test_metadata_present():
+    root=Path(__file__).parents[1]
+    assert (root/".assayflux"/"project.json").is_file()
+def test_readme_present():
+    assert (Path(__file__).parents[1]/"README.md").is_file()
+""")
+    except Exception:
+        shutil.rmtree(dest, ignore_errors=True)
+        raise
+    return dest

assayflux-0.4.0/src/assayflux/planner.py

@@ -0,0 +1,8 @@
+def create_plan(project):
+    tasks = [{"id": "validate_spec", "engine": "core", "depends_on": []},
+             {"id": "write_metadata", "engine": "core", "depends_on": ["validate_spec"]}]
+    for target in project.targets:
+        engine = {"website": "html", "backend": "python", "cli": "python"}.get(target, target)
+        tasks.append({"id": f"generate_{target}", "engine": engine, "depends_on": ["write_metadata"]})
+    tasks.append({"id": "package_delivery", "engine": "core", "depends_on": [t["id"] for t in tasks]})
+    return {"schema_version": 1, "project": project.name, "tasks": tasks}

assayflux-0.4.0/src/assayflux/project.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+import re
+from pathlib import Path
+from .errors import AssayFluxError, ProjectNameError
+
+VALID_TARGETS = {"website", "html", "css", "backend", "cli", "python", "c", "cpp", "javascript", "java", "kotlin", "php", "bash", "android"}
+
+def validate_name(name: str) -> str:
+    if not isinstance(name, str) or not re.fullmatch(r"[A-Za-z][A-Za-z0-9_-]{0,63}", name):
+        raise ProjectNameError("Name must start with a letter and contain only letters, digits, '_' or '-' (max 64 characters).")
+    return name
+
+class Project:
+    def __init__(self, name, root=".", targets=None, features=None):
+        self.name = validate_name(name)
+        self.root = Path(root).expanduser().resolve()
+        raw_targets = ["website"] if targets is None else list(targets)
+        if not raw_targets: raise AssayFluxError("Select at least one target.")
+        if any(not isinstance(t, str) for t in raw_targets): raise AssayFluxError("Targets must be strings.")
+        self.targets = list(dict.fromkeys(raw_targets))
+        self.features = list(dict.fromkeys(features or []))
+        unknown = set(self.targets) - VALID_TARGETS
+        if unknown: raise AssayFluxError("Unsupported target(s): " + ", ".join(sorted(unknown)))
+        if any(not isinstance(x, str) or not re.fullmatch(r"[A-Za-z0-9_.-]{1,64}", x) for x in self.features):
+            raise AssayFluxError("Features must be 1-64 characters using letters, digits, '.', '_' or '-'.")
+
+    @classmethod
+    def create(cls, name, root=".", targets=None, features=None): return cls(name, root, targets, features)
+    @property
+    def directory(self): return self.root / self.name
+    @property
+    def delivery_directory(self): return self.root / "deliverables" / self.name
+    def describe(self):
+        return {"name": self.name, "root": str(self.root), "directory": str(self.directory), "delivery_directory": str(self.delivery_directory), "targets": self.targets, "features": self.features}
+    def generate(self):
+        from .generator import generate_project
+        return generate_project(self)
+    def plan(self):
+        from .planner import create_plan
+        return create_plan(self)
+    def build(self, force=False, android_artifacts="both"):
+        from .builder import build_project
+        return build_project(self, force=force, android_artifacts=android_artifacts)

assayflux-0.4.0/src/assayflux/relay.py

@@ -0,0 +1,26 @@
+from .engines import ENGINE_REGISTRY
+from .errors import BuildError
+
+class Relay:
+    """Capability-aware task router. Actual build steps are dispatched by the builder."""
+    def __init__(self):
+        self.engines = ENGINE_REGISTRY
+
+    def engines_report(self):
+        return [engine.describe() for engine in self.engines.values()]
+
+    def route(self, task):
+        engine_name = task.get("engine")
+        if engine_name == "core":
+            return None
+        engine = self.engines.get(engine_name)
+        if engine is None:
+            raise BuildError(f"No engine registered for {engine_name!r}")
+        return engine
+
+    def dispatch(self, task, context):
+        engine = self.route(task)
+        if engine is None:
+            return {"task": task["id"], "status": "handled_by_core"}
+        return {"task": task["id"], "status": "routed", "engine": engine.name,
+                "available": engine.describe()["available"]}

assayflux-0.4.0/src/assayflux.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: assayflux
+Version: 0.4.0
+Summary: Python-driven multi-language project generation, testing, and build orchestration
+Author: AssayFlux contributors
+License-Expression: MIT
+Keywords: build-tool,project-generator,android,apk,aab,multi-language
+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
+
+**AssayFlux is a Python-based multi-language project generator and build orchestrator.** It creates starter workspaces, plans tasks, detects local toolchains, runs supported project targets, packages source into a separate delivery folder, and can orchestrate Android debug APK and release AAB builds when a compatible toolchain is configured.
+
+AssayFlux is a project toolkit, not a new programming language and not a transpiler: it does not translate arbitrary source code between languages.
+
+## Requirements
+
+- Python 3.10 or newer
+- Optional per-target toolchains: Node.js, C/C++ compiler, JDK, Kotlin compiler, PHP, Bash
+- Android builds: JDK 17, Gradle 8.9 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`
+
+## Install for development
+
+```bash
+python -m pip install -e '.[dev]'
+python -m pytest -q
+assayflux --version
+assayflux info
+assayflux engines
+assayflux doctor
+```
+
+## Quick start
+
+```bash
+assayflux new ResearchSite --target website --target backend --feature offline_database
+cd ResearchSite
+assayflux plan
+assayflux test
+assayflux build
+assayflux run --target backend
+```
+
+Open `http://127.0.0.1:8080/api/health` for the generated local backend while it is running. The starter backend binds to loopback only. The website can be served using `assayflux run --target website` and then opened at `http://127.0.0.1:8000`.
+
+## Supported targets
+
+`website`, `html`, `css`, `backend`, `cli`, `python`, `c`, `cpp`, `javascript`, `java`, `kotlin`, `php`, `bash`, `android`.
+
+```bash
+assayflux new NativeDemo --target android
+cd NativeDemo
+assayflux build --android-artifacts apk    # debug APK
+assayflux build --android-artifacts aab    # release AAB
+assayflux build --android-artifacts both   # both outputs
+```
+
+APK and AAB are separate build tasks and can be requested independently. Android build failures or missing tools are recorded honestly in `BUILD_REPORT.json`; a source delivery is not described as a successful Android build when binaries are missing. Read [docs/GOOGLE_COLAB_ANDROID.md](docs/GOOGLE_COLAB_ANDROID.md) to test builds in Google Colab.
+
+## Delivery structure
+
+```text
+workspace/
+  ResearchSite/                   # Editable project
+    .assayflux/project.json
+    .assayflux/plan.json
+    web/                          # if website target selected
+    backend_app.py                # if backend target selected
+    tests/
+  deliverables/ResearchSite/
+    source/                       # Source snapshot
+    artifacts/                    # Produced APK/AAB or other build artifacts
+    logs/                         # Android build stdout/stderr
+    BUILD_REPORT.json             # Machine-readable status
+    DELIVERY_README.md
+```
+
+`assayflux build` will not overwrite an existing delivery folder unless `--force` is explicitly passed. `--force` only replaces the delivery folder, not the editable source workspace.
+
+## Commands
+
+- `assayflux info`, `assayflux --version`
+- `assayflux engines` — engine capabilities/tool detection
+- `assayflux doctor [--json]` — toolchain diagnostics
+- `assayflux new NAME [--root DIR] [--target TARGET] [--feature FEATURE]`
+- `assayflux plan [PROJECT_DIR]`
+- `assayflux test [PROJECT_DIR]`
+- `assayflux build [PROJECT_DIR] [--force] [--android-artifacts apk|aab|both|none]`
+- `assayflux run --project-dir DIR --target TARGET`
+
+## Python API
+
+```python
+from assayflux import Project
+
+project = Project.create("ResearchPortal", root=".", targets=["website", "backend"], features=["offline_database", "data_analysis"])
+project.generate()
+result = project.build()
+print(result.delivery_dir)
+```
+
+## Security and limitations
+
+- Build/test/run commands can execute generated or project-local code. Do not run untrusted projects; this is not a sandbox.
+- Generated backend starter code is a minimal example, not a hardened internet-facing API. Keep it on loopback unless you add authentication, TLS, rate limits, and deployment hardening.
+- Android release AAB signing is not configured automatically. Configure signing secrets securely and test on devices before store release.
+- Non-Android `build` currently snapshots source and reports packaging; it does not claim to compile every language target. Use `run` and that target's toolchain to compile/run supported examples.
+- The normalized PyPI endpoint for `assayflux` returned not-found during the preparation check, but PyPI name availability must still be confirmed while creating the project under your own account. Also, this package uses the Python import namespace `assayflux`; do not install it in the same environment as your older, separate AssayFlux interpreter package if that package also uses the same import namespace. Configure a Trusted Publisher or API token. A ZIP/build check cannot publish the package for you.
+
+## Release build
+
+```bash
+python -m pip install --upgrade build twine
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+For GitHub Actions publishing, configure PyPI Trusted Publishing for the repository and workflow `.github/workflows/publish.yml`, then create a GitHub Release matching the version in `pyproject.toml`.
+
+## Google Colab release workflow
+
+Use `AssayFlux_Colab_Full_Test_then_PyPI.ipynb` to test the source, build fresh distributions, validate the wheel and source archive, test the built wheel in isolation, and only then optionally publish to real PyPI. This workflow skips TestPyPI and requires an explicit production-publish confirmation.

assayflux-0.4.0/src/assayflux.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/assayflux/__init__.py
+src/assayflux/__main__.py
+src/assayflux/builder.py
+src/assayflux/cli.py
+src/assayflux/doctor.py
+src/assayflux/errors.py
+src/assayflux/generator.py
+src/assayflux/planner.py
+src/assayflux/project.py
+src/assayflux/relay.py
+src/assayflux.egg-info/PKG-INFO
+src/assayflux.egg-info/SOURCES.txt
+src/assayflux.egg-info/dependency_links.txt
+src/assayflux.egg-info/entry_points.txt
+src/assayflux.egg-info/requires.txt
+src/assayflux.egg-info/top_level.txt
+src/assayflux/engines/__init__.py
+src/assayflux/engines/base.py
+tests/test_cli.py
+tests/test_project.py

assayflux-0.4.0/src/assayflux.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

assayflux-0.4.0/src/assayflux.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+assayflux = assayflux.cli:main

assayflux-0.4.0/src/assayflux.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=8.0
+build>=1.2
+twine>=5.1

assayflux-0.4.0/src/assayflux.egg-info/top_level.txt

@@ -0,0 +1 @@
+assayflux

assayflux-0.4.0/tests/test_cli.py

@@ -0,0 +1,18 @@
+import json
+from assayflux.cli import main
+
+def test_cli_info(capsys):
+    assert main(["info"]) == 0
+    assert "AssayFlux 0.4.0" in capsys.readouterr().out
+
+def test_cli_new_plan_build(tmp_path, capsys):
+    assert main(["new", "Demo", "--root", str(tmp_path), "--target", "website"]) == 0
+    assert main(["plan", str(tmp_path / "Demo")]) == 0
+    assert '"package_delivery"' in capsys.readouterr().out
+    assert main(["build", str(tmp_path / "Demo")]) == 0
+    assert (tmp_path / "deliverables/Demo/BUILD_REPORT.json").is_file()
+
+def test_doctor_json(capsys):
+    assert main(["doctor", "--json"]) == 0
+    data = json.loads(capsys.readouterr().out)
+    assert data[0]["tool"] == "Python"

assayflux-0.4.0/tests/test_project.py

@@ -0,0 +1,102 @@
+import json
+import pytest
+from assayflux import Project, __version__
+from assayflux.errors import ProjectNameError, ProjectPathError, AssayFluxError, BuildError
+from assayflux.generator import generate_project
+from assayflux.builder import build_project, find_project, load_metadata
+from assayflux.planner import create_plan
+from assayflux.relay import Relay
+
+def test_product_identity():
+    assert __version__ == "0.4.0"
+    assert Project.create("Demo").name == "Demo"
+
+def test_project_name_validation():
+    with pytest.raises(ProjectNameError): Project.create("../bad")
+    with pytest.raises(ProjectNameError): Project.create("1starts-with-number")
+
+def test_empty_and_unknown_targets_rejected(tmp_path):
+    with pytest.raises(AssayFluxError): Project.create("Demo", root=tmp_path, targets=[])
+    with pytest.raises(AssayFluxError): Project.create("Demo", root=tmp_path, targets=["unknown"])
+
+def test_generates_website_and_backend(tmp_path):
+    p = Project.create("Demo", root=tmp_path, targets=["website", "backend"])
+    d = generate_project(p)
+    assert (d / "web/index.html").is_file()
+    assert (d / "backend_app.py").is_file()
+    meta = json.loads((d / ".assayflux/project.json").read_text())
+    assert meta["name"] == "Demo" and meta["product"] == "AssayFlux"
+    assert "ASSAYFLUX" in (d / "web/index.html").read_text()
+
+def test_no_overwrite_project(tmp_path):
+    p = Project.create("Demo", root=tmp_path)
+    generate_project(p)
+    with pytest.raises(ProjectPathError): generate_project(p)
+
+def test_delivery_is_separate_and_report_is_valid(tmp_path):
+    p = Project.create("Demo", root=tmp_path, targets=["website"])
+    generate_project(p)
+    result = build_project(p)
+    assert result.delivery_dir == tmp_path / "deliverables" / "Demo"
+    assert (result.delivery_dir / "source/Demo/web/index.html").is_file()
+    report = json.loads((result.delivery_dir / "BUILD_REPORT.json").read_text())
+    assert report["product"] == "AssayFlux" and report["status"] == "source_packaged"
+    with pytest.raises(ProjectPathError): build_project(p)
+
+def test_force_replaces_only_delivery_folder(tmp_path):
+    p = Project.create("Demo", root=tmp_path)
+    generate_project(p); first = build_project(p)
+    marker = first.delivery_dir / "remove-me.txt"; marker.write_text("x")
+    second = build_project(p, force=True)
+    assert not (second.delivery_dir / "remove-me.txt").exists()
+    assert p.directory.exists()
+
+def test_plan_dependencies_are_valid(tmp_path):
+    p = Project.create("Demo", root=tmp_path, targets=["website", "android"])
+    plan = create_plan(p); ids = {t["id"] for t in plan["tasks"]}
+    for task in plan["tasks"]:
+        assert set(task["depends_on"]) <= ids
+
+def test_engine_registry_has_android_outputs():
+    names = {e["name"] for e in Relay().engines_report()}
+    assert {"python", "c", "cpp", "javascript", "java", "kotlin", "php", "bash", "android", "android-apk", "android-aab"} <= names
+
+def test_android_project_package_id_handles_hyphen(tmp_path):
+    p = Project.create("Demo-App", root=tmp_path, targets=["android"])
+    d = generate_project(p)
+    assert (d / "app/src/main/java/org/assayflux/demoapp/MainActivity.kt").is_file()
+    assert 'applicationId = "org.assayflux.demoapp"' in (d / "app/build.gradle.kts").read_text()
+
+def test_android_build_missing_toolchain_is_reported(tmp_path, monkeypatch):
+    monkeypatch.delenv("ANDROID_HOME", raising=False); monkeypatch.delenv("ANDROID_SDK_ROOT", raising=False)
+    monkeypatch.setattr("assayflux.builder.shutil.which", lambda name: None)
+    p = Project.create("AndroidDemo", root=tmp_path, targets=["android"])
+    generate_project(p)
+    result = build_project(p, android_artifacts="apk")
+    report = json.loads((result.delivery_dir / "BUILD_REPORT.json").read_text())
+    assert report["status"] == "partial"
+    assert report["android_build"]["status"] == "blocked"
+    assert "Gradle" in report["android_build"]["message"]
+
+def test_delivery_symlink_is_not_followed_or_deleted(tmp_path):
+    p = Project.create("Demo", root=tmp_path); generate_project(p)
+    other = tmp_path / "deliverables" / "Other"
+    other.mkdir(parents=True); marker = other / "keep.txt"; marker.write_text("safe")
+    p.delivery_directory.parent.mkdir(parents=True, exist_ok=True)
+    try: p.delivery_directory.symlink_to(other, target_is_directory=True)
+    except OSError: pytest.skip("Symlinks unavailable on this platform")
+    with pytest.raises(ProjectPathError): build_project(p, force=True)
+    assert marker.read_text() == "safe"
+
+def test_html_and_css_targets_generate_files(tmp_path):
+    p = Project.create("WebBits", root=tmp_path, targets=["html", "css"])
+    d = generate_project(p)
+    assert (d / "web/index.html").is_file()
+    assert (d / "src/style.css").is_file()
+
+def test_android_artifact_argument_validated(tmp_path):
+    p = Project.create("Demo", root=tmp_path, targets=["website"]); generate_project(p)
+    with pytest.raises(BuildError): build_project(p, android_artifacts="bundle")
+
+def test_load_metadata_rejects_non_project(tmp_path):
+    with pytest.raises(BuildError): find_project(tmp_path)