Some of Adams structure

.gitattributes

@@ -33,3 +33,14 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+adam/__pycache__/planner.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+adam/ui/__pycache__/main_window.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+adam/ui/__pycache__/main_window.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+adam/ui/__pycache__/studio.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+assets/adam_atom.ico filter=lfs diff=lfs merge=lfs -text
+assets/adam_atom.png filter=lfs diff=lfs merge=lfs -text
+build/ADAM/ADAM.exe filter=lfs diff=lfs merge=lfs -text
+build/ADAM/ADAM.pkg filter=lfs diff=lfs merge=lfs -text
+build/ADAM/PYZ-00.pyz filter=lfs diff=lfs merge=lfs -text
+build/ADAM/xref-ADAM.html filter=lfs diff=lfs merge=lfs -text
+tests/__pycache__/test_generations.cpython-311-pytest-8.4.2.pyc filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+venv/
+logs/*.log
+data/projects/*
+!data/projects/.gitkeep
+config/settings.local.json
+*.tmp
+

ADAM.spec

@@ -0,0 +1,74 @@
+# -*- mode: python ; coding: utf-8 -*-
+from PyInstaller.utils.hooks import collect_submodules
+
+
+hiddenimports = (
+    collect_submodules("adam.tools")
+    + collect_submodules("transformers.models.dinov2")
+    + ["transformers", "torch", "PIL"]
+)
+
+a = Analysis(
+    ["main.py"],
+    pathex=[],
+    binaries=[],
+    datas=[
+        ("assets/adam_atom.png", "assets"),
+        ("config/tools.json", "config"),
+        ("config/settings.json", "config"),
+        ("config/external_tools.json", "config"),
+    ],
+    hiddenimports=hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    # Some ML/scientific packages advertise optional Qt integrations. ADAM uses
+    # PySide6 exclusively, and PyInstaller cannot bundle multiple Qt bindings.
+    excludes=[
+        "PyQt5",
+        "PyQt6",
+        "PySide2",
+        "IPython",
+        "jupyter",
+        "matplotlib",
+        "nltk",
+        "notebook",
+        "pandas",
+        "pytest",
+        "sklearn",
+        "tensorboard",
+        "tensorflow",
+        "torch.utils.tensorboard",
+    ],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    exclude_binaries=True,
+    name="ADAM",
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon="assets/adam_atom.ico",
+)
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.datas,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    name="ADAM",
+)

Build ADAM.exe.ps1

@@ -0,0 +1,25 @@
+$ErrorActionPreference = "Stop"
+Set-Location -LiteralPath $PSScriptRoot
+
+$ErrorActionPreference = "Continue"
+python -c "import PyInstaller" 2>$null
+$pyInstallerMissing = $LASTEXITCODE -ne 0
+$ErrorActionPreference = "Stop"
+if ($pyInstallerMissing) {
+    python -m pip install pyinstaller
+    if ($LASTEXITCODE -ne 0) { throw "PyInstaller installation failed." }
+}
+
+python -c "from PIL import Image; image=Image.open(r'assets/adam_atom.png').convert('RGBA'); image.save(r'assets/adam_atom.ico', sizes=[(16,16),(24,24),(32,32),(48,48),(64,64),(128,128),(256,256)])"
+if ($LASTEXITCODE -ne 0) { throw "ADAM icon creation failed." }
+
+python -m PyInstaller --noconfirm ADAM.spec
+if ($LASTEXITCODE -ne 0) { throw "ADAM executable build failed." }
+
+$portableAssets = Join-Path $PSScriptRoot "dist\ADAM\assets"
+New-Item -ItemType Directory -Force -Path $portableAssets | Out-Null
+Copy-Item -LiteralPath (Join-Path $PSScriptRoot "assets\adam_atom.png") -Destination $portableAssets -Force
+
+Write-Host ""
+Write-Host "ADAM.exe was created at:"
+Write-Host (Join-Path $PSScriptRoot "dist\ADAM\ADAM.exe")

Launch ADAM.bat

@@ -0,0 +1,61 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+python -c "import yt_dlp, cv2, numpy" 2>nul
+if errorlevel 1 (
+  echo Installing the ADAM Video Dataset Collector requirements...
+  python -m pip install -r "%~dp0requirements.txt"
+  if errorlevel 1 goto :adam_dependency_error
+)
+python -c "import selenium, requests, PIL" 2>nul
+if errorlevel 1 (
+  echo Installing the Dataset Collector requirements for ADAM...
+  python -m pip install -r "D:\Users\PlayRobloxAllDay\Desktop\Programs\GoogleImageDatasetCollector\requirements.txt"
+  if errorlevel 1 goto :dependency_error
+)
+python -c "import datasets, diffusers, transformers, accelerate, torch, torchvision" 2>nul
+if errorlevel 1 (
+  echo Installing the DDPM training requirements for ADAM...
+  python -m pip install -r "D:\Users\PlayRobloxAllDay\Desktop\Programs\DDPM\requirements.txt"
+  if errorlevel 1 goto :ddpm_dependency_error
+)
+python main.py
+if errorlevel 1 (
+  echo.
+  echo ADAM could not start. Install the requirements with:
+  echo   python -m pip install -r requirements.txt
+  echo.
+  pause
+)
+endlocal
+exit /b
+
+:adam_dependency_error
+echo.
+echo ADAM could not install its Video Dataset Collector requirements.
+echo Run this command with the same Python used to start ADAM:
+echo   python -m pip install -r "%~dp0requirements.txt"
+echo.
+pause
+endlocal
+exit /b
+
+:dependency_error
+echo.
+echo ADAM could not install the Dataset Collector requirements.
+echo Run this command and then launch ADAM again:
+echo   python -m pip install -r "D:\Users\PlayRobloxAllDay\Desktop\Programs\GoogleImageDatasetCollector\requirements.txt"
+echo.
+pause
+endlocal
+exit /b
+
+:ddpm_dependency_error
+echo.
+echo ADAM could not install the DDPM training requirements.
+echo Run this command and then launch ADAM again:
+echo   python -m pip install -r "D:\Users\PlayRobloxAllDay\Desktop\Programs\DDPM\requirements.txt"
+echo.
+pause
+endlocal
+exit /b

README.md

@@ -0,0 +1,346 @@
+# ADAM — AI Development and Automation Manager
+
+ADAM is a local, safety-first desktop hub for orchestrating AI project tools.
+It includes registered dataset, DDPM, and SDXL LoRA workflows with background
+planning, approval gates, progress reporting, and persistent asset history.
+
+Dataset preparation, captioning, and preview placeholders remain clearly marked
+as demo tools. The connected Dataset Collector, DDPM trainer, and Local SDXL
+LoRA Trainer use real adapters and never fall back to simulated training.
+
+Existing program folders can be connected from **Settings → Tool folders**.
+ADAM stores only the path and scans for likely entry points; it does not copy or
+modify the external project. Folder assignments can also be pasted into chat:
+
+```text
+DDPM Trainer: D:\AI\DDPM
+Flow Matching Trainer: D:\AI\FlowMatchImageGenerator
+```
+
+Detection does not automatically authorize training. A real training adapter
+remains gated until its dataset, model name, run settings, and output location
+are explicit.
+
+## Training agents
+
+ADAM's training lifecycle is divided into four explainable responsibilities:
+
+- **EVE** reviews dataset membership and leaves uncertain images for the user.
+- **ORION** reviews planned epochs, batch size, resolution, image exposures, and
+  estimated optimizer steps. He can require approval but never silently changes
+  the requested settings. In the Model Creation Assistant, **ORION: apply a
+  starting recipe** fills a conservative, editable draft from the image count
+  and selected resolution before a plan is built.
+- **ATLAS** watches active training for non-finite loss, sustained critical GPU
+  temperature, critically low disk space, stalls, and large runtime overruns.
+  Critical conditions pause the trainer process tree so the user can inspect it.
+- **NOVA** examines available post-training previews and samples for unreadable
+  files and exact-looking duplicate collapse. Her report explicitly separates
+  technical sample health from subjective or subject-quality review.
+
+ORION, ATLAS, and NOVA reports are stored with each durable job record and are
+shown in Current Plan, Active Job, and Jobs / History respectively. ATLAS's
+default thresholds can be overridden in `config/settings.json` with the
+`atlas_*` settings defined in `adam/config.py`.
+
+## Real image collection
+
+When a valid Dataset Collector folder is connected, the `dataset_collector`
+registry entry uses ADAM's real visible-browser adapter. After plan approval it:
+
+- opens Bing Images in a normal visible Chrome window;
+- waits when consent/CAPTCHA/human-verification text is detected;
+- resumes automatically after the user resolves the page;
+- downloads valid images at least 256×256;
+- removes exact duplicate downloads;
+- writes a matching `.txt` caption beside every image; and
+- records URLs, captions, sources, and dimensions in `metadata.csv`.
+
+No CAPTCHA or website restriction is bypassed. Closing Chrome or stopping the
+job ends collection safely. A new timestamped dataset folder is used rather
+than overwriting an existing collection.
+
+ADAM keeps an incomplete DDPM request in conversation memory. A follow-up such
+as `dataset folder Mario, model name Mario V2, epoch count 100, output D:\Runs`
+fills the pending fields and validates named datasets against the connected
+collector. It will not start if the dataset cannot be found.
+
+## Showcase videos
+
+The **Showcase Video** workspace creates a finished MP4 directly from completed
+DDPM and Flow Matching models. Select and reorder the models, choose 12–24
+images per model, a 3-, 4-, or 5-second image duration, shared steps and aspect
+ratio, provider-compatible samplers, seed, and 720p or 1080p output. ADAM runs
+the image batches sequentially and then renders a request-list interface that
+tracks the active model, image number, trainer, steps, sampler, and aspect ratio.
+LoRA models are intentionally excluded from this streamlined workflow.
+
+When Ollama is reachable, messages that are not workflow commands receive a
+short conversational answer. Ollama may explain or plan, but it still cannot
+bypass the registry or confirmation gates.
+
+## Web search in Chat Mode
+
+Chat Mode can give local Ollama current web context without an API key. Enable
+it in **Settings → Planning model**, then ask naturally, for example:
+
+```text
+Search the web for Dandy's World character ideas.
+What are the latest Ollama release notes?
+Look up a reference for a cyberpunk city character.
+```
+
+ADAM sends only that search query to Bing's public results feed, reads the
+result titles and snippets,
+and passes up to five titles, snippets, and links to Ollama. It does not open
+the result pages, download anything, or let web content run tools. Results are
+untrusted reference material, so ADAM is instructed to cite the links and flag
+uncertainty. Disable the setting to keep Chat Mode fully local.
+
+When you explicitly ask ADAM to **read**, **open**, or **research** result links,
+it can read up to three public HTML/text pages and give Ollama short extracts.
+For example: `Search the web for Undertale character ideas and read the most
+relevant links.` Direct links can be read with `Read https://example.com/ and
+summarize it.` Private/local addresses, non-web protocols, oversized pages,
+downloads, and more than three pages are blocked. This control can be disabled
+in Settings.
+
+Planning runs away from the interface thread, and conversational Ollama output
+is streamed into the chat. ADAM validates training commands against a strict
+schema and each registered trainer's declared capabilities before offering a
+job.
+
+In **Settings → Planning model**, **Chat response length** sets the maximum
+number of generated tokens for a Chat Mode reply. Higher values allow longer
+research summaries but use more time and GPU memory. The default is 1,024,
+which gives Qwen3 enough room to reason and still produce a visible response.
+
+ADAM stores friendly dataset/model names, paths, trainer types, epochs, and
+resume checkpoints in `data/assets.json`. Requests such as:
+
+```text
+From the Mario dataset, train it on a DDPM for 300 epochs.
+With the Mario dataset, train it on a LoRA for 100 epochs.
+Continue the Mario model from the DDPM for 50 epochs.
+```
+
+are resolved to real paths before approval. Continuation is offered only when a
+compatible checkpoint exists. New DDPM runs retain the latest resume checkpoint.
+
+## Run
+
+```powershell
+python main.py
+```
+
+On Windows, you can also double-click `Launch ADAM.bat`.
+
+The app requires Python 3.10+ and PySide6. Optional integrations use `psutil`
+for system information and `pynvml` for NVIDIA GPU information.
+
+```powershell
+python -m pip install -r requirements.txt
+```
+
+Try:
+
+- Click **Create a model…** in Trainer Mode for the guided Model Creation Assistant.
+- `Adam, train a LoRA of Hatsune Miku`
+- `Adam, collect a dataset of liminal spaces`
+- `Adam, generate previews`
+- `Adam, check GPU status`
+- `From the Mario dataset, train it on a DDPM for 300 epochs`
+- `With the Mario dataset, train it on a LoRA for 100 epochs`
+
+Training and large collection plans are never started until you approve the
+plan. All actions are recorded in `logs/adam.log`, while project artifacts live
+under `data/projects/`.
+
+The Model Creation Assistant can start from a built-in Character LoRA, Style
+LoRA, DDPM, or Flow Matching preset. It can create a dataset or select a
+registered one, recommends starting values, and saves personal presets. The
+result still goes through ADAM's normal validated planner and approval gate.
+Use **+ Add model** to build a multi-model training batch. Each wide model tab
+keeps its own dataset, trainer, name, and settings; the minus button removes an
+unwanted model, and tabs can be dragged to change the run order. ADAM validates
+all models, presents one combined approval plan, and runs them sequentially so
+only one training workflow uses the GPU at a time. A failed step stops the batch
+before a later model starts.
+Before approval, ADAM adds checks for connected tools, dataset contents, the
+LoRA base model, and output-drive free space. Completed dataset and training
+jobs also include a suggested next step.
+
+### Model Batch Builder
+
+Use **Create model batch…** to paste one requested subject per line. ADAM turns
+the list into editable model tabs, removes duplicate names, and lets the current
+trainer recipe be applied to any multi-selection of models. The batch is saved
+as a draft so it can be closed and resumed later.
+
+For a review-first workflow, choose **Collect missing datasets first**. This
+queues only sequential dataset collection and leaves training in the saved
+draft. After collection, reopen the draft, use **Find collected datasets**, and
+review each dataset in Training Studio. **Exclude rejected** moves rejected
+images out of the training folder into a recoverable quarantine, and **Restore
+excluded** reverses it. **Keep all images** marks the whole selected dataset as
+accepted in one action, after which individual bad images can still be rejected.
+Training remains locked until each model is explicitly
+marked as reviewed and ready. If every linked dataset is acceptable as-is,
+**Approve all datasets** marks the entire batch ready after one confirmation;
+it does not inspect individual images or apply pending rejection decisions.
+
+Completed Flow Matching models can be selected in **Fine-tune**. ADAM uses the
+saved Flow model folder as the continuation source, locks the continuation to
+the model's original resolution, and writes the fine-tuned result to a new
+output folder. This continues the saved weights while starting a fresh optimizer
+and learning-rate schedule; it does not overwrite the original model.
+
+## Training Studio
+
+The **Training Studio** turns completed work into a reviewable experiment loop:
+
+- **Datasets** provides an image gallery, keep/reject decisions, caption editing,
+  exact duplicate detection, and visually similar duplicate candidates.
+- **Experiments** compares job settings and outcomes, opens outputs, marks a
+  preferred model, and converts successful settings into reusable recipes.
+- **Checkpoint Lab** browses model checkpoints and output images, records
+  consistent prompt/seed evaluations, and sends preview requests through the
+  normal approval-aware planner.
+- **Recipes** preserves training starting points and can import or export
+  portable JSON recipe files.
+
+### EVE AI Dataset Review
+
+In Training Studio → Datasets, **EVE AI Review…** performs a local reference-
+guided visual review. Add one or more good reference images and optional bad
+references, then choose Keep and Reject confidence thresholds. EVE uses a small
+DINOv2 vision model to divide the selected dataset into **Keep**, **Reject**, and
+**Uncertain** galleries with confidence scores. The model is downloaded once on
+first use and subsequent analysis stays local.
+
+Nothing is applied automatically. Inspect both sides, double-click images for a
+full view, and move selected results between the three groups before choosing
+**Apply EVE review**. EVE's decisions remain ordinary Training Studio review
+marks: they can be manually changed, and rejected files are not moved until
+**Exclude rejected** is selected. The latest proposal is also saved under
+`data/eve_reviews/` for auditing. Use **Select all in current group** (or
+Ctrl/Shift selection) to move many images at once; EVE transfers only the
+chosen thumbnails so manual sorting stays responsive on large datasets.
+
+Training panels show elapsed time, a progress-based ETA, recent logs, and a
+loss sparkline when the connected trainer reports `loss`. Preflight summaries
+include clearly labelled workload, duration, VRAM, and disk estimates. These
+estimates are planning hints rather than hardware guarantees.
+
+Create a Model also supports live training previews with a configurable
+epoch interval, prompt, and reproducible seed for each model tab. While a
+training job is active, its newest 256×256 preview appears in the right sidebar
+with the source epoch and next scheduled preview. The full-size trainer output
+can be opened from the card. Built-in adapters may publish previews directly;
+registered DDPM, Flow, LoRA, APVD, MaskGit, and other trainers can also
+participate by writing conventionally named `preview`, `sample`, or `epoch`
+images beneath their declared output folder.
+
+## Generations
+
+The **Generations** workspace runs compatible registered image generators
+without opening their separate desktop interfaces. The connected DDPM and Flow
+Matching projects can generate from completed models with a reproducible seed,
+sampler or ODE method, step count, image count, and aspect ratio. Generation
+work uses the normal ADAM job queue, progress reporting, cancellation, and
+logging.
+
+Every completed batch is stored under `data/generations/` with its images and a
+`generation.json` sidecar. The history gallery can open an image or batch folder
+and restore the exact settings for another run. DDPM creative notes are stored
+with a batch for organization; they are not presented as text conditioning for
+an unconditional DDPM model.
+
+**Generation Cycle…** selects multiple compatible completed models and queues
+one generation step per model. Choose images per model, a shared prompt or
+creative note, starting seed, slideshow duration, looping, fullscreen playback,
+and an optional model/trainer label. When the cycle finishes, ADAM opens the
+results as a local slideshow while preserving every ordinary generation record
+in history.
+
+If ADAM discovers a job interrupted by an unexpected shutdown, it offers to
+open Jobs & History. The previous record remains intact and can be retried as a
+new approval-gated job. Job logs can also be exported for troubleshooting.
+
+## Connect an existing tool
+
+ADAM supports importable Python functions and command-line Python scripts.
+For a no-code setup, open **Settings → External Tools → Add external tool**.
+Choose the program folder, select its training entry script and important
+configuration files, then review ADAM's static compatibility and safety report.
+The report covers:
+
+- detected command-line options and required inputs;
+- likely dataset formats;
+- output and checkpoint behavior;
+- progress reporting;
+- resume-training support; and
+- potentially risky operations visible in the selected entry script.
+
+The 1–10 rating measures how clearly the script fits ADAM's safe command-line
+contract. It is not a guarantee that third-party code is harmless. ADAM does
+not execute a script while scanning it, external tools cannot replace built-in
+registry entries, and every external-tool run requires explicit approval.
+
+After registration, a tool can be planned with a request such as:
+
+```text
+Run APVD Model Trainer with dataset=D:\DreamData, epochs=20, output=D:\APVD\output
+```
+
+ADAM will ask for any required inputs that were omitted before it offers the
+approval plan.
+
+For manual registry configuration, edit the relevant item in
+`config/tools.json`:
+
+```json
+{
+  "backend": {
+    "type": "python",
+    "module": "my_tools.lora",
+    "function": "train"
+  },
+  "demo": false
+}
+```
+
+The function receives a `ToolContext` as its first argument and keyword
+arguments from the approved plan. This keeps training code in one place: your
+existing GUI and ADAM can both call the same backend.
+
+For scripts:
+
+```json
+{
+  "backend": {
+    "type": "script",
+    "path": "D:/AI/LoRATrainer/train.py"
+  },
+  "demo": false
+}
+```
+
+ADAM invokes scripts directly with the current Python interpreter, captures
+stdout/stderr, and never drives another GUI with mouse clicks.
+
+## Safety model
+
+- Plans are shown before execution.
+- Long, destructive, or high-volume work requires confirmation.
+- Unregistered tools cannot be invoked.
+- External paths and arguments are validated before execution.
+- The LLM may propose a plan, but only registered tools can execute it.
+- Pause, resume, and cancel controls are available for active jobs.
+- Every tool action and state transition is logged.
+
+## Tests
+
+```powershell
+python -m pytest -q
+```

adam/__init__.py

@@ -0,0 +1,4 @@
+"""ADAM — AI Development and Automation Manager."""
+
+__version__ = "0.1.0"
+

adam/__pycache__/planner.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae169edb82edce349fc8706aca61f2f58984794b462aa999203aa52af1b92770
+size 100876