Changed: openssl dependency is now conditional (cfg(not(windows))) — no longer pulled in on Windows, fixing Windows CI builds that lack Perl Locale::Maketext::Simple. On Linux (including musl cross-compilation) the vendored OpenSSL build is unchanged.

- `build.kind = "efi"` — UEFI PE32+ executable support. Links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10`, output via `efi_path()` with `.efi` extension, rejected by `dcr run`.
- `build.kind = "elf"` — bare-metal ELF executable support. Uses `elf_path()` output path, rejected by `dcr run`, no extra linker flags.

Fixed:

- `dcr run` with `--target` or `build.target` now correctly finds the binary in the arch-specific target directory.
- `dcr run` checks profile-specific `build.{profile}.kind` before rejecting library builds (previously only checked `build.kind`).
- `dcr clean` now reads `build.target` from `dcr.toml` when no `--target` flag is given.
- Linux: target directory is now consistent — `target/<arch>-unknown-linux-gnu/<profile>/` (no stale `target/<profile>/`).
- `dcr.lock` is now populated with all resolved dependencies (registry, path, git) instead of being always empty.
- Git dependencies are now properly recognized and recorded in `dcr.lock`.
- `is_registry_dep` correctly identifies version-based registry dependency tables (`{ version = "..." }`) and rejects tables with unknown keys.
- `dcr test` accepts `--debug`/`--release` flags (defaults to `debug` profile instead of always `release`).
- Build fingerprint cache (`build_cache_path`) now includes `target_dir` — different targets no longer share a single cache entry.
- `object_path` no longer hardcodes the `src/` prefix — works correctly with custom `build.roots` (e.g. `roots = ["lib"]`).
- `dcr update` now generates `.exe` candidates for all Windows targets, not just `x86_64-pc-windows-msvc`.
- Compiler existence is verified before starting the build (clear error if compiler is not found in PATH).
- Consolidated duplicate `OUTPUT_MUTEX` definitions — MSVC backend now uses the shared mutex from `common.rs`.
- Registry cache root directory is created if missing (prevents cryptic errors when `~/.dcr/` does not exist).

.github/workflows/aur.yml

@@ -0,0 +1,138 @@
+name: AUR Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Tag version without v prefix (e.g. 0.2.2)"
+        required: true
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  publish-aur:
+    # Не публикуем dev/pre-release теги в AUR
+    if: "!contains(github.ref_name, '-')"
+    runs-on: ubuntu-latest
+    environment: aur
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Derive version and checksum
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]; then
+            PKGVER="${{ inputs.version }}"
+          else
+            PKGVER="${GITHUB_REF_NAME#v}"
+          fi
+          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/v${PKGVER}.tar.gz"
+          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
+
+          echo "pkgver=$PKGVER" >> "$GITHUB_OUTPUT"
+          echo "source_url=$SRC_URL" >> "$GITHUB_OUTPUT"
+          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+
+      - name: Render AUR metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER='${{ steps.meta.outputs.pkgver }}'
+          SRC_URL='${{ steps.meta.outputs.source_url }}'
+          SHA256='${{ steps.meta.outputs.sha256 }}'
+
+          cat > packaging/aur/dcr/PKGBUILD <<PKG
+          pkgname=dcr
+          pkgver=${PKGVER}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects"
+          arch=('x86_64' 'aarch64')
+          url="https://github.com/dexoron/dcr"
+          license=('MIT')
+          depends=('gcc-libs')
+          makedepends=('cargo')
+          options=('!lto')
+          optdepends=(
+            'gcc: build C/C++ projects with GCC'
+            'clang: build C/C++ projects with Clang'
+          )
+          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
+          sha256sums=('${SHA256}')
+
+          build() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            export CARGO_PROFILE_RELEASE_LTO=false
+            export RUSTFLAGS="\${RUSTFLAGS:-}"
+            export RUSTFLAGS="\${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
+            cargo build --release --locked
+          }
+
+          package() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
+            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+          }
+          PKG
+
+          cat > packaging/aur/dcr/.SRCINFO <<SRC
+          pkgbase = dcr
+          	pkgdesc = Cargo-like utility to manage C/C++ projects
+          	pkgver = ${PKGVER}
+          	pkgrel = 1
+          	url = https://github.com/dexoron/dcr
+          	arch = x86_64
+          	arch = aarch64
+          	license = MIT
+          	makedepends = cargo
+          	depends = gcc-libs
+          	optdepends = gcc: build C/C++ projects with GCC
+          	optdepends = clang: build C/C++ projects with Clang
+            options = !lto
+          	source = dcr-${PKGVER}.tar.gz::${SRC_URL}
+          	sha256sums = ${SHA256}
+
+          pkgname = dcr
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if [[ -z "${AUR_SSH_PRIVATE_KEY:-}" ]]; then
+            echo "AUR_SSH_PRIVATE_KEY secret is missing"
+            exit 1
+          fi
+
+          install -d -m 700 ~/.ssh
+          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > ~/.ssh/aur
+          chmod 600 ~/.ssh/aur
+          ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
+
+          export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
+          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
+          cp packaging/aur/dcr/PKGBUILD aur-repo/PKGBUILD
+          cp packaging/aur/dcr/.SRCINFO aur-repo/.SRCINFO
+
+          cd aur-repo
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          if git diff --quiet; then
+            echo "No AUR changes"
+            exit 0
+          fi
+
+          git add PKGBUILD .SRCINFO
+          git commit -m "dcr ${{ steps.meta.outputs.pkgver }}"
+          git push

.github/workflows/release.yml

@@ -4,33 +4,126 @@ on:
   push:
     tags:
       - "v*"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to build and upload assets for (e.g. v0.6.5)"
+        required: true
 
 permissions:
   contents: write
 
 jobs:
+  notes:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # При ручном запуске чекаутим нужный тег
+          ref: ${{ github.event.inputs.tag || github.ref }}
+
+      - name: Prepare Release Notes
+        shell: bash
+        run: |
+          set -euo pipefail
+          # При ручном запуске берём версию из инпута, иначе из тега
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            tag="${{ github.event.inputs.tag }}"
+            tag="${tag#v}"
+          else
+            tag="${GITHUB_REF_NAME#v}"
+          fi
+          notes_file=".github/release-notes.md"
+          if grep -q "^## \\[${tag}\\]" CHANGELOG.md; then
+            awk -v ver="$tag" '
+              $0 ~ "^## \\[" ver "\\]" {found=1; next}
+              found && $0 ~ "^## \\[" {exit}
+              found {print}
+            ' CHANGELOG.md | sed -e '${/^$/d;}' > "$notes_file"
+          else
+            echo "No CHANGELOG section for $tag." > "$notes_file"
+            git log -1 --pretty=format:"%s%n%n%b" >> "$notes_file"
+          fi
+
+      - name: Upload Notes Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-notes
+          path: .github/release-notes.md
+
   build:
     strategy:
       fail-fast: false
       matrix:
         include:
+          # ── Linux GNU ──────────────────────────────────────────────────────
           - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
-            asset_name: dcr-x86_64-unknown-linux-gnu
+
-          - os: macos-13
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+            apt: gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+            env_cc: CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
+            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
+
+          # ── Linux Musl ─────────────────────────────────────────────────────
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+            apt: musl-tools
+            env_cc: CC_x86_64_unknown_linux_musl=musl-gcc
+            env_linker: CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=musl-gcc
+
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-musl
+            musl_cross: aarch64-linux-musl-cross
+            env_cc: CC_aarch64_unknown_linux_musl=aarch64-linux-musl-gcc
+            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER=aarch64-linux-musl-gcc
+
+          # ── macOS ──────────────────────────────────────────────────────────
+          - os: macos-15-intel
             target: x86_64-apple-darwin
-            asset_name: dcr-x86_64-apple-darwin
+
-          - os: macos-14
+          - os: macos-latest
             target: aarch64-apple-darwin
-            asset_name: dcr-aarch64-apple-darwin
+
+          # ── Windows MSVC ───────────────────────────────────────────────────
           - os: windows-latest
             target: x86_64-pc-windows-msvc
-            asset_name: dcr-x86_64-pc-windows-msvc.exe
+
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+
+          # ── Windows GNU ────────────────────────────────────────────────────
+          - os: windows-latest
+            target: x86_64-pc-windows-gnu
+
+          # gnullvm исключён: LLVM MinGW не предустановлен на GitHub Actions
 
     runs-on: ${{ matrix.os }}
-
+    needs: notes
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Install cargo-zigbuild (Linux cross-compilation)
+        if: runner.os == 'Linux'
+        run: |
+          pip install cargo-zigbuild
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Setup LLVM + MinGW (gnullvm)
+        if: contains(matrix.target, 'gnullvm')
+        shell: pwsh
+        run: |
+          choco install llvm mingw -y --no-progress
+          echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
@@ -38,21 +131,51 @@ jobs:
           targets: ${{ matrix.target }}
 
       - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+        shell: bash
+        run: |
+          if [ "${{ runner.os }}" = "Linux" ] && [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
+            cargo zigbuild --release --target ${{ matrix.target }}
+          else
+            cargo build --release --target ${{ matrix.target }}
+          fi
+
+      - name: Derive version string
+        shell: bash
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            RAW_TAG="${{ github.event.inputs.tag }}"
+          else
+            RAW_TAG="${GITHUB_REF_NAME}"
+          fi
+          echo "RELEASE_TAG=${RAW_TAG}" >> "$GITHUB_ENV"
+          echo "RELEASE_VERSION=${RAW_TAG#v}" >> "$GITHUB_ENV"
+
+      - name: Derive asset name (Unix)
+        if: runner.os != 'Windows'
+        shell: bash
+        run: |
+          echo "ASSET_NAME=dcr-${{ matrix.target }}-${RELEASE_VERSION}" >> "$GITHUB_ENV"
+
+      - name: Derive asset name (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          "ASSET_NAME=dcr-${{ matrix.target }}-$($env:RELEASE_VERSION).exe" >> $env:GITHUB_ENV
 
       - name: Prepare Artifact (Unix)
         if: runner.os != 'Windows'
         shell: bash
-        run: |
+        run: cp target/${{ matrix.target }}/release/dcr "$ASSET_NAME"
-          cp target/${{ matrix.target }}/release/dcr ${{ matrix.asset_name }}
 
       - name: Prepare Artifact (Windows)
         if: runner.os == 'Windows'
         shell: pwsh
-        run: |
+        run: Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "$env:ASSET_NAME"
-          Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "${{ matrix.asset_name }}"
 
       - name: Upload Release Asset
         uses: softprops/action-gh-release@v2
         with:
-          files: ${{ matrix.asset_name }}
+          tag_name: ${{ env.RELEASE_TAG }}
+          files: ${{ env.ASSET_NAME }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ contains(env.RELEASE_TAG, '-') }}

.gitignore

@@ -2,4 +2,6 @@ target/
 sandbox/**
 .idea/
 .vscode/
-.env
+.env
+
+personal/

AGENTS.md

@@ -0,0 +1,56 @@
+# AGENTS.md
+
+## Quick start
+
+```bash
+cargo build --release && ./target/release/dcr setup
+```
+
+## Pre-PR (CI) gate
+
+```bash
+cargo fmt --all --check
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check --all-targets --all-features
+cargo test
+```
+
+CI (`.github/workflows/ci.yml`) runs fmt, clippy, check — **not** tests.
+
+## Tests
+
+- Integration tests in `tests/` build the dcr binary and run it in temp dirs under `sandbox/cli-tests/` (gitignored).
+- Some tests **skip** if no C compiler (`gcc`/`clang`/`cc`) is found at runtime.
+- Compiler can be overridden via `DCR_COMPILER` or `DCR_CC` env vars.
+- Tests use `$CARGO_BIN_EXE_dcr` when available, else `target/debug/dcr`.
+
+## Architecture
+
+- **Single Rust package** (edition 2024), not a workspace. Only one binary: `dcr`.
+- **Entrypoint**: `src/main.rs` — matches `args[1]` against command names.
+- **Compiler backends** in `src/core/builder/`: `unix_cc` (gcc/clang), `msvc` (cl/clang-cl), `gas`, `nasm`. Dispatched by matching compiler name string.
+- **Config**: `dcr.toml` (per-project), `~/.dcr/config.toml` (registry), `~/.dcr/index.json` (index). Defaults: `language=c`, `standard=c11`, `compiler=clang`, `kind=bin`.
+- **`build.rs`** embeds `TARGET` as `DCR_TARGET` env var (shown in `--version`).
+- **CLI output** must be in English. Use `utils::log` for messaging.
+
+## Key commands
+
+| Command | Notes |
+|---|---|
+| `dcr new <name>` | Creates project dir |
+| `dcr init` | Init from CWD (must be empty) |
+| `dcr build [--debug\|--release] [--target <triple>]` | Default profile: `--debug` |
+| `dcr run [--debug\|--release]` | Only for `kind = "bin"` |
+| `dcr clean [--debug\|--release] [--all]` | `--all` for workspace roots |
+| `dcr tree` | Dependency tree viewer |
+| `dcr test [--init]` | Runs/test project tests |
+| `dcr gen <vscode\|clion\|compile-commands>` | IDE integration |
+| `dcr --update` | Self-update from GitHub Releases |
+
+## Cross-compilation
+
+`--target` accepts short names (`linux`, `macos`, `windows`) or full triples. In CI, Linux cross-builds use `cargo-zigbuild`. When `build.target` is set in `dcr.toml`, DCR auto-injects `--target=<value>` into cflags (clang). Bare-metal targets (containing `none`/`-elf`/`eabi`/`baremetal`) skip DCR's default compiler flags.
+
+## Dependencies (Cargo)
+
+reqwest (blocking+json+rustls-tls), serde, toml, git2, openssl (vendored), self-replace, sha2, ctrlc.

CHANGELOG.md

@@ -1,40 +1,318 @@
 # Changelog
 
+## [0.6.7] - 2026-05-26
+
+Added:
+
+- `build.kind = "efi"` — UEFI PE32+ executable support. Links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10`, output via `efi_path()` with `.efi` extension, rejected by `dcr run`.
+- `build.kind = "elf"` — bare-metal ELF executable support. Uses `elf_path()` output path, rejected by `dcr run`, no extra linker flags.
+- `build.filename` and `build.extension` in `dcr.toml` — complete control over the final artifact name without relying on `package.name`.
+  Example:
+  ```toml
+  [build]
+  filename = "KERNEL"
+  extension = "EFI"
+  ```
+  Produces `KERNEL.EFI` (works for `bin`, `staticlib`, and `sharedlib`).
+- Automatic injection of `--target=<build.target>` into compiler flags when `build.target` is set in `dcr.toml`. This greatly simplifies clang-based cross-compilation (especially for bare-metal targets like `aarch64-none-elf`).
+- Bare-metal targets (containing `none`, `-elf`, `eabi`, `baremetal`) no longer receive DCR's internal default flags (`-g`, `-Wall`, `-Wextra`, `-fno-omit-frame-pointer`, `-DDCR_DEBUG`, etc.). Prevents unwanted sections (`.comment`, debug info, etc.) that break custom linker scripts when `inherit = true`.
+- `build.ldscript` in `dcr.toml` — linker script path passed as `-T <path>` to the linker. Essential for bare-metal/embedded/freestanding targets.
+- `dcr build --verbose` — prints compiler/linker command lines (also works with `DCR_DEBUG` env var).
+- `dcr add <name>` without a source argument — if a registry is configured, DCR looks up the package by name and adds it as a version dependency.
+
+Fixed:
+
+- `build.target` declared in `dcr.toml` is now correctly used as the default target even when `--target` is not passed on the command line (previously the host target was always forced for config resolution).
+- `dcr run` with `--target` or `build.target` now correctly finds the binary in the arch-specific target directory.
+- `dcr run` checks profile-specific `build.{profile}.kind` before rejecting library builds (previously only checked `build.kind`).
+- `dcr clean` now reads `build.target` from `dcr.toml` when no `--target` flag is given.
+- Linux: target directory is now consistent — `target/<arch>-unknown-linux-gnu/<profile>/` (no stale `target/<profile>/`).
+- `dcr.lock` is now populated with all resolved dependencies (registry, path, git) instead of being always empty.
+- Git dependencies are now properly recognized and recorded in `dcr.lock`.
+- `is_registry_dep` correctly identifies version-based registry dependency tables (`{ version = "..." }`) and rejects tables with unknown keys.
+- `dcr test` accepts `--debug`/`--release` flags (defaults to `debug` profile instead of always `release`).
+- Build fingerprint cache (`build_cache_path`) now includes `target_dir` — different targets no longer share a single cache entry.
+- `object_path` no longer hardcodes the `src/` prefix — works correctly with custom `build.roots` (e.g. `roots = ["lib"]`).
+- `dcr update` now generates `.exe` candidates for all Windows targets, not just `x86_64-pc-windows-msvc`.
+- Compiler existence is verified before starting the build (clear error if compiler is not found in PATH).
+- Consolidated duplicate `OUTPUT_MUTEX` definitions — MSVC backend now uses the shared mutex from `common.rs`.
+- Registry cache root directory is created if missing (prevents cryptic errors when `~/.dcr/` does not exist).
+
+Changed:
+
+- `openssl` dependency is now conditional (`cfg(not(windows))`) — no longer pulled in on Windows, fixing Windows CI builds that lack Perl `Locale::Maketext::Simple`. On Linux (including musl cross-compilation) the vendored OpenSSL build is unchanged.
+
+## [0.6.6] - 2026-05-18
+
+Fixed:
+
+- Path dependencies now work correctly: `dcr add` stores them as `{ path =
+"./..." }` tables, `is_registry_dep` properly distinguishes registry strings
+from path/git strings, and `deps/mod.rs` resolves both table-form and
+legacy string-form path dependencies
+- Registry dependency paths no longer hardcoded to `project_root/dcr-index`;
+now use `package_root_from_registry_info()` which resolves relative to the
+registry cache root (`~/.dcr/`)
+- Registry dependencies are now actually built: `build_project_at()` is
+called when `include_dir` or `lib_dir` is missing
+
+Added:
+
+- `SIGINT`/`Ctrl+C` handler via `ctrlc` crate — `dcr build` now checks
+`BUILD_INTERRUPTED` flag at key points and aborts cleanly
+- `utils/build.rs` — extracted shared utilities: `parse_version_info`,
+`normalize_target_os`, `resolve_compiler`, `primary_language`,
+`resolve_pkg_config_flags` and config helpers. Eliminates code duplication
+between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
+- `utils/fs.rs::with_dir` — extracted common directory-scoped execution
+- `run_command_sync_output` in `builder/common.rs` with global `OUTPUT_MUTEX`
+— synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
+- New helper functions in `deps/register.rs`: `get_registry_cache_root`,
+`package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
+`path_from_string_dep`
+- Unit tests for `register.rs` (`is_registry_dep`, `package_root_from_registry_info`),
+  `deps/mod.rs` (`path_dep_path`, `push_default_lib_dirs`),
+  `utils/build.rs` (`normalize_target_os`, `parse_version_info`)
+- `dcr tree` command — visual dependency tree viewer (similar to `cargo tree`)
+
+Removed:
+
+- Removed unused dependencies `indicatif` and `console` from `Cargo.toml`
+
+## [0.6.5] - 2026-05-13
+
+Added:
+
+- New dependency registry system
+- Package type support (`lib`, `app`, `none`) in `dcr.toml`
+- Library packaging functionality: automatically generates `include` and `lib` directories in `target/` for `lib` type projects
+- Expanded CI build targets:
+  - Linux: `aarch64-unknown-linux-gnu`, `x86_64-unknown-linux-musl`, `aarch64-unknown-linux-musl`
+  - Windows: `aarch64-pc-windows-msvc`, `x86_64-pc-windows-gnu`, `aarch64-pc-windows-gnullvm`
+
+Changed:
+
+- `src/core/deps/` modular architecture overhaul
+- Native platform pathing defaults for Linux (now dynamic architecture detection)
+- Improved `run` command output handling
+
+## [0.6.0] - 2026-05-12
+
+Added:
+
+- Full Git dependency support in `dcr.toml`
+  - Support for `git`, `branch`, `tag`, and `rev` fields
+  - Automatic cloning and checkout via `git2`
+  - Dependencies are stored in `target/<profile>/deps/git/`
+- New `dcr add` command for easy dependency management
+  - Short syntax: `github:user/repo`, `gitlab:user/repo`, `path:/to/lib`
+  - Automatic GitHub resolution for `git:user/repo`
+- Visual feedback for dependency fetching with in-place status updates ("Fetching" → "Fetched")
+- Modular dependency management architecture in `src/core/deps/`
+
+## [0.5.1] - 2026-04-12
+
+Fixed:
+
+- Windows compatibility for target-specific config without --target flag
+
+Added:
+
+- Default host target detection for automatic target overrides
+- Unit tests for target normalization
+
+Improved:
+
+- Config value lookup optimization
+- Documentation for Windows cross-compilation
+
+## [0.5.0] - 2026-04-10
+
+Added:
+
+- Full inheritance system for all config sections: `build`, `toolchain`, `run`, `workspace`, `dependencies`
+  - Order: `section.target.profile` → `section.profile.target` → `section.target` → `section.profile` → `section`
+  - `inherit = false` to disable inheritance completely
+  - Target-specific overrides: `[build.linux]`, `[toolchain.windows]`, `[run.macos]`, etc.
+- Cross-compilation support with `--target <triple>`
+  - Full target triples and short names (`linux`, `macos`, `windows`)
+  - Target-specific config sections: `[build.<target>]`, `[toolchain.<target>]`, `[run.<target>]`
+- Workspace and dependencies support target/profile inheritance
+- Multiple targets build: `[build.targets]` to build for multiple targets simultaneously
+- Target directory structure: `target/<target>/<profile>/` (native or triple)
+- Updated documentation with cross-compilation guide and Arch Linux examples
+
+## [0.4.0] - 2026-04-10
+
+Added:
+
+- Test command: `dcr test` and `dcr tests`
+  - Automatic compilation and linking for tests without manual configuration
+  - `dcr test --init` creates test template and header
+  - Test framework with EXPECT/SKIP macros in `dcr_test.h`
+- Improved test integration: added test CLI module and basic test suite
+- Documentation updates for testing functionality
+
+## [0.3.0] - 2026-03-18
+
+Added:
+
+- `dcr gen` command for IDE integration and build tool support
+    - `dcr gen project-info`: Output project metadata as JSON
+    - `dcr gen compile-commands`: Generate `compile_commands.json` for clangd and clang-tidy
+    - `dcr gen vscode`: Generate VS Code `.vscode/` integration (launch.json, tasks.json, settings.json)
+    - `dcr gen clion`: Generate JetBrains CLion `.idea/` integration (run configurations, build targets)
+- Full workspace support for all `gen` subcommands
+
+## [0.2.10] - 2026-03-16
+
+Added:
+
+- `build.steps` for pre-build generators (e.g., `moc`/`uic`/`rcc`)
+- `build.pkg_config` for `pkg-config`-driven cflags/ldflags resolution
+- `[toolchain]` support for `uic`, `moc`, `rcc`
+- Step command variables (`{uic}`, `{moc}`, `{rcc}`, `{cflags}`, `{stem}`, `{in}`, `{out}`)
+- `{profile}` placeholder support for dependency paths
+
+## [0.2.9] - 2026-03-14
+
+Added:
+
+- Header dependency tracking for fine-grained incremental builds (rebuilds when `#include` files change)
+- Complete internal rewrite of the builder module: merged duplicate compilation backends
+
+Changed:
+
+- `cflags` and `default_flags` no longer incorrectly leak to the linker stage in GCC/Clang
+- Reduced builder codebase size by over 20% while increasing reliability
+- Greatly expanded test suite with 34 new tests covering configuration, CLI errors, and path operations
+
+## [0.2.8] - 2026-03-06
+
+Added:
+
+- Workspace support (`[workspace]` with deps ordering)
+- `clean --all` for workspace members
+  Changed:
+- Project root discovery for `build/run/clean` (searches parent dirs)
+- Workspace paths are excluded from root source scan
+- Build output now uses a Cargo-style `Compiling <name> v<version>` line
+- Build time now reports total time for the whole build stage (workspace included)
+- Cache hits are silent (no compile line when nothing is rebuilt)
+- Safer build cache: fingerprints include headers and resolved library files
+
+## [0.2.7] - 2026-03-03
+
+Added:
+
+- Toolchain overrides via `[toolchain]` and env (`DCR_*`)
+- ASM `.S` preprocessing via GCC/Clang (`-x assembler-with-cpp`)
+
+## [0.2.6] - 2026-03-01
+
+Added:
+
+- `sharedlib` build kind (shared library output)
+- ASM projects (`build.language = "asm"`)
+- NASM and GAS backends
+- `build.platform` architecture hint for `-march` / `/arch`
+- Basic CLI integration tests
+
+## [0.2.5] - 2026-02-26
+
+Added:
+
+- Incremental builds (object caching by mtime)
+- `build.kind` with `staticlib` support
+- Custom output directory via `build.target`
+
+## [0.2.4] - 2026-02-22
+
+Added:
+
+- Custom build flags: `build.cflags` and `build.ldflags`
+- Recursive source discovery inside `src/`
+- Path dependencies with auto include/lib resolution and `dcr.lock` generation (experimental)
+- Add docs/index.md and docs/dcr-toml.md
+
+## [0.2.3] - 2026-02-21
+
+Added:
+
+- Modular builders for `gcc`, `clang`, `msvc`
+- Platform-specific binary path generation (Linux/macOS/Windows)
+
+Changed:
+
+- Build configuration moved to `[build]` (`language`, `standard`, `compiler`)
+- `dcr.toml` formatting now includes the `[build]` section
+- Build uses built-in `debug/release` flags per compiler
+- Build compiles all `*.c/*.cpp` files in `src/` into a single binary (no incremental build)
+- Updated `dcr.toml` examples in documentation
+
+## [0.2.2] - 2026-02-20
+
+Changed:
+
+- Reworked `dcr.toml` handling: added read, validation, and edit through `core::config`
+- `new` and `init` use the new config creation logic
+- `build` and `run` now require `dcr.toml` and read `compiler` and `name` from it
+
+## [0.2.1] - 2026-02-18
+
+Changed:
+
+- Translated user-facing CLI messages to English
+- Unified error and warning output via `utils::log::{error, warn}`
+- Updated `--help` output: translated headers and examples to English, used `printc`, and applied `BOLD_*` styles
+- Translated installer script messages in `install.sh` and `install.ps1` to English
+
 ## [0.2.0] - 2026-02-17
-Изменено:
-- Проект переведен с Python на Rust
-- CLI и команды (`new`, `init`, `build`, `run`, `clean`, `--help`, `--version`, `--update`) перенесены на Rust
-- Обновлен флаг `--update` - добавлена поддержка GNU\Linux, Windows, MacOS
-- Обновлены `README.md`, `CONTRIBUTING.md`, `install.sh` под Rust-реализацию
-- Добавлен `install.ps1` для Windows
-- Обновлен `install.sh` для GNU/Linux и MacOS
 
-Добавлено:
+Changed:
-- Добавлен `install.ps1` для Windows
-- Поддержка GNU\Linux, Windows, MacOS(x86_64/arm)
 
-ВАЖНО:
+- Project migrated from Python to Rust
-- Код перенесен с помощью нейронных сетей, в будущих версиях будет баг-фикс и изменение логики
+- CLI and commands (`new`, `init`, `build`, `run`, `clean`, `--help`, `--version`, `--update`) ported to Rust
+- Updated `--update` flag: added support for GNU/Linux, Windows, macOS
+- Updated `README.md`, `CONTRIBUTING.md`, and `install.sh` for the Rust implementation
+- Added `install.ps1` for Windows
+- Updated `install.sh` for GNU/Linux and macOS
+
+Added:
+
+- Added `install.ps1` for Windows
+- Support for GNU/Linux, Windows, macOS (x86_64/arm)
+
+Important:
+
+- Code was ported with neural networks; future versions will include bug fixes and logic changes
 
 ## [0.1.2] - 2026-02-12
-Добавлено:
-- Команда обновления
-- Скрипт установки `install.sh` и инструкции по установке в README
-- Флаг `--version` для вывода версии
 
-Изменено:
+Added:
-- Улучшен консольный вывод команд, добавлены цвета и обновлена справка `--help`
+
-- Обновлен запуск проекта и обработка сборки в `run.py`/`build.py`
+- Update command
+- `install.sh` install script and README instructions
+- `--version` flag
+
+Changed:
+
+- Improved CLI output, added colors, and updated `--help`
+- Updated project run/build handling in `run.py`/`build.py`
 
 ## [0.1.1] - 2026-02-11
-Изменено:
+
-- Обновлена справка `--help`
+Changed:
-- `main.py` теперь корректно запускается при прямом выполнении
+
+- Updated `--help`
+- `main.py` now runs correctly when executed directly
 
 ## [0.1.0] - 2026-02-11
-Первый публичный релиз.
 
-Добавлено:
+First public release.
-- Базовые команды `new`, `init`, `build`, `run`, `clean`
+
-- Профили сборки `debug` и `release`
+Added:
-- Шаблоны `dcr.toml` и `src/main.c`
+
+- Base commands `new`, `init`, `build`, `run`, `clean`
+- Build profiles `debug` and `release`
+- `dcr.toml` and `src/main.c` templates

CONTRIBUTING.md

@@ -1,13 +1,13 @@
-# Вклад в проект
+# Contributing
 
-Спасибо за интерес к проекту.
+Thanks for your interest in the project.
 
-## Требования
+## Requirements
 
-- Использовать Rust stable.
+- Use Rust stable.
-- Перед PR код должен проходить форматирование, линт и сборку.
+- Before opening a PR, the code must pass formatting, linting, and build.
 
-## Быстрый старт
+## Quick Start
 
 ```bash
 git clone https://github.com/dexoron/dcr.git
@@ -15,43 +15,65 @@ cd dcr
 cargo check
 ```
 
-## Стиль кода
+## Code Style
 
-- Форматируйте код через `cargo fmt`.
+- Format code with `cargo fmt`.
-- Проверяйте предупреждения через `cargo clippy`.
+- Check warnings with `cargo clippy`.
-- Держите функции небольшими и сфокусированными.
+- Keep functions small and focused.
-- Предпочитайте понятные имена вместо "хитрых".
+- Prefer clear names over clever ones.
 
-## Проверки
+## Target System
 
-Перед PR запускайте:
+DCR supports cross-compilation via `--target <triple>` or short names:
+
+- `dcr build --target linux --release` (maps to `x86_64-unknown-linux-gnu`)
+- `dcr build --target macos --release` (maps to `x86_64-apple-darwin`)
+- `dcr build --target windows --release` (maps to `x86_64-pc-windows-msvc`)
+- Full triples: `dcr build --target aarch64-linux-gnu --release`
+- Configure multiple targets in `dcr.toml`:
+  ```
+  [build.targets]
+  targets = ["linux", "macos"]
+
+  [build.linux]
+  compiler = "gcc"
+
+  [build.macos]
+  compiler = "clang"
+  ```
+- If no `--target`, builds for targets in `build.targets` or native if empty.
+
+## Checks
+
+Before PR, run:
 
 ```bash
 cargo fmt --all
 cargo clippy --all-targets --all-features -- -D warnings
 cargo check
+cargo test
 ```
 
-## CI/CD и релизы
+## CI/CD and Releases
 
 - CI: `.github/workflows/ci.yml`
 - Release: `.github/workflows/release.yml`
-- Релиз запускается по тегу `v*` и публикует бинарники для:
+- Releases are triggered by tags `v*` and publish binaries for:
 - `x86_64-unknown-linux-gnu`
 - `x86_64-apple-darwin`
 - `aarch64-apple-darwin`
 - `x86_64-pc-windows-msvc`
 
-## Коммиты и PR
+## Commits and PRs
 
-- Делайте коммиты понятными.
+- Write clear commit messages.
-- В PR указывайте краткое описание и мотивацию изменений.
+- In PRs, include a short description and rationale.
-- Обновляйте документацию при изменении поведения.
+- Update documentation when behavior changes.
 
-## Вопросы
+## Questions
 
-Если что-то непонятно, открой issue или задайте вопрос в PR.
+If anything is unclear, open an issue or ask in the PR.
 
-Также можно задать вопрос напрямую:
+You can also reach out directly:
 - TG: @dexoron
 - DS: dexoron

Cargo.lock

@@ -26,6 +26,24 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.19.1"
@@ -45,6 +63,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
 dependencies = [
  "find-msvc-tools",
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
@@ -61,12 +81,71 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
-name = "dcr"
+name = "cpufeatures"
-version = "0.2.0"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctrlc"
+version = "3.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162"
+dependencies = [
+ "dispatch2",
+ "nix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dcr"
+version = "0.6.7"
+dependencies = [
+ "ctrlc",
+ "git2",
+ "glob",
+ "openssl",
  "reqwest",
  "self-replace",
  "serde",
+ "serde_json",
+ "sha2",
+ "toml",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags",
+ "block2",
+ "libc",
+ "objc2",
 ]
 
 [[package]]
@@ -114,6 +193,21 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -172,6 +266,16 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -212,6 +316,27 @@ dependencies = [
  "wasip3",
 ]
 
+[[package]]
+name = "git2"
+version = "0.20.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b88256088d75a56f8ecfa070513a775dd9107f6530ef14919dac831af9cfe2b"
+dependencies = [
+ "bitflags",
+ "libc",
+ "libgit2-sys",
+ "log",
+ "openssl-probe",
+ "openssl-sys",
+ "url",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -475,6 +600,16 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.85"
@@ -497,6 +632,46 @@ version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
+[[package]]
+name = "libgit2-sys"
+version = "0.18.4+1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b26f66f35e1871b22efcf7191564123d2a446ca0538cde63c23adfefa9b15b7"
+dependencies = [
+ "cc",
+ "libc",
+ "libssh2-sys",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+]
+
+[[package]]
+name = "libssh2-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "220e4f05ad4a218192533b300327f5150e809b54c4ec83b5a1d91833601811b9"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc3a226e576f50782b3305c5ccf458698f92798987f551c6a02efe8276721e22"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.11.0"
@@ -538,12 +713,92 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "nix"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "openssl"
+version = "0.10.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf0b434746ee2832f4f0baf10137e1cabb18cbe6912c69e2e33263c45250f542"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-src"
+version = "300.6.0+3.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8e8cbfd3a4a8c8f089147fd7aaa33cf8c7450c4d09f8f80698a0cf093abeff4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.115"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "158fe5b292746440aa6e7a7e690e55aeb72d41505e2804c23c6973ad0e9c9781"
+dependencies = [
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -562,6 +817,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@@ -878,6 +1139,15 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -890,6 +1160,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -1043,6 +1324,45 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "toml"
+version = "1.0.3+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7614eaf19ad818347db24addfa201729cf2a9b6fdfd9eb0ab870fcacc606c0c"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.0.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.9+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
 [[package]]
 name = "tower"
 version = "0.5.3"
@@ -1113,6 +1433,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -1149,6 +1475,18 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "want"
 version = "0.3.1"
@@ -1466,6 +1804,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
+[[package]]
+name = "winnow"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"

Cargo.toml

@@ -1,10 +1,19 @@
 [package]
 name = "dcr"
-version = "0.2.0"
+version = "0.6.7"
 edition = "2024"
 build = "build.rs"
 
 [dependencies]
+glob = "0.3"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 self-replace = "1"
+sha2 = "0.10"
+toml = "1.0.3"
+git2 = "0.20.4"
+serde_json = "1"
+ctrlc = "3"
+
+[target.'cfg(not(windows))'.dependencies]
+openssl = { version = "0.10", features = ["vendored"] }

FAQ.md

@@ -0,0 +1,102 @@
+# FAQ
+
+## What is this project about?
+`dcr` is a tool for managing C/C++ projects and their dependencies.
+It is inspired by Cargo, but it is not a direct equivalent of Makefile, CMake, or other classic build systems.
+
+The goal is to provide a simpler and easier-to-configure development workflow.
+
+## How is the project developed?
+The project is written in Rust and is primarily developed by one maintainer, Dexoron.
+
+AI tools are used during development, but they do not write the project end-to-end. Their role is limited to supporting specific tasks (for example, suggestions, wording checks, and translations).
+
+## Which tools are used for development?
+Main development stack:
+- `RustRover` 2025 - development IDE.
+- `Codex` (`GPT-5.3-Codex (medium)`) - primary AI tool, integrated via JetBrains AI Chat.
+- `Rust` - main project language.
+- `Cargo` - tool for building, testing, and dependency management in Rust projects.
+
+## Is the project open source?
+Yes, the project is open source.
+You can propose ideas, report issues, and contribute code changes.
+
+The project is distributed under the MIT license (see `LICENSE`).
+
+## How can I contribute?
+Thank you for contributing.
+You can:
+- help with code;
+- help with translations;
+- help with documentation;
+- suggest an idea or report a bug.
+
+### If you want to submit changes (code, translation, documentation)
+1. Fork the required repository: `dexoron/dcr` (main project) or `dexoron/dcr-site` (project website).
+2. Make your changes following the rules in `CONTRIBUTING.md`.
+3. Push changes to your fork.
+4. Open a Pull Request.
+5. Wait for review.
+
+### If you want to report a problem or suggest an idea
+1. Open the relevant repository: `dexoron/dcr` or `dexoron/dcr-site`.
+2. Go to the `Issues` tab.
+3. Create an Issue and specify its type (bug, suggestion, question/help).
+4. Describe the problem or idea clearly and concisely.
+5. Wait for feedback.
+
+## How do I install `dcr`?
+Available installation methods may vary by project version.
+Recommended path:
+- check instructions in `README.md`;
+- if there is no prebuilt package for your platform, build from source using `cargo build --release`.
+
+## How can I get started quickly?
+Minimal workflow:
+1. Install `dcr`.
+2. Create a project (or open an existing C/C++ project).
+3. Initialize `dcr` configuration.
+4. Add project dependencies.
+5. Build using `dcr`.
+
+For detailed commands and examples, see `README.md` and the project documentation.
+
+## What is the project status?
+`dcr` is under active development.
+This means some interfaces and behaviors may change between versions.
+
+Before upgrading, check the changelog and release notes.
+
+## Which systems does `dcr` support?
+`dcr` targets modern C/C++ development environments.
+Actual compatibility depends on the `dcr` version, operating system, and toolchain.
+
+Before starting, check documentation for:
+- supported operating systems;
+- supported compilers and linkers;
+- version-specific limitations.
+
+## How is `dcr` different from Make/CMake?
+`dcr` does not aim to be a direct replacement for Make/CMake.
+Its main focus is simplifying project and dependency management with a Cargo-like experience.
+
+If you need low-level, full control over build steps, classic tools may be a better fit.
+If you want a simpler and more uniform configuration model, `dcr` may be more convenient.
+
+## Where can I find documentation and examples?
+Primary sources:
+- `README.md` in the repository;
+- project documentation (see the project website);
+- `Issues` for known problems and discussions.
+
+## How do I report a bug properly?
+To make a bug report easy to reproduce, include:
+1. `dcr` version.
+2. OS and compiler/toolchain version.
+3. Steps to reproduce.
+4. Expected behavior.
+5. Actual behavior and error output.
+6. Minimal project example (if possible).
+
+Submit bugs and issues through `Issues` in the relevant repository.

README.md

@@ -1,31 +1,47 @@
 # DCR (Dexoron Cargo Realization)
 
-DCR — это утилита для управления проектами на C/C++ в стиле Cargo.
+DCR is a utility for managing C/C++ projects in a Cargo-like style.
 
-Текущая реализация написана на Rust.
+The current implementation is written in Rust.
 
-## Зачем DCR
+## Why DCR
-- Единая структура проекта без ручной настройки
+- Unified project structure without manual setup
-- Простые команды для типовых задач
+- Simple commands for common tasks
-- Прозрачная компиляция и предсказуемые профили сборки
+- Transparent compilation and predictable build profiles
 
-## Возможности
+## Features
-- Создание нового проекта или инициализация текущей директории
+- Create a new project or initialize the current directory
-- Сборка проекта в профилях `debug` и `release`
+- Build a project with `debug` and `release` profiles
-- Запуск собранного бинарника
+- Run the compiled binary
-- Очистка результатов сборки
+- Clean build artifacts
-- Генерация минимального шаблона C-проекта
+- Generate IDE integration files (VS Code, CLion) and compilation databases
-- Обновление бинарника через `dcr --update` (GitHub Releases)
+- Generate a minimal C project template
+- Build static, shared libraries, UEFI PE32+ executables, and bare-metal ELF executables
+- Dependency management:
+  - Git and Path dependencies with `dcr.lock`
+  - Registry-based dependency resolution
+- Library packaging functionality (auto-generate `include/` and `lib/` for `type = "lib"` packages)
+- ASM projects with NASM/GAS or via GCC/Clang
+- Mixed language projects
+- Cross-compilation with `--target` (full triple support and short names)
+- Target-specific configurations and inheritance
+- Update the binary via `dcr --update` (GitHub Releases)
 
-## Поддерживаемые платформы
+## Supported Platforms
-- Linux: `x86_64-unknown-linux-gnu`
+- Linux: x86_64/aarch64 (GNU and Musl)
-- macOS Intel: `x86_64-apple-darwin`
+- macOS: x86_64/aarch64
-- macOS Apple Silicon: `aarch64-apple-darwin`
+- Windows: x86_64/aarch64 (MSVC, GNU, LLVM)
-- Windows: `x86_64-pc-windows-msvc`
 
-## Установка
+## Installation
 
-### Из исходников
+### Package Manager
+
+**Arch Linux**
+```sh
+yay -S dcr # or paru and other AUR package managers
+```
+
+### From Source
 
 ```sh
 git clone https://github.com/dexoron/dcr.git
@@ -35,37 +51,45 @@ mkdir -p ~/.local/bin
 ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
 ```
 
-### Через install.sh (Linux/macOS)
+### Via `install.sh` (Linux/macOS)
 
 ```sh
-curl -fsSL https://raw.githubusercontent.com/dexoron/dcr/master/install.sh | bash
+curl -fsSL https://dcr.dexoron.su/install.sh | bash
 ```
 
-### Через install.ps1 (Windows)
+### Via `install.ps1` (Windows)
 
 ```powershell
-irm https://raw.githubusercontent.com/dexoron/dcr/master/install.ps1 | iex
+irm https://dcr.dexoron.su/install.ps1 | iex
 ```
 
-Оба скрипта при запуске спрашивают:
+When executed, both scripts ask whether to:
-- скачать готовый бинарник из GitHub Release
+- download a prebuilt binary from GitHub Releases
-- или собрать проект из `git`
+- or build the project from `git`
 
-Релизные ассеты:
+Release assets:
 - `dcr-x86_64-unknown-linux-gnu`
 - `dcr-x86_64-apple-darwin`
 - `dcr-aarch64-apple-darwin`
 - `dcr-x86_64-pc-windows-msvc.exe`
 
-## Быстрый старт
+## Update
 
-Создать новый проект:
+- If DCR was installed from GitHub release assets, `install.sh`, `install.ps1`, or built manually:
+  - use `dcr --update`
+- If DCR is installed via `pacman/AUR`:
+  - update with your package manager: `paru/yay -Syu dcr` or `sudo pacman -Syu dcr`
+  - `dcr --update` detects package-managed installs and asks you to update via package manager
+
+## Quick Start
+
+Create a new project:
 `dcr new hello`
 
-Или инициализировать текущую директорию (директория должна быть пустой):
+Or initialize the current directory (the directory must be empty):
 `dcr init`
 
-Структура проекта:
+Project structure:
 
 ```txt
 hello/
@@ -74,55 +98,159 @@ hello/
 - dcr.toml
 ```
 
-Сборка и запуск проекта:
+Build and run the project:
-`dcr run` или `dcr run --release`
+`dcr run` or `dcr run --release`
 
-## Команды
+## Commands
 
 ### `dcr new <name>`
-Создает проект в текущей директории с указанным именем.
+Creates a project with the specified name in the current directory.
 
 ### `dcr init`
-Создает проект в текущей директории. Имя проекта будет равно имени директории. Директория должна быть пустой.
+Creates a project in the current directory. The project name is taken from the directory name. The directory must be empty.
+
+### `dcr setup`
+Initializes the registry system by reading `~/.dcr/config.toml` and verifying the availability of configured indices.
+
+### `dcr add <name> <source>`
+Adds a dependency to `dcr.toml`.
+If a registry is configured, `dcr` automatically finds the package.
+Git/Path syntax: `path:`, `github:`, `gitlab:`, `git:`, or a full URL.
+Use `--branch`, `--tag`, or `--rev` for Git dependencies.
 
 ### `dcr build [profile]`
-Собирает проект. Если профиль не указан, используется `--debug`.
+Builds the project. If no profile is specified, `--debug` is used.
+Use `--force` to rebuild without cache, `--clean` to clean before build.
 
 ### `dcr run [profile]`
-Собирает проект и запускает бинарник. Если профиль не указан, используется `--debug`.
+Builds the project and runs the binary. If no profile is specified, `--debug` is used.
+Use `--force` to rebuild without cache, `--clean` to clean before build.
 
-Запуск вручную:
+Run manually:
-`./target/<profile>/main`
+`./target/<profile>/<name>`
 
 ### `dcr clean`
-Удаляет папку `target` в корне проекта.
+Removes the `target` directory in the project root.
+Use `dcr clean --all` in a workspace root to clean all member projects.
 
-## Профили сборки
+### `dcr gen`
-Поддерживаются два профиля:
+Generates IDE integration files and build tools.
-- `--debug` (по умолчанию) — флаги: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDEBUG`
+- `dcr gen vscode`: VS Code workspace config
-- `--release` — флаги: `-O3 -DNDEBUG -march=native`
+- `dcr gen clion`: CLion project files
+- `dcr gen compile-commands`: `compile_commands.json` for clang tools
 
-## Конфигурация
+### `dcr test`
-Основной файл проекта — `dcr.toml`.
+Runs the test suite.
+Use `dcr test --init` to create test files.
 
-Пример `dcr.toml`:
+## Build Profiles
+Two profiles are supported:
+- `--debug` (default) - built-in flags per compiler
+- `--release` - built-in flags per compiler
+
+Custom flags can be added in `dcr.toml` via `build.cflags` and `build.ldflags`.
+Profile-specific flags can be added via `[build.debug]` and `[build.release]`.
+You can also set `build.target` to override the output directory (profile-independent).
+You can set `build.platform` to pass `-march=<platform>` (GCC/Clang) or `/arch:*` (MSVC) where supported.
+Use `build.kind = "staticlib"` to build a static library instead of a binary.
+Use `build.kind = "sharedlib"` to build a shared library (`.so`/`.dylib`/`.dll`).
+Use `build.kind = "efi"` to build a UEFI PE32+ executable (`.efi`).
+Use `build.kind = "elf"` to build a bare-metal ELF executable.
+`dcr run` is only for `build.kind = "bin"` and will fail for libraries, EFI, and ELF.
+Use `build.exclude`/`build.include` to control source/header collection.
+Use `build.roots` and `build.src_disable` to replace the default `src/` root.
+Use `build.steps` and `build.post_steps` to run custom commands.
+Use `build.clean` for extra cleanup paths and `[run].cmd` to override run command.
+
+## Cross-compilation
+
+DCR supports cross-compilation via `--target <triple>` or short names:
+
+```sh
+dcr build --target linux --release    # x86_64-unknown-linux-gnu
+dcr build --target macos --release    # x86_64-apple-darwin
+dcr build --target windows --release  # x86_64-pc-windows-msvc
+dcr run --target aarch64-linux-gnu
+```
+
+Configure multiple targets and target-specific settings in `dcr.toml`:
+
+```toml
+[build.targets]
+targets = ["linux", "windows"]
+
+[build.linux]
+compiler = "gcc"
+cflags = ["-O2"]
+
+[build.windows]
+compiler = "x86_64-w64-mingw32-gcc"
+```
+
+See [Cross-compilation guide](docs/dependencies-and-build/cross-compilation.md) for details.
+
+## Configuration
+The main project file is `dcr.toml`.
+For multi-registry management, use `~/.dcr/config.toml`.
+
+Example `dcr.toml`:
 
 ```toml
 [package]
 name = "hello"
 version = "0.1.0"
+type = "app" # or "lib", "none"
+
+[build]
 language = "c"
+standard = "c11"
 compiler = "clang"
+kind = "bin" # "bin", "staticlib", "sharedlib", "efi", "elf"
+# Optional platform hint
+# platform = "x86_64"
+# Optional custom flags
+cflags = ["-Wall", "-Wextra"]
+ldflags = ["-lm"]
+#
+# Optional include/exclude:
+# exclude = ["src/vendor", "src/legacy/**"]
+# include = ["src/boot/arch/**"]
+
+[toolchain]
+# Optional tool overrides:
+# cc = "clang"
+# cxx = "clang++"
+# as = "as"
+# ar = "ar"
+# ld = "ld"
+# uic = "uic"
+# moc = "moc"
+# rcc = "rcc"
 
 [dependencies]
+my_lib = "path:./libs/my_lib"
+cool_lib = { git = "https://github.com/user/cool_lib", tag = "v1.0" }
 ```
 
-## Требования
+Workspace example:
-- Rust toolchain (`rustc`, `cargo`) - Для ручной сборки DCR
+...
-- C-компилятор (`clang`, `gcc` или другие)
+[workspace]
+kernel = { path = "src/kernel", deps = ["core", "userspace"] }
+core = { path = "src/core", deps = ["userspace"] }
+userspace = { path = "src/userspace" }
+```
 
-## Релизы
+Git and Path dependencies are supported. DCR will resolve them on build and generate `dcr.lock`.
-Релизы собираются автоматически через GitHub Actions (`.github/workflows/release.yml`) при пуше тега формата `v*`.
 
-## Лицензия
+Incremental build note: object files are rebuilt when source `.c/.cpp` or included header files change.
-См. файл `LICENSE`.
+
+
+## Requirements
+- Rust toolchain (`rustc`, `cargo`) - for building DCR from source
+- C compiler (`clang`, `gcc`, or 'cl'(msvc))
+
+## Releases
+Releases are built automatically via GitHub Actions (`.github/workflows/release.yml`) when a tag matching `v*` is pushed.
+
+## License
+See `LICENSE`.

TODO.md

@@ -0,0 +1,67 @@
+# DCR TODO.md
+
+Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers.
+
+## 🔥 High Priority (Next Releases)
+
+- [x] **Git dependencies support**  
+  `git = "https://github.com/user/repo.git#branch"` and `git = "..."@tag`
+- [ ] **Conan and vcpkg integration**  
+  Automatic download, installation and linking of packages
+- [ ] **Full freestanding / embedded support**  
+  `-nostdlib`, linker scripts, bare-metal targets (i686-elf, aarch64-none-elf, etc.)
+- [ ] **EFI support**  
+  Dedicated platform configuration for EFI targets
+- [ ] **Custom project name**  
+  Override binary name in `dcr.toml`
+- [ ] **Custom build steps / targets**  
+  Ability to define custom pre-build, post-build, codegen steps in `dcr.toml`
+- [ ] **Improved mixed C/C++/ASM projects**  
+  Better handling of `.S` and `.asm` files with correct flags
+- [ ] **dcr publish + official package registry**  
+  Publish and fetch your own libraries easily
+
+## ✅ Medium Priority
+
+- [ ] **Static analysis** (`dcr check`)  
+  Integration with clang-tidy, cppcheck, include-what-you-use
+- [ ] **Linter + Formatter** (`dcr fmt`, `dcr lint`)
+- [ ] **Hot reload / Live reload** for applications (raylib, SFML, SDL, etc.)
+- [ ] **Better cross-compilation experience**  
+  Ready-to-use toolchains + automatic download
+- [ ] **Linker script support** + direct linker control
+- [ ] **Workspaces improvements**  
+  Per-member include directories, selective builds, better dependency graph
+- [ ] **Build-time code generation**  
+  Support for protobuf, flatbuffers, Qt moc, custom generators
+
+## 📌 Low Priority / Nice to Have
+
+- [ ] Support for Meson and Ninja as alternative backends
+- [ ] Dockerfile generation (`dcr docker init`)
+- [ ] First-class Windows MSVC support (currently works but rough)
+- [ ] Documentation generation (`dcr doc`)
+- [ ] Sanitizers integration (`dcr sanitize`)
+- [ ] Benchmarks and comparison with CMake/Meson
+- [ ] C++20 modules support (when it becomes stable)
+
+## 🧠 Future Ideas
+
+- Official DCR package registry (dcrhub)
+- GUI wrapper (dcr-gui)
+- Plugin system
+- Toolchain manager (like rustup)
+- Zig as alternative compiler
+- deb/rpm/flatpak/AppImage packaging support
+
+---
+
+**Currently in progress:**
+- ...
+
+**Completed in recent releases:**
+- Workspaces
+- Cross-compilation
+- IDE config generation (VS Code, CLion, compile_commands.json)
+- Self-update (`dcr --update`)
+- Header tracking

docs/README.md

@@ -0,0 +1,46 @@
+# Introduction
+
+DCR (Dexoron Cargo Realization) is a Cargo-style CLI for C/C++ projects.
+
+Current DCR focuses on a simple, predictable workflow:
+
+- create or initialize a project (`dcr new`, `dcr init`)
+- build with `debug` or `release` profiles (`dcr build`)
+- run binaries (`dcr run`)
+- clean artifacts (`dcr clean`)
+- update the installed binary (`dcr --update`)
+
+## What is implemented in this version
+
+- Project configuration in `dcr.toml` with `[package]`, `[build]`, `[dependencies]`.
+- Recursive source discovery in `src/`:
+  - C: `*.c`
+  - C++: `*.cpp`, `*.cxx`, `*.cc`
+- Compiler selection from `dcr.toml` (`clang`, `gcc`, `cl`, `clang-cl`, etc.).
+- ASM support via `language = "asm"` (GCC/Clang, NASM, GAS).
+- Mixed language builds via `language = ["c", "asm"]` and similar combinations.
+- Three build kinds:
+  - `bin` (default)
+  - `staticlib`
+  - `sharedlib`
+- Optional custom output directory via `build.target`.
+- Optional `build.platform` to pass architecture hints (`-march` / `/arch`).
+- Optional `build.exclude`/`build.include` for source/header selection.
+- Optional `build.roots`/`build.src_disable` to replace the default `src/` root.
+- Optional build steps with `build.steps` and `build.post_steps`.
+- Optional `build.pkg_config` integration.
+- Optional `build.clean` and `build.expect`.
+- Optional `[run].cmd` to override run command.
+- Workspace builds via `[workspace]` with per-project `dcr.toml`.
+- Path dependencies with include/lib resolution and `dcr.lock` generation.
+
+## Important behavior notes
+
+- `dcr.toml` is required for `build`, `run`, and `clean`.
+- `run` works only with `build.kind = "bin"`.
+- Incremental rebuild tracks source file timestamps and header dependencies (rebuilds when either source or included headers change).
+- Object files are always created under `target/<profile>/obj/`.
+
+## Repository
+
+- <https://github.com/dexoron/dcr>

docs/SUMMARY.md

@@ -0,0 +1,49 @@
+# Table of contents
+
+* [Introduction](README.md)
+
+## Getting started
+
+* [Installation](getting-started/installation.md)
+* [Create your first project](getting-started/create-your-first-project.md)
+* [Project structure](getting-started/project-structure.md)
+* [Build and run](getting-started/build-and-run.md)
+
+## Configuration
+
+* [dcr.toml overview](configuration/dcr.toml-overview.md)
+* [Package section](configuration/package-section.md)
+* [Build section](configuration/build-section.md)
+* [Dependencies section](configuration/dependencies-section.md)
+* [Build profiles](configuration/build-profiles.md)
+
+## Commands
+
+* [Global options](commands/global-options.md)
+* [dcr init/new](commands/dcr-init-or-new.md)
+* [dcr add](commands/dcr-add.md)
+* [dcr build](commands/dcr-build.md)
+* [dcr run](commands/dcr-run.md)
+* [dcr clean](commands/dcr-clean.md)
+* [dcr gen](commands/dcr-gen.md)
+* [dcr test](commands/dcr-test.md)
+* [dcr tree](commands/dcr-tree.md)
+
+## Dependencies & Build
+
+* [Dependency format](dependencies-and-build/dependency-format.md)
+* [Local dependencies](dependencies-and-build/local-dependencies.md)
+* [Versioning & lock file](dependencies-and-build/versioning-and-lock-file.md)
+* [Target directory](dependencies-and-build/target-directory.md)
+* [Cross-compilation and targets](dependencies-and-build/cross-compilation.md)
+* [Compilers & linking](dependencies-and-build/compilers-and-linking.md)
+
+## Reference & Help
+
+* [CLI reference](reference-and-help/cli-reference.md)
+* [Config reference](reference-and-help/config-reference.md)
+* [Workspace guide](reference-and-help/workspace-guide.md)
+* [Flags & environment](reference-and-help/flags-and-environment.md)
+* [Troubleshooting map](reference-and-help/troubleshooting-map.md)
+* [FAQ](reference-and-help/faq.md)
+* [Contributing & Bug reports](reference-and-help/contributing-and-bug-reports.md)

docs/commands/dcr-add.md

@@ -0,0 +1,37 @@
+# dcr add
+
+Add a dependency to `dcr.toml`.
+
+## Usage
+
+```bash
+dcr add <name> [source] [options]
+```
+
+If `<source>` is omitted and a registry is configured, DCR will look up the
+package by name in the registry and add it as a version dependency.
+
+## Sources
+
+- *omitted*: Look up in the configured registry.
+- `path:./path/to/lib`: Local directory.
+- `github:user/repo`: GitHub repository.
+- `gitlab:user/repo`: GitLab repository.
+- `git:host.com/user/repo`: Generic Git repository (HTTPS).
+- `https://...`: Full Git URL.
+
+## Options
+
+- `--branch <name>`: Use a specific branch.
+- `--tag <name>`: Use a specific tag.
+- `--rev <sha>`: Use a specific commit hash.
+
+## Examples
+
+```bash
+dcr add my_lib path:./libs/my_lib
+dcr add cool_lib github:user/cool_lib
+dcr add shared_lib gitlab:org/shared --branch develop
+dcr add custom_lib git:git.internal.com/r/lib --tag v1.0.0
+dcr add mylib                    # Looks up in registry
+```

docs/commands/dcr-build.md

@@ -0,0 +1,76 @@
+# dcr build
+
+Builds the project in `debug` or `release` profile.
+
+## Usage
+
+```sh
+dcr build
+dcr build --debug
+dcr build --release
+dcr build --target linux --release
+dcr build --release --force
+dcr build --debug --clean
+```
+
+## What `build` does
+
+1. Checks that `dcr.toml` exists and is valid.
+2. Reads build settings from `[build]`.
+3. Resolves path dependencies from `[dependencies]`.
+4. Creates required output directories.
+5. Recursively compiles sources from `src/`.
+6. Links final artifact (binary or library).
+
+## Config values used
+
+- `package.name`
+- `build.filename`
+- `build.extension`
+- `build.compiler`
+- `build.language`
+- `build.standard`
+- `build.kind`
+- `build.target`
+- `build.platform`
+- `build.cflags`
+- `build.ldflags`
+- `build.ldscript`
+- `build.debug` / `build.release`
+- `build.exclude`
+- `build.include`
+- `build.pkg_config`
+- `build.steps`
+- `build.post_steps`
+- `build.generated`
+- `build.expect`
+- `build.clean`
+
+## Source selection
+
+- `language = "c"` -> `*.c`
+- `language = "c++" | "cpp" | "cxx"` -> `*.cpp`, `*.cxx`, `*.cc`
+- `language = "asm"` -> `*.s`, `*.S`, `*.asm`
+- Mixed languages are supported with arrays, for example `language = ["c", "asm"]`.
+- By default sources are searched in `src/`; use `build.roots` and `build.src_disable` to override.
+
+## Notes
+
+- Profile flag (`--debug` / `--release`) can appear in any argument position (duplicates are rejected).
+- Unknown profile flags return an error.
+- `--target <triple>` builds for specified target (short names: `linux`, `macos`, `windows`).
+- `--verbose` prints the compiler/linker command lines to stderr (also works via `DCR_DEBUG` env var).
+- If no `--target`, builds for `build.targets` or native.
+- Incremental rebuild checks source/object mtime and tracked header dependencies.
+- `--force` skips build cache checks and recompiles.
+- `--clean` removes `target/<profile>` and `build.clean` paths before building.
+- `build.filename` + `build.extension` allow full control over the final artifact name (e.g. `KERNEL.BIN` instead of using `package.name`). When `build.kind = "efi"`, the output is a PE32+ executable with `.efi` extension.
+- `build.kind = "efi"` links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10` for UEFI PE32+ format. Use `build.filename` and `build.extension` for full control over the artifact name.
+- `build.kind = "elf"` produces a bare-metal ELF executable. Linking flags are user-controlled via `build.ldflags` (no PIE/CRT defaults are added).
+- Default GCC/Clang profile flags: `debug` -> `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`, `release` -> `-O3 -DNDEBUG`.
+  These defaults are **not applied** for bare-metal targets (e.g. `aarch64-none-elf`, targets containing `none` / `-elf` / `eabi`).
+- For `language = "asm"` with `compiler = "as"`/`"gas"`, use `.s` files (no preprocessing). For `.S`, use `gcc` or `clang`.
+- In workspace root, `dcr build` builds all members in dependency order.
+- `build.exclude` removes paths from source/header collection; `build.include` re-allows matching paths and has priority over `exclude`.
+- `build.steps` run before compilation; `build.post_steps` run after linking.
+- `build.generated` is cleaned when `build.steps` need to rerun; `build.expect` is verified after post-steps.

docs/commands/dcr-clean.md

@@ -0,0 +1,27 @@
+# dcr clean
+
+Removes build artifacts in `target/`.
+
+## Usage
+
+```sh
+dcr clean
+dcr clean --debug
+dcr clean --release
+dcr clean --all
+dcr clean --release --all
+```
+
+## Behavior
+
+- Without arguments: removes entire `target/`.
+- With profile: removes only the profile-specific directory. Respects `build.target` from config: if `build.target = "aarch64-unknown-linux-gnu"`, cleans `target/aarch64-unknown-linux-gnu/<profile>/`.
+- With `--all`: also cleans all workspace members.
+- Additionally removes paths from `build.clean` if configured.
+- `build.clean` supports `{profile}` and version placeholders.
+
+## Validation
+
+- `dcr.toml` must exist.
+- Unknown flags are treated as error.
+- If `target` or selected profile directory does not exist, command prints a warning.

docs/commands/dcr-gen.md

@@ -0,0 +1,170 @@
+# dcr gen
+
+Generates IDE and build tool integration files for C/C++ development environments.
+
+## Usage
+
+```sh
+dcr gen project-info
+dcr gen project-info --release
+dcr gen compile-commands
+dcr gen compile-commands --debug
+dcr gen vscode
+dcr gen vscode --release
+dcr gen clion
+dcr gen clion --debug
+```
+
+## Subcommands
+
+### `dcr gen project-info`
+
+Outputs project metadata as JSON array.
+
+```sh
+dcr gen project-info [--debug | --release]
+```
+
+Outputs structured information about the project (root project + all workspace members if present):
+
+```json
+[
+  {
+    "name": "my-project",
+    "version": "1.0.0",
+    "root": "/path/to/root",
+    "profile": "debug",
+    "language": "c++",
+    "standard": "c++17",
+    "compiler": "g++",
+    "kind": "bin",
+    "sources": ["/path/to/root/src/main.cpp", ...],
+    "include_dirs": ["/path/to/dep/include", ...],
+    "lib_dirs": ["/path/to/dep/lib", ...],
+    "libs": ["somelib", ...],
+    "cflags": ["-Wall", ...],
+    "ldflags": ["-lm", ...]
+  }
+]
+```
+
+This is useful for integrating DCR projects with custom build tools or scripts.
+
+### `dcr gen compile-commands`
+
+Generates `compile_commands.json` for use by `clangd`, `clang-tidy`, and other tools.
+
+```sh
+dcr gen compile-commands [--debug | --release]
+```
+
+Writes `./compile_commands.json` containing compilation database entries for all source files. This file is recognized by:
+- LSP servers (`clangd`, `clang-tools-extra`)
+- Linters (`clang-tidy`)
+- Format tools (`clang-format`)
+
+The entries include:
+- Full compiler command with flags
+- Source file path
+- Object file output path
+- Project root as working directory
+
+### `dcr gen vscode`
+
+Generates Visual Studio Code integration files.
+
+```sh
+dcr gen vscode [--debug | --release]
+```
+
+Creates `.vscode/` directory with:
+
+- **`launch.json`**: Debug configurations (one per binary target, debug + release variants)
+- **`tasks.json`**: Build/run/clean tasks using `dcr` commands
+- **`settings.json`**: Clangd configuration pointing to `compile_commands.json`
+- **`extensions.json`**: Recommends `clangd`, disables `cpptools`
+- **`compile_commands.json`**: Compilation database (same as `dcr gen compile-commands`)
+
+Usage in VSCode:
+- Open the Command Palette (`Ctrl+Shift+P`) and select **"Debug: Start Debugging"** to run debugger
+- Press `Ctrl+Shift+B` to run the build task
+- Clangd will provide IntelliSense and diagnostics based on `compile_commands.json`
+- Generated `launch.json` uses CodeLLDB (`type: "lldb"`), so install `vadimcn.vscode-lldb`
+
+### `dcr gen clion`
+
+Generates JetBrains CLion integration files.
+
+```sh
+dcr gen clion [--debug | --release]
+```
+
+Creates `.idea/` directory with:
+
+- **`externalTools.xml`**: Registers DCR build/clean/gen commands as external tools
+- **`customTargets.xml`**: Defines build targets for debug and release
+- **`misc.xml`**: Points CLion to `compile_commands.json` for compilation database
+- **`.idea/.gitignore`**: Ignores auto-generated files
+- **`runConfigurations/*.xml`**: Debug run configs (one per binary target)
+- **`compile_commands.json`**: Compilation database (same as `dcr gen compile-commands`)
+
+Usage in CLion:
+- Build/clean via **Tools → DCR → Build Debug/Release/Clean**
+- Run/debug via **Run → Run Configurations** (dropdown) → select generated config
+- Code completion and diagnostics come from the compilation database
+
+## Config values used
+
+- `package.name`
+- `build.compiler`
+- `build.language`
+- `build.standard`
+- `build.kind`
+- `build.target`
+- `build.platform`
+- `build.cflags`
+- `build.ldflags`
+- `build.debug` / `build.release`
+- `build.exclude`
+- `build.include`
+- `build.pkg_config`
+- `build.roots`
+- `build.src_disable`
+- Workspace members (if `[workspace]` is present)
+
+## Workspace support
+
+When running `dcr gen` in a workspace root, all commands process both the root project and all workspace members:
+
+- `project-info` returns an array with entries for each member + root
+- `compile-commands` includes entries from all members
+- `vscode` and `clion` generate unified configurations that work across all members
+
+## Troubleshooting
+
+### Clangd not picking up includes
+
+- Ensure `compile_commands.json` exists in the workspace root
+- In VSCode settings, verify `clangd.arguments` includes `--compile-commands-dir=<workspace-root>`
+- Rebuild via `dcr gen compile-commands` if sources or dependencies changed
+
+### Debug configuration not working
+
+- Verify binary paths in `launch.json` match actual build output (`target/<profile>/binary-name`)
+- For workspace projects, each member's debug config uses its own `target/` directory
+- Ensure GDB/LLDB is installed: `gdb --version` or `lldb --version`
+- If VSCode reports unsupported debugger type, install the extension that matches `launch.json` type (`vadimcn.vscode-lldb` for `lldb`)
+
+### CLion not recognizing includes
+
+- Regenerate via `dcr gen clion --debug`
+- File → Invalidate Caches → Invalidate and Restart
+- Verify `.idea/misc.xml` points to correct `compile_commands.json` path
+
+## Notes
+
+- Profiles default to `debug` if not specified
+- Generation does not require the project to be built first
+- Generated files are safe to commit; they are generated from `dcr.toml` and thus repeatable
+- IDE configurations may be customized after generation, but changes will be overwritten on next `dcr gen` run
+- For multi-binary projects, `vscode` and `clion` generate debug configs for all binaries (both debug + release variants)

docs/commands/dcr-init-or-new.md

@@ -0,0 +1,43 @@
+# dcr init/new
+
+## `dcr new <name>`
+
+Creates a new project directory and initializes it.
+
+```sh
+dcr new hello
+```
+
+Behavior:
+
+1. Validates arguments (`<name>` is required, only one name is allowed).
+2. Creates `<name>/`.
+3. Creates `<name>/dcr.toml`.
+4. Sets `package.name = "<name>"`.
+5. Creates `<name>/src/main.c` with a Hello World template.
+
+Errors:
+
+- Missing project name.
+- Extra arguments.
+- Target directory already exists.
+
+## `dcr init`
+
+Initializes DCR in the current directory.
+
+```sh
+dcr init
+```
+
+Behavior:
+
+1. Requires current directory to be empty.
+2. Creates `dcr.toml`.
+3. Sets `package.name` from the current directory name.
+4. Creates `src/main.c`.
+
+Errors:
+
+- Any arguments are treated as invalid.
+- Non-empty directory is rejected.

docs/commands/dcr-run.md

@@ -0,0 +1,40 @@
+# dcr run
+
+Builds the project and runs the resulting binary.
+
+## Usage
+
+```sh
+dcr run
+dcr run --debug
+dcr run --release
+dcr run --target linux --release
+dcr run --release --force
+dcr run --debug --clean
+```
+
+## Behavior
+
+1. Validates `dcr.toml`.
+2. Reads `package.name`, `build.kind`, and optional `build.target`.
+3. Runs the same build flow as `dcr build`.
+4. Executes the built artifact path for the selected profile.
+5. If `[run].cmd` is set, runs that command instead of the built binary.
+
+## Restrictions
+
+- If `build.kind` (or `build.{profile}.kind`) is `"staticlib"` or `"sharedlib"`, `run` exits with error.
+- The profile is selected from the first argument.
+- `--target <triple>` runs the binary for specified target (short names: `linux`, `macos`, `windows`).
+- `--force` skips build cache checks and recompiles.
+- `--clean` removes `target/<profile>` and `build.clean` paths before building.
+
+## `run.cmd` variables
+
+`run.cmd` supports the same variables as build steps: `{profile}`, `{version}`, `{version_major}`,
+`{version_minor}`, `{version_patch}`, `{version_suffix}`, `{version_suffix_dash}`.
+The command runs via `sh -c` on Unix and `cmd /C` on Windows.
+
+## On build failure
+
+`dcr run` attempts to launch an existing binary from the same profile if present; otherwise it reports that code errors must be fixed.

docs/commands/dcr-test.md

@@ -0,0 +1,45 @@
+# dcr test
+
+Runs the project's test suite.
+
+## Usage
+
+```sh
+dcr test
+dcr test --debug
+dcr test --release
+dcr test --target linux
+dcr test --init
+```
+
+## What `test` does
+
+1. Builds the project with the specified profile/target.
+2. Compiles test files in `tests/` (e.g., `tests/test.c`) into a test binary.
+3. Runs the test binary and parses output for PASS/SKIP/FAIL results.
+4. Reports summary with colored output.
+
+## Test Structure
+
+DCR uses a simple test framework:
+
+- Header: `tests/dcr_test.h` (generated by `dcr test --init`)
+- Test file: `tests/test.c` (template generated by `dcr test --init`)
+- Macros: `TEST(name)`, `TEST_CASE(name)`, `EXPECT(condition)`, `SKIP(reason)`
+- Output: `[PASS] test_name`, `[FAIL] test_name`, or `[SKIP] test_name`
+
+## Config values used
+
+- `package.name`
+- `build.compiler`, `build.language`, `build.standard`
+- `build.cflags`, `build.ldflags`
+- `build.debug` / `build.release`
+- `build.targets` (if specified)
+
+## Notes
+
+- Test binary is linked with the main project (for lib projects) or standalone.
+- `--init` creates `tests/dcr_test.h` and `tests/test.c` if missing.
+- Tests run in debug mode by default. Use `--release` for release mode.
+- Custom test logic can be added by editing `tests/test.c`.
+- Fails if no `tests/test.c` exists (run `dcr test --init` first).

docs/commands/dcr-tree.md

@@ -0,0 +1,22 @@
+# dcr tree
+
+Displays a visual dependency tree for the current project (similar to `cargo tree`).
+
+## Usage
+
+```sh
+dcr tree
+dcr tree --invert
+dcr tree -p some-package
+```
+
+## What it shows
+
+- All direct and transitive dependencies
+- Version of each dependency
+- Whether a dependency is a registry, git, or path dependency
+
+## Notes
+
+- Useful for debugging dependency issues and understanding the build graph.
+- Output format is inspired by `cargo tree`.

docs/commands/global-options.md

@@ -0,0 +1,44 @@
+# Global options
+
+## `dcr --help`
+
+```sh
+dcr --help
+```
+
+Prints top-level CLI usage, commands, flags, and examples.
+
+## `dcr --version`
+
+```sh
+dcr --version
+```
+
+Prints:
+
+```text
+dcr <version> (<target>)
+```
+
+## `dcr --update`
+
+```sh
+dcr --update
+```
+
+Update flow:
+
+1. Requests latest release from GitHub API.
+2. Finds asset matching current `DCR_TARGET`.
+3. Downloads replacement binary.
+4. Replaces current executable via `self-replace`.
+
+Limitations and behavior:
+
+- No extra arguments are accepted.
+- Requires network access to GitHub API/assets.
+- On Linux, if binary is owned by pacman, DCR prints package-manager update instructions instead of self-updating.
+
+## Running without command
+
+Running plain `dcr` (without arguments) shows help output.

docs/configuration/build-profiles.md

@@ -0,0 +1,74 @@
+# Build profiles
+
+DCR supports two profiles:
+
+- `debug` (default)
+- `release`
+
+## How to select
+
+```sh
+dcr build --debug
+dcr build --release
+dcr run --release
+dcr clean --debug
+```
+
+You can also add `--force` or `--clean` to `build`/`run`.
+
+## Default profile flags
+
+### GCC/Clang-like toolchains
+
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
+- `release`: `-O3 -DNDEBUG`
+
+### MSVC toolchain
+
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
+- `release`: `/O2 /DNDEBUG`
+
+## Artifacts
+
+By default:
+
+- `target/debug/<name>` (or `.exe` on Windows)
+- `target/release/<name>` (or `.exe` on Windows)
+
+Default compiler flags:
+
+GCC/Clang:
+
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
+- `release`: `-O3 -DNDEBUG`
+
+MSVC:
+
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
+- `release`: `/O2 /DNDEBUG`
+
+Static library mode (`kind = "staticlib"`):
+
+- Linux/macOS: `lib<name>.a`
+- Windows: `<name>.lib`
+
+Shared library mode (`kind = "sharedlib"`):
+
+- Linux: `lib<name>.so`
+- macOS: `lib<name>.dylib`
+- Windows: `<name>.dll`
+
+## Profile overrides
+
+Use `[build.debug]` and `[build.release]` to override build settings per profile.
+All values inherit from `[build]`. If a field is present in the profile table, it replaces the base value.
+For arrays (like `cflags`/`ldflags`), the profile value is appended to the base array.
+
+```toml
+[build.debug]
+cflags = ["-g3"]
+
+[build.release]
+cflags = ["-O3"]
+ldflags = ["-s"]
+```

docs/configuration/build-section.md

@@ -0,0 +1,154 @@
+# Build section
+
+## Schema
+
+```toml
+[build]
+language = "c"
+standard = "c11"
+compiler = "clang"
+kind = "bin"
+# filename = "KERNEL"
+# extension = "BIN"
+# optional:
+# inherit = true  # Inherit from base (default true)
+# targets = ["linux", "macos"]  # Multiple targets to build
+# target = "./dist"
+# platform = "x86_64"
+# cflags = ["-Wall"]
+# ldflags = ["-lm"]
+# exclude = ["src/vendor", "src/legacy/**"]
+# include = ["src/legacy/boot/**"]
+# roots = ["kernel", "drivers"]
+# src_disable = true
+# pkg_config = ["Qt6Core", "Qt6Widgets"]
+# generated = ["src/ui/*.h"]
+# expect = ["./target/{profile}/boot/*.bin"]
+# clean = ["./target/{profile}/boot", "/tmp/image/*.img"]
+```
+
+## Fields
+
+- `language` (string or array, required): `c`, `c++`, `cpp`, `cxx`, or `asm`.
+  Mixed languages can be specified as an array, for example `["c", "c++", "asm"]`.
+- `standard` (string, required): language standard passed to compiler.
+- `compiler` (string, required): compiler command (for example `clang`, `gcc`, `cl`).
+- `kind` (string, required): `bin`, `staticlib`, `sharedlib`, `efi`, or `elf`.
+- `filename` (string, optional): custom output filename (without extension). Overrides `package.name` for the final artifact.
+- `extension` (string, optional): custom file extension without the leading dot (e.g. `BIN`, `efi`, `EFI`). Combined with `filename`.
+- `inherit` (bool, optional): inherit settings from base `[build]` (default `true`). If `false`, only use target/profile specific settings.
+- `targets` (string array, optional): list of targets to build simultaneously. Supports short names (`linux`, `macos`, `windows`).
+- `target` (string, optional): custom output directory for final artifact.
+  When set, DCR automatically injects `--target=<value>` into `cflags` (useful for clang cross-compilation).
+- `platform` (string, optional): architecture hint for compiler (used for `-march` or `/arch`).
+- `cflags` (string array, optional): extra compile flags.
+- `ldflags` (string array, optional): extra link flags.
+- `ldscript` (string, optional): linker script path. Passed as `-T <path>` to the linker. Useful for bare-metal/embedded/freestanding targets.
+- `exclude` (string array, optional): paths or glob patterns to skip during source/header collection.
+- `include` (string array, optional): allowlist paths or globs that override `exclude`.
+- `include` directory entries (non-glob) are also passed to the compiler as `-I` include paths.
+- `roots` (string array, optional): additional source roots to scan instead of `src/`.
+- `src_disable` (bool, optional): disables default `src/` root when true.
+- `pkg_config` (string array, optional): packages used to append `pkg-config --cflags/--libs`.
+- `generated` (string array, optional): generated files to delete when build steps rerun.
+- `expect` (string array, optional): artifacts that must exist after build/post-steps.
+- `clean` (string array, optional): additional paths removed by `dcr clean` and `--clean`.
+
+Notes for `exclude`/`include`:
+- Supports `*` and `**` glob patterns.
+- If `include` is set, it has priority over `exclude`.
+- Use `include` to re-allow nested paths, for example exclude `src/boot` but allow `src/boot/arch/**`.
+When using glob patterns in `exclude`, DCR converts them internally, so `exclude` globs still work as expected.
+
+### Build steps
+
+Build steps run shell commands before compilation. Post steps run after linking.
+
+```toml
+[[build.steps]]
+name = "uic"
+in = "src/ui/*.ui"
+out = "src/ui/{stem}.h"
+cmd = "{uic} {in} -o {out}"
+
+[[build.post_steps]]
+name = "image"
+in = "target/{profile}/boot/*.bin"
+out = "/tmp/image/os-{version}.img"
+cmd = "dd if=/dev/zero of={out} bs=1M count=8"
+```
+
+Step notes:
+- `in` supports glob patterns.
+- If `in` expands to multiple files, `out` must include `{stem}`.
+- Steps run only when inputs are newer than outputs.
+- Variables: `{in}`, `{out}`, `{stem}`, `{cflags}`, `{uic}`, `{moc}`, `{rcc}`, `{profile}`,
+  `{version}`, `{version_major}`, `{version_minor}`, `{version_patch}`, `{version_suffix}`, `{version_suffix_dash}`.
+
+`build.clean` supports `{profile}` and version placeholders (`{version}`, `{version_major}`, ...).
+
+### Profile overrides
+
+Profile tables inherit all values from `[build]`. Any field present in the profile table replaces the base value.
+Array fields (like `cflags`/`ldflags`) are appended to the base array.
+
+Target tables override profile and base settings for specific targets. Full inheritance order:
+1. `[build.<target>.<profile>]`
+2. `[build.<profile>.<target>]`
+3. `[build.<target>]`
+4. `[build.<profile>]`
+5. `[build]`
+
+If custom `cflags` are set (non-empty), default compiler flags are disabled.
+
+```toml
+[build.debug]
+cflags = ["-g3"]
+
+[build.release]
+cflags = ["-O3"]
+ldflags = ["-s"]
+
+# Target-specific overrides (applied after profile)
+[build.linux]
+compiler = "gcc"
+cflags = ["-march=x86_64"]
+
+[build.macos]
+compiler = "clang"
+cflags = ["-arch", "x86_64"]
+
+# Full inheritance example
+[build.linux.release]
+cflags = ["-O3", "-march=native"]  # Overrides profile and base
+
+[build.release.linux]
+ldflags = ["-static"]  # Alternative order
+
+[build.windows.debug]
+compiler = "x86_64-w64-mingw32-gcc"
+cflags = []  # Empty to disable defaults
+
+[build.release]
+inherit = false  # No inheritance, only explicit settings
+```
+
+## Toolchain section
+
+```toml
+[toolchain]
+cc = "clang"
+cxx = "clang++"
+as = "as"
+ar = "ar"
+ld = "ld"
+uic = "uic"
+moc = "moc"
+rcc = "rcc"
+```
+
+## Behavior notes
+
+- Compiler backend is selected by compiler string (`gcc`, `clang`, `cl`, `clang-cl`).
+- Empty or unknown compiler value falls back to clang-like build path.
+- `run` is not allowed for library kinds (`staticlib`, `sharedlib`), `efi`, or `elf`.

docs/configuration/dcr.toml-overview.md

@@ -0,0 +1,71 @@
+# dcr.toml overview
+
+`dcr.toml` is the main project file used by DCR.
+
+## Minimal generated template
+
+```toml
+[package]
+name = "hello"
+version = "0.1.0"
+
+[build]
+language = "c"
+standard = "c11"
+compiler = "clang"
+kind = "bin"
+
+[dependencies]
+```
+
+`dcr new` and `dcr init` generate this structure automatically.
+
+## Required sections
+
+- `[package]`
+- `[build]`
+- `[dependencies]`
+
+Workspace-only root:
+- `[workspace]` can be added to a normal root config to define members and dependency order.
+- Root config still requires `[package]`, `[build]`, and `[dependencies]`.
+
+## Required keys
+
+- `package.name`
+- `package.version`
+- `build.language`
+- `build.standard`
+- `build.compiler`
+- `build.kind`
+
+`build.kind` must be either `bin`, `staticlib`, or `sharedlib`.
+
+## Optional keys
+
+- `build.inherit`
+- `build.targets`
+- `build.target`
+- `build.platform`
+- `build.cflags`
+- `build.ldflags`
+- `build.exclude`
+- `build.include`
+- `build.roots`
+- `build.src_disable`
+- `build.pkg_config`
+- `build.steps`
+- `build.post_steps`
+- `build.generated`
+- `build.expect`
+- `build.clean`
+- `build.debug`
+- `build.release`
+- `build.<target>` (target-specific overrides)
+- dependency fields (`include`, `lib`, `libs`, `system`)
+- `[toolchain]` overrides (`cc`, `cxx`, `as`, `ar`, `ld`, `uic`, `moc`, `rcc`)
+- `[toolchain.<target>]` (target-specific toolchain)
+- `[workspace]` members
+- `[workspace.<target>]` (target-specific workspace)
+- `[run]` overrides (`cmd`)
+- `[run.<target>]` (target-specific run)

docs/configuration/dependencies-section.md

@@ -0,0 +1,44 @@
+# Dependencies section
+
+DCR supports registry-based dependencies and path dependencies.
+
+## Example
+
+```toml
+[dependencies]
+# Registry dependency
+mylib = "0.1.0"
+# Git dependency
+json = { git = "https://github.com/nlohmann/json", tag = "v3.11.2" }
+# Path dependency
+frecli = { path = "./lib/frecli", include = ["."], lib = ["."], libs = ["frecli"] }
+```
+
+## Supported dependency types
+
+### Registry dependencies
+Defined by name and version string. DCR automatically resolves the package from the configured registry index.
+
+### Git dependencies
+Defined by repository URL and optionally branch, tag, or revision.
+- `git` (string, required): repository URL.
+- `branch`, `tag`, `rev` (string, optional): Git reference.
+
+### Path dependencies
+- `path` (string, required): absolute path or path relative to project root.
+- `include` (string array, optional): include directories inside dependency.
+- `lib` (string array, optional): library directories inside dependency.
+- `libs` (string array, optional): library names for linker.
+
+## Defaults for path dependencies
+
+- If `include` is omitted, DCR tries `<dep>/include`.
+- If `lib` is omitted, DCR tries `<dep>/lib`, then `<dep>/lib64`.
+- If `libs` is omitted, dependency key name is used.
+
+## Validation
+
+- Dependency value must be a string (registry) or a TOML table (path).
+- Registry dependencies use the version string to match versions in the registry.
+- `path` is mandatory for path dependencies.
+- `include`/`lib`/`libs` must be arrays of strings if provided.

docs/configuration/package-section.md

@@ -0,0 +1,23 @@
+# Package section
+
+## Schema
+
+```toml
+[package]
+name = "my-app"
+version = "0.1.0"
+type = "app"
+```
+
+## Fields
+
+- `name` (string, required): used as output artifact base name.
+- `version` (string, required): used in `dcr.lock` project entry.
+- `type` (string, optional): project type (`app`, `lib`, `none`).
+
+## Notes
+
+- Empty `name` or `version` makes config invalid.
+- `dcr new` sets `name` from the passed project name.
+- `dcr init` sets `name` from current directory name.
+- If `type = "lib"`, DCR generates `include/` and `lib/` directories in the target path, copying public headers and built libraries.

docs/dependencies-and-build/compilers-and-linking.md

@@ -0,0 +1,78 @@
+# Compilers & linking
+
+## Compiler backend selection
+
+DCR picks a backend from `build.compiler`:
+
+- contains `clang-cl` -> MSVC backend
+- equals `as` or contains `gas` -> GAS backend (standalone assembler)
+- contains `gcc` or `g++` -> GCC backend
+- contains `clang` or `clang++` -> Clang backend
+- equals `cl` or contains `msvc` -> MSVC backend
+- contains `nasm` -> NASM backend
+- otherwise -> Clang backend fallback
+
+## Compilation model
+
+- Source files are found recursively in `src/` based on `build.language`.
+- `build.roots` and `build.src_disable` can replace the default `src/` root.
+- Mixed language builds use arrays, for example `build.language = ["c", "asm"]`.
+- Each source is compiled to `target/<target>/<profile>/obj/<relative-path>.o` (`.obj` on MSVC, where `<target>` is `native` or target triple).
+- Recompile happens when source mtime is newer than object mtime.
+- `build.exclude` removes paths from source/header collection; `build.include` re-allows matching paths and has priority over `exclude`.
+
+## Default build flags
+
+These flags are applied automatically based on profile and compiler backend.
+
+GCC/Clang:
+
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
+- `release`: `-O3 -DNDEBUG`
+
+MSVC:
+
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
+- `release`: `/O2 /DNDEBUG`
+
+Note: If custom `cflags` are set in `dcr.toml`, default profile flags are disabled to allow full control.
+
+## Platform hint
+
+If `build.platform` is set, DCR passes it as an architecture hint:
+
+- GCC/Clang: `-march=<platform>`
+- MSVC: maps to `/arch:*` for known values (`x86`, `i386`, `i486`, `i586`, `i686`, `sse2`, `avx`, `avx2`)
+
+## Toolchain overrides
+
+If `[toolchain]` is set, DCR uses its values to override compiler/linker tools:
+
+- `cc`, `cxx`, `as` override compilers for C/C++/ASM
+- `ar` overrides the archiver (used for `staticlib`)
+- `ld` overrides the linker (used by GCC/Clang/NASM/GAS backends)
+- `uic`, `moc`, `rcc` override Qt tools used in `build.steps`
+
+Environment overrides (highest priority):
+- `DCR_COMPILER` (all languages)
+- `DCR_CC`, `DCR_CXX`, `DCR_AS`, `DCR_AR`, `DCR_LD`
+- `DCR_DEBUG` enables verbose build logging
+
+## Linking
+
+For `kind = "bin"`:
+
+- Object files are linked into executable artifact.
+- Dependency lib dirs and library names are passed to linker.
+- `build.ldflags` are appended to link command.
+
+For `kind = "staticlib"`:
+
+- Linux/macOS (GCC/Clang): `ar rcs` creates `.a` archive.
+- Windows (MSVC): `lib` creates `.lib` archive.
+
+For `kind = "sharedlib"`:
+
+- Linux (GCC/Clang): `-shared` with output `.so`.
+- macOS (Clang): `-dynamiclib` with output `.dylib`.
+- Windows (MSVC): `/LD` with output `.dll`.

docs/dependencies-and-build/cross-compilation.md

@@ -0,0 +1,203 @@
+# Cross-compilation and Targets
+
+DCR supports cross-compilation to different platforms using the `--target` flag. This allows building your project for architectures and operating systems different from the host.
+
+## Basic Usage
+
+```bash
+# Build for a specific target
+dcr build --target x86_64-unknown-linux-gnu --release
+
+# Short names for common platforms
+dcr build --target linux --release    # x86_64-unknown-linux-gnu
+dcr build --target macos --release    # x86_64-apple-darwin
+dcr build --target windows --release  # x86_64-pc-windows-msvc
+
+# Run for a specific target
+dcr run --target linux --release
+```
+
+## Supported Targets
+
+### Short Names
+- `linux` → `x86_64-unknown-linux-gnu`
+- `macos` → `x86_64-apple-darwin`
+- `windows` → `x86_64-pc-windows-msvc`
+
+### Full Target Triples
+DCR supports any valid target triple in the format `<arch>-<vendor>-<os>-<abi>`. Common examples:
+- `x86_64-unknown-linux-gnu`
+- `aarch64-linux-gnu`
+- `x86_64-apple-darwin`
+- `aarch64-apple-darwin`
+- `x86_64-pc-windows-msvc`
+- `i686-pc-windows-gnu`
+
+## Configuration
+
+### Multiple Targets
+
+Configure multiple targets to build simultaneously:
+
+```toml
+[build.targets]
+targets = ["linux", "macos", "windows"]
+
+# Or per profile
+[build.release.targets]
+targets = ["linux", "macos"]
+```
+
+If no `--target` is specified, DCR builds for all targets in `build.targets` (or native if empty).
+
+### Target-Specific Settings
+
+Override settings for specific targets:
+
+```toml
+[build.linux]
+compiler = "gcc"
+cflags = ["-Wall", "-O2"]
+
+[build.macos]
+compiler = "clang"
+cflags = ["-Wall", "-O2", "-arch", "x86_64"]
+
+[build.windows]
+compiler = "x86_64-w64-mingw32-gcc"
+ldflags = ["-static"]
+```
+
+### Target-Specific Toolchain
+
+Configure toolchain per target:
+
+```toml
+[toolchain.linux]
+cc = "gcc"
+ld = "ld"
+
+[toolchain.macos]
+cc = "clang"
+ld = "ld"
+
+[toolchain.windows]
+cc = "x86_64-w64-mingw32-gcc"
+ld = "x86_64-w64-mingw32-ld"
+```
+
+### Target-Specific Run Commands
+
+Use custom run commands per target:
+
+```toml
+[run.linux]
+cmd = "./target/linux/release/myapp"
+
+[run.macos]
+cmd = "open ./target/macos/release/myapp.app"
+
+[run.windows]
+cmd = "wine ./target/windows/release/myapp.exe"
+```
+
+## Workspace and Dependencies Inheritance
+
+Workspace and dependencies sections also support target/profile inheritance:
+
+```toml
+[workspace.linux]
+members = [
+  { name = "lib1", path = "libs/lib1" },
+]
+
+[dependencies.linux]
+sdl2 = { system = true, include = ["/usr/include/SDL2"] }
+
+[dependencies.windows]
+sdl2 = { system = true, include = ["C:/SDL2/include"] }
+```
+
+Order: `workspace.target.profile` → `workspace.profile.target` → `workspace.target` → `workspace.profile` → `workspace`.
+
+Add `inherit = false` to disable inheritance in any section.
+
+Settings are applied in order:
+1. `[build.<target>]`
+2. `[build.<profile>]`
+3. `[build]`
+
+### Toolchain Configuration
+
+For cross-compilation, configure toolchains:
+
+```toml
+[toolchain]
+cc = "aarch64-linux-gnu-gcc"
+cxx = "aarch64-linux-gnu-g++"
+ar = "aarch64-linux-gnu-ar"
+ld = "aarch64-linux-gnu-ld"
+```
+
+## Output Structure
+
+Build outputs are organized by target:
+
+```
+target/
+├── native/
+│   ├── debug/
+│   └── release/
+├── x86_64-unknown-linux-gnu/
+│   ├── debug/
+│   └── release/
+└── aarch64-linux-gnu/
+    ├── debug/
+    └── release/
+```
+
+## Requirements
+
+- Cross-compilation requires appropriate toolchains installed (e.g., `aarch64-linux-gnu-gcc` on Arch Linux).
+- For Windows targets on Linux, install MinGW: `pacman -S mingw-w64-gcc`.
+- For macOS targets on Linux, use `osxcross` or similar.
+
+## Examples
+
+### ARM Linux Build
+
+```bash
+# Install toolchain (Arch Linux)
+pacman -S aarch64-linux-gnu-gcc
+
+# Configure
+echo '[build.aarch64-linux-gnu]
+compiler = "aarch64-linux-gnu-gcc"' >> dcr.toml
+
+# Build
+dcr build --target aarch64-linux-gnu --release
+```
+
+**Note:** If you set `target = "aarch64-linux-gnu"` (or any value) directly under `[build]`, DCR will automatically add `--target=...` to cflags when using clang. You usually don't need to repeat it manually.
+
+### Windows Build on Linux
+
+```bash
+# Install toolchain (Arch Linux)
+pacman -S mingw-w64-gcc
+
+# Configure
+echo '[build.windows]
+compiler = "x86_64-w64-mingw32-gcc"' >> dcr.toml
+
+# Build
+dcr build --target windows --release
+```
+
+## Troubleshooting
+
+- **Toolchain not found**: Ensure the compiler is installed and in PATH, or configure `[toolchain]` in `dcr.toml`. For Arch Linux: `pacman -S aarch64-linux-gnu-gcc` for ARM, `pacman -S mingw-w64-gcc` for Windows cross-compilation.
+- **Linking errors**: Check `ldflags` and library paths for cross-compilation.
+- **Header issues**: Include paths may differ; use target-specific `cflags`.
+
+For more help, see [Troubleshooting map](troubleshooting-map.md).

docs/dependencies-and-build/dependency-format.md

@@ -0,0 +1,40 @@
+# Dependency format
+
+Dependencies are defined in `dcr.toml` under `[dependencies]`.
+
+## Full example (Path)
+
+```toml
+[dependencies]
+fmt = { path = "./third_party/fmt", include = ["include"], lib = ["lib"], libs = ["fmt"] }
+```
+
+## Full example (Git)
+
+```toml
+[dependencies]
+json = { git = "https://github.com/nlohmann/json", tag = "v3.11.2" }
+```
+
+## Field reference
+
+- `path`: local path to dependency root.
+- `git`: URL of Git repository.
+- `branch`: Git branch name.
+- `tag`: Git tag name.
+- `rev`: Git commit SHA.
+- `include`: optional include subpaths (absolute or relative to dep root).
+- `lib`: optional library subpaths (absolute or relative to dep root).
+- `libs`: optional linker library names.
+
+## Common valid compact forms
+
+```toml
+[dependencies]
+mylib = { path = "./libs/mylib" }
+gitlib = { git = "https://github.com/user/repo" }
+# Shortest form for path
+simple = "./libs/simple"
+```
+
+In these forms DCR will try defaults for include/lib dirs and use the dependency name as the linker library name.

docs/dependencies-and-build/local-dependencies.md

@@ -0,0 +1,24 @@
+# Local dependencies
+
+## Resolution flow during build
+
+For each dependency in `[dependencies]`, DCR:
+
+1. Resolves `path` (absolute or project-relative).
+2. Resolves include dirs (`include` or default `include`).
+3. Resolves lib dirs (`lib` or defaults `lib`, `lib64`).
+4. Resolves link libs (`libs` or dependency name).
+5. Synchronizes dependency files to `target/<profile>/deps/<dep-name>/`.
+6. Adds include/lib/link options to compile/link commands.
+
+### Profile placeholders
+
+`path`, `include`, and `lib` entries may use `{profile}` which expands to the active profile
+(`debug` or `release`).
+
+## Failure cases
+
+- Dependency path is missing or not a directory.
+- No valid include/lib directories were found.
+- Any configured include/lib path does not exist.
+- Invalid field types in dependency config.

docs/dependencies-and-build/target-directory.md

@@ -0,0 +1,23 @@
+# Target directory
+
+By default, DCR writes final artifacts to `target/<target>/<profile>/` (where `<target>` is `native` or target triple).
+
+You can override this with `build.target`:
+
+```toml
+[build]
+target = "./dist"
+```
+
+## Behavior
+
+- Binary mode:
+  - Linux/macOS: `<target>/<name>`
+  - Windows: `<target>/<name>.exe`
+- Static library mode:
+  - Linux/macOS: `<target>/lib<name>.a`
+  - Windows: `<target>/<name>.lib`
+
+## Important detail
+
+`build.target` changes only the final artifact location. Object cache and dependency sync directories still use `target/<target>/<profile>/...`.

docs/dependencies-and-build/versioning-and-lock-file.md

@@ -0,0 +1,32 @@
+# Versioning & lock file
+
+DCR generates `dcr.lock` when dependency resolution succeeds and at least one dependency exists.
+
+## What is stored
+
+- Project entry (`name`, `version`, dependency names).
+- One entry per resolved dependency:
+  - `name`
+  - `version` (from dependency `dcr.toml`, fallback `0.0.0`)
+  - `source` (`path+...`)
+  - `checksum` (SHA-256 over dependency files, excluding nested `target/`).
+
+## Example shape
+
+```toml
+[[package]]
+name = "my-app"
+version = "0.1.0"
+dependencies = ["fmt"]
+
+[[package]]
+name = "fmt"
+version = "1.2.3"
+source = "path+./third_party/fmt"
+checksum = "..."
+```
+
+## Notes
+
+- `dcr.lock` is rewritten on successful dependency resolution.
+- If `[dependencies]` is empty, lock generation is skipped.

docs/getting-started/build-and-run.md

@@ -0,0 +1,57 @@
+# Build and run
+
+## Build
+
+Debug (default):
+
+```sh
+dcr build
+# or
+dcr build --debug
+dcr build --target linux --debug
+dcr build --debug --clean
+```
+
+Release:
+
+```sh
+dcr build --release
+dcr build --target windows --release
+```
+
+## Run
+
+```sh
+dcr run
+# or
+dcr run --target macos
+dcr run --release
+dcr run --target linux --release
+dcr run --release --force
+```
+
+`dcr run` first builds, then launches the produced binary.
+
+## Clean artifacts
+
+```sh
+dcr clean
+```
+
+Profile-only cleanup:
+
+```sh
+dcr clean --debug
+dcr clean --release
+dcr clean --all
+dcr clean --release --all
+```
+
+## Notes
+
+- `run` is unavailable for `build.kind = "staticlib"`, `build.kind = "sharedlib"`, `build.kind = "efi"`, and `build.kind = "elf"`.
+- Build profile flag (`--debug` / `--release`) can be passed in any argument position.
+- Unknown profile flags produce an error.
+- In workspace root, `clean --all` cleans all member projects.
+- `--target` builds/runs for specified target (short names: `linux`, `macos`, `windows`).
+- `--clean` for `build`/`run` removes `target/<target>/<profile>` and paths from `build.clean`.

docs/getting-started/create-your-first-project.md

@@ -0,0 +1,41 @@
+# Create your first project
+
+## Create in a new folder
+
+```sh
+dcr new hello
+cd hello
+```
+
+This creates:
+
+```text
+hello/
+- dcr.toml
+- src/
+- - main.c
+```
+
+## Or initialize current folder
+
+```sh
+mkdir hello
+cd hello
+dcr init
+```
+
+`dcr init` requires the current directory to be empty.
+
+## Next steps
+
+Build and run:
+
+```sh
+dcr run
+```
+
+Release build/run:
+
+```sh
+dcr run --release
+```

docs/getting-started/installation.md

@@ -0,0 +1,56 @@
+# Installation
+
+## Option 1: Install via script
+
+### Linux/macOS
+
+```sh
+curl -fsSL https://dcr.dexoron.su/install.sh | bash
+```
+
+Alternative with `wget`:
+
+```sh
+wget -qO- https://dcr.dexoron.su/install.sh | bash
+```
+
+### Windows (PowerShell)
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://dcr.dexoron.su/install.ps1 | iex"
+```
+
+## Option 2: Build from source
+
+```sh
+git clone https://github.com/dexoron/dcr.git
+cd dcr
+cargo build --release
+mkdir -p ~/.local/bin
+ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+```
+
+## Option 3: Arch Linux (AUR)
+
+```sh
+yay -S dcr
+```
+
+(You can also use `paru` or other AUR helpers.)
+
+## Verify installation
+
+```sh
+dcr --version
+```
+
+Expected format:
+
+```text
+dcr <version> (<target>)
+```
+
+## Update policy
+
+- If DCR was installed from GitHub releases, scripts, or manual build: use `dcr --update`.
+- If DCR is managed by `pacman/AUR`: update via package manager. On Linux, `dcr --update` detects pacman-owned binaries and prints a package-manager hint.

docs/getting-started/project-structure.md

@@ -0,0 +1,40 @@
+# Project structure
+
+## Minimal project
+
+```text
+project/
+- dcr.toml
+- src/
+- - main.c
+```
+
+## Typical generated/optional files
+
+```text
+project/
+- dcr.toml
+- dcr.lock
+- src/
+- - ... source files ...
+- target/
+- - debug/
+- - - obj/
+- - - deps/
+- - release/
+- - - obj/
+- - - deps/
+```
+
+## Meaning
+
+- `dcr.toml`: main project configuration.
+- `dcr.lock`: generated lock file for resolved path dependencies.
+- `src/`: recursively scanned source directory.
+- `target/<target>/<profile>/obj/`: cached object files for incremental rebuild (where `<target>` is `native` or target triple).
+- `target/<target>/<profile>/deps/`: synchronized copies of path dependencies.
+- `target/<target>/<profile>/<name>` (or `.exe` on Windows): output for `kind = "bin"`.
+- `target/<target>/<profile>/lib<name>.a` (or `<name>.lib` on Windows): output for `kind = "staticlib"`.
+- `target/<target>/<profile>/lib<name>.so` (or `.dylib` on macOS, `<name>.dll` on Windows): output for `kind = "sharedlib"`.
+
+If `build.target` is set, the final artifact is written to that custom directory, while object cache still stays in `target/<target>/<profile>/obj`.

docs/reference-and-help/cli-reference.md

@@ -0,0 +1,34 @@
+# CLI reference
+
+## Command list
+
+```text
+dcr new <name>
+dcr init
+dcr setup
+dcr add <name> <source>(optional)
+dcr build [--debug|--release] [--target <triple>]
+dcr run [--debug|--release]
+dcr clean [--debug|--release] [--all]
+dcr tree
+dcr test
+dcr gen <subcommand>
+dcr --help
+dcr --version
+dcr --update
+```
+
+## Notes on argument parsing
+
+- `build`/`run` parse flags in any order (`--debug|--release`, `--force`, `--clean`, `--verbose`) and reject duplicates.
+- `new` requires exactly one argument.
+- `init` and `--update` do not accept extra arguments.
+- `clean` accepts `--debug|--release` and optional `--all`.
+- `gen` supports `project-info`, `compile-commands`, `vscode`, `clion`.
+- `tree` shows a dependency tree (similar to `cargo tree`).
+- `test` / `tests` runs the project's tests.
+
+## Exit behavior overview
+
+- Successful command execution returns `0`.
+- Validation/build/runtime failures return non-zero status.

docs/reference-and-help/config-reference.md

@@ -0,0 +1,106 @@
+# Config reference
+
+## Full schema
+
+```toml
+[package]
+name = "string"      # required
+version = "string"   # required
+
+[build]
+language = "c|c++|cpp|cxx|asm"     # required (string or array)
+standard = "string"            # required
+compiler = "string"            # required
+kind = "bin|staticlib|sharedlib"         # required
+filename = "string"            # optional (custom output name without extension)
+extension = "string"           # optional (custom extension without dot, e.g. "BIN")
+target = "string"              # optional
+platform = "string"            # optional
+cflags = ["string", "..."]     # optional
+ldflags = ["string", "..."]    # optional
+ldscript = "string"            # optional (linker script, passed as -T<path>)
+exclude = ["string", "..."]    # optional
+include = ["string", "..."]    # optional
+roots = ["string", "..."]      # optional
+src_disable = false            # optional
+pkg_config = ["string", "..."] # optional
+generated = ["string", "..."]  # optional
+expect = ["string", "..."]     # optional
+clean = ["string", "..."]      # optional
+
+[[build.steps]]
+name = "string"
+in = "glob"
+out = "path or glob"
+cmd = "string"
+
+[[build.post_steps]]
+name = "string"
+in = "glob"
+out = "path or glob"
+cmd = "string"
+
+# Inline array form (equivalent to [[build.steps]] / [[build.post_steps]])
+steps = [
+  { name = "string", in = "glob", out = "path or glob", cmd = "string" },
+]
+post_steps = [
+    { name = "string", in = "glob", out = "path or glob", cmd = "string" },
+]
+
+[build.debug]
+cflags = ["string", "..."]     # optional
+ldflags = ["string", "..."]    # optional
+
+[build.release]
+cflags = ["string", "..."]     # optional
+ldflags = ["string", "..."]    # optional
+
+[toolchain]
+cc = "string"   # optional
+cxx = "string"  # optional
+as = "string"   # optional
+ar = "string"   # optional
+ld = "string"   # optional
+uic = "string"  # optional
+moc = "string"  # optional
+rcc = "string"  # optional
+
+[run]
+cmd = "string"  # optional
+
+[workspace]
+name = { path = "string", deps = ["string", "..."] }
+
+[dependencies]
+name = {
+  path = "string",              # required for each dependency
+  include = ["string", "..."],  # optional
+  lib = ["string", "..."],      # optional
+  libs = ["string", "..."],     # optional
+}
+```
+
+## Validation rules
+
+- `[package]`, `[build]`, `[dependencies]` must exist.
+- Required string fields must be non-empty.
+- `build.kind` must be `bin`, `staticlib`, or `sharedlib`.
+- Dependency fields `include/lib/libs` must be string arrays when provided.
+- `build.exclude`/`build.include` must be string arrays when provided.
+- `build.roots` must be a string array when provided.
+- `build.src_disable` must be boolean when provided.
+- `build.clean`/`build.generated`/`build.pkg_config`/`build.expect` must be string arrays when provided.
+- `build.debug`/`build.release` must be tables; their `cflags`/`ldflags` must be string arrays.
+- `build.steps`/`build.post_steps` entries must include `name`, `in`, `out`, `cmd`.
+- `build.language` may be a string or array (for example `["c", "c++", "asm"]`).
+- `[build.<profile>]` tables inherit all base values and override any fields they specify.
+  Array fields (like `cflags`/`ldflags`) are appended to the base array.
+
+## Generated defaults (`dcr new` / `dcr init`)
+
+- `package.version = "0.1.0"`
+- `build.language = "c"`
+- `build.standard = "c11"`
+- `build.compiler = "clang"`
+- `build.kind = "bin"`

docs/reference-and-help/contributing-and-bug-reports.md

@@ -0,0 +1,34 @@
+# Contributing & Bug reports
+
+## Contribution workflow
+
+1. Fork `dexoron/dcr` (and `dexoron/dcr-site` if docs website changes are needed).
+2. Make focused changes.
+3. Run checks locally:
+
+```bash
+cargo fmt --all
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check
+```
+
+4. Open a PR with short rationale and behavior impact.
+5. Update docs when CLI behavior changes.
+
+## Bug report checklist
+
+Include:
+
+1. DCR version (`dcr --version`).
+2. OS and compiler/toolchain version.
+3. Reproduction steps.
+4. Expected result.
+5. Actual result and full error output.
+6. Minimal reproducible project.
+
+## Where to report
+
+Use GitHub Issues in the relevant repository:
+
+- <https://github.com/dexoron/dcr>
+- <https://github.com/dexoron/dcr-site>

docs/reference-and-help/faq.md

@@ -0,0 +1,35 @@
+# FAQ
+
+## What commands are available?
+
+`new`, `init`, `build`, `run`, `clean`, `gen`, `--help`, `--version`, `--update`.
+
+## Is `dcr.toml` mandatory?
+
+Yes, for `build`, `run`, and `clean`.
+
+## What source files are compiled?
+
+DCR scans `src/` recursively:
+
+- for C: `*.c`
+- for C++: `*.cpp`, `*.cxx`, `*.cc`
+
+## Can I switch compiler?
+
+Yes. Set `build.compiler` in `dcr.toml` (for example `gcc`, `clang`, `cl`, `clang-cl`).
+
+## How does incremental rebuild work?
+
+It compares source file mtime with object file mtime.
+Header dependencies are tracked too: if an included header changes (or disappears), rebuild is triggered.
+
+## What does `dcr run` do if build fails?
+
+It tries to run an existing binary from the selected profile; if none exists, it reports an error.
+
+## How do I update DCR?
+
+Use `dcr --update` for non-package-managed installs.
+
+If installed through pacman/AUR, update via package manager.

docs/reference-and-help/flags-and-environment.md

@@ -0,0 +1,48 @@
+# Flags & environment
+
+This page summarizes runtime flags and environment variables that affect DCR behavior.
+
+## Build/run flags
+
+Used with `dcr build` and `dcr run`:
+
+- `--debug`: select debug profile.
+- `--release`: select release profile.
+- `--force`: ignore incremental cache checks and rebuild.
+- `--clean`: remove `target/<profile>` and `build.clean` paths before build.
+
+Notes:
+
+- Flags can be passed in any order.
+- Duplicate profile flags are rejected.
+
+## Clean flags
+
+Used with `dcr clean`:
+
+- `--debug` / `--release`: clean only selected profile directory.
+- `--all`: in workspace root, also clean all members.
+
+## Environment variables
+
+Tool selection overrides:
+
+- `DCR_COMPILER` (all languages)
+- `DCR_CC`, `DCR_CXX`, `DCR_AS`, `DCR_AR`, `DCR_LD`
+
+Diagnostics:
+
+- `DCR_DEBUG=1` enables verbose build logging.
+
+## Quick examples
+
+```sh
+# Force full release rebuild
+dcr build --release --force
+
+# Clean before debug run
+dcr run --clean --debug
+
+# Use custom compiler from env
+DCR_CC=clang-18 dcr build --debug
+```

docs/reference-and-help/troubleshooting-map.md

@@ -0,0 +1,75 @@
+# Troubleshooting map
+
+Fast mapping from symptom to likely cause and first action.
+
+## `dcr.toml file not found`
+
+Likely cause:
+- you are outside project root (or member root).
+
+First action:
+```sh
+pwd
+ls
+```
+Run DCR from directory that contains `dcr.toml`.
+
+## `Invalid config: missing [package]` / `missing [build]`
+
+Likely cause:
+- incomplete config in root project.
+
+First action:
+- ensure root `dcr.toml` includes `[package]`, `[build]`, and `[dependencies]`.
+- for workspace setups, keep these sections in root and add `[workspace]` additionally.
+
+## `Unknown build flag` or profile-flag errors
+
+Likely cause:
+- typo in flag or duplicate profile flag.
+
+First action:
+```sh
+dcr --help
+```
+Use only supported flags and at most one of `--debug` / `--release`.
+
+## Dependency include/lib path errors
+
+Likely cause:
+- path in `[dependencies]` does not exist.
+
+First action:
+- verify `path`, `include`, `lib` values.
+- if using profile placeholders, confirm expanded paths exist for selected profile.
+
+## `Cannot run library build`
+
+Likely cause:
+- `build.kind` is `staticlib` or `sharedlib`.
+
+First action:
+- switch `build.kind` to `bin`, or set `[run].cmd` if you intentionally need custom run command.
+
+## Build succeeds but output is stale
+
+Likely cause:
+- stale artifacts or generated files from previous runs.
+
+First action:
+```sh
+dcr clean --all
+dcr build --force
+```
+
+## `dcr --update` suggests package manager update
+
+Likely cause:
+- DCR binary is managed by pacman/AUR.
+
+First action:
+```sh
+yay -Syu dcr
+# or
+paru -Syu dcr
+```

docs/reference-and-help/workspace-guide.md

@@ -0,0 +1,53 @@
+# Workspace guide
+
+`[workspace]` lets you build related DCR projects in dependency order from one root.
+
+## Important rule
+
+Workspace root still needs a valid root project config:
+
+- `[package]`
+- `[build]`
+- `[dependencies]`
+
+`[workspace]` augments that root config; it does not replace required root sections.
+
+## Minimal example
+
+```toml
+[package]
+name = "root-app"
+version = "0.1.0"
+
+[build]
+language = "c"
+standard = "c11"
+compiler = "clang"
+kind = "bin"
+
+[dependencies]
+
+[workspace]
+core = { path = "./modules/core", deps = [] }
+net = { path = "./modules/net", deps = ["core"] }
+app = { path = "./modules/app", deps = ["core", "net"] }
+```
+
+Each member path must point to a directory containing its own `dcr.toml`.
+
+## Build behavior
+
+- Running `dcr build` in workspace root builds members in topological dependency order, then builds the root project.
+
+- Running `dcr clean --all` in workspace root cleans all members too.
+
+- `dcr gen` in workspace root includes root + members in generated outputs.
+
+## Common errors
+
+- `workspace.<name>.path does not contain dcr.toml`:
+  member path is wrong or config is missing.
+- `workspace dependency '<name>' not found`:
+  `deps` references unknown member.
+- `workspace dependency cycle at <name>`:
+  cyclic dependencies in member graph.

install.ps1

@@ -1,64 +1,96 @@
 $ErrorActionPreference = 'Stop'
 
-$RepoUrl = 'https://github.com/dexoron/dcr'
+$RepoUrl    = 'https://github.com/dexoron/dcr'
-$ApiUrl = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiLatest  = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiAll     = 'https://api.github.com/repos/dexoron/dcr/releases'
 $InstallPath = Join-Path $env:LOCALAPPDATA 'dcr'
-$BinPath = Join-Path $env:USERPROFILE '.local\bin'
+$BinPath     = Join-Path $env:USERPROFILE '.local\bin'
-$BinaryPath = Join-Path $InstallPath 'dcr.exe'
+$BinaryPath  = Join-Path $InstallPath 'dcr.exe'
 
-function Info($msg) { Write-Host "[INFO] $msg" -ForegroundColor Cyan }
+function Info($msg)  { Write-Host "[INFO] $msg"  -ForegroundColor Cyan   }
-function Ok($msg) { Write-Host "[OK] $msg" -ForegroundColor Green }
+function Ok($msg)    { Write-Host "[OK] $msg"    -ForegroundColor Green  }
-function Warn($msg) { Write-Host "[WARN] $msg" -ForegroundColor Yellow }
+function Warn($msg)  { Write-Host "[WARN] $msg"  -ForegroundColor Yellow }
-function Fail($msg) { Write-Host "[ERROR] $msg" -ForegroundColor Red; exit 1 }
+function Fail($msg)  { Write-Host "[ERROR] $msg" -ForegroundColor Red; exit 1 }
 
 function Require-Cmd($name) {
     if (-not (Get-Command $name -ErrorAction SilentlyContinue)) {
-        Fail "Не найдено: $name"
+        Fail "Not found: $name"
+    }
+}
+
+function Select-Channel {
+    Write-Host "Choose channel:"
+    Write-Host "  1) Latest stable release (default)"
+    Write-Host "  2) Latest dev (pre-release)"
+    $choice = Read-Host "Enter 1 or 2 [1]"
+    if ([string]::IsNullOrWhiteSpace($choice)) { $choice = '1' }
+
+    switch ($choice) {
+        '1' { return 'stable' }
+        '2' { return 'dev'    }
+        default { Fail 'Unknown option' }
     }
 }
 
 function Select-Mode {
-    Write-Host "Выбери способ установки:"
+    Write-Host "Choose installation mode:"
-    Write-Host "  1) Скачать готовый бинарник из GitHub Release (рекомендуется)"
+    Write-Host "  1) Download prebuilt binary from GitHub Release (recommended)"
-    Write-Host "  2) Собрать из git"
+    Write-Host "  2) Build from git"
-    $choice = Read-Host "Введите 1 или 2 [1]"
+    $choice = Read-Host "Enter 1 or 2 [1]"
     if ([string]::IsNullOrWhiteSpace($choice)) { $choice = '1' }
 
     switch ($choice) {
         '1' { return 'release' }
-        '2' { return 'build' }
+        '2' { return 'build'   }
-        default { Fail 'Неизвестный вариант' }
+        default { Fail 'Unknown option' }
     }
 }
 
 function Get-Target {
     if ($env:PROCESSOR_ARCHITECTURE -ne 'AMD64') {
-        Fail "Поддерживается только x86_64 Windows, текущая архитектура: $env:PROCESSOR_ARCHITECTURE"
+        Fail "Only x86_64 Windows is supported, current architecture: $env:PROCESSOR_ARCHITECTURE"
     }
     return 'x86_64-pc-windows-msvc'
 }
 
+function Fetch-ReleaseJson($channel) {
+    if ($channel -eq 'dev') {
+        Info "Looking for latest dev (pre-release)..."
+        $releases = Invoke-RestMethod -Method Get -Uri $ApiAll
+        $pre = $releases | Where-Object { $_.prerelease -eq $true } | Select-Object -First 1
+        if (-not $pre) { Fail "No dev (pre-release) found on GitHub" }
+        return $pre
+    } else {
+        return Invoke-RestMethod -Method Get -Uri $ApiLatest
+    }
+}
+
 function Install-FromRelease {
-    param([string]$target)
+    param([string]$target, [string]$channel)
 
     New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
 
-    $assetName = "dcr-$target.exe"
+    $release = Fetch-ReleaseJson $channel
-    Info "Получение последнего релиза..."
+    $tag     = $release.tag_name
-    $release = Invoke-RestMethod -Method Get -Uri $ApiUrl
+    $version = $tag.TrimStart('v')
+
+    # Имя бинарника: dcr-<triple>-<version>.exe
+    $assetName = "dcr-$target-$version.exe"
+
+    Info "Fetching release $tag (channel: $channel)..."
 
     $asset = $release.assets | Where-Object { $_.name -eq $assetName } | Select-Object -First 1
     if (-not $asset) {
-        Fail "Не найден ассет $assetName в релизе $($release.tag_name)"
+        Fail "Asset $assetName not found in release $tag"
     }
 
-    Info "Скачивание $assetName..."
+    Info "Downloading $assetName..."
     Invoke-WebRequest -Uri $asset.browser_download_url -OutFile $BinaryPath
-    Ok "Скачан бинарник $assetName"
+    Ok "Binary downloaded: $assetName"
 }
 
 function Install-FromSource {
-    param([string]$target)
+    param([string]$target, [string]$channel)
 
     Require-Cmd 'git'
     Require-Cmd 'cargo'
@@ -66,17 +98,25 @@ function Install-FromSource {
     $tmp = Join-Path $env:TEMP 'dcr-install'
     if (Test-Path $tmp) { Remove-Item -Recurse -Force $tmp }
 
-    Info 'Клонирование репозитория...'
+    Info 'Cloning repository...'
-    git clone --depth 1 $RepoUrl $tmp | Out-Null
+    if ($channel -eq 'dev') {
+        # Пробуем ветку dev
+        $result = git clone --depth 1 --branch dev $RepoUrl $tmp 2>&1
+        if ($LASTEXITCODE -ne 0) {
+            git clone --depth 1 $RepoUrl $tmp | Out-Null
+        }
+    } else {
+        git clone --depth 1 $RepoUrl $tmp | Out-Null
+    }
 
-    Info 'Сборка release-бинарника...'
+    Info 'Building release binary...'
     Push-Location $tmp
     cargo build --release --target $target
     Pop-Location
 
     New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
     Copy-Item (Join-Path $tmp "target\$target\release\dcr.exe") $BinaryPath -Force
-    Ok 'Установлен бинарник из исходников'
+    Ok 'Binary installed from source'
 
     Remove-Item -Recurse -Force $tmp
 }
@@ -93,21 +133,22 @@ function Setup-Path {
         $newPath = if ($userPath) { "$userPath;$BinPath" } else { $BinPath }
         [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')
         $env:Path = "$env:Path;$BinPath"
-        Warn "Добавлен путь в PATH: $BinPath"
+        Warn "Added path to PATH: $BinPath"
     }
 
-    Ok "Команда dcr доступна через $linkPath"
+    Ok "dcr command is available via $linkPath"
 }
 
-Info 'Запуск установки DCR'
+Info 'Starting DCR installation'
-$mode = Select-Mode
+$channel = Select-Channel
-$target = Get-Target
+$mode    = Select-Mode
+$target  = Get-Target
 
 if ($mode -eq 'build') {
-    Install-FromSource -target $target
+    Install-FromSource -target $target -channel $channel
 } else {
-    Install-FromRelease -target $target
+    Install-FromRelease -target $target -channel $channel
 }
 
 Setup-Path
-Ok 'Установка завершена успешно'
+Ok 'Installation completed successfully'

install.sh

@@ -6,7 +6,8 @@ INSTALL_PATH="$HOME/.local/share/dcr"
 BINPATH="$HOME/.local/bin"
 LOGFILE="$HOME/.cache/dcr-install.log"
 REPO_URL="https://github.com/dexoron/dcr"
-GITHUB_API="https://api.github.com/repos/dexoron/dcr/releases/latest"
+GITHUB_API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
+GITHUB_API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
 
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -17,17 +18,20 @@ NC='\033[0m'
 mkdir -p "$(dirname "$LOGFILE")"
 exec > >(tee -a "$LOGFILE") 2>&1
 
-log() { echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"; }
+log()     { echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"; }
 success() { echo -e "${GREEN}✔ $1${NC}"; }
-warn() { echo -e "${YELLOW}⚠ $1${NC}"; }
+warn()    { echo -e "${YELLOW}⚠ $1${NC}"; }
-error() { echo -e "${RED}✖ $1${NC}"; }
+error()   { echo -e "${RED}✖ $1${NC}"; }
 
-trap 'error "Ошибка на строке $LINENO"; exit 1' ERR
+trap 'error "Error on line $LINENO"; exit 1' ERR
+
+INSTALL_MODE=""
+CHANNEL=""
 
 check_os() {
     case "$(uname -s)" in
         Linux|Darwin) ;;
-        *) error "Поддерживаются только Linux и macOS"; exit 1 ;;
+        *) error "Only Linux and macOS are supported"; exit 1 ;;
     esac
 }
 
@@ -37,83 +41,145 @@ detect_target() {
     arch="$(uname -m)"
 
     case "$os:$arch" in
-        Linux:x86_64) TARGET_TRIPLE="x86_64-unknown-linux-gnu" ;;
+        Linux:x86_64)          TARGET_TRIPLE="x86_64-unknown-linux-gnu" ;;
-        Darwin:x86_64) TARGET_TRIPLE="x86_64-apple-darwin" ;;
+        Darwin:x86_64)         TARGET_TRIPLE="x86_64-apple-darwin" ;;
         Darwin:arm64|Darwin:aarch64) TARGET_TRIPLE="aarch64-apple-darwin" ;;
-        *) error "Неподдерживаемая платформа: $os/$arch"; exit 1 ;;
+        *) error "Unsupported platform: $os/$arch"; exit 1 ;;
     esac
-
-    ASSET_NAME="dcr-${TARGET_TRIPLE}"
 }
 
 check_common_dependencies() {
-    command -v curl >/dev/null 2>&1 || { error "curl не установлен"; exit 1; }
+    command -v curl >/dev/null 2>&1 || { error "curl is not installed"; exit 1; }
 }
 
 check_build_dependencies() {
-    command -v git >/dev/null 2>&1 || { error "git не установлен"; exit 1; }
+    command -v git   >/dev/null 2>&1 || { error "git is not installed"; exit 1; }
-    command -v cargo >/dev/null 2>&1 || { error "cargo не установлен"; exit 1; }
+    command -v cargo >/dev/null 2>&1 || { error "cargo is not installed"; exit 1; }
 }
 
-prepare_sources() {
+select_channel() {
-    log "Получение исходников..."
+    echo "Choose channel:"
-    rm -rf "$TMPDIR"
+    echo "  1) Latest stable release (default)"
-    git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    echo "  2) Latest dev (pre-release)"
-    success "Исходники получены"
+    read -r -p "Enter 1 or 2 [1]: " choice
+
+    case "${choice:-1}" in
+        1) CHANNEL="stable" ;;
+        2) CHANNEL="dev"    ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
 }
 
-build_binary() {
+select_install_mode() {
-    log "Сборка release-бинарника..."
+    echo "Choose installation mode:"
-    (cd "$TMPDIR" && cargo build --release)
+    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
-    success "Сборка завершена"
+    echo "  2) Build from git"
+    read -r -p "Enter 1 or 2 [1]: " choice
+
+    case "${choice:-1}" in
+        1) INSTALL_MODE="release" ;;
+        2) INSTALL_MODE="build"   ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
 }
 
-fetch_latest_release_json() {
+# Возвращает JSON нужного релиза в stdout
-    curl -fsSL "$GITHUB_API"
+fetch_release_json() {
+    if [[ "$CHANNEL" == "dev" ]]; then
+        log "Looking for latest dev (pre-release)..."
+        local json
+        json="$(curl -fsSL "$GITHUB_API_ALL")"
+        # Первый pre-release в списке
+        local result
+        result="$(printf '%s' "$json" | python3 - <<'EOF'
+import sys, json
+releases = json.load(sys.stdin)
+pre = [r for r in releases if r.get("prerelease", False)]
+if not pre:
+    print("{}", end="")
+else:
+    print(json.dumps(pre[0]), end="")
+EOF
+)"
+        if [[ -z "$result" || "$result" == "{}" ]]; then
+            error "No dev (pre-release) found on GitHub"
+            exit 1
+        fi
+        printf '%s' "$result"
+    else
+        curl -fsSL "$GITHUB_API_LATEST"
+    fi
 }
 
 download_binary() {
-    log "Получение последнего релиза..."
+    local release_json tag version asset_name download_url
 
-    local release_json download_url tag
+    release_json="$(fetch_release_json)"
-    release_json="$(fetch_latest_release_json)"
 
-    tag="$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
+    tag="$(printf '%s\n' "$release_json" | \
+        sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
     if [[ -z "$tag" ]]; then
-        error "Не удалось определить версию релиза"
+        error "Failed to determine release version"
         exit 1
     fi
 
-    download_url="$(printf '%s\n' "$release_json" | sed -n "s#.*\"browser_download_url\": \"\([^\"]*${ASSET_NAME}\)\".*#\1#p" | head -n1)"
+    # Версия без ведущего 'v'
+    version="${tag#v}"
+    # Имя бинарника: dcr-<triple>-<version>
+    asset_name="dcr-${TARGET_TRIPLE}-${version}"
+
+    log "Fetching release ${tag} (channel: ${CHANNEL})..."
+
+    download_url="$(printf '%s\n' "$release_json" | \
+        sed -n "s#.*\"browser_download_url\": \"\([^\"]*/${asset_name}\)\".*#\1#p" | head -n1)"
+
     if [[ -z "$download_url" ]]; then
-        error "Не найден ассет ${ASSET_NAME} в релизе ${tag}"
+        error "Asset ${asset_name} not found in release ${tag}"
         exit 1
     fi
 
     mkdir -p "$INSTALL_PATH"
     curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
     chmod +x "$INSTALL_PATH/dcr"
-    success "Скачан бинарник ${ASSET_NAME} (${tag})"
+    success "Binary ${asset_name} downloaded (${tag})"
+}
+
+prepare_sources() {
+    log "Fetching sources..."
+    rm -rf "$TMPDIR"
+    git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    if [[ "$CHANNEL" == "dev" ]]; then
+        # Клонируем dev ветку, если она есть
+        git clone --depth 1 --branch dev "$REPO_URL" "$TMPDIR" 2>/dev/null || \
+        git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    fi
+    success "Sources fetched"
+}
+
+build_binary() {
+    log "Building release binary..."
+    (cd "$TMPDIR" && cargo build --release)
+    success "Build completed"
 }
 
 install_built_binary() {
     mkdir -p "$INSTALL_PATH"
     cp "$TMPDIR/target/release/dcr" "$INSTALL_PATH/dcr"
     chmod +x "$INSTALL_PATH/dcr"
-    success "Установлен бинарник из исходников"
+    success "Binary installed from source"
 }
 
 install_link() {
-    log "Создание симлинка..."
+    log "Creating symlink..."
     mkdir -p "$BINPATH"
     ln -sf "$INSTALL_PATH/dcr" "$BINPATH/dcr"
-    success "Команда 'dcr' добавлена в $BINPATH"
+    success "Command 'dcr' added to $BINPATH"
 }
 
 check_path() {
     if ! echo "$PATH" | grep -q "$BINPATH"; then
-        warn "Каталог $BINPATH не найден в PATH"
+        warn "Directory $BINPATH not found in PATH"
-        echo "Добавь в ~/.bashrc или ~/.zshrc:"
+        echo "Add this to ~/.bashrc or ~/.zshrc:"
         echo "export PATH=\"$BINPATH:\$PATH\""
     fi
 }
@@ -122,25 +188,13 @@ cleanup() {
     rm -rf "$TMPDIR" 2>/dev/null || true
 }
 
-select_install_mode() {
-    echo "Выбери способ установки:"
-    echo "  1) Скачать готовый бинарник из GitHub Release (рекомендуется)"
-    echo "  2) Собрать из git"
-    read -r -p "Введите 1 или 2 [1]: " choice
-
-    case "${choice:-1}" in
-        1) INSTALL_MODE="release" ;;
-        2) INSTALL_MODE="build" ;;
-        *) error "Неизвестный вариант"; exit 1 ;;
-    esac
-}
-
 main() {
-    log "Запуск установки DCR"
+    log "Starting DCR installation"
 
     check_os
     detect_target
     check_common_dependencies
+    select_channel
     select_install_mode
     cleanup
 
@@ -157,8 +211,8 @@ main() {
     check_path
     cleanup
 
-    success "Установка завершена успешно"
+    success "Installation completed successfully"
-    log "Лог сохранён в $LOGFILE"
+    log "Log saved to $LOGFILE"
 }
 
-main "$@"
+main "$@"

packaging/aur/README.md

@@ -0,0 +1,21 @@
+# AUR publishing
+
+This repository includes an automated AUR publish workflow:
+- package files: `packaging/aur/dcr/PKGBUILD`, `packaging/aur/dcr/.SRCINFO`
+- workflow: `.github/workflows/aur.yml`
+
+## One-time setup
+
+1. Create the `dcr` package on AUR and initialize its git repository.
+2. Create an SSH key pair for CI.
+3. Add the public key to your AUR account.
+4. Add the private key to GitHub Actions secret `AUR_SSH_PRIVATE_KEY`.
+
+## Release flow
+
+1. Bump project version in `Cargo.toml`.
+2. Push tag `v<version>` (example: `v0.2.2`).
+3. GitHub Actions will:
+- compute source tarball SHA256
+- render `PKGBUILD` and `.SRCINFO`
+- push updates to `ssh://aur@aur.archlinux.org/dcr.git`

packaging/aur/dcr/.SRCINFO

@@ -0,0 +1,17 @@
+pkgbase = dcr
+	pkgdesc = Cargo-like utility to manage C/C++ projects
+	pkgver = 0.2.1
+	pkgrel = 1
+	url = https://github.com/dexoron/dcr
+	arch = x86_64
+	arch = aarch64
+	license = MIT
+	makedepends = cargo
+	depends = gcc-libs
+	optdepends = gcc: build C/C++ projects with GCC
+	optdepends = clang: build C/C++ projects with Clang
+	options = !lto
+	source = dcr-0.2.1.tar.gz::https://github.com/dexoron/dcr/archive/refs/tags/v0.2.1.tar.gz
+	sha256sums = 30e334fa98cd51073c0fa84c80a982584b00156b57084311ad53419441ce6235
+
+pkgname = dcr

packaging/aur/dcr/PKGBUILD

@@ -0,0 +1,30 @@
+pkgname=dcr
+pkgver=0.2.1
+pkgrel=3
+pkgdesc="Cargo-like utility to manage C/C++ projects"
+arch=('x86_64' 'aarch64')
+url="https://github.com/dexoron/dcr"
+license=('MIT')
+depends=('gcc-libs')
+makedepends=('cargo')
+options=('!lto')
+optdepends=(
+  'gcc: build C/C++ projects with GCC'
+  'clang: build C/C++ projects with Clang'
+)
+source=("$pkgname-$pkgver.tar.gz::$url/archive/refs/tags/v$pkgver.tar.gz")
+sha256sums=('30e334fa98cd51073c0fa84c80a982584b00156b57084311ad53419441ce6235')
+
+build() {
+  cd "$srcdir/$pkgname-$pkgver"
+  export CARGO_PROFILE_RELEASE_LTO=false
+  export RUSTFLAGS="${RUSTFLAGS:-}"
+  export RUSTFLAGS="${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
+  cargo build --release --locked
+}
+
+package() {
+  cd "$srcdir/$pkgname-$pkgver"
+  install -Dm755 "target/release/dcr" "$pkgdir/usr/bin/dcr"
+  install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}

src/cli/add.rs

@@ -0,0 +1,236 @@
+use crate::core::config::Config;
+use crate::core::deps::register;
+use crate::utils::fs::find_project_root;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, colored};
+use toml::Value;
+use toml::map::Map;
+
+pub struct AddArgs {
+    pub name: String,
+    pub path: Option<String>,
+    pub git: Option<String>,
+    pub branch: Option<String>,
+    pub tag: Option<String>,
+    pub rev: Option<String>,
+    pub version_from_registry: Option<String>,
+}
+
+pub fn add(args: &[String]) -> i32 {
+    let add_args = match parse_add_args(args) {
+        Ok(a) => a,
+        Err(code) => return code,
+    };
+
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+
+    let mut config = match Config::open(&root.join("dcr.toml").to_string_lossy()) {
+        Ok(cfg) => cfg,
+        Err(err) => {
+            error(&err.to_string());
+            return 1;
+        }
+    };
+
+    let dep_value = if let Some(git_url) = add_args.git {
+        if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() {
+            let mut table = Map::new();
+            table.insert("git".to_string(), Value::String(git_url));
+            Value::Table(table)
+        } else {
+            let mut table = Map::new();
+            table.insert("git".to_string(), Value::String(git_url));
+            if let Some(b) = add_args.branch {
+                table.insert("branch".to_string(), Value::String(b));
+            }
+            if let Some(t) = add_args.tag {
+                table.insert("tag".to_string(), Value::String(t));
+            }
+            if let Some(r) = add_args.rev {
+                table.insert("rev".to_string(), Value::String(r));
+            }
+            Value::Table(table)
+        }
+    } else if let Some(path) = add_args.path {
+        let mut table = Map::new();
+        table.insert("path".to_string(), Value::String(path));
+        Value::Table(table)
+    } else if let Some(version) = add_args.version_from_registry {
+        Value::String(version)
+    } else {
+        error("Dependency source (path or git) must be provided");
+        return 1;
+    };
+
+    let key = format!("dependencies.{}", add_args.name);
+    if let Err(err) = config.edit(&key, dep_value) {
+        error(&format!("Failed to update dcr.toml: {}", err));
+        return 1;
+    }
+
+    println!(
+        "    {} dependency `{}` to dcr.toml",
+        colored("Added", BOLD_GREEN),
+        add_args.name
+    );
+    0
+}
+
+fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
+    if args.is_empty() {
+        error("Usage: dcr add <name> <source> [--branch <branch> | --tag <tag> | --rev <rev>]");
+        error("Sources:");
+        error("  user/repo                 -> github.com/user/repo");
+        error("  github:user/repo          -> github.com/user/repo");
+        error("  gitlab:user/repo          -> gitlab.com/user/repo");
+        error("  git:host.com/user/repo    -> host.com/user/repo");
+        error("  path:./path/to/lib        -> local path");
+        return Err(1);
+    }
+
+    let mut name = String::new();
+    let source_spec: String;
+    let mut branch = None;
+    let mut tag = None;
+    let mut rev = None;
+
+    let mut iter = args.iter();
+    if let Some(n) = iter.next() {
+        if n.starts_with("--") {
+            error("First argument must be the dependency name");
+            return Err(1);
+        }
+        name = n.clone();
+    }
+
+    if let Some(s) = iter.next() {
+        if s.starts_with("--") {
+            error("Second argument must be the dependency source");
+            return Err(1);
+        }
+        source_spec = s.clone();
+    } else {
+        // No source provided — try registry auto-lookup
+        match register::resolve_package_from_registry(&name) {
+            Ok(info) => {
+                let version = info
+                    .get("latest_version")
+                    .or_else(|| info.get("version"))
+                    .and_then(|v| v.as_str())
+                    .ok_or_else(|| {
+                        (
+                            "Registry entry for `".to_string() + &name + "` has no version field",
+                            1,
+                        )
+                    })
+                    .map_err(|(msg, code)| {
+                        error(&msg);
+                        code
+                    })?;
+                return Ok(AddArgs {
+                    name,
+                    path: None,
+                    git: None,
+                    branch: None,
+                    tag: None,
+                    rev: None,
+                    version_from_registry: Some(version.to_string()),
+                });
+            }
+            Err(e) => {
+                error(&format!("Cannot add `{}` without source: {}", name, e));
+                return Err(1);
+            }
+        }
+    }
+
+    while let Some(arg) = iter.next() {
+        match arg.as_str() {
+            "--branch" => {
+                branch = iter.next().cloned();
+                if branch.is_none() {
+                    error("--branch requires a value");
+                    return Err(1);
+                }
+            }
+            "--tag" => {
+                tag = iter.next().cloned();
+                if tag.is_none() {
+                    error("--tag requires a value");
+                    return Err(1);
+                }
+            }
+            "--rev" => {
+                rev = iter.next().cloned();
+                if rev.is_none() {
+                    error("--rev requires a value");
+                    return Err(1);
+                }
+            }
+            _ => {
+                error(&format!("Unknown argument: {}", arg));
+                return Err(1);
+            }
+        }
+    }
+
+    let mut path = None;
+    let mut git = None;
+
+    if let Some(p) = source_spec.strip_prefix("path:") {
+        path = Some(p.to_string());
+    } else if let Some(g) = source_spec.strip_prefix("github:") {
+        git = Some(format!("https://github.com/{}", g));
+    } else if let Some(g) = source_spec.strip_prefix("gitlab:") {
+        git = Some(format!("https://gitlab.com/{}", g));
+    } else if let Some(g) = source_spec.strip_prefix("git:") {
+        if g.contains('/') && !g.contains('.') {
+            // git:user/repo -> default to github
+            git = Some(format!("https://github.com/{}", g));
+        } else {
+            // git:host.com/user/repo
+            let url = if g.starts_with("http") || g.starts_with("git@") {
+                g.to_string()
+            } else {
+                format!("https://{}", g)
+            };
+            git = Some(url);
+        }
+    } else if source_spec.starts_with("http://")
+        || source_spec.starts_with("https://")
+        || source_spec.starts_with("git@")
+    {
+        git = Some(source_spec);
+    } else {
+        error("Source must have a prefix (path:, git:, github:, gitlab:) or be a full URL");
+        return Err(1);
+    }
+
+    Ok(AddArgs {
+        name,
+        path,
+        git,
+        branch,
+        tag,
+        rev,
+        version_from_registry: None,
+    })
+}

src/cli/clean.rs

@@ -1,72 +1,239 @@
 use crate::config::flags;
-use crate::utils::fs::check_dir;
+use crate::core::config::Config;
-use crate::utils::text::{BOLD, BRIGHT_GREEN, BRIGHT_RED, BRIGHT_YELLOW, colored};
+use crate::core::workspace::parse_workspace;
+use crate::utils::build::parse_version_info;
+use crate::utils::fs::{check_dir, find_project_root, with_dir};
+use crate::utils::log::{error, warn};
+use crate::utils::text::{BOLD_GREEN, colored};
+use glob::glob;
 use std::fs;
+use std::path::Path;
 
 pub fn clean(args: &[String]) -> i32 {
-    let red_bold = BRIGHT_RED.to_owned() + BOLD;
+    let start_dir = match std::env::current_dir() {
-    let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
+        Ok(dir) => dir,
-    let yellow_bold = BRIGHT_YELLOW.to_owned() + BOLD;
+        Err(_) => {
-
+            error("Failed to determine current directory");
-    let project_name = std::env::current_dir()
-        .ok()
-        .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
-        .unwrap_or_else(|| "project".to_string());
-    let items = check_dir(None).unwrap_or_default();
-
-    if args.len() > 1 {
-        println!("{}: неизвестный аргумент", colored("error", &red_bold));
-        return 1;
-    }
-    if !items.contains(&"dcr.toml".to_string()) {
-        println!("{}: не найден файл dcr.toml", colored("error", &red_bold));
-        return 1;
-    }
-
-    println!(
-        "    Очистка проекта `{}`",
-        colored(&project_name, &green_bold)
-    );
-    if !items.contains(&"target".to_string()) {
-        println!(
-            "{}: директория target не найдена",
-            colored("warn", &yellow_bold)
-        );
-        return 1;
-    }
-
-    if let Some(arg) = args.first() {
-        let mut profile = arg.clone();
-        if profile.starts_with("--") {
-            profile = profile.trim_start_matches("--").to_string();
-        }
-        if flags(&profile).is_none() {
-            println!("{}: неизвестный профиль", colored("error", &red_bold));
             return 1;
         }
-
+    };
-        let target_items = check_dir(Some("target")).unwrap_or_default();
+    let root = match find_project_root(&start_dir) {
-        if !target_items.contains(&profile) {
+        Ok(Some(dir)) => dir,
-            println!(
+        Ok(None) => {
-                "{}: директория target/{profile} не найдена",
+            error("dcr.toml file not found");
-                colored("warn", &yellow_bold)
-            );
             return 1;
         }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+    let flags = match parse_clean_flags(args) {
+        Ok(v) => v,
+        Err(msg) => {
+            error(&msg);
+            return 1;
+        }
+    };
 
-        println!("    Профиль: {}", colored(&profile, &green_bold));
+    match with_dir(&root, || clean_from_root(&root, &flags)) {
-        let _ = fs::remove_dir_all(format!("target/{profile}"));
+        Ok(()) => 0,
-        println!(
+        Err(msg) => {
-            "{} Удалена директория target/{profile}",
+            error(&msg);
-            colored("\n    ✔", &green_bold)
+            1
-        );
+        }
-        return 0;
     }
-
+}
-    let _ = fs::remove_dir_all("target");
+
-    println!(
+struct CleanFlags {
-        "{} Удалена директория target",
+    profile: Option<String>,
-        colored("\n    ✔", &green_bold)
+    target: Option<String>,
-    );
+    all: bool,
-    0
+}
+
+fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
+    let mut profile: Option<String> = None;
+    let mut target: Option<String> = None;
+    let mut all = false;
+    let mut iter = args.iter();
+    while let Some(arg) = iter.next() {
+        if arg == "--all" {
+            all = true;
+            continue;
+        }
+        if arg == "--target" {
+            if let Some(t) = iter.next() {
+                target = Some(t.clone());
+            } else {
+                return Err("--target requires a value".to_string());
+            }
+            continue;
+        }
+        if arg.starts_with("--") {
+            let candidate = arg.trim_start_matches("--").to_string();
+            if flags(&candidate).is_some() {
+                if profile.is_some() {
+                    return Err("Duplicate profile flag".to_string());
+                }
+                profile = Some(candidate);
+                continue;
+            }
+        }
+        return Err("Unknown argument".to_string());
+    }
+    Ok(CleanFlags {
+        profile,
+        target,
+        all,
+    })
+}
+
+fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
+    let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+
+    let target = flags
+        .target
+        .clone()
+        .or_else(|| {
+            config
+                .get("build.target")
+                .and_then(|v| v.as_str())
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+        })
+        .or_else(|| {
+            Some(if cfg!(target_os = "linux") {
+                "x86_64-unknown-linux-gnu".to_string()
+            } else if cfg!(target_os = "macos") {
+                "x86_64-apple-darwin".to_string()
+            } else if cfg!(target_os = "windows") {
+                "x86_64-pc-windows-msvc".to_string()
+            } else {
+                "unknown".to_string()
+            })
+        });
+
+    if flags.all
+        && let Some(workspace) = parse_workspace(
+            &config,
+            flags.profile.as_deref().unwrap_or("debug"),
+            target.as_deref(),
+            root,
+        )?
+    {
+        for member in &workspace.members {
+            clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
+        }
+    }
+    clean_project_at(root, flags.profile.as_deref(), target.as_deref())
+}
+
+fn clean_project_at(
+    project_root: &Path,
+    profile: Option<&str>,
+    target: Option<&str>,
+) -> Result<(), String> {
+    with_dir(project_root, || {
+        let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        let project_name = std::env::current_dir()
+            .ok()
+            .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
+            .unwrap_or_else(|| "project".to_string());
+        let items = check_dir(None).map_err(|_| "Failed to read project directory".to_string())?;
+        if !items.contains(&"dcr.toml".to_string()) {
+            return Err("dcr.toml file not found".to_string());
+        }
+        println!(
+            "    Cleaning project `{}`",
+            colored(&project_name, BOLD_GREEN)
+        );
+        if let Some(profile) = profile {
+            let target_dir = if let Some(t) = target {
+                format!("target/{t}/{profile}")
+            } else {
+                format!("target/{profile}")
+            };
+            let target_items = check_dir(Some("target")).unwrap_or_default();
+            let parent_dir = target.unwrap_or("");
+            let dir_exists = if target.is_some() {
+                target_items.contains(&parent_dir.to_string())
+            } else {
+                target_items.contains(&profile.to_string())
+            };
+            if !dir_exists {
+                warn(&format!("Directory target/{} not found", target_dir));
+            } else {
+                println!("    Profile: {}", colored(profile, BOLD_GREEN));
+                if let Some(t) = target {
+                    println!("    Target: {}", colored(t, BOLD_GREEN));
+                }
+                let _ = fs::remove_dir_all(&target_dir);
+                println!(
+                    "{} Removed directory {}",
+                    colored("\n    ✔", BOLD_GREEN),
+                    target_dir
+                );
+            }
+            clean_custom_paths(&config, profile)?;
+            return Ok(());
+        }
+
+        if items.contains(&"target".to_string()) {
+            let _ = fs::remove_dir_all("target");
+            println!(
+                "{} Removed directory target",
+                colored("\n    ✔", BOLD_GREEN)
+            );
+        } else {
+            warn("Directory target not found");
+        }
+        clean_custom_paths(&config, "debug")?;
+        clean_custom_paths(&config, "release")?;
+        Ok(())
+    })
+}
+
+fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
+    let patterns = match config.get("build.clean") {
+        Some(v) => v
+            .as_array()
+            .ok_or_else(|| "build.clean must be an array of strings".to_string())?
+            .iter()
+            .filter_map(|item| item.as_str())
+            .map(|s| {
+                let value = s.replace("{profile}", profile);
+                substitute_version_vars(&value, config)
+            })
+            .collect::<Vec<String>>(),
+        None => Vec::new(),
+    };
+    if patterns.is_empty() {
+        return Ok(());
+    }
+    for pattern in patterns {
+        for entry in glob(&pattern).map_err(|err| format!("glob error: {err}"))? {
+            let path = entry.map_err(|err| format!("glob error: {err}"))?;
+            if path.is_dir() {
+                let _ = fs::remove_dir_all(&path);
+            } else if path.is_file() {
+                let _ = fs::remove_file(&path);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn substitute_version_vars(value: &str, config: &Config) -> String {
+    let version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let info = parse_version_info(version);
+    value
+        .replace("{version}", &info.full)
+        .replace("{version_major}", &info.major)
+        .replace("{version_minor}", &info.minor)
+        .replace("{version_patch}", &info.patch)
+        .replace("{version_suffix}", &info.suffix)
+        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/flag_update.rs

@@ -1,7 +1,10 @@
+use crate::utils::log::{error, warn};
 use reqwest::blocking::Client;
 use serde::Deserialize;
 use std::fs;
 use std::path::{Path, PathBuf};
+#[cfg(target_os = "linux")]
+use std::process::Command;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 const LATEST_RELEASE_URL: &str = "https://api.github.com/repos/dexoron/dcr/releases/latest";
@@ -20,16 +23,32 @@ struct ReleaseAsset {
 
 pub fn flag_update(args: &[String]) -> i32 {
     if !args.is_empty() {
-        println!("Ошибка: команда не поддежривает аргументы");
+        warn("Command does not support additional arguments");
         return 1;
     }
 
+    let current_exe = match std::env::current_exe() {
+        Ok(path) => path,
+        Err(_) => {
+            error("Failed to resolve current binary path");
+            return 1;
+        }
+    };
+
+    if let Some(package_name) = pacman_owned_package(&current_exe) {
+        warn("This dcr binary is managed by pacman/AUR");
+        println!(
+            "Update via package manager: yay/paru -Syu {package_name} or sudo pacman -Syu {package_name}"
+        );
+        return 0;
+    }
+
     let current_version = env!("CARGO_PKG_VERSION");
     let target = env!("DCR_TARGET");
     let client = match Client::builder().user_agent("dcr-updater").build() {
         Ok(client) => client,
         Err(_) => {
-            println!("Ошибка: не удалось инициализировать HTTP клиент");
+            error("Failed to initialize HTTP client");
             return 1;
         }
     };
@@ -37,14 +56,14 @@ pub fn flag_update(args: &[String]) -> i32 {
     let release = match fetch_latest_release(&client) {
         Ok(release) => release,
         Err(err) => {
-            println!("Ошибка: не удалось проверить обновления: {err}");
+            error(&format!("Failed to check for updates: {err}"));
             return 1;
         }
     };
 
     let latest_version = release.tag_name.trim_start_matches('v');
     if latest_version == current_version {
-        println!("Установлена последняя версия: {current_version}");
+        println!("Latest version is already installed: {current_version}");
         return 0;
     }
 
@@ -54,41 +73,34 @@ pub fn flag_update(args: &[String]) -> i32 {
         .iter()
         .find(|asset| candidate_names.iter().any(|name| name == &asset.name))
     else {
-        println!("Ошибка: не найден бинарник для таргета {target}");
+        error(&format!("Binary for target {target} not found"));
         return 1;
     };
 
     let bytes = match download_asset(&client, &asset.browser_download_url) {
         Ok(bytes) => bytes,
         Err(err) => {
-            println!("Ошибка: не удалось скачать обновление: {err}");
+            error(&format!("Failed to download update: {err}"));
             return 1;
         }
     };
 
-    let current_exe = match std::env::current_exe() {
-        Ok(path) => path,
-        Err(_) => {
-            println!("Ошибка: не удалось определить путь текущего бинарника");
-            return 1;
-        }
-    };
     let temp_path = temp_binary_path(&current_exe);
 
     if fs::write(&temp_path, &bytes).is_err() {
-        println!("Ошибка: не удалось записать временный бинарник");
+        error("Failed to write temporary binary");
         return 1;
     }
     set_executable_permissions(&temp_path);
 
     if self_replace::self_replace(&temp_path).is_err() {
         let _ = fs::remove_file(&temp_path);
-        println!("Ошибка: не удалось заменить текущий бинарник");
+        error("Failed to replace current binary");
         return 1;
     }
 
     let _ = fs::remove_file(&temp_path);
-    println!("Обновление завершено: {current_version} -> {latest_version}");
+    println!("Update completed: {current_version} -> {latest_version}");
     0
 }
 
@@ -96,38 +108,38 @@ fn fetch_latest_release(client: &Client) -> Result<Release, String> {
     let response = client
         .get(LATEST_RELEASE_URL)
         .send()
-        .map_err(|_| "запрос к GitHub API завершился ошибкой".to_string())?;
+        .map_err(|_| "GitHub API request failed".to_string())?;
 
     if !response.status().is_success() {
-        return Err(format!("GitHub API вернул статус {}", response.status()));
+        return Err(format!("GitHub API returned status {}", response.status()));
     }
 
     response
         .json::<Release>()
-        .map_err(|_| "ответ GitHub API имеет неожиданный формат".to_string())
+        .map_err(|_| "GitHub API response has an unexpected format".to_string())
 }
 
 fn download_asset(client: &Client, url: &str) -> Result<Vec<u8>, String> {
     let response = client
         .get(url)
         .send()
-        .map_err(|_| "запрос на скачивание завершился ошибкой".to_string())?;
+        .map_err(|_| "Download request failed".to_string())?;
 
     if !response.status().is_success() {
-        return Err(format!("скачивание вернуло статус {}", response.status()));
+        return Err(format!("Download returned status {}", response.status()));
     }
 
     response
         .bytes()
         .map(|bytes| bytes.to_vec())
-        .map_err(|_| "не удалось прочитать скачанные данные".to_string())
+        .map_err(|_| "Failed to read downloaded data".to_string())
 }
 
 fn asset_candidates(target: &str) -> Vec<String> {
     let mut names = vec![format!("dcr-{target}")];
 
-    if target == "x86_64-pc-windows-msvc" {
+    if target.contains("-windows-") || target.ends_with("-windows") {
-        names.push("dcr-x86_64-pc-windows-msvc.exe".to_string());
+        names.push(format!("dcr-{target}.exe"));
     }
 
     names
@@ -145,14 +157,34 @@ fn temp_binary_path(current_exe: &Path) -> PathBuf {
     current_exe.with_extension(extension)
 }
 
-fn set_executable_permissions(path: &Path) {
+fn set_executable_permissions(_path: &Path) {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
-        if let Ok(meta) = fs::metadata(path) {
+        if let Ok(meta) = fs::metadata(_path) {
             let mut perms = meta.permissions();
             perms.set_mode(0o755);
-            let _ = fs::set_permissions(path, perms);
+            let _ = fs::set_permissions(_path, perms);
         }
     }
 }
+
+#[cfg(target_os = "linux")]
+fn pacman_owned_package(path: &Path) -> Option<String> {
+    let output = Command::new("pacman").arg("-Qoq").arg(path).output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+
+    let package_name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    if package_name.is_empty() {
+        return None;
+    }
+
+    Some(package_name)
+}
+
+#[cfg(not(target_os = "linux"))]
+fn pacman_owned_package(_path: &Path) -> Option<String> {
+    None
+}

src/cli/flags.rs

@@ -0,0 +1,66 @@
+use crate::config::{PROFILE, flags};
+use crate::utils::log::warn;
+
+pub struct BuildRunFlags {
+    pub profile: String,
+    pub target: Option<String>,
+    pub force: bool,
+    pub clean: bool,
+    pub verbose: bool,
+}
+
+pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
+    let mut profile = PROFILE.to_string();
+    let mut target = None;
+    let mut force = false;
+    let mut clean = false;
+    let mut verbose = false;
+    let mut iter = args.iter();
+
+    while let Some(arg) = iter.next() {
+        if !arg.starts_with("--") {
+            warn("Unknown argument");
+            return Err(1);
+        }
+        let candidate = arg.trim_start_matches("--");
+        if candidate == "force" {
+            force = true;
+            continue;
+        }
+        if candidate == "clean" {
+            clean = true;
+            continue;
+        }
+        if candidate == "verbose" {
+            verbose = true;
+            continue;
+        }
+        if candidate == "target" {
+            if let Some(t) = iter.next() {
+                target = Some(t.clone());
+            } else {
+                warn("--target requires a value");
+                return Err(1);
+            }
+            continue;
+        }
+        if flags(candidate).is_some() {
+            if profile != PROFILE {
+                warn("Duplicate profile flag");
+                return Err(1);
+            }
+            profile = candidate.to_string();
+            continue;
+        }
+        warn("Unknown build flag");
+        return Err(1);
+    }
+
+    Ok(BuildRunFlags {
+        profile,
+        target,
+        force,
+        clean,
+        verbose,
+    })
+}

src/cli/help.rs

@@ -1,36 +1,39 @@
-use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 
 pub fn help() -> i32 {
-    let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
-    let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
-
     println!("DCR (Dexoron Cargo Realization)");
-    println!("Менеджер C-проектов, вдохновленный Cargo.");
+    println!("C project manager inspired by Cargo.");
     println!();
-    println!("{}", colored("ИСПОЛЬЗОВАНИЕ:", &green_bold));
+    printc("USAGE:", BOLD_GREEN);
-    println!("{}", colored("    dcr <команда> [опции]", &cyan_bold));
+    printc("    dcr <command> [options]", BOLD_CYAN);
     println!();
-    println!("{}", colored("КОМАНДЫ:", &green_bold));
+    printc("COMMANDS:", BOLD_GREEN);
-    println!("    new <name>        Создать новый проект");
+    println!("    new <name>        Create a new project");
-    println!("    init              Инициализировать текущую директорию как проект");
+    println!("    init              Initialize the current directory as a project");
-    println!("    build [--profile] Собрать проект (по умолчанию: --debug)");
+    println!("    build [--profile] Build the project (default: --debug)");
-    println!("    run [--profile]   Собрать и запустить (по умолчанию: --debug)");
+    println!("    run [--profile]   Build and run the project (default: --debug)");
-    println!("    clean             Удалить директорию target");
+    println!("    tree              Display the dependency tree");
-    println!("{}", colored("ФЛАГИ:", &green_bold));
+    println!("    test              Run project tests (alias: tests)");
-    println!("    --help            Показать справку по команде");
+    println!("    clean             Remove the target directory");
-    println!("    --update          Обновить dcr до актуальной версии");
+    println!("    gen <subcommand>  Generate IDE integration files");
-    println!("    --version         Показать версию dcr");
+    printc("FLAGS:", BOLD_GREEN);
+    println!("    --help            Show command help");
+    println!("    --update          Update dcr to the latest version");
+    println!("    --version         Show dcr version");
     println!();
-    println!("{}", colored("ОПЦИИ:", &green_bold));
+    printc("OPTIONS:", BOLD_GREEN);
-    println!("    --debug           Сборка с профилем debug");
+    println!("    --debug           Use debug profile");
-    println!("    --release         Сборка с профилем release");
+    println!("    --release         Use release profile");
+    println!("    --force           Force rebuild (build/run)");
+    println!("    --clean           Clean before build (build/run)");
+    println!("    --all             Clean all workspace members (clean)");
     println!();
-    println!("{}", colored("ПРИМЕРЫ:", &green_bold));
+    printc("EXAMPLES:", BOLD_GREEN);
-    println!("{}", colored("    dcr new hello", &cyan_bold));
+    printc("    dcr new hello", BOLD_CYAN);
-    println!("{}", colored("    dcr build --release", &cyan_bold));
+    printc("    dcr build --release", BOLD_CYAN);
-    println!("{}", colored("    dcr run --debug", &cyan_bold));
+    printc("    dcr run --debug", BOLD_CYAN);
     println!();
-    println!("{}", colored("ПОДСКАЗКА:", &green_bold));
+    printc("TIP:", BOLD_GREEN);
-    println!("    Запусти 'dcr <команда> --help' для справки по команде.");
+    println!("    Run 'dcr <command> --help' for command-specific help.");
     0
 }

src/cli/init.rs

@@ -1,19 +1,15 @@
-use crate::config::{FILE_MAIN_C, file_dcr_toml};
+use crate::config::FILE_MAIN_C;
+use crate::core::config::Config;
 use crate::utils::fs::check_dir;
-use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, BRIGHT_RED, colored, printc};
+use crate::utils::log::{error, warn};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use std::fs;
 use std::io::Write;
+use toml::Value;
 
 pub fn init(args: &[String]) -> i32 {
-    let red_bold = BRIGHT_RED.to_owned() + BOLD;
-    let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
-    let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
-
     if !args.is_empty() {
-        println!(
+        warn("Command does not support additional arguments");
-            "{}: команда не поддерживает доп. аргументы",
-            colored("error", &red_bold)
-        );
         return 1;
     }
 
@@ -24,73 +20,61 @@ pub fn init(args: &[String]) -> i32 {
         .unwrap_or_else(|| "project".to_string());
 
     if !items.is_empty() {
-        println!("{}: директория не пуста", colored("error", &red_bold));
+        error("Directory not empty");
         return 1;
     }
 
     let cwd = std::env::current_dir()
         .map(|v| v.to_string_lossy().to_string())
         .unwrap_or_else(|_| ".".to_string());
-    println!("Инициализация проекта в {cwd}");
+    println!("Initializing the project in {cwd}");
 
-    let mut dcr_toml = match fs::File::create("./dcr.toml") {
+    let mut config = match Config::new("./dcr.toml") {
-        Ok(file) => file,
+        Ok(cfg) => cfg,
         Err(_) => {
-            println!(
+            error("Failed to create dcr.toml");
-                "{}: не удалось создать dcr.toml",
-                colored("error", &red_bold)
-            );
             return 1;
         }
     };
-    if dcr_toml
+    if config
-        .write_all(file_dcr_toml(&project_name).as_bytes())
+        .edit("package.name", Value::String(project_name.clone()))
         .is_err()
     {
-        println!(
+        error("Failed to write dcr.toml");
-            "{}: не удалось записать dcr.toml",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     println!(
-        "    {} Создан файл {}",
+        "    {} Created file {}",
-        colored("✔", &green_bold),
+        colored("✔", BOLD_GREEN),
-        colored("dcr.toml", &cyan_bold)
+        colored("dcr.toml", BOLD_CYAN)
     );
 
     if fs::create_dir("src").is_err() {
-        println!("{}: не удалось создать src", colored("error", &red_bold));
+        error("Failed to create src/");
         return 1;
     }
     let mut main_c = match fs::File::create("./src/main.c") {
         Ok(file) => file,
         Err(_) => {
-            println!(
+            error("Failed to create src/main.c");
-                "{}: не удалось создать src/main.c",
-                colored("error", &red_bold)
-            );
             return 1;
         }
     };
     if main_c.write_all(FILE_MAIN_C.as_bytes()).is_err() {
-        println!(
+        error("Failed to write src/main.c");
-            "{}: не удалось записать src/main.c",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     println!(
-        "    {} Создан файл {}\n",
+        "    {} Created file {}",
-        colored("✔", &green_bold),
+        colored("✔", BOLD_GREEN),
-        colored("src/main.c", &cyan_bold)
+        colored("src/main.c", BOLD_CYAN)
     );
 
     println!(
-        "Проект `{}` успешно создан\n",
+        "Project `{}` successfully created\n",
-        colored(&project_name, &green_bold)
+        colored(project_name.as_str(), BOLD_GREEN)
     );
-    printc("Следуюший шаг:", &green_bold);
+    printc("Next step:", BOLD_GREEN);
-    printc("    dcr run", &cyan_bold);
+    printc("    dcr run", BOLD_CYAN);
     0
 }

src/cli/mod.rs

@@ -1,7 +1,13 @@
+pub mod add;
 pub mod build;
 pub mod clean;
 pub mod flag_update;
+pub mod flags;
+pub mod r#gen;
 pub mod help;
 pub mod init;
 pub mod new;
 pub mod run;
+pub mod setup;
+pub mod test;
+pub mod tree;

src/cli/new.rs

@@ -1,123 +1,101 @@
-use crate::config::{FILE_MAIN_C, file_dcr_toml};
+use crate::config::FILE_MAIN_C;
+use crate::core::config::Config;
 use crate::utils::fs::check_dir;
-use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, BRIGHT_RED, colored, printc};
+use crate::utils::log::{error, warn};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use std::fs;
 use std::io::Write;
+use toml::Value;
 
 pub fn new(args: &[String]) -> i32 {
     let items = check_dir(None).unwrap_or_default();
-    let red_bold = BRIGHT_RED.to_owned() + BOLD;
-    let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
-    let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
 
     if args.is_empty() {
-        println!(
+        error("Project name not specified");
-            "{}: не указанно название проекта",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     if args.len() > 1 {
-        println!(
+        warn("Command does not support additional arguments");
-            "{}: команда не поддерживает доп. аргументы",
-            colored("error", &red_bold)
-        );
         return 1;
     }
 
     let project_name = &args[0];
     println!(
-        "Создание проекта `{}`...",
+        "Creating a Project `{}`...",
-        colored(project_name, &green_bold)
+        colored(project_name, BOLD_CYAN)
     );
 
     if items.contains(project_name) {
+        error(&format!(
+            "Directory `{}` already exists\n",
+            colored(project_name, BOLD_CYAN)
+        ));
+        printc("Подсказка:", BOLD_CYAN);
         println!(
-            "{}: директория `{}` уже существует\n",
+            "    Use `{}` to initialize an existing project\n    or specify a different project name",
-            colored("error", &red_bold),
+            colored("dcr init", BOLD_CYAN)
-            colored(project_name, &green_bold)
-        );
-        printc("Подсказка:", &green_bold);
-        println!(
-            "    Используй `{}` для инициализации существующего проекта\n    или задай другое имя проекта",
-            colored("dcr init", &cyan_bold)
         );
         return 1;
     }
 
     if fs::create_dir(project_name).is_err() {
-        println!(
+        error("Failed to create directory");
-            "{}: не удалось создать директорию",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     println!(
-        "    {} Создана директория {}",
+        "    {} Directory created {}",
-        colored("✔", &green_bold),
+        colored("✔", BOLD_GREEN),
         project_name
     );
 
     let toml_path = format!("./{project_name}/dcr.toml");
-    let mut dcr_toml = match fs::File::create(&toml_path) {
+    let mut config = match Config::new(&toml_path) {
-        Ok(file) => file,
+        Ok(cfg) => cfg,
         Err(_) => {
-            println!(
+            error("Failed to create dcr.toml");
-                "{}: не удалось создать dcr.toml",
-                colored("error", &red_bold)
-            );
             return 1;
         }
     };
-    if dcr_toml
+    if config
-        .write_all(file_dcr_toml(project_name).as_bytes())
+        .edit("package.name", Value::String(project_name.to_string()))
         .is_err()
     {
-        println!(
+        error("Failed to write dcr.toml");
-            "{}: не удалось записать dcr.toml",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     println!(
-        "    {} Создан файл {}",
+        "    {} Created file {}",
-        colored("✔", &green_bold),
+        colored("✔", BOLD_GREEN),
-        colored("dcr.toml", &cyan_bold)
+        colored("dcr.toml", BOLD_CYAN)
     );
 
     if fs::create_dir_all(format!("./{project_name}/src")).is_err() {
-        println!("{}: не удалось создать src", colored("error", &red_bold));
+        error("Failed to create src/");
         return 1;
     }
     let main_c_path = format!("./{project_name}/src/main.c");
     let mut main_c = match fs::File::create(&main_c_path) {
         Ok(file) => file,
         Err(_) => {
-            println!(
+            error("Failed to create src/main.c");
-                "{}: не удалось создать src/main.c",
-                colored("error", &red_bold)
-            );
             return 1;
         }
     };
     if main_c.write_all(FILE_MAIN_C.as_bytes()).is_err() {
-        println!(
+        error("Failed to write src/main.c");
-            "{}: не удалось записать src/main.c",
-            colored("error", &red_bold)
-        );
         return 1;
     }
     println!(
-        "    {} Создан файл {}\n",
+        "    {} Created file {}",
-        colored("✔", &green_bold),
+        colored("✔", BOLD_GREEN),
-        colored("src/main.c", &cyan_bold)
+        colored("src/main.c", BOLD_CYAN)
     );
 
     println!(
-        "Проект `{}` успешно создан\n",
+        "Project `{}` successfully created\n",
-        colored(project_name, &green_bold)
+        colored(project_name, BOLD_GREEN)
     );
-    printc("Следуюший шаг:", &green_bold);
+    printc("Next step:", BOLD_GREEN);
-    printc(&format!("    cd {project_name}\n    dcr run"), &cyan_bold);
+    printc(&format!("    cd {}\n    dcr run", project_name), BOLD_CYAN);
     0
 }

src/cli/run.rs

@@ -1,55 +1,176 @@
 use crate::cli::build::build;
-use crate::config::{PROFILE, flags};
+use crate::cli::flags::parse_build_run_flags;
-use crate::utils::fs::check_dir;
+use crate::core::config::Config;
-use crate::utils::text::{BOLD, BRIGHT_RED, colored};
+use crate::core::runner::run_binary;
+use crate::utils::build::{normalize_target_os, parse_version_info};
+use crate::utils::fs::find_project_root;
+use crate::utils::fs::with_dir;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, colored};
 use std::process::Command;
 
-pub fn run(args: &[String]) -> i32 {
+fn get_run_cmd(
-    let red_bold = BRIGHT_RED.to_owned() + BOLD;
+    config: &Config,
-    let mut active_profile = PROFILE.to_string();
+    profile: &str,
-
+    target: Option<&str>,
-    let items = check_dir(None).unwrap_or_default();
+    version: &str,
-    if !items.contains(&"dcr.toml".to_string()) {
+) -> Option<String> {
-        println!("{}: не найден файл dcr.toml", colored("error", &red_bold));
+    let base = config.get("run.cmd").and_then(|v| v.as_str());
-        return 1;
+    let target_cmd = if let Some(t) = target {
+        let normalized_t = normalize_target_os(t);
+        config
+            .get(&format!("run.{}.cmd", normalized_t))
+            .or_else(|| config.get(&format!("run.{}.cmd", t)))
+            .and_then(|v| v.as_str())
+    } else {
+        None
+    };
+    let profile_cmd = config
+        .get(&format!("run.{}.cmd", profile))
+        .and_then(|v| v.as_str());
+    let cmd = target_cmd.or(profile_cmd).or(base)?;
+    let trimmed = cmd.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(substitute_run_vars(trimmed, profile, version))
     }
+}
 
-    if let Some(first_arg) = args.first() {
+pub fn run(args: &[String]) -> i32 {
-        if first_arg.starts_with("--") {
+    let start_dir = match std::env::current_dir() {
-            let candidate = first_arg.trim_start_matches("--");
+        Ok(dir) => dir,
-            if flags(candidate).is_some() {
+        Err(_) => {
-                active_profile = candidate.to_string();
+            error("Failed to determine current directory");
-            } else {
-                println!("{}: неизвестный флаг сборки", colored("error", &red_bold));
-                return 1;
-            }
-        } else {
-            println!("{}: неизвестный аргумент", colored("error", &red_bold));
             return 1;
         }
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+    let config = match with_dir(&root, || {
+        Config::open("./dcr.toml").map_err(|err| err.to_string())
+    }) {
+        Ok(cfg) => cfg,
+        Err(err) => {
+            error(&err);
+            return 1;
+        }
+    };
+    let project_name: &str = config
+        .get("package.name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+
+    let mut flags = match parse_build_run_flags(args) {
+        Ok(v) => v,
+        Err(_) => return 1,
+    };
+
+    // If no target specified, use default host target for target-specific config
+    if flags.target.is_none() {
+        let default_target = if cfg!(target_os = "linux") {
+            "x86_64-unknown-linux-gnu"
+        } else if cfg!(target_os = "macos") {
+            "x86_64-apple-darwin"
+        } else if cfg!(target_os = "windows") {
+            "x86_64-pc-windows-msvc"
+        } else {
+            "unknown"
+        };
+        flags.target = Some(default_target.to_string());
     }
 
-    let build_status = build(args);
+    let build_kind = config
-    if build_status == 0 {
+        .get(&format!("build.{}.kind", flags.profile))
-        println!("\n    Запуск target/{active_profile}/main");
+        .and_then(|v| v.as_str())
-        println!("--------------------------------");
+        .or_else(|| config.get("build.kind").and_then(|v| v.as_str()))
-        return Command::new(format!("./target/{active_profile}/main"))
+        .unwrap_or("");
-            .status()
-            .map(|status| status.code().unwrap_or(1))
-            .unwrap_or(1);
-    }
 
-    if check_dir(Some(&format!("target/{active_profile}")))
+    let normalized_target_dir = flags
-        .unwrap_or_default()
+        .target
-        .contains(&active_profile)
+        .as_ref()
+        .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile));
+
+    let version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let run_cmd = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), version);
+
+    let kind = build_kind.trim();
+    if run_cmd.is_none()
+        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
     {
-        println!("Запуск последнего релиза");
+        error("Cannot run library build");
-        return Command::new(format!("./target/{active_profile}/main"))
+        return 1;
-            .status()
+    }
-            .map(|status| status.code().unwrap_or(1))
+    let build_status = build(args);
-            .unwrap_or(1);
+    let bin_path = crate::platform::bin_path(
+        &flags.profile,
+        project_name,
+        normalized_target_dir.as_deref(),
+    );
+    if build_status == 0 {
+        if let Some(cmd) = run_cmd {
+            println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
+            println!("--------------------------------");
+            return run_shell(&cmd);
+        }
+        println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
+        println!("--------------------------------");
+        return run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        );
     }
 
-    println!("Исправьте ошибки в коде для запуска проекта");
+    let fallback_code = if let Some(cmd) = run_cmd {
-    0
+        run_shell(&cmd)
+    } else {
+        run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        )
+    };
+    if fallback_code != 1 {
+        return fallback_code;
+    }
+
+    error("Fix errors in the code to run the project");
+    1
+}
+
+fn run_shell(cmd: &str) -> i32 {
+    let status = if cfg!(target_os = "windows") {
+        Command::new("cmd").arg("/C").arg(cmd).status()
+    } else {
+        Command::new("sh").arg("-c").arg(cmd).status()
+    };
+    match status {
+        Ok(s) if s.success() => 0,
+        Ok(s) => s.code().unwrap_or(1),
+        Err(_) => 1,
+    }
+}
+
+fn substitute_run_vars(cmd: &str, profile: &str, version: &str) -> String {
+    let info = parse_version_info(version);
+    cmd.replace("{profile}", profile)
+        .replace("{version}", &info.full)
+        .replace("{version_major}", &info.major)
+        .replace("{version_minor}", &info.minor)
+        .replace("{version_patch}", &info.patch)
+        .replace("{version_suffix}", &info.suffix)
+        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/setup.rs

@@ -0,0 +1,16 @@
+pub fn setup(_args: &[String]) -> i32 {
+    println!("Setting up DCR registries...");
+    match crate::core::registry::RegistryManager::load() {
+        Ok(manager) => {
+            println!("Loaded {} registries.", manager.config.registry.len());
+            for (name, reg) in manager.config.registry {
+                println!("- {}: {} (priority {})", name, reg.url, reg.priority);
+            }
+            0
+        }
+        Err(e) => {
+            println!("Error: {}", e);
+            1
+        }
+    }
+}

src/cli/test.rs

@@ -0,0 +1,371 @@
+use crate::cli::build;
+use crate::config::{FILE_DCR_TEST_H, FILE_TEST_C, flags};
+use crate::core::config::Config;
+use crate::utils::build::{
+    get_config_opt, get_config_str, get_language_with_profile, get_list_with_profile,
+    get_string_with_profile, resolve_compiler, resolve_pkg_config_flags,
+};
+use crate::utils::fs::{find_project_root, with_dir};
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, BOLD_RED, RESET, colored};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const BOLD_BLUE: &str = "\x1b[1m\x1b[94m";
+
+pub fn test(args: &[String]) -> i32 {
+    let mut init_header = false;
+    let mut profile = "debug";
+    for arg in args {
+        if arg == "--help" {
+            println!("USAGE:");
+            println!("    dcr test [--init] [--debug | --release]");
+            println!();
+            println!("ALIASES:");
+            println!("    dcr tests");
+            println!();
+            println!("DESCRIPTION:");
+            println!("    Runs project tests and prints a unified testsuite report.");
+            println!();
+            println!("OPTIONS:");
+            println!("    --init            Create tests/dcr_test.h in current project");
+            println!("    --debug           Build and run tests with debug profile (default)");
+            println!("    --release         Build and run tests with release profile");
+            return 0;
+        }
+        if arg == "--init" {
+            init_header = true;
+            continue;
+        }
+        if arg == "--debug" || arg == "--release" {
+            profile = arg.trim_start_matches("--");
+            continue;
+        }
+        error("Unknown argument");
+        return 1;
+    }
+
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+
+    if init_header {
+        match with_dir(&root, ensure_test_header) {
+            Ok(()) => {}
+            Err(msg) => {
+                error(&msg);
+                return 1;
+            }
+        }
+    }
+
+    match with_dir(&root, || run_testsuite(profile)) {
+        Ok(code) => code,
+        Err(msg) => {
+            error(&msg);
+            1
+        }
+    }
+}
+
+fn run_testsuite(profile: &str) -> Result<i32, String> {
+    if build::build(&[format!("--{profile}")]) != 0 {
+        return Ok(1);
+    }
+
+    let config = Config::open("./dcr.toml").map_err(|_| "Failed to read dcr.toml".to_string())?;
+    let name = get_config_str(&config, "package.name");
+    let language = get_language_with_profile(&config, profile)?;
+    let compiler_cfg = get_string_with_profile(&config, "compiler", profile);
+    let standard = get_string_with_profile(&config, "standard", profile);
+    let package_type = get_config_str(&config, "package.type");
+    let build_kind = get_string_with_profile(&config, "kind", profile);
+    let tc_cc = get_config_opt(&config, "toolchain.cc");
+    let tc_cxx = get_config_opt(&config, "toolchain.cxx");
+    let tc_as = get_config_opt(&config, "toolchain.as");
+    let compiler = resolve_compiler(
+        &language,
+        &compiler_cfg,
+        tc_cc.as_deref(),
+        tc_cxx.as_deref(),
+        tc_as.as_deref(),
+    );
+
+    let mut cflags: Vec<String> = flags(profile)
+        .unwrap_or(&[])
+        .iter()
+        .map(|v| v.to_string())
+        .collect();
+    cflags.extend(get_list_with_profile(&config, "cflags", profile));
+    let ldflags = get_list_with_profile(&config, "ldflags", profile);
+    let pkg_configs = get_list_with_profile(&config, "pkg_config", profile);
+    let (cflags, ldflags) = resolve_pkg_config_flags(&pkg_configs, &cflags, &ldflags)?;
+    let includes = test_include_dirs(&config, profile);
+    let test_sources = collect_test_sources()?;
+    if test_sources.is_empty() {
+        return Err("tests/test.c not found; run 'dcr test --init' first".to_string());
+    }
+
+    let link_project_lib =
+        package_type == "lib" || build_kind == "staticlib" || build_kind == "sharedlib";
+    let mut stdout = String::new();
+    let mut declared = Vec::new();
+    let mut suite_success = true;
+
+    fs::create_dir_all("./tests/target")
+        .map_err(|e| format!("Failed to create tests/target: {e}"))?;
+    for source in &test_sources {
+        declared.extend(extract_test_names_path(source));
+        let stem = source
+            .file_stem()
+            .and_then(|v| v.to_str())
+            .unwrap_or("test");
+        let obj_path = Path::new("./tests/target").join(format!("{stem}.o"));
+        let bin_path =
+            Path::new("./tests/target").join(format!("{stem}{}", std::env::consts::EXE_SUFFIX));
+
+        compile_test_source(&compiler, &standard, &cflags, &includes, source, &obj_path)?;
+        link_test_binary(
+            &compiler,
+            &ldflags,
+            link_project_lib.then_some(name.as_str()),
+            &obj_path,
+            &bin_path,
+        )?;
+
+        let out = Command::new(&bin_path)
+            .output()
+            .map_err(|_| format!("Failed to run `{}`", bin_path.display()))?;
+        stdout.push_str(&String::from_utf8_lossy(&out.stdout));
+        let stderr = String::from_utf8_lossy(&out.stderr);
+        if !stderr.trim().is_empty() {
+            eprint!("{}", stderr);
+        }
+        if !out.status.success() {
+            suite_success = false;
+        }
+    }
+
+    let mut pass = 0;
+    let mut skip = 0;
+    let mut fail = 0;
+    let mut parsed_any = false;
+
+    for line in stdout.lines() {
+        let line = line.trim();
+        if let Some(name) = line.strip_prefix("[PASS] ") {
+            println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+            pass += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some(name) = line.strip_prefix("[SKIP] ") {
+            println!("{} {}", colored("[SKIP]", BOLD_BLUE), name);
+            skip += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some(name) = line.strip_prefix("[FAIL] ") {
+            println!("{} {}", colored("[FAIL]", BOLD_RED), name);
+            fail += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some((status, name)) = line.split_once('\t') {
+            match status {
+                "PASS" => {
+                    println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+                    pass += 1;
+                    parsed_any = true;
+                }
+                "SKIP" => {
+                    println!("{} {}", colored("[SKIP]", BOLD_BLUE), name);
+                    skip += 1;
+                    parsed_any = true;
+                }
+                "FAIL" => {
+                    println!("{} {}", colored("[FAIL]", BOLD_RED), name);
+                    fail += 1;
+                    parsed_any = true;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if !parsed_any {
+        if suite_success {
+            for name in &declared {
+                println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+            }
+            pass = declared.len() as i32;
+        } else {
+            println!("{} testsuite", colored("[FAIL]", BOLD_RED));
+            fail = 1;
+        }
+    }
+
+    let total = if parsed_any || declared.is_empty() {
+        pass + skip + fail
+    } else {
+        declared.len() as i32
+    };
+
+    println!();
+    println!("{}", colored("=====================", BOLD_GREEN));
+    println!("{}", colored("  Testsuite summary  ", BOLD_GREEN));
+    println!("{}", colored("=====================", BOLD_GREEN));
+    println!("TOTAL: {}", total);
+    print_field("PASS", pass, BOLD_GREEN);
+    print_field("SKIP", skip, BOLD_BLUE);
+    print_field("FAIL", fail, BOLD_RED);
+    println!("{}", colored("=====================", BOLD_GREEN));
+
+    if fail > 0 || !suite_success {
+        return Ok(1);
+    }
+    Ok(0)
+}
+
+fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
+    let tests_dir = Path::new("./tests");
+    if !tests_dir.is_dir() {
+        return Ok(Vec::new());
+    }
+    let mut sources = Vec::new();
+    for entry in fs::read_dir(tests_dir).map_err(|e| format!("Failed to read tests/: {e}"))? {
+        let path = entry
+            .map_err(|e| format!("Failed to read tests/: {e}"))?
+            .path();
+        if path.extension().and_then(|v| v.to_str()) == Some("c") {
+            sources.push(path);
+        }
+    }
+    sources.sort();
+    Ok(sources)
+}
+
+fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
+    let mut dirs = vec![
+        "./tests".to_string(),
+        "./src".to_string(),
+        "./target/include".to_string(),
+    ];
+    dirs.extend(get_list_with_profile(config, "include", profile));
+    dirs
+}
+
+fn compile_test_source(
+    compiler: &str,
+    standard: &str,
+    cflags: &[String],
+    includes: &[String],
+    source: &Path,
+    obj_path: &Path,
+) -> Result<(), String> {
+    let mut cmd = Command::new(compiler);
+    cmd.arg("-c").arg(source).arg("-o").arg(obj_path);
+    if !standard.trim().is_empty() {
+        cmd.arg(format!("-std={}", standard.trim()));
+    }
+    for flag in cflags {
+        cmd.arg(flag);
+    }
+    for dir in includes {
+        cmd.arg(format!("-I{dir}"));
+    }
+    let output = cmd
+        .output()
+        .map_err(|e| format!("Failed to compile {}: {e}", source.display()))?;
+    print_command_output(&output);
+    if !output.status.success() {
+        return Err(format!("Compilation of {} failed", source.display()));
+    }
+    Ok(())
+}
+
+fn link_test_binary(
+    compiler: &str,
+    ldflags: &[String],
+    project_lib: Option<&str>,
+    obj_path: &Path,
+    bin_path: &Path,
+) -> Result<(), String> {
+    let mut cmd = Command::new(compiler);
+    cmd.arg(obj_path);
+    if let Some(name) = project_lib {
+        cmd.arg("-Ltarget/lib").arg(format!("-l{name}"));
+    }
+    for flag in ldflags {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o").arg(bin_path);
+    let output = cmd
+        .output()
+        .map_err(|e| format!("Failed to link {}: {e}", bin_path.display()))?;
+    print_command_output(&output);
+    if !output.status.success() {
+        return Err(format!("Linking of {} failed", bin_path.display()));
+    }
+    Ok(())
+}
+
+fn print_command_output(output: &std::process::Output) {
+    if !output.stdout.is_empty() {
+        print!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    if !output.stderr.is_empty() {
+        eprint!("{}", String::from_utf8_lossy(&output.stderr));
+    }
+}
+
+fn ensure_test_header() -> Result<(), String> {
+    fs::create_dir_all("./tests").map_err(|_| "Failed to create tests/".to_string())?;
+    fs::write("./tests/dcr_test.h", FILE_DCR_TEST_H)
+        .map_err(|_| "Failed to write tests/dcr_test.h".to_string())?;
+    println!("Created tests/dcr_test.h");
+    fs::write("./tests/test.c", FILE_TEST_C)
+        .map_err(|_| "Failed to write tests/test.c".to_string())?;
+    println!("Created tests/test.c");
+    Ok(())
+}
+
+fn extract_test_names_path(path: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(path) else {
+        return Vec::new();
+    };
+    let mut names = Vec::new();
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix("TEST_CASE(")
+            && let Some(name) = rest.strip_suffix("),")
+        {
+            names.push(name.to_string());
+        }
+    }
+    names
+}
+
+fn print_field(label: &str, value: i32, color: &str) {
+    if value == 0 {
+        println!("{}:  {}", label, value);
+    } else {
+        println!("{}{}:  {}{}", color, label, value, RESET);
+    }
+}

src/cli/tree.rs

@@ -0,0 +1,118 @@
+use crate::core::config::Config;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_CYAN, printc};
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use toml::Value;
+
+pub fn tree(_args: &[String]) -> i32 {
+    let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let config = match Config::open("dcr.toml") {
+        Ok(c) => c,
+        Err(_) => {
+            error("dcr.toml not found in current directory");
+            return 1;
+        }
+    };
+
+    let name = config
+        .get("package.name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+    let version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("0.0.0");
+
+    printc(&format!("{} v{}", name, version), BOLD_CYAN);
+
+    let mut seen = HashSet::new();
+    seen.insert(name.to_string());
+
+    if let Some(deps) = config.get("dependencies").and_then(|v| v.as_table()) {
+        print_deps(deps, &current_dir, "", &mut seen);
+    }
+
+    0
+}
+
+fn print_deps(
+    deps: &toml::value::Table,
+    base_path: &Path,
+    prefix: &str,
+    seen: &mut HashSet<String>,
+) {
+    let mut dep_list: Vec<_> = deps.iter().collect();
+    dep_list.sort_by_key(|(name, _)| *name);
+
+    for (i, (name, value)) in dep_list.iter().enumerate() {
+        let is_last = i == dep_list.len() - 1;
+        let connector = if is_last { "└── " } else { "├── " };
+        let child_prefix = if is_last { "    " } else { "│   " };
+
+        let dep_path = resolve_dep_path(value, base_path);
+        let mut version = String::new();
+        let mut sub_deps = None;
+        let mut resolved_path = None;
+
+        if let Some(path) = &dep_path {
+            let dcr_toml = path.join("dcr.toml");
+            if dcr_toml.exists()
+                && let Ok(config) = Config::open(&dcr_toml.to_string_lossy())
+            {
+                if let Some(v) = config.get("package.version").and_then(|v| v.as_str()) {
+                    version = format!(" v{}", v);
+                }
+                sub_deps = config
+                    .get("dependencies")
+                    .and_then(|v| v.as_table())
+                    .cloned();
+                resolved_path = Some(path.clone());
+            }
+        }
+
+        if version.is_empty() {
+            version = match value {
+                Value::String(s) if s.starts_with("git:") || s.starts_with("github:") => {
+                    format!(" ({})", s)
+                }
+                Value::Table(t) => {
+                    if let Some(v) = t.get("version").and_then(|v| v.as_str()) {
+                        format!(" v{}", v)
+                    } else if let Some(git) = t.get("git").and_then(|v| v.as_str()) {
+                        format!(" ({})", git)
+                    } else {
+                        "".to_string()
+                    }
+                }
+                _ => "".to_string(),
+            };
+        }
+
+        println!("{}{}{}{}", prefix, connector, name, version);
+
+        if let Some(s_deps) = sub_deps
+            && !seen.contains(*name)
+        {
+            seen.insert(name.to_string());
+            let new_prefix = format!("{}{}", prefix, child_prefix);
+            if let Some(path) = resolved_path {
+                print_deps(&s_deps, &path, &new_prefix, seen);
+            }
+            seen.remove(*name);
+        }
+    }
+}
+
+fn resolve_dep_path(value: &Value, base_path: &Path) -> Option<PathBuf> {
+    match value {
+        Value::String(s) => s
+            .strip_prefix("path:")
+            .map(|stripped| base_path.join(stripped)),
+        Value::Table(t) => t
+            .get("path")
+            .and_then(|v| v.as_str())
+            .map(|path| base_path.join(path)),
+        _ => None,
+    }
+}

src/config.rs

@@ -1,24 +1,4 @@
-pub const PROJECT_VERSION: &str = "0.1.0";
-pub const PROJECT_LANGUAGE: &str = "c";
-pub const PROJECT_COMPILER: &str = "clang";
 pub const PROFILE: &str = "debug";
-
-pub fn file_dcr_toml(project_name: &str) -> String {
-    format!(
-        r#"[package]
-name = "{project_name}"
-version = "{project_version}"
-language = "{project_language}"
-compiler = "{project_compiler}"
-
-[dependencies]
-"#,
-        project_version = PROJECT_VERSION,
-        project_language = PROJECT_LANGUAGE,
-        project_compiler = PROJECT_COMPILER
-    )
-}
-
 pub const FILE_MAIN_C: &str = r#"#include <stdio.h>
 
 int main(void) {
@@ -27,16 +7,88 @@ int main(void) {
 }
 "#;
 
+pub const FILE_DCR_TEST_H: &str = r#"#pragma once
+#include <stdio.h>
+#include <string.h>
+
+#define DCR_TEST_PASS 0
+#define DCR_TEST_FAIL 1
+#define DCR_TEST_SKIP 2
+
+#define EXPECT(expr) \
+    do { \
+        if (!(expr)) { \
+            fprintf(stderr, "assert failed: %s (%s:%d)\n", #expr, __FILE__, __LINE__); \
+            return DCR_TEST_FAIL; \
+        } \
+    } while (0)
+
+#define SKIP(reason) \
+    do { \
+        (void)(reason); \
+        return DCR_TEST_SKIP; \
+    } while (0)
+
+#define TEST(name) static int name(void)
+#define TEST_CASE(name) {#name, name}
+
+typedef int (*test_fn_t)(void);
+
+typedef struct {
+    const char *name;
+    test_fn_t fn;
+} test_case_t;
+
+static inline int dcr_test_raw_mode(int argc, char **argv) {
+    return argc > 1 && strcmp(argv[1], "--dcr-raw") == 0;
+}
+
+static inline void dcr_test_print_result(const char *name, int rc, int raw_mode) {
+    const char *tag = (rc == DCR_TEST_PASS) ? "PASS" : (rc == DCR_TEST_SKIP) ? "SKIP" : "FAIL";
+    if (raw_mode) {
+        printf("%s\t%s\n", tag, name);
+    } else {
+        printf("[%s] %s\n", tag, name);
+    }
+}
+"#;
+
+pub const FILE_TEST_C: &str = r#"#include "dcr_test.h"
+
+TEST(test_example) {
+    EXPECT(1 + 1 == 2);
+    return DCR_TEST_PASS;
+}
+
+static test_case_t CASES[] = {
+    TEST_CASE(test_example),
+};
+
+int main(int argc, char **argv) {
+    int raw = dcr_test_raw_mode(argc, argv);
+    int rc = 0;
+    int count = (int)(sizeof(CASES) / sizeof(CASES[0]));
+    for (int i = 0; i < count; ++i) {
+        int status = CASES[i].fn();
+        dcr_test_print_result(CASES[i].name, status, raw);
+        if (status == DCR_TEST_FAIL) {
+            rc = 1;
+        }
+    }
+    return rc;
+}
+"#;
+
 pub fn flags(profile: &str) -> Option<&'static [&'static str]> {
     match profile {
-        "release" => Some(&["-O3", "-DNDEBUG", "-march=native"]),
+        "release" => Some(&["-O3", "-DNDEBUG"]),
         "debug" => Some(&[
             "-O0",
             "-g",
             "-Wall",
             "-Wextra",
             "-fno-omit-frame-pointer",
-            "-DDEBUG",
+            "-DDCR_DEBUG",
         ]),
         _ => None,
     }

src/core/builder/common.rs

@@ -0,0 +1,696 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::{Mutex, OnceLock};
+
+static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+
+pub fn get_output_lock() -> &'static Mutex<()> {
+    OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
+}
+
+pub fn collect_sources(
+    roots: &[PathBuf],
+    extensions: &[&str],
+    exclude_dirs: &[PathBuf],
+    include_paths: &[String],
+) -> Result<Vec<String>, String> {
+    let mut sources = Vec::new();
+    for root in roots {
+        collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+    }
+    sources.sort();
+    if sources.is_empty() {
+        return Err(format!("No source files found in {}", format_roots(roots)));
+    }
+    Ok(sources)
+}
+
+fn collect_sources_rec(
+    dir: &Path,
+    extensions: &[&str],
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+    include_paths: &[String],
+) -> Result<(), String> {
+    let full_dir = if dir.is_absolute() {
+        dir.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir)
+    };
+    if is_excluded(&full_dir, exclude_dirs, include_paths) && include_paths.is_empty() {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
+    for entry in entries {
+        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
+                continue;
+            }
+            collect_sources_rec(&path, extensions, out, exclude_dirs, include_paths)?;
+            continue;
+        }
+        if !path.is_file() {
+            continue;
+        }
+        if is_excluded(&path, exclude_dirs, include_paths) {
+            continue;
+        }
+        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
+        let ext_lower = ext_raw.to_lowercase();
+        let matched = extensions
+            .iter()
+            .any(|allowed| *allowed == ext_raw || *allowed == ext_lower);
+        if matched {
+            out.push(normalize_source_path(&path));
+        }
+    }
+    Ok(())
+}
+
+fn format_roots(roots: &[PathBuf]) -> String {
+    if roots.is_empty() {
+        return "<none>".to_string();
+    }
+    let mut out = Vec::new();
+    for root in roots {
+        out.push(root.to_string_lossy().to_string());
+    }
+    out.join(", ")
+}
+
+pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[String]) -> bool {
+    if matches_patterns(path, include_paths, true) {
+        return false;
+    }
+    if matches_patterns(path, include_paths, false) {
+        return true;
+    }
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
+    if patterns.is_empty() {
+        return false;
+    }
+    let cwd = std::env::current_dir().ok();
+    let abs_path = if path.is_absolute() {
+        path.to_path_buf()
+    } else if let Some(base) = cwd.as_ref() {
+        base.join(path)
+    } else {
+        path.to_path_buf()
+    };
+    let abs = abs_path.to_string_lossy().replace('\\', "/");
+    let rel = cwd
+        .as_ref()
+        .and_then(|base| abs_path.strip_prefix(base).ok())
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+        .unwrap_or_default();
+    let rel_dot = if rel.is_empty() {
+        String::new()
+    } else {
+        format!("./{rel}")
+    };
+    for raw in patterns {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let is_neg = trimmed.starts_with('!');
+        if is_neg == positive {
+            continue;
+        }
+        let normalized = trimmed.trim_start_matches('!').replace('\\', "/");
+        if normalized.is_empty() {
+            continue;
+        }
+        if has_glob_magic(&normalized) {
+            let pat = match glob::Pattern::new(&normalized) {
+                Ok(p) => p,
+                Err(_) => continue,
+            };
+            if pat.matches(&abs)
+                || (!rel.is_empty() && (pat.matches(&rel) || pat.matches(&rel_dot)))
+            {
+                return true;
+            }
+            continue;
+        }
+        let norm = normalized.trim_end_matches('/');
+        let candidate = Path::new(norm);
+        let full = if candidate.is_absolute() {
+            candidate.to_path_buf()
+        } else if let Some(base) = cwd.as_ref() {
+            base.join(candidate)
+        } else {
+            candidate.to_path_buf()
+        };
+        if abs_path.starts_with(&full) {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn has_glob_magic(value: &str) -> bool {
+    value.chars().any(|c| matches!(c, '*' | '?' | '['))
+}
+
+pub fn parallel_build<F>(total_tasks: usize, task_fn: F) -> Result<(), String>
+where
+    F: Fn(usize) -> Result<(), String> + Sync + Send,
+{
+    let num_threads = std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(1);
+
+    let counter = std::sync::atomic::AtomicUsize::new(0);
+    let err_msg = std::sync::Mutex::new(None);
+
+    std::thread::scope(|s| {
+        for _ in 0..num_threads {
+            s.spawn(|| {
+                loop {
+                    if err_msg.lock().unwrap().is_some() {
+                        break;
+                    }
+
+                    let i = counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    if i >= total_tasks {
+                        break;
+                    }
+
+                    if let Err(e) = task_fn(i) {
+                        let mut err = err_msg.lock().unwrap();
+                        if err.is_none() {
+                            *err = Some(e);
+                        }
+                        break;
+                    }
+                }
+            });
+        }
+    });
+
+    if let Some(err) = err_msg.into_inner().unwrap() {
+        return Err(err);
+    }
+
+    Ok(())
+}
+
+pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
+    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+    let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap();
+    if !output.stdout.is_empty() {
+        print!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    if !output.stderr.is_empty() {
+        eprint!("{}", String::from_utf8_lossy(&output.stderr));
+    }
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err("Build failed".to_string())
+    }
+}
+
+pub fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
+pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
+    let rel = stripped
+        .components()
+        .skip(1)
+        .collect::<std::path::PathBuf>();
+    let rel = if rel.components().next().is_some() {
+        rel
+    } else {
+        stripped.to_path_buf()
+    };
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    out.to_string_lossy().to_string()
+}
+
+pub fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    let o_time = match obj_time {
+        Ok(t) => t,
+        Err(_) => return true,
+    };
+    match src_time {
+        Ok(s) if s > o_time => return true,
+        Err(_) => return true,
+        _ => {}
+    }
+
+    let d_file = PathBuf::from(object).with_extension("d");
+    if let Ok(content) = fs::read_to_string(&d_file) {
+        let deps = parse_d_file(&content);
+        for dep in deps {
+            let dep_path = Path::new(&dep);
+            if dep_path == Path::new(object) || dep_path == Path::new(source) {
+                continue;
+            }
+            if let Ok(dep_meta) = fs::metadata(dep_path) {
+                if let Ok(dep_time) = dep_meta.modified()
+                    && dep_time > o_time
+                {
+                    return true;
+                }
+            } else {
+                return true; // Missing dependency triggers rebuild
+            }
+        }
+    }
+    false
+}
+
+fn parse_d_file(content: &str) -> Vec<String> {
+    let mut deps = Vec::new();
+    let text = content.replace("\\\n", " ").replace("\\\r\n", " ");
+    let mut target_end = 0;
+    let chars: Vec<char> = text.chars().collect();
+    for i in 0..chars.len() {
+        if chars[i] == ':' {
+            if i == 1
+                && chars[0].is_ascii_alphabetic()
+                && i + 1 < chars.len()
+                && (chars[i + 1] == '\\' || chars[i + 1] == '/')
+            {
+                continue; // Windows drive letter
+            }
+            target_end = i + 1;
+            break;
+        }
+    }
+
+    let deps_str = if target_end > 0 {
+        &text[target_end..]
+    } else {
+        &text
+    };
+
+    let mut current_path = String::new();
+    let mut in_escape = false;
+
+    for c in deps_str.chars() {
+        if in_escape {
+            if c != '\n' && c != '\r' {
+                current_path.push(c);
+            }
+            in_escape = false;
+        } else if c == '\\' {
+            in_escape = true;
+        } else if c.is_whitespace() {
+            if !current_path.is_empty() {
+                deps.push(current_path.clone());
+                current_path.clear();
+            }
+        } else {
+            current_path.push(c);
+        }
+    }
+    if !current_path.is_empty() {
+        deps.push(current_path);
+    }
+    deps
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::path::PathBuf;
+    use std::sync::Mutex;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
+    static CWD_LOCK: Mutex<()> = Mutex::new(());
+
+    fn temp_dir(prefix: &str) -> PathBuf {
+        let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn default_roots() -> Vec<PathBuf> {
+        vec![PathBuf::from("src")]
+    }
+
+    #[test]
+    fn object_path_basic() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.o");
+    }
+
+    #[test]
+    fn object_path_nested() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/core/utils.c", "o");
+        assert_eq!(result, "target/debug/obj/core/utils.o");
+    }
+
+    #[test]
+    fn object_path_no_prefix() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.o");
+    }
+
+    #[test]
+    fn object_path_msvc_ext() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "obj");
+        assert_eq!(result, "target/debug/obj/main.obj");
+    }
+
+    #[test]
+    fn needs_rebuild_no_object() {
+        let dir = temp_dir("rebuild_no_obj");
+        let src = dir.join("test.c");
+        fs::write(&src, "int main() {}").unwrap();
+        let obj = dir.join("test.o");
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_fresh() {
+        let dir = temp_dir("rebuild_fresh");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&src, "int main() {}").unwrap();
+        // Sleep briefly to ensure mtime difference
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+        assert!(!needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_stale() {
+        let dir = temp_dir("rebuild_stale");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&obj, "").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&src, "int main() { return 1; }").unwrap();
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn is_excluded_match() {
+        let include: Vec<String> = Vec::new();
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(is_excluded(
+            Path::new("/project/src/vendor"),
+            &excluded,
+            &include
+        ));
+        assert!(is_excluded(
+            Path::new("/project/src/vendor/lib.c"),
+            &excluded,
+            &include
+        ));
+    }
+
+    #[test]
+    fn is_excluded_no_match() {
+        let include: Vec<String> = Vec::new();
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(!is_excluded(
+            Path::new("/project/src/main.c"),
+            &excluded,
+            &include
+        ));
+        assert!(!is_excluded(
+            Path::new("/other/vendor"),
+            &excluded,
+            &include
+        ));
+    }
+
+    #[test]
+    fn collect_sources_c_files() {
+        let dir = temp_dir("collect_c");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(src.join("utils.c"), "").unwrap();
+        fs::write(src.join("README.md"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+        assert!(sources.iter().any(|s| s.ends_with("main.c")));
+        assert!(sources.iter().any(|s| s.ends_with("utils.c")));
+    }
+
+    #[test]
+    fn collect_sources_cpp_files() {
+        let dir = temp_dir("collect_cpp");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.cpp"), "").unwrap();
+        fs::write(src.join("helper.cxx"), "").unwrap();
+        fs::write(src.join("other.cc"), "").unwrap();
+        fs::write(src.join("skip.c"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["cpp", "cxx", "cc"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 3);
+    }
+
+    #[test]
+    fn collect_sources_empty_dir() {
+        let dir = temp_dir("collect_empty");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        assert!(result.is_err(), "empty src should return error");
+    }
+
+    #[test]
+    fn collect_sources_respects_excludes() {
+        let dir = temp_dir("collect_exclude");
+        let src = dir.join("src");
+        let vendor = src.join("vendor");
+        fs::create_dir_all(&vendor).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded
+
+        let exclude = vec![vendor.clone()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("main.c"));
+    }
+
+    #[test]
+    fn collect_sources_nested() {
+        let dir = temp_dir("collect_nested");
+        let src = dir.join("src");
+        let sub = src.join("core").join("deep");
+        fs::create_dir_all(&sub).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(sub.join("nested.c"), "").unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+    }
+
+    #[test]
+    fn include_overrides_exclude() {
+        let dir = temp_dir("include_override");
+        let src = dir.join("src");
+        let boot = src.join("boot");
+        let arch = boot.join("arch");
+        fs::create_dir_all(&arch).unwrap();
+        fs::write(arch.join("start.s"), "").unwrap();
+        fs::write(boot.join("skip.c"), "").unwrap();
+
+        let exclude = vec![boot.clone()];
+        let include = vec!["src/boot/arch/**".to_string()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["s", "c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("start.s"));
+    }
+
+    #[test]
+    fn exclude_glob_with_include_override() {
+        let dir = temp_dir("exclude_glob");
+        let src = dir.join("src");
+        let legacy = src.join("legacy");
+        let allow = legacy.join("allow");
+        fs::create_dir_all(&allow).unwrap();
+        fs::write(legacy.join("skip.c"), "").unwrap();
+        fs::write(allow.join("keep.c"), "").unwrap();
+
+        let exclude = vec![dir.join("src"), dir.join(".")];
+        let include = vec![
+            "!src/legacy/**".to_string(),
+            "src/legacy/allow/**".to_string(),
+        ];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("keep.c"));
+    }
+
+    #[test]
+    fn exclude_glob_without_include_keeps_other_files() {
+        let dir = temp_dir("exclude_glob_only");
+        let src = dir.join("src");
+        let gen_dir = src.join("gen");
+        fs::create_dir_all(&gen_dir).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(gen_dir.join("skip.c"), "").unwrap();
+
+        let exclude: Vec<PathBuf> = Vec::new();
+        let include = vec!["!src/gen/**".to_string()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("main.c"));
+    }
+
+    #[test]
+    fn normalize_relative_path() {
+        let result = normalize_source_path(Path::new("./src/main.c"));
+        assert_eq!(result, "./src/main.c");
+    }
+
+    #[test]
+    fn parse_d_file_gcc_format() {
+        let content = "target/obj/main.o: src/main.c src/utils.h \\\n src/core/types.h";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["src/main.c", "src/utils.h", "src/core/types.h"]);
+    }
+
+    #[test]
+    fn parse_d_file_msvc_format() {
+        let content = "target/obj/main.obj: \\\n  C:/sdk/include/windows.h \\\n  src/main.c";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["C:/sdk/include/windows.h", "src/main.c"]);
+    }
+
+    #[test]
+    fn needs_rebuild_header_modified() {
+        let dir = temp_dir("rebuild_header");
+        let src = dir.join("test.c");
+        let header = dir.join("test.h");
+        let obj = dir.join("test.o");
+        let d_file = dir.join("test.d");
+
+        fs::write(&src, "int main() {}").unwrap();
+        fs::write(&header, "#define A 1").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+
+        let d_content = format!(
+            "{}: {} {}",
+            obj.to_string_lossy(),
+            src.to_string_lossy(),
+            header.to_string_lossy()
+        );
+        fs::write(&d_file, d_content).unwrap();
+
+        assert!(
+            !needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "should be fresh"
+        );
+
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&header, "#define A 2").unwrap(); // modify header
+
+        assert!(
+            needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "changed header should trigger rebuild"
+        );
+    }
+}

src/core/builder/gas.rs

@@ -0,0 +1,157 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let lang = ctx.language.to_lowercase();
+    if lang.split('+').any(|p| p.trim() != "asm") {
+        return Err("GAS backend requires build.language = \"asm\"".to_string());
+    }
+    let assembler = if ctx.compiler.is_empty() {
+        "as"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let sources = collect_sources(ctx)?;
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+    let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
+            "lib"
+        } else {
+            "ar"
+        });
+        let mut cmd = Command::new(archiver);
+        if cfg!(target_os = "windows") && archiver == "lib" {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // GAS handles only lowercase .s files
+    common::collect_sources(
+        ctx.source_roots,
+        &["s"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+fn build_objects(
+    assembler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
+        .collect();
+
+    common::parallel_build(sources.len(), |i| {
+        build_object(assembler, &sources[i], &objects[i], ctx)
+    })?;
+
+    Ok(objects)
+}
+
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg(source).arg("-o").arg(obj_path);
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}

src/core/builder/mod.rs

@@ -0,0 +1,77 @@
+pub mod common;
+pub mod gas;
+pub mod msvc;
+pub mod nasm;
+pub mod unix_cc;
+
+pub struct BuildContext<'a> {
+    pub profile: &'a str,
+    pub project_name: &'a str,
+    pub compiler: &'a str,
+    pub language: &'a str,
+    pub standard: &'a str,
+    #[allow(dead_code)]
+    pub target: Option<&'a str>,
+    pub target_dir: Option<&'a str>,
+    pub kind: &'a str,
+    pub platform: Option<&'a str>,
+    pub linker: Option<&'a str>,
+    pub archiver: Option<&'a str>,
+    pub package_type: Option<&'a str>,
+    pub source_roots: &'a [std::path::PathBuf],
+    pub exclude_dirs: &'a [std::path::PathBuf],
+    pub include_paths: &'a [String],
+    pub include_dirs: &'a [String],
+    pub lib_dirs: &'a [String],
+    pub libs: &'a [String],
+    pub cflags: &'a [String],
+    pub ldflags: &'a [String],
+    pub output_filename: Option<&'a str>,
+    pub output_extension: Option<&'a str>,
+    pub verbose: bool,
+}
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = ctx.compiler.to_lowercase();
+    if !check_compiler_exists(ctx.compiler) {
+        return Err(format!(
+            "Compiler not found: {}. Make sure it is installed and available in PATH.",
+            ctx.compiler
+        ));
+    }
+    if compiler.contains("clang-cl") {
+        return msvc::build(ctx);
+    }
+    if compiler == "as" || compiler.contains("gas") {
+        return gas::build(ctx);
+    }
+    if compiler.contains("nasm") {
+        return nasm::build(ctx);
+    }
+    if compiler == "cl" || compiler.contains("msvc") {
+        return msvc::build(ctx);
+    }
+    unix_cc::build(ctx)
+}
+
+fn check_compiler_exists(compiler: &str) -> bool {
+    let name = if compiler.is_empty() { "cc" } else { compiler };
+    std::process::Command::new(name)
+        .arg("--version")
+        .output()
+        .is_ok()
+}
+
+pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let compiler = ctx.compiler.to_lowercase();
+    if compiler.contains("clang-cl") || compiler == "cl" || compiler.contains("msvc") {
+        return msvc::collect_sources(ctx);
+    }
+    if compiler == "as" || compiler.contains("gas") {
+        return gas::collect_sources(ctx);
+    }
+    if compiler.contains("nasm") {
+        return nasm::collect_sources(ctx);
+    }
+    unix_cc::collect_sources(ctx)
+}

src/core/builder/msvc.rs

@@ -0,0 +1,320 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = if ctx.compiler.is_empty() {
+        "cl"
+    } else {
+        ctx.compiler
+    };
+    let lang = ctx.language.to_lowercase();
+    if lang.contains("asm") {
+        return Err("MSVC backend does not support build.language with asm".to_string());
+    }
+    let start_time = Instant::now();
+    let sources = collect_sources(ctx)?;
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
+        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("/nologo");
+    if ctx.kind == "sharedlib" {
+        cmd.arg("/LD");
+    }
+    match ctx.language.to_lowercase().as_str() {
+        "c" => {
+            cmd.arg("/TC");
+        }
+        "c++" | "cpp" | "cxx" => {
+            cmd.arg("/TP");
+        }
+        _ => {
+            return Err("Unsupported language".to_string());
+        }
+    }
+
+    if !ctx.standard.is_empty() {
+        let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+        cmd.arg(std_flag);
+    }
+
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    if ctx.cflags.is_empty() {
+        for flag in default_flags(ctx.profile) {
+            cmd.arg(flag);
+        }
+    }
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("/LIBPATH:{dir}"));
+    }
+    for lib in ctx.libs {
+        if lib.to_lowercase().ends_with(".lib") {
+            cmd.arg(lib);
+        } else {
+            cmd.arg(format!("{lib}.lib"));
+        }
+    }
+    if !ctx.ldflags.is_empty() {
+        cmd.arg("/link");
+        for flag in ctx.ldflags {
+            cmd.arg(flag);
+        }
+    }
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    };
+    cmd.arg(format!("/Fe:{out_path}"));
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(
+        ctx.source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+fn source_extensions(language: &str) -> Vec<&str> {
+    let mut out = Vec::new();
+    for part in language.split('+') {
+        let lang = part.trim().to_lowercase();
+        match lang.as_str() {
+            "c" => out.extend(["c"]),
+            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
+            "asm" => {}
+            _ => {}
+        }
+    }
+    if out.is_empty() {
+        out.extend(["c"]);
+    }
+    out
+}
+
+fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
+    let lang = language.to_lowercase();
+    let std = standard.to_lowercase();
+    if lang == "c" {
+        return match std.as_str() {
+            "c11" => Ok("/std:c11".to_string()),
+            "c17" => Ok("/std:c17".to_string()),
+            _ => Err("Unsupported C standard for MSVC".to_string()),
+        };
+    }
+    if lang == "c++" || lang == "cpp" || lang == "cxx" {
+        return match std.as_str() {
+            "c++11" => Ok("/std:c++11".to_string()),
+            "c++14" => Ok("/std:c++14".to_string()),
+            "c++17" => Ok("/std:c++17".to_string()),
+            "c++20" => Ok("/std:c++20".to_string()),
+            "c++23" => Ok("/std:c++latest".to_string()),
+            _ => Err("Unsupported C++ standard for MSVC".to_string()),
+        };
+    }
+    Err("Unsupported language".to_string())
+}
+
+fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
+    let raw = platform?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let p = raw.to_lowercase().replace('-', "_");
+    if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
+        return Some("/arch:IA32");
+    }
+    match p.as_str() {
+        "sse2" => Some("/arch:SSE2"),
+        "avx" => Some("/arch:AVX"),
+        "avx2" => Some("/arch:AVX2"),
+        _ => None,
+    }
+}
+
+fn default_flags(profile: &str) -> &'static [&'static str] {
+    match profile {
+        "release" => &["/O2", "/DNDEBUG"],
+        "debug" => &["/Od", "/Zi", "/W4", "/DDCR_DEBUG", "/Oy-"],
+        _ => &[],
+    }
+}
+
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
+        .collect();
+
+    common::parallel_build(sources.len(), |i| {
+        build_object(compiler, &sources[i], &objects[i], ctx)
+    })?;
+
+    Ok(objects)
+}
+
+fn build_object(
+    compiler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("/nologo");
+
+    match ctx.language.to_lowercase().as_str() {
+        "c" => {
+            cmd.arg("/TC");
+        }
+        "c++" | "cpp" | "cxx" => {
+            cmd.arg("/TP");
+        }
+        _ => return Err("Unsupported language".to_string()),
+    }
+
+    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
+        let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+        cmd.arg(std_flag);
+    }
+
+    if let Some(flag) = msvc_arch_flag(ctx.platform) {
+        cmd.arg(flag);
+    }
+
+    if ctx.cflags.is_empty() {
+        for flag in default_flags(ctx.profile) {
+            cmd.arg(flag);
+        }
+    }
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    for dir in ctx.include_dirs {
+        cmd.arg(format!("/I{dir}"));
+    }
+
+    cmd.arg("/c").arg(source).arg(format!("/Fo:{}", obj_path));
+    cmd.arg("/showIncludes");
+
+    if std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    let mut headers = Vec::new();
+    let mut clean_stdout = String::new();
+
+    for line in stdout.lines() {
+        if let Some(stripped) = line.strip_prefix("Note: including file:") {
+            headers.push(stripped.trim().to_string());
+        } else if let Some(stripped) = line.strip_prefix("Примечание: включение файла:")
+        {
+            headers.push(stripped.trim().to_string());
+        } else {
+            clean_stdout.push_str(line);
+            clean_stdout.push('\n');
+        }
+    }
+
+    let _lock = common::get_output_lock().lock().unwrap();
+
+    if !output.status.success() {
+        eprint!("{}", clean_stdout);
+        eprint!("{}", stderr);
+        return Err("Build failed".to_string());
+    }
+
+    let trimmed_out = clean_stdout.trim();
+    let trimmed_err = stderr.trim();
+    let src_filename = Path::new(source)
+        .file_name()
+        .and_then(|v| v.to_str())
+        .unwrap_or("");
+
+    if !trimmed_out.is_empty() && trimmed_out != src_filename {
+        print!("{}", clean_stdout);
+    }
+
+    if !trimmed_err.is_empty() {
+        eprintln!("{}", trimmed_err);
+    }
+
+    let d_path = Path::new(obj_path).with_extension("d");
+    let mut d_content = format!("{}: \\\n", obj_path.replace('\\', "/"));
+    for h in headers {
+        let escaped = h.replace('\\', "/").replace(" ", "\\ ");
+        d_content.push_str(&format!("  {} \\\n", escaped));
+    }
+    fs::write(&d_path, d_content).map_err(|err| format!("d file error: {err}"))?;
+
+    Ok(())
+}

src/core/builder/nasm.rs

@@ -0,0 +1,204 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let lang = ctx.language.to_lowercase();
+    if lang.split('+').any(|p| p.trim() != "asm") {
+        return Err("NASM backend requires build.language = \"asm\"".to_string());
+    }
+    let assembler = if ctx.compiler.is_empty() {
+        "nasm"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let sources = collect_sources(ctx)?;
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+    let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
+            "lib"
+        } else {
+            "ar"
+        });
+        let mut cmd = Command::new(archiver);
+        if cfg!(target_os = "windows") && archiver == "lib" {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // NASM handles lowercase .s and .asm only (not .S which is GCC preprocessed)
+    common::collect_sources(
+        ctx.source_roots,
+        &["asm", "s"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+fn build_objects(
+    assembler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
+        .collect();
+
+    let format = nasm_format(ctx.platform);
+
+    common::parallel_build(sources.len(), |i| {
+        build_object(assembler, &sources[i], &objects[i], format, ctx)
+    })?;
+
+    Ok(objects)
+}
+
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    format: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg("-f")
+        .arg(format)
+        .arg(source)
+        .arg("-o")
+        .arg(obj_path);
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}
+
+fn nasm_format(platform: Option<&str>) -> &'static str {
+    if let Some(p) = platform {
+        let p = p.to_lowercase().replace('-', "_");
+        if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
+            #[cfg(target_os = "macos")]
+            {
+                return "macho32";
+            }
+            #[cfg(target_os = "windows")]
+            {
+                return "win32";
+            }
+            #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+            {
+                return "elf32";
+            }
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "elf64"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macho64"
+    }
+    #[cfg(target_os = "windows")]
+    {
+        "win64"
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        "elf64"
+    }
+}

src/core/builder/unix_cc.rs

@@ -0,0 +1,248 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = if ctx.compiler.is_empty() {
+        "cc"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let extensions = source_extensions(ctx.language);
+    let sources = common::collect_sources(
+        ctx.source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )?;
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
+        cmd.arg("rcs").arg(&lib_path);
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or(compiler));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    if ctx.kind == "efi" {
+        cmd.arg("-shared");
+        cmd.arg("-nostdlib");
+        cmd.arg("-Wl,-dll");
+        cmd.arg("-Wl,--subsystem,10");
+    }
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "efi" {
+        platform::efi_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(
+        ctx.source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+fn source_extensions(language: &str) -> Vec<&str> {
+    let mut out = Vec::new();
+    for part in language.split('+') {
+        let lang = part.trim().to_lowercase();
+        match lang.as_str() {
+            "c" => out.extend(["c"]),
+            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
+            "asm" => out.extend(["s", "S", "asm"]),
+            _ => {}
+        }
+    }
+    if out.is_empty() {
+        out.extend(["c"]);
+    }
+    out
+}
+
+fn default_flags(profile: &str) -> &'static [&'static str] {
+    match profile {
+        "release" => &["-O3", "-DNDEBUG"],
+        "debug" => &[
+            "-O0",
+            "-g",
+            "-Wall",
+            "-Wextra",
+            "-fno-omit-frame-pointer",
+            "-DDCR_DEBUG",
+        ],
+        _ => &[],
+    }
+}
+
+fn is_bare_metal_target(target: Option<&str>) -> bool {
+    if let Some(t) = target {
+        let lower = t.to_lowercase();
+        lower.contains("none")
+            || lower.contains("-elf")
+            || lower.contains("eabi")
+            || lower.contains("baremetal")
+            || lower.contains("bare-metal")
+    } else {
+        false
+    }
+}
+
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
+        .collect();
+
+    common::parallel_build(sources.len(), |i| {
+        build_object(compiler, &sources[i], &objects[i], ctx)
+    })?;
+
+    Ok(objects)
+}
+
+fn build_object(
+    compiler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("-c").arg(source).arg("-o").arg(obj_path);
+
+    if ctx.kind == "sharedlib" {
+        cmd.arg("-fPIC");
+    }
+
+    if let Some(flag) = asm_lang_flag(source) {
+        cmd.arg("-x").arg(flag);
+    }
+
+    if let Some(platform) = ctx.platform
+        && !platform.trim().is_empty()
+    {
+        cmd.arg(format!("-march={}", platform));
+    }
+
+    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
+        cmd.arg(format!("-std={}", ctx.standard));
+    }
+
+    let use_dcr_defaults = ctx.cflags.is_empty() && !is_bare_metal_target(ctx.target);
+    if use_dcr_defaults {
+        for flag in default_flags(ctx.profile) {
+            cmd.arg(flag);
+        }
+    }
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    for dir in ctx.include_dirs {
+        cmd.arg(format!("-I{dir}"));
+    }
+
+    let d_path = Path::new(obj_path).with_extension("d");
+    cmd.arg("-MMD").arg("-MF").arg(&d_path);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}
+
+fn asm_lang_flag(source: &str) -> Option<&'static str> {
+    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
+    match ext {
+        "S" => Some("assembler-with-cpp"),
+        "s" | "asm" => Some("assembler"),
+        _ => None,
+    }
+}

src/core/deps/common.rs

@@ -0,0 +1,111 @@
+#[allow(dead_code)]
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum DepSource {
+    Path(String),
+    Git {
+        url: String,
+        branch: Option<String>,
+        tag: Option<String>,
+        rev: Option<String>,
+    },
+    Registry {
+        version: String,
+        features: Option<Vec<String>>,
+    },
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct DepSpec {
+    pub name: String,
+    pub source: DepSource,
+    pub include_raw: Option<Vec<String>>,
+    pub lib_raw: Option<Vec<String>>,
+    pub libs_raw: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ResolvedDeps {
+    pub include_dirs: Vec<String>,
+    pub lib_dirs: Vec<String>,
+    pub libs: Vec<String>,
+}
+
+#[allow(dead_code)]
+pub fn resolve_path(project_root: &Path, raw: &str) -> Result<PathBuf, String> {
+    let p = Path::new(raw);
+    let full = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        project_root.join(p)
+    };
+    Ok(full)
+}
+
+#[allow(dead_code)]
+pub fn resolve_paths(
+    base: &Path,
+    raw: Option<&[String]>,
+    defaults: &[&str],
+    profile: &str,
+) -> Result<Vec<PathBuf>, String> {
+    let mut out = Vec::new();
+    if let Some(raw) = raw {
+        for r in raw {
+            let expanded = expand_profile(r, profile);
+            let p = Path::new(&expanded);
+            let full = if p.is_absolute() {
+                p.to_path_buf()
+            } else {
+                base.join(p)
+            };
+            if !full.exists() {
+                return Err(format!("Path does not exist: {}", full.display()));
+            }
+            out.push(full);
+        }
+        return Ok(out);
+    }
+
+    for d in defaults {
+        let candidate = base.join(d);
+        if candidate.exists() {
+            out.push(candidate);
+        }
+    }
+    Ok(out)
+}
+
+#[allow(dead_code)]
+pub fn expand_profile(raw: &str, profile: &str) -> String {
+    raw.replace("{profile}", profile)
+}
+
+#[allow(dead_code)]
+pub fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> {
+    if dst.exists() {
+        fs::remove_dir_all(dst)?;
+    }
+    copy_dir_all(src, dst)
+}
+
+#[allow(dead_code)]
+pub fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if ty.is_dir() {
+            copy_dir_all(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}

src/core/deps/git.rs

@@ -0,0 +1,54 @@
+use std::path::Path;
+
+#[allow(dead_code)]
+pub fn fetch_git_dep(
+    url: &str,
+    target_dir: &Path,
+    branch: Option<&str>,
+    tag: Option<&str>,
+    rev: Option<&str>,
+) -> Result<(), String> {
+    if target_dir.exists() {
+        return Ok(());
+    }
+
+    let mut builder = git2::build::RepoBuilder::new();
+    if let Some(b) = branch {
+        builder.branch(b);
+    }
+
+    let repo = builder
+        .clone(url, target_dir)
+        .map_err(|e| format!("failed to clone {}: {}", url, e))?;
+
+    if let Some(t) = tag {
+        checkout_ref(&repo, &format!("refs/tags/{}", t))?;
+    } else if let Some(r) = rev {
+        checkout_ref(&repo, r)?;
+    }
+
+    Ok(())
+}
+
+#[allow(dead_code)]
+fn checkout_ref(repo: &git2::Repository, reference_str: &str) -> Result<(), String> {
+    let (object, reference) = repo
+        .revparse_ext(reference_str)
+        .map_err(|e| format!("failed to find ref {}: {}", reference_str, e))?;
+
+    repo.checkout_tree(&object, None).map_err(|e| {
+        let ref_name = reference.as_ref().and_then(|r| r.name()).unwrap_or("HEAD");
+        format!("failed to checkout {}: {}", ref_name, e)
+    })?;
+
+    match reference {
+        Some(gref) => {
+            let ref_name = gref.name().unwrap_or("HEAD");
+            repo.set_head(ref_name)
+        }
+        None => repo.set_head_detached(object.id()),
+    }
+    .map_err(|e| format!("failed to set HEAD: {}", e))?;
+
+    Ok(())
+}

src/core/deps/lock.rs

@@ -0,0 +1,120 @@
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::path::Path;
+use toml::Value;
+
+#[derive(Debug, Clone)]
+pub struct DepLock {
+    pub name: String,
+    pub version: String,
+    pub checksum: String,
+    pub source: String,
+}
+
+pub fn write_lock(
+    project_root: &Path,
+    project_name: &str,
+    project_version: &str,
+    packages: &[DepLock],
+) -> Result<(), String> {
+    let mut out = String::new();
+    out.push_str("[[package]]\n");
+    out.push_str(&format!("name = \"{}\"\n", escape_value(project_name)));
+    out.push_str(&format!(
+        "version = \"{}\"\n",
+        escape_value(project_version)
+    ));
+    if !packages.is_empty() {
+        out.push_str(&format!(
+            "dependencies = [{}]\n",
+            quote_list(&packages.iter().map(|p| p.name.clone()).collect::<Vec<_>>())
+        ));
+    }
+    out.push('\n');
+
+    for pkg in packages {
+        out.push_str("[[package]]\n");
+        out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name)));
+        out.push_str(&format!("version = \"{}\"\n", escape_value(&pkg.version)));
+        out.push_str(&format!("source = \"{}\"\n", escape_value(&pkg.source)));
+        out.push_str(&format!("checksum = \"{}\"\n", escape_value(&pkg.checksum)));
+        out.push('\n');
+    }
+    fs::write(project_root.join("dcr.lock"), out)
+        .map_err(|err| format!("Failed to write dcr.lock: {err}"))?;
+    Ok(())
+}
+
+fn quote_list(items: &[String]) -> String {
+    items
+        .iter()
+        .map(|s| format!("\"{}\"", escape_value(s)))
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+fn escape_value(input: &str) -> String {
+    input.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+#[allow(dead_code)]
+pub fn read_dep_version(dep_path: &Path) -> Option<String> {
+    let path = dep_path.join("dcr.toml");
+    let content = fs::read_to_string(path).ok()?;
+    let value: Value = content.parse().ok()?;
+    value
+        .get("package")
+        .and_then(|v| v.as_table())
+        .and_then(|t| t.get("version"))
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string())
+}
+
+#[allow(dead_code)]
+pub fn compute_checksum(root: &Path) -> Result<String, String> {
+    let mut files = Vec::new();
+    collect_files(root, root, &mut files)?;
+    files.sort();
+    let mut hasher = Sha256::new();
+    for rel in files {
+        hasher.update(rel.as_bytes());
+        let data =
+            fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?;
+        hasher.update(&data);
+    }
+    let hash = hasher.finalize();
+    Ok(to_hex(&hash))
+}
+
+#[allow(dead_code)]
+fn collect_files(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
+    for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? {
+        let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?;
+        let path = entry.path();
+        let name = entry.file_name();
+        let name_str = name.to_string_lossy();
+        if name_str == "target" {
+            continue;
+        }
+        if path.is_dir() {
+            collect_files(root, &path, out)?;
+        } else if path.is_file() {
+            let rel = path
+                .strip_prefix(root)
+                .unwrap_or(&path)
+                .to_string_lossy()
+                .to_string();
+            out.push(rel);
+        }
+    }
+    Ok(())
+}
+
+#[allow(dead_code)]
+fn to_hex(bytes: &[u8]) -> String {
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        out.push_str(&format!("{:02x}", b));
+    }
+    out
+}

src/core/deps/mod.rs

@@ -0,0 +1,227 @@
+pub mod common;
+pub mod git;
+pub mod lock;
+pub mod register;
+
+use crate::core::config::Config;
+use crate::core::deps::common::ResolvedDeps;
+use crate::core::deps::lock::{DepLock, write_lock};
+use std::path::Path;
+
+fn dep_version(path: &Path) -> String {
+    Config::open(&path.join("dcr.toml").to_string_lossy())
+        .ok()
+        .and_then(|c| {
+            c.get("package.version")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .unwrap_or_default()
+}
+
+pub fn resolve_deps(
+    config: &Config,
+    _profile: &str,
+    _target: Option<&str>,
+    project_root: &Path,
+) -> Result<ResolvedDeps, String> {
+    let mut resolved = ResolvedDeps::default();
+    let project_name = config
+        .get("package.name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let project_version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    let deps_table = config.get("dependencies").and_then(|v| v.as_table());
+    let mut lock_packages: Vec<DepLock> = Vec::new();
+
+    if let Some(deps) = deps_table {
+        for (name, value) in deps {
+            if register::is_registry_dep(value) {
+                let pkg_info = register::resolve_package_from_registry(name)?;
+                let dep_root = register::package_root_from_registry_info(&pkg_info)?;
+
+                resolved.include_dirs.push(
+                    register::registry_include_dir(&dep_root)
+                        .to_string_lossy()
+                        .to_string(),
+                );
+                resolved.lib_dirs.push(
+                    register::registry_lib_dir(&dep_root)
+                        .to_string_lossy()
+                        .to_string(),
+                );
+                resolved.libs.push(name.clone());
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: pkg_info
+                        .get("version")
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("")
+                        .to_string(),
+                    checksum: String::new(),
+                    source: format!(
+                        "registry+{}",
+                        pkg_info
+                            .get("registry_url")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("https://dcr-registry.pages.dev")
+                    ),
+                });
+            } else if let Some(path) = path_dep_path(value) {
+                let dep_root = project_root.join(path);
+                if let Some(table) = value.as_table() {
+                    if let Some(includes) = table.get("include").and_then(|v| v.as_array()) {
+                        for inc in includes {
+                            if let Some(inc_str) = inc.as_str() {
+                                resolved
+                                    .include_dirs
+                                    .push(dep_root.join(inc_str).to_string_lossy().to_string());
+                            }
+                        }
+                    } else {
+                        push_if_exists(&mut resolved.include_dirs, &dep_root.join("include"));
+                    }
+
+                    if let Some(lib_dirs) = table.get("lib").and_then(|v| v.as_array()) {
+                        for lib_dir in lib_dirs {
+                            if let Some(lib_dir_str) = lib_dir.as_str() {
+                                resolved
+                                    .lib_dirs
+                                    .push(dep_root.join(lib_dir_str).to_string_lossy().to_string());
+                            }
+                        }
+                    } else {
+                        push_default_lib_dirs(&mut resolved.lib_dirs, &dep_root);
+                    }
+
+                    if let Some(libs) = table.get("libs").and_then(|v| v.as_array()) {
+                        for lib in libs {
+                            if let Some(lib_str) = lib.as_str() {
+                                resolved.libs.push(lib_str.to_string());
+                            }
+                        }
+                    } else {
+                        resolved.libs.push(name.clone());
+                    }
+                } else {
+                    push_if_exists(&mut resolved.include_dirs, &dep_root.join("include"));
+                    push_default_lib_dirs(&mut resolved.lib_dirs, &dep_root);
+                    resolved.libs.push(name.clone());
+                }
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: dep_version(&dep_root),
+                    checksum: String::new(),
+                    source: format!("path+{}", dep_root.display()),
+                });
+            } else if let Some(git_info) = git_dep(value) {
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: git_info.version.unwrap_or_default(),
+                    checksum: String::new(),
+                    source: format!("git+{}", git_info.url),
+                });
+            }
+        }
+    }
+
+    write_lock(
+        project_root,
+        &project_name,
+        &project_version,
+        &lock_packages,
+    )?;
+
+    Ok(resolved)
+}
+
+struct GitDep<'a> {
+    url: &'a str,
+    version: Option<String>,
+}
+
+fn git_dep(value: &toml::Value) -> Option<GitDep<'_>> {
+    if let Some(table) = value.as_table()
+        && let Some(url) = table.get("git").and_then(|v| v.as_str())
+    {
+        let version = table
+            .get("version")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        return Some(GitDep { url, version });
+    }
+    None
+}
+
+fn path_dep_path(value: &toml::Value) -> Option<&str> {
+    if let Some(table) = value.as_table() {
+        return table.get("path").and_then(|v| v.as_str());
+    }
+    register::path_from_string_dep(value)
+}
+
+fn push_if_exists(paths: &mut Vec<String>, path: &Path) {
+    if path.exists() {
+        paths.push(path.to_string_lossy().to_string());
+    }
+}
+
+fn push_default_lib_dirs(paths: &mut Vec<String>, dep_root: &Path) {
+    for dir in ["lib", "lib64"] {
+        push_if_exists(paths, &dep_root.join(dir));
+    }
+    push_if_exists(paths, &dep_root.join("target").join("lib"));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use toml::Value;
+
+    #[test]
+    fn path_dep_path_supports_table_and_legacy_strings() {
+        let table = Value::Table(
+            [(
+                "path".to_string(),
+                Value::String("./libs/mylib".to_string()),
+            )]
+            .into_iter()
+            .collect(),
+        );
+        assert_eq!(path_dep_path(&table), Some("./libs/mylib"));
+        assert_eq!(
+            path_dep_path(&Value::String("path:./libs/mylib".to_string())),
+            Some("./libs/mylib")
+        );
+        assert_eq!(
+            path_dep_path(&Value::String("./libs/mylib".to_string())),
+            Some("./libs/mylib")
+        );
+        assert_eq!(path_dep_path(&Value::String("1.2.3".to_string())), None);
+    }
+
+    #[test]
+    fn default_lib_dirs_include_packaged_library_output() {
+        let root = std::env::temp_dir().join(format!(
+            "dcr_default_lib_dirs_{}_{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(root.join("target/lib")).unwrap();
+        let mut paths = Vec::new();
+        push_default_lib_dirs(&mut paths, &root);
+        assert!(paths.iter().any(|p| p.ends_with("target/lib")));
+        let _ = std::fs::remove_dir_all(root);
+    }
+}

src/core/deps/register.rs

@@ -0,0 +1,223 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+use std::fs;
+use std::path::{Path, PathBuf};
+use toml::Value as TomlValue;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Registry {
+    pub url: String,
+    pub priority: i32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DcrConfig {
+    pub registry: std::collections::HashMap<String, Registry>,
+}
+
+fn home_dir() -> Option<PathBuf> {
+    if let Ok(home) = std::env::var("HOME") {
+        return Some(PathBuf::from(home));
+    }
+    if let Ok(profile) = std::env::var("USERPROFILE") {
+        return Some(PathBuf::from(profile));
+    }
+    None
+}
+
+fn dcr_config_dir() -> Option<PathBuf> {
+    home_dir().map(|h| h.join(".dcr"))
+}
+
+pub fn get_registry_config() -> Option<DcrConfig> {
+    let home = home_dir()?;
+    let config_path = home.join(".dcr/config.toml");
+    if !config_path.exists() {
+        return None;
+    }
+
+    let content = fs::read_to_string(config_path).ok()?;
+    toml::from_str(&content).ok()
+}
+
+pub fn get_index_path() -> PathBuf {
+    std::env::var("DCR_INDEX_PATH")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dcr_config_dir()
+                .unwrap_or_else(|| PathBuf::from("."))
+                .join("index.json")
+        })
+}
+
+pub fn get_registry_cache_root() -> PathBuf {
+    let index_path = get_index_path();
+    if let Some(parent) = index_path.parent() {
+        if parent.exists() {
+            return parent.to_path_buf();
+        }
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            eprintln!("Warning: failed to create registry cache directory: {e}");
+        }
+        parent.to_path_buf()
+    } else {
+        PathBuf::from(".")
+    }
+}
+
+pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf, String> {
+    let raw_path = pkg_info
+        .get("path")
+        .and_then(|v| v.as_str())
+        .ok_or("Registry package is missing path")?;
+    if raw_path.trim().is_empty() {
+        return Err("Registry package path is empty".to_string());
+    }
+
+    let path = Path::new(raw_path);
+    let full_path = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        get_registry_cache_root().join(path)
+    };
+
+    if full_path.file_name().and_then(|v| v.to_str()) == Some("dcr.toml") {
+        return full_path
+            .parent()
+            .map(Path::to_path_buf)
+            .ok_or_else(|| format!("Invalid registry package path: {}", full_path.display()));
+    }
+
+    Ok(full_path)
+}
+
+pub fn registry_include_dir(dep_root: &Path) -> PathBuf {
+    dep_root.join("target").join("include")
+}
+
+pub fn registry_lib_dir(dep_root: &Path) -> PathBuf {
+    dep_root.join("target").join("lib")
+}
+
+pub fn resolve_package_from_registry(name: &str) -> Result<JsonValue, String> {
+    let config = get_registry_config().ok_or("No registry config found")?;
+    let mut registries: Vec<(&String, &Registry)> = config.registry.iter().collect();
+    registries.sort_by_key(|b| std::cmp::Reverse(b.1.priority));
+
+    for (_name_reg, _reg) in registries {
+        let index_path = get_index_path();
+        if index_path.exists() {
+            let index_content = fs::read_to_string(&index_path).map_err(|e| e.to_string())?;
+            let index: JsonValue =
+                serde_json::from_str(&index_content).map_err(|e| e.to_string())?;
+            if let Some(pkgs) = index.get("packages").and_then(|v| v.as_array()) {
+                for pkg in pkgs {
+                    if pkg.get("name").and_then(|v| v.as_str()) == Some(name) {
+                        return Ok(pkg.clone());
+                    }
+                }
+            }
+        }
+    }
+    Err(format!(
+        "Package {} not found in registry (checked: {:?})",
+        name,
+        get_index_path()
+    ))
+}
+
+pub fn is_registry_dep(value: &TomlValue) -> bool {
+    if let Some(raw) = value.as_str() {
+        let raw = raw.trim();
+        return !is_path_like_string(raw) && !is_git_like_string(raw);
+    }
+    if let Some(table) = value.as_table() {
+        if table.contains_key("git") || table.contains_key("path") || table.contains_key("url") {
+            return false;
+        }
+        table.contains_key("version")
+            || table.contains_key("features")
+            || table.contains_key("optional")
+            || table.contains_key("registry")
+    } else {
+        false
+    }
+}
+
+pub fn path_from_string_dep(value: &TomlValue) -> Option<&str> {
+    let raw = value.as_str()?.trim();
+    if let Some(path) = raw.strip_prefix("path:") {
+        return Some(path);
+    }
+    if is_path_like_string(raw) {
+        return Some(raw);
+    }
+    None
+}
+
+fn is_path_like_string(raw: &str) -> bool {
+    raw.starts_with("path:")
+        || raw.starts_with("./")
+        || raw.starts_with("../")
+        || raw.starts_with('/')
+        || raw.starts_with("~/")
+        || raw.contains('\\')
+}
+
+fn is_git_like_string(raw: &str) -> bool {
+    raw.starts_with("git:")
+        || raw.starts_with("github:")
+        || raw.starts_with("gitlab:")
+        || raw.starts_with("http://")
+        || raw.starts_with("https://")
+        || raw.starts_with("git@")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use toml::map::Map;
+
+    #[test]
+    fn registry_dep_detection_excludes_local_and_git_strings() {
+        assert!(is_registry_dep(&TomlValue::String("1.2.3".to_string())));
+        assert!(!is_registry_dep(&TomlValue::String(
+            "path:./libs/mylib".to_string()
+        )));
+        assert!(!is_registry_dep(&TomlValue::String(
+            "./libs/mylib".to_string()
+        )));
+        assert!(!is_registry_dep(&TomlValue::String(
+            "git:https://example.com/repo.git".to_string()
+        )));
+    }
+
+    #[test]
+    fn registry_dep_detection_excludes_source_tables() {
+        let mut path_table = Map::new();
+        path_table.insert(
+            "path".to_string(),
+            TomlValue::String("./libs/mylib".to_string()),
+        );
+        assert!(!is_registry_dep(&TomlValue::Table(path_table)));
+
+        let mut registry_table = Map::new();
+        registry_table.insert("features".to_string(), TomlValue::Array(Vec::new()));
+        assert!(is_registry_dep(&TomlValue::Table(registry_table)));
+    }
+
+    #[test]
+    fn registry_package_root_accepts_package_dir_or_manifest_path() {
+        let pkg = serde_json::json!({ "path": "/tmp/pkg" });
+        assert_eq!(
+            package_root_from_registry_info(&pkg).unwrap(),
+            PathBuf::from("/tmp/pkg")
+        );
+
+        let pkg = serde_json::json!({ "path": "/tmp/pkg/dcr.toml" });
+        assert_eq!(
+            package_root_from_registry_info(&pkg).unwrap(),
+            PathBuf::from("/tmp/pkg")
+        );
+    }
+}

src/core/mod.rs

@@ -0,0 +1,6 @@
+pub mod builder;
+pub mod config;
+pub mod deps;
+pub mod registry;
+pub mod runner;
+pub mod workspace;

src/core/registry.rs

@@ -0,0 +1,52 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Registry {
+    pub url: String,
+    pub priority: i32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Config {
+    pub registry: HashMap<String, Registry>,
+}
+
+pub struct RegistryManager {
+    pub config: Config,
+    #[allow(dead_code)]
+    pub path: PathBuf,
+}
+
+fn home_dir() -> Option<PathBuf> {
+    if let Ok(home) = std::env::var("HOME") {
+        return Some(PathBuf::from(home));
+    }
+    if let Ok(profile) = std::env::var("USERPROFILE") {
+        return Some(PathBuf::from(profile));
+    }
+    None
+}
+
+impl RegistryManager {
+    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
+        let dcr_dir = home_dir()
+            .ok_or("Cannot determine home directory")?
+            .join(".dcr");
+        let config_path = dcr_dir.join("config.toml");
+
+        if !config_path.exists() {
+            return Err("Config file ~/.dcr/config.toml not found".into());
+        }
+
+        let content = fs::read_to_string(&config_path)?;
+        let config: Config = toml::from_str(&content)?;
+
+        Ok(Self {
+            config,
+            path: dcr_dir,
+        })
+    }
+}

src/core/runner.rs

@@ -0,0 +1,21 @@
+use crate::platform;
+use std::path::Path;
+use std::process::Command;
+
+pub fn run_binary(project_name: &str, profile: &str, target_dir: Option<&str>) -> i32 {
+    let bin_path = platform::bin_path(profile, project_name, target_dir);
+    if Path::new(&bin_path).exists() {
+        let output = Command::new(&bin_path).output();
+        match output {
+            Ok(o) => {
+                print!("{}", String::from_utf8_lossy(&o.stdout));
+                eprint!("{}", String::from_utf8_lossy(&o.stderr));
+                return o.status.code().unwrap_or(0);
+            }
+            Err(_) => {
+                return 1;
+            }
+        }
+    }
+    1
+}

src/core/workspace.rs

@@ -0,0 +1,150 @@
+use crate::core::config::Config;
+use crate::utils::build::normalize_target_os;
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use toml::Value;
+
+#[derive(Debug, Clone)]
+pub struct WorkspaceMember {
+    pub name: String,
+    pub path: PathBuf,
+    pub deps: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    pub members: Vec<WorkspaceMember>,
+}
+
+pub fn parse_workspace(
+    config: &Config,
+    profile: &str,
+    target: Option<&str>,
+    root: &Path,
+) -> Result<Option<Workspace>, String> {
+    let mut table = None;
+    // Order: workspace.target.profile, workspace.profile.target, workspace.target, workspace.profile, workspace
+    let combinations = if let Some(t) = target {
+        let normalized_t = normalize_target_os(t);
+        vec![
+            format!("workspace.{}.{}", normalized_t, profile),
+            format!("workspace.{}.{}", profile, normalized_t),
+            format!("workspace.{}", normalized_t),
+            format!("workspace.{}", profile),
+            "workspace".to_string(),
+        ]
+    } else {
+        vec![format!("workspace.{}", profile), "workspace".to_string()]
+    };
+    for key in combinations {
+        if let Some(val) = config.get(&key).and_then(|v| v.as_table()) {
+            table = Some(val);
+            break;
+        }
+    }
+    let table = match table {
+        Some(t) => t,
+        None => return Ok(None),
+    };
+
+    let mut members = Vec::new();
+    for (name, value) in table {
+        let tbl = value
+            .as_table()
+            .ok_or_else(|| format!("workspace.{name} must be a table with path and deps"))?;
+        let path_raw = tbl
+            .get("path")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| format!("workspace.{name}.path is required"))?;
+        let path = resolve_path(root, path_raw)?;
+        if !path.join("dcr.toml").is_file() {
+            return Err(format!(
+                "workspace.{name}.path does not contain dcr.toml: {}",
+                path.display()
+            ));
+        }
+        let deps = parse_deps(tbl.get("deps"))?;
+        members.push(WorkspaceMember {
+            name: name.to_string(),
+            path,
+            deps,
+        });
+    }
+
+    let mut ws = Workspace { members };
+    ws.members = topo_sort(&ws.members)?;
+    Ok(Some(ws))
+}
+
+fn resolve_path(root: &Path, raw: &str) -> Result<PathBuf, String> {
+    let p = Path::new(raw);
+    let full = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        root.join(p)
+    };
+    Ok(full)
+}
+
+fn parse_deps(value: Option<&Value>) -> Result<Vec<String>, String> {
+    let Some(value) = value else {
+        return Ok(Vec::new());
+    };
+    let arr = value
+        .as_array()
+        .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+    let mut out = Vec::new();
+    for item in arr {
+        let s = item
+            .as_str()
+            .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+        out.push(s.to_string());
+    }
+    Ok(out)
+}
+
+fn topo_sort(members: &[WorkspaceMember]) -> Result<Vec<WorkspaceMember>, String> {
+    let mut map = HashMap::new();
+    for m in members {
+        map.insert(m.name.clone(), m.clone());
+    }
+    let mut state: HashMap<String, u8> = HashMap::new();
+    let mut order: Vec<WorkspaceMember> = Vec::new();
+
+    for name in map.keys() {
+        if *state.get(name).unwrap_or(&0) == 0 {
+            visit(name, &map, &mut state, &mut order)?;
+        }
+    }
+    Ok(order)
+}
+
+fn visit(
+    name: &str,
+    map: &HashMap<String, WorkspaceMember>,
+    state: &mut HashMap<String, u8>,
+    order: &mut Vec<WorkspaceMember>,
+) -> Result<(), String> {
+    match state.get(name).copied().unwrap_or(0) {
+        1 => return Err(format!("workspace dependency cycle at {name}")),
+        2 => return Ok(()),
+        _ => {}
+    }
+    state.insert(name.to_string(), 1);
+    let member = map
+        .get(name)
+        .ok_or_else(|| format!("unknown workspace member {name}"))?;
+    let mut seen = HashSet::new();
+    for dep in &member.deps {
+        if !seen.insert(dep) {
+            continue;
+        }
+        if !map.contains_key(dep) {
+            return Err(format!("workspace dependency '{dep}' not found"));
+        }
+        visit(dep, map, state, order)?;
+    }
+    state.insert(name.to_string(), 2);
+    order.push(member.clone());
+    Ok(())
+}

src/main.rs

@@ -1,5 +1,8 @@
+use crate::utils::log::error;
 mod cli;
 mod config;
+mod core;
+mod platform;
 mod utils;
 
 fn main() {
@@ -15,9 +18,14 @@ fn main() {
     let code = match cmd {
         "new" => cli::r#new::new(rest),
         "init" => cli::init::init(rest),
+        "setup" => cli::setup::setup(rest),
+        "add" => cli::add::add(rest),
         "build" => cli::build::build(rest),
         "run" => cli::run::run(rest),
+        "tree" => cli::tree::tree(rest),
+        "test" | "tests" => cli::test::test(rest),
         "clean" => cli::clean::clean(rest),
+        "gen" => cli::r#gen::r#gen(rest),
         "--version" => {
             println!("dcr {} ({})", env!("CARGO_PKG_VERSION"), env!("DCR_TARGET"));
             0
@@ -25,7 +33,7 @@ fn main() {
         "--help" => cli::help::help(),
         "--update" => cli::flag_update::flag_update(rest),
         _ => {
-            println!("Неизвестная команда или аргумент");
+            error("Unknown command or argument");
             0
         }
     };

src/platform/linux.rs

@@ -0,0 +1,110 @@
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/{name}")
+        }
+    }
+}
+
+pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/lib{name}.a")
+        }
+    }
+}
+
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/{name}")
+        }
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/{name}.efi")
+        }
+    }
+}
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/lib{name}.so")
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bin_path_default() {
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/hello");
+        assert_eq!(bin_path("debug", "hello", None), expected);
+    }
+
+    #[test]
+    fn bin_path_release() {
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/release/hello");
+        assert_eq!(bin_path("release", "hello", None), expected);
+    }
+
+    #[test]
+    fn bin_path_custom_target() {
+        assert_eq!(bin_path("debug", "hello", Some("out")), "out/hello");
+    }
+
+    #[test]
+    fn bin_path_custom_target_trailing_slash() {
+        assert_eq!(bin_path("debug", "hello", Some("out/")), "out/hello");
+    }
+
+    #[test]
+    fn lib_path_default() {
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.a");
+        assert_eq!(lib_path("debug", "mylib", None), expected);
+    }
+
+    #[test]
+    fn lib_path_custom_target() {
+        assert_eq!(lib_path("debug", "mylib", Some("out")), "out/libmylib.a");
+    }
+
+    #[test]
+    fn shared_lib_path_default() {
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.so");
+        assert_eq!(shared_lib_path("debug", "mylib", None), expected);
+    }
+
+    #[test]
+    fn shared_lib_path_custom_target() {
+        assert_eq!(
+            shared_lib_path("release", "mylib", Some("dist")),
+            "dist/libmylib.so"
+        );
+    }
+}

src/platform/macos.rs

@@ -0,0 +1,34 @@
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}"),
+    }
+}
+
+pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/lib{name}.a"),
+    }
+}
+
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}"),
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.efi"),
+    }
+}
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.dylib", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/lib{name}.dylib"),
+    }
+}

src/platform/mod.rs

@@ -0,0 +1,116 @@
+#[cfg(target_os = "linux")]
+pub mod linux;
+#[cfg(target_os = "macos")]
+pub mod macos;
+#[cfg(target_os = "windows")]
+pub mod windows;
+
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::bin_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::bin_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::bin_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}"),
+        }
+    }
+}
+
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::elf_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::elf_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::elf_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}"),
+        }
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::efi_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::efi_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::efi_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}.efi"),
+        }
+    }
+}
+
+pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::lib_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::lib_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::lib_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/lib{name}.a"),
+        }
+    }
+}
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::shared_lib_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::shared_lib_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::shared_lib_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/lib{name}.so"),
+        }
+    }
+}

src/platform/windows.rs

@@ -0,0 +1,34 @@
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.exe"),
+    }
+}
+
+pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.lib", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.lib"),
+    }
+}
+
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.exe"),
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.efi"),
+    }
+}
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.dll", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.dll"),
+    }
+}

src/utils/build.rs

@@ -0,0 +1,376 @@
+use crate::core::config::Config;
+use crate::utils::log::warn;
+
+pub struct VersionInfo {
+    pub full: String,
+    pub major: String,
+    pub minor: String,
+    pub patch: String,
+    pub suffix: String,
+    pub suffix_dash: String,
+}
+
+pub fn parse_version_info(version: &str) -> VersionInfo {
+    let mut full = version.trim().to_string();
+    if full.is_empty() {
+        full = "0.0.0".to_string();
+    }
+    let full_clone = full.clone();
+    let (base, suffix) = match full_clone.split_once('-') {
+        Some((head, tail)) => (head, tail),
+        None => (full_clone.as_str(), ""),
+    };
+    let mut parts = base.split('.');
+    let major = parts.next().unwrap_or("0").to_string();
+    let minor = parts.next().unwrap_or("0").to_string();
+    let patch = parts.next().unwrap_or("0").to_string();
+    let suffix_dash = if suffix.is_empty() {
+        "".to_string()
+    } else {
+        format!("-{suffix}")
+    };
+    VersionInfo {
+        full,
+        major,
+        minor,
+        patch,
+        suffix: suffix.to_string(),
+        suffix_dash,
+    }
+}
+
+pub fn normalize_target_os(target: &str) -> &str {
+    match target {
+        "linux" => "x86_64-unknown-linux-gnu",
+        "macos" => "x86_64-apple-darwin",
+        "windows" => "x86_64-pc-windows-msvc",
+        _ if target.contains('-') => target,
+        _ => {
+            warn(&format!(
+                "Unknown target '{}', using as-is. Supported short names: linux, macos, windows",
+                target
+            ));
+            target
+        }
+    }
+}
+
+pub fn get_config_str(config: &Config, key: &str) -> String {
+    config
+        .get(key)
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string()
+}
+
+pub fn profile_table<'a>(config: &'a Config, profile: &str) -> Option<&'a toml::value::Table> {
+    config
+        .get("build")
+        .and_then(|v| v.as_table())
+        .and_then(|b| b.get(profile))
+        .and_then(|v| v.as_table())
+}
+
+pub fn get_config_opt(config: &Config, key: &str) -> Option<String> {
+    let value = config.get(key)?.as_str()?;
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+pub fn get_string_with_profile(config: &Config, field: &str, profile: &str) -> String {
+    let base = get_config_str(config, &format!("build.{field}"));
+    let Some(table) = profile_table(config, profile) else {
+        return base;
+    };
+    let value = table.get(field).and_then(|v| v.as_str()).unwrap_or("");
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        base
+    } else {
+        trimmed.to_string()
+    }
+}
+
+pub fn get_config_list(config: &Config, key: &str) -> Vec<String> {
+    config
+        .get(key)
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str())
+                .map(|s| s.to_string())
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+pub fn get_list_with_profile(config: &Config, field: &str, profile: &str) -> Vec<String> {
+    let mut out = get_config_list(config, &format!("build.{field}"));
+    if let Some(table) = profile_table(config, profile)
+        && let Some(extra) = table.get(field).and_then(|v| v.as_array())
+    {
+        out.extend(
+            extra
+                .iter()
+                .filter_map(|v| v.as_str())
+                .map(|s| s.to_string()),
+        );
+    }
+    out
+}
+
+pub fn get_bool_with_profile(config: &Config, field: &str, profile: &str, default: bool) -> bool {
+    let base = config
+        .get(&format!("build.{field}"))
+        .and_then(|v| v.as_bool());
+    let profile_val =
+        profile_table(config, profile).and_then(|t| t.get(field).and_then(|v| v.as_bool()));
+    profile_val.or(base).unwrap_or(default)
+}
+
+pub fn get_language_with_profile(config: &Config, profile: &str) -> Result<String, String> {
+    if let Some(table) = profile_table(config, profile)
+        && let Some(value) = table.get("language")
+    {
+        return parse_language_value(value, "build.language");
+    }
+    match config.get("build.language") {
+        Some(v) => parse_language_value(v, "build.language"),
+        None => Err("build.language is missing".to_string()),
+    }
+}
+
+pub fn get_language_with_profile_or_default(config: &Config, profile: &str) -> String {
+    get_language_with_profile(config, profile).unwrap_or_else(|_| "c".to_string())
+}
+
+pub fn parse_language_value(value: &toml::Value, key: &str) -> Result<String, String> {
+    if let Some(s) = value.as_str() {
+        let trimmed = s.trim();
+        if trimmed.is_empty() {
+            return Err(format!("{key} is empty"));
+        }
+        return Ok(trimmed.to_string());
+    }
+    let arr = value
+        .as_array()
+        .ok_or_else(|| format!("{key} must be string or array of strings"))?;
+    let mut parts = Vec::new();
+    for item in arr {
+        let s = item
+            .as_str()
+            .ok_or_else(|| format!("{key} must be string or array of strings"))?;
+        let trimmed = s.trim();
+        if trimmed.is_empty() {
+            return Err(format!("{key} contains empty value"));
+        }
+        parts.push(trimmed.to_string());
+    }
+    if parts.is_empty() {
+        return Err(format!("{key} is empty"));
+    }
+    Ok(parts.join("+"))
+}
+
+pub fn resolve_compiler(
+    language: &str,
+    compiler: &str,
+    tc_cc: Option<&str>,
+    tc_cxx: Option<&str>,
+    tc_as: Option<&str>,
+) -> String {
+    let lang = primary_language(language);
+    env_override_compiler(&lang)
+        .or_else(|| toolchain_override_compiler(&lang, tc_cc, tc_cxx, tc_as))
+        .unwrap_or_else(|| compiler.to_string())
+}
+
+fn env_override_compiler(lang: &str) -> Option<String> {
+    if let Ok(value) = std::env::var("DCR_COMPILER") {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return Some(trimmed.to_string());
+        }
+    }
+    if lang == "asm" {
+        if let Ok(value) = std::env::var("DCR_AS") {
+            let trimmed = value.trim();
+            if !trimmed.is_empty() {
+                return Some(trimmed.to_string());
+            }
+        }
+        return None;
+    }
+    if (lang == "c++" || lang == "cpp" || lang == "cxx")
+        && let Ok(value) = std::env::var("DCR_CXX")
+    {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return Some(trimmed.to_string());
+        }
+    }
+    if let Ok(value) = std::env::var("DCR_CC") {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return Some(trimmed.to_string());
+        }
+    }
+    None
+}
+
+fn toolchain_override_compiler(
+    lang: &str,
+    tc_cc: Option<&str>,
+    tc_cxx: Option<&str>,
+    tc_as: Option<&str>,
+) -> Option<String> {
+    if lang == "asm" {
+        return tc_as.map(|v| v.to_string());
+    }
+    if (lang == "c++" || lang == "cpp" || lang == "cxx")
+        && let Some(v) = tc_cxx
+    {
+        return Some(v.to_string());
+    }
+    tc_cc.map(|v| v.to_string())
+}
+
+pub fn primary_language(language: &str) -> String {
+    let parts: Vec<String> = language
+        .split('+')
+        .map(|p| p.trim().to_lowercase())
+        .filter(|p| !p.is_empty())
+        .collect();
+    for p in &parts {
+        if p == "c++" || p == "cpp" || p == "cxx" {
+            return p.clone();
+        }
+    }
+    if parts.iter().any(|p| p == "c") {
+        return "c".to_string();
+    }
+    if parts.iter().any(|p| p == "asm") {
+        return "asm".to_string();
+    }
+    language.to_lowercase()
+}
+
+pub fn resolve_tool(env_key: &str, fallback: Option<&str>) -> Option<String> {
+    if let Ok(value) = std::env::var(env_key) {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return Some(trimmed.to_string());
+        }
+    }
+    fallback.map(|v| v.to_string())
+}
+
+pub fn resolve_pkg_config_flags(
+    pkgs: &[String],
+    base_cflags: &[String],
+    base_ldflags: &[String],
+) -> Result<(Vec<String>, Vec<String>), String> {
+    let mut cflags = base_cflags.to_vec();
+    let mut ldflags = base_ldflags.to_vec();
+    for pkg in pkgs {
+        let c_out = run_pkg_config(pkg, "--cflags")?;
+        let l_out = run_pkg_config(pkg, "--libs")?;
+        cflags.extend(split_flags(&c_out));
+        ldflags.extend(split_flags(&l_out));
+    }
+    Ok((cflags, ldflags))
+}
+
+pub fn resolve_pkg_config_flags_lossy(
+    pkgs: &[String],
+    base_cflags: &[String],
+    base_ldflags: &[String],
+) -> (Vec<String>, Vec<String>) {
+    match resolve_pkg_config_flags(pkgs, base_cflags, base_ldflags) {
+        Ok(flags) => flags,
+        Err(err) => {
+            eprintln!("Warning: {err}");
+            (base_cflags.to_vec(), base_ldflags.to_vec())
+        }
+    }
+}
+
+fn run_pkg_config(pkg: &str, arg: &str) -> Result<String, String> {
+    let output = std::process::Command::new("pkg-config")
+        .arg(arg)
+        .arg(pkg)
+        .output()
+        .map_err(|err| format!("Failed to run pkg-config: {err}"))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("pkg-config failed for {pkg}: {stderr}"));
+    }
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}
+
+fn split_flags(value: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut current = String::new();
+    let mut chars = value.chars().peekable();
+    let mut quote: Option<char> = None;
+    while let Some(ch) = chars.next() {
+        if let Some(q) = quote {
+            if ch == q {
+                quote = None;
+            } else {
+                current.push(ch);
+            }
+            continue;
+        }
+        match ch {
+            '\'' | '"' => quote = Some(ch),
+            '\\' => {
+                if let Some(next) = chars.next() {
+                    current.push(next);
+                }
+            }
+            c if c.is_whitespace() => {
+                if !current.is_empty() {
+                    out.push(std::mem::take(&mut current));
+                }
+            }
+            c => current.push(c),
+        }
+    }
+    if !current.is_empty() {
+        out.push(current);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalize_target_short_names() {
+        assert_eq!(normalize_target_os("linux"), "x86_64-unknown-linux-gnu");
+        assert_eq!(normalize_target_os("macos"), "x86_64-apple-darwin");
+        assert_eq!(normalize_target_os("windows"), "x86_64-pc-windows-msvc");
+        assert_eq!(
+            normalize_target_os("x86_64-unknown-linux-gnu"),
+            "x86_64-unknown-linux-gnu"
+        );
+        assert_eq!(normalize_target_os("unknown"), "unknown");
+    }
+
+    #[test]
+    fn parse_version_parts() {
+        let info = parse_version_info("1.2.3-beta");
+        assert_eq!(info.full, "1.2.3-beta");
+        assert_eq!(info.major, "1");
+        assert_eq!(info.minor, "2");
+        assert_eq!(info.patch, "3");
+        assert_eq!(info.suffix, "beta");
+        assert_eq!(info.suffix_dash, "-beta");
+    }
+}

src/utils/fs.rs

@@ -1,6 +1,7 @@
 use std::io;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
+#[allow(dead_code)]
 pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
     let path: PathBuf = match dir {
         None | Some(".") | Some("./") => std::env::current_dir()?,
@@ -15,3 +16,27 @@ pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
 
     Ok(items)
 }
+
+pub fn find_project_root(start: &Path) -> io::Result<Option<PathBuf>> {
+    let mut current = start.to_path_buf();
+    loop {
+        if current.join("dcr.toml").is_file() {
+            return Ok(Some(current));
+        }
+        if !current.pop() {
+            break;
+        }
+    }
+    Ok(None)
+}
+
+pub fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+where
+    F: FnOnce() -> Result<T, String>,
+{
+    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+    let result = f();
+    let _ = std::env::set_current_dir(prev);
+    result
+}

src/utils/log.rs

@@ -1,30 +1,24 @@
-use crate::utils::text::{BOLD, BRIGHT_GREEN, BRIGHT_RED, BRIGHT_YELLOW, colored};
+use crate::utils::text::{BOLD_CYAN, colored};
 
 #[allow(dead_code)]
 pub fn error(msg: &str) {
-    println!(
+    println!("{}: {msg}", colored("error", BOLD_CYAN),);
-        "{}: {msg}",
-        colored("error", &(BRIGHT_RED.to_owned() + BOLD))
-    );
 }
 
 #[allow(dead_code)]
 pub fn warn(msg: &str) {
-    println!(
+    println!("{}: {msg}", colored("warn", BOLD_CYAN),);
-        "{}: {msg}",
-        colored("warn", &(BRIGHT_YELLOW.to_owned() + BOLD))
-    );
 }
 
-#[allow(dead_code)]
+// #[allow(dead_code)]
-pub fn info(msg: &str) {
+// pub fn info(msg: &str) {
-    println!("{}: {msg}", colored("info", BOLD));
+//     println!("{}: {msg}", colored("info", BOLD));
-}
+// }
-
+//
-#[allow(dead_code)]
+// #[allow(dead_code)]
-pub fn ok(msg: &str) {
+// pub fn ok(msg: &str) {
-    println!(
+//     println!(
-        "{}: {msg}",
+//         "{}: {msg}",
-        colored("ok", &(BRIGHT_GREEN.to_owned() + BOLD))
+//         colored("ok", &(BRIGHT_GREEN.to_owned() + BOLD))
-    );
+//     );
-}
+// }

src/utils/mod.rs

@@ -1,3 +1,4 @@
+pub mod build;
 pub mod fs;
 pub mod log;
 pub mod text;

src/utils/text.rs

@@ -1,16 +1,32 @@
+#[allow(dead_code)]
 pub const RESET: &str = "\x1b[0m";
 
+#[allow(dead_code)]
 pub const BOLD: &str = "\x1b[1m";
 
+#[allow(dead_code)]
 pub const BRIGHT_RED: &str = "\x1b[91m";
+#[allow(dead_code)]
 pub const BRIGHT_GREEN: &str = "\x1b[92m";
+#[allow(dead_code)]
 pub const BRIGHT_YELLOW: &str = "\x1b[93m";
+#[allow(dead_code)]
 pub const BRIGHT_CYAN: &str = "\x1b[96m";
+#[allow(dead_code)]
+pub const BOLD_RED: &str = "\x1b[1m\x1b[91m";
+#[allow(dead_code)]
+pub const BOLD_GREEN: &str = "\x1b[1m\x1b[92m";
+#[allow(dead_code)]
+pub const BOLD_YELLOW: &str = "\x1b[1m\x1b[93m";
+#[allow(dead_code)]
+pub const BOLD_CYAN: &str = "\x1b[1m\x1b[96m";
 
+#[allow(dead_code)]
 pub fn colored(msg: &str, style: &str) -> String {
     format!("{style}{msg}{RESET}")
 }
 
+#[allow(dead_code)]
 pub fn printc(msg: &str, style: &str) {
     println!("{style}{msg}{RESET}");
 }

tests/cli_basic.rs

@@ -0,0 +1,424 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::Once;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static COUNTER: AtomicUsize = AtomicUsize::new(0);
+static BUILD_ONCE: Once = Once::new();
+
+fn bin_path() -> PathBuf {
+    if let Ok(exe) = std::env::var("CARGO_BIN_EXE_dcr") {
+        return PathBuf::from(exe);
+    }
+    ensure_bin_built();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("target");
+    path.push("debug");
+    path.push(format!("dcr{}", std::env::consts::EXE_SUFFIX));
+    path
+}
+
+fn unique_sandbox_dir(prefix: &str) -> PathBuf {
+    let pid = std::process::id();
+    let n = COUNTER.fetch_add(1, Ordering::SeqCst);
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("sandbox");
+    path.push("cli-tests");
+    path.push(format!("dcr_{prefix}_{pid}_{n}_{now}"));
+    std::fs::create_dir_all(&path).expect("failed to create temp dir");
+    path
+}
+
+fn run_dcr(args: &[&str], cwd: &Path) -> std::process::Output {
+    run_dcr_env(args, cwd, &[])
+}
+
+fn run_dcr_env(args: &[&str], cwd: &Path, envs: &[(&str, &str)]) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    for (k, v) in envs {
+        cmd.env(k, v);
+    }
+    cmd.output().expect("failed to run dcr")
+}
+
+fn ensure_bin_built() {
+    BUILD_ONCE.call_once(|| {
+        let status = Command::new("cargo")
+            .arg("build")
+            .current_dir(env!("CARGO_MANIFEST_DIR"))
+            .status()
+            .expect("failed to run cargo build");
+        assert!(status.success(), "cargo build failed");
+    });
+}
+
+fn available_compiler() -> Option<&'static str> {
+    for candidate in ["gcc", "clang", "cc"] {
+        let ok = Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false);
+        if ok {
+            return Some(candidate);
+        }
+    }
+    None
+}
+
+#[test]
+fn help_and_version_work() {
+    let dir = unique_sandbox_dir("help");
+    let out = run_dcr(&["--help"], &dir);
+    assert!(out.status.success(), "--help should succeed");
+
+    let out = run_dcr(&["--version"], &dir);
+    assert!(out.status.success(), "--version should succeed");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("dcr"), "version output should mention dcr");
+}
+
+#[test]
+fn new_creates_project_layout() {
+    let dir = unique_sandbox_dir("new");
+    let out = run_dcr(&["new", "hello"], &dir);
+    assert!(out.status.success(), "dcr new should succeed");
+
+    let project_dir = dir.join("hello");
+    assert!(project_dir.is_dir(), "project dir should exist");
+    assert!(project_dir.join("dcr.toml").is_file(), "dcr.toml missing");
+    assert!(
+        project_dir.join("src").join("main.c").is_file(),
+        "src/main.c missing"
+    );
+}
+
+#[test]
+fn init_and_clean_remove_target() {
+    let dir = unique_sandbox_dir("init");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let target_debug = dir.join("target").join("debug");
+    std::fs::create_dir_all(&target_debug).expect("failed to create target/debug");
+    std::fs::write(target_debug.join("dummy.o"), "x").expect("failed to write dummy file");
+
+    let out = run_dcr(&["clean"], &dir);
+    assert!(out.status.success(), "dcr clean should succeed");
+    assert!(!dir.join("target").exists(), "target should be removed");
+}
+
+#[test]
+fn build_run_clean_flags_normal_project() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping build/run test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("normal");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    assert!(out.status.success(), "dcr build should succeed");
+
+    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
+    assert!(out.status.success(), "dcr build --release should succeed");
+
+    let out = run_dcr_env(&["run"], &dir, &envs);
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("Running"), "dcr run should start");
+
+    let out = run_dcr_env(&["clean", "--release"], &dir, &envs);
+    assert!(out.status.success(), "dcr clean --release should succeed");
+    let target_dir = "target/x86_64-unknown-linux-gnu".to_string();
+    assert!(
+        !dir.join(&target_dir).join("release").exists(),
+        "target/x86_64-unknown-linux-gnu/release should be removed"
+    );
+    assert!(
+        dir.join(&target_dir).join("debug").is_dir(),
+        "target/x86_64-unknown-linux-gnu/debug should remain"
+    );
+
+    let out = run_dcr_env(&["clean"], &dir, &envs);
+    assert!(out.status.success(), "dcr clean should succeed");
+    assert!(!dir.join("target").exists(), "target should be removed");
+}
+
+#[test]
+fn workspace_build_and_clean_all() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping workspace test");
+        return;
+    };
+
+    let root = unique_sandbox_dir("workspace");
+    let out = run_dcr(&["init"], &root);
+    assert!(out.status.success(), "root init should succeed");
+
+    let members = [
+        ("userspace", &[][..]),
+        ("core", &["userspace"][..]),
+        ("kernel", &["core"][..]),
+    ];
+    for (name, _) in &members {
+        let member_dir = root.join("src").join(name);
+        std::fs::create_dir_all(&member_dir).expect("failed to create member dir");
+        let out = run_dcr(&["init"], &member_dir);
+        assert!(out.status.success(), "member init should succeed");
+    }
+
+    let workspace_toml = "[package]\nname = \"ws-root\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"bin\"\n\n[workspace]\nuserspace = { path = \"src/userspace\", deps = [] }\ncore = { path = \"src/core\", deps = [\"userspace\"] }\nkernel = { path = \"src/kernel\", deps = [\"core\"] }\n\n[dependencies]\n";
+    std::fs::write(root.join("dcr.toml"), workspace_toml).expect("failed to write root dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &root, &envs);
+    assert!(out.status.success(), "workspace build should succeed");
+
+    let out = run_dcr_env(&["build"], &root, &envs);
+    assert!(out.status.success(), "workspace build should succeed");
+
+    let out = run_dcr_env(&["build", "--release"], &root, &envs);
+    assert!(
+        out.status.success(),
+        "workspace build --release should succeed"
+    );
+
+    let out = run_dcr_env(&["clean", "--release", "--all"], &root, &envs);
+    assert!(
+        out.status.success(),
+        "workspace clean --all --release should succeed"
+    );
+
+    for (name, _) in &members {
+        let member = root.join("src").join(name);
+        let target_dir = "target/x86_64-unknown-linux-gnu";
+        assert!(
+            !member.join(target_dir).join("release").exists(),
+            "member target/x86_64-unknown-linux-gnu/release should be removed"
+        );
+        assert!(
+            member.join(target_dir).join("debug").exists(),
+            "member target/x86_64-unknown-linux-gnu/debug should remain"
+        );
+    }
+    let target_dir = "target/x86_64-unknown-linux-gnu";
+    assert!(
+        !root.join(target_dir).join("release").exists(),
+        "root target/x86_64-unknown-linux-gnu/release should be removed"
+    );
+    assert!(
+        root.join(target_dir).join("debug").exists(),
+        "root target/x86_64-unknown-linux-gnu/debug should remain"
+    );
+}
+
+#[test]
+fn dcr_add_dependencies() {
+    let dir = unique_sandbox_dir("add_dep");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    // Test path: prefix
+    let out = run_dcr(&["add", "mylib", "path:./libs/mylib"], &dir);
+    assert!(out.status.success(), "dcr add path should succeed");
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    assert!(
+        toml.contains("mylib = { path = \"./libs/mylib\" }"),
+        "path dep not found in toml"
+    );
+
+    // Test github: prefix
+    let out = run_dcr(&["add", "gh_lib", "github:user/repo"], &dir);
+    assert!(out.status.success(), "dcr add github should succeed");
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    assert!(
+        toml.contains("gh_lib = { git = \"https://github.com/user/repo\" }"),
+        "github dep not found in toml"
+    );
+
+    // Test git: prefix (generic)
+    let out = run_dcr(&["add", "custom_git", "git:host.com/user/repo"], &dir);
+    assert!(out.status.success(), "dcr add custom git should succeed");
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    assert!(
+        toml.contains("custom_git = { git = \"https://host.com/user/repo\" }"),
+        "custom git dep not found in toml"
+    );
+
+    // Test git: prefix (github default)
+    let out = run_dcr(&["add", "git_short", "git:user/repo"], &dir);
+    assert!(out.status.success(), "dcr add git short should succeed");
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    assert!(
+        toml.contains("git_short = { git = \"https://github.com/user/repo\" }"),
+        "git short dep not found in toml"
+    );
+
+    // Test flags (branch)
+    let out = run_dcr(
+        &["add", "branch_lib", "github:user/repo", "--branch", "dev"],
+        &dir,
+    );
+    assert!(out.status.success(), "dcr add with branch should succeed");
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    assert!(
+        toml.contains("branch_lib = { git = \"https://github.com/user/repo\", branch = \"dev\" }"),
+        "branch lib not found in toml"
+    );
+
+    // Test failure on no prefix
+    let out = run_dcr(&["add", "fail_lib", "user/repo"], &dir);
+    assert!(!out.status.success(), "dcr add without prefix should fail");
+}
+
+#[test]
+fn dcr_builds_lib_package() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping lib package test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("lib_package");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap();
+    let updated_toml = toml
+        .replace("kind = \"bin\"", "kind = \"staticlib\"")
+        .replace("type = \"none\"", "type = \"lib\"");
+    std::fs::write(dir.join("dcr.toml"), updated_toml).expect("failed to write toml");
+
+    std::fs::write(dir.join("src").join("my_lib.h"), "void hello();")
+        .expect("failed to write header");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    if !out.status.success() {
+        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
+        eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr));
+    }
+    assert!(out.status.success(), "dcr build should succeed");
+
+    let target_dir = dir.join("target");
+    assert!(
+        target_dir.join("include").join("my_lib.h").is_file(),
+        "include/my_lib.h missing"
+    );
+    assert!(target_dir.join("lib").exists(), "lib directory missing");
+}
+
+#[test]
+fn registry_dependency_is_built_from_cache() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping registry dependency build test");
+        return;
+    };
+
+    let root = unique_sandbox_dir("registry_dep");
+    let home = root.join("home");
+    let dcr_home = home.join(".dcr");
+    let dep = root.join("cache").join("mylib");
+    let app = root.join("app");
+    std::fs::create_dir_all(dcr_home.as_path()).expect("failed to create dcr home");
+    std::fs::create_dir_all(dep.join("src")).expect("failed to create dep src");
+    std::fs::create_dir_all(app.join("src")).expect("failed to create app src");
+
+    std::fs::write(
+        dcr_home.join("config.toml"),
+        "[registry.local]\nurl = \"file://local\"\npriority = 1\n",
+    )
+    .expect("failed to write registry config");
+    std::fs::write(
+        dcr_home.join("index.json"),
+        format!(
+            "{{\"packages\":[{{\"name\":\"mylib\",\"latest_version\":\"0.1.0\",\"path\":\"{}\"}}]}}",
+            dep.display()
+        ),
+    )
+    .expect("failed to write registry index");
+
+    std::fs::write(
+        dep.join("dcr.toml"),
+        "[package]\nname = \"mylib\"\nversion = \"0.1.0\"\ntype = \"lib\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"staticlib\"\n\n[dependencies]\n",
+    )
+    .expect("failed to write dep dcr.toml");
+    std::fs::write(dep.join("src").join("mylib.h"), "int answer(void);\n")
+        .expect("failed to write header");
+    std::fs::write(
+        dep.join("src").join("mylib.c"),
+        "int answer(void) { return 42; }\n",
+    )
+    .expect("failed to write dep source");
+
+    std::fs::write(
+        app.join("dcr.toml"),
+        "[package]\nname = \"app\"\nversion = \"0.1.0\"\ntype = \"none\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"bin\"\n\n[dependencies]\nmylib = \"0.1.0\"\n",
+    )
+    .expect("failed to write app dcr.toml");
+    std::fs::write(
+        app.join("src").join("main.c"),
+        "#include \"mylib.h\"\nint main(void) { return answer() == 42 ? 0 : 1; }\n",
+    )
+    .expect("failed to write app source");
+
+    let index_path = dcr_home.join("index.json");
+    let envs = [
+        ("DCR_COMPILER", compiler),
+        ("HOME", home.to_str().unwrap()),
+        ("DCR_INDEX_PATH", index_path.to_str().unwrap()),
+    ];
+    let out = run_dcr_env(&["build"], &app, &envs);
+    if !out.status.success() {
+        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
+        eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr));
+    }
+    assert!(
+        out.status.success(),
+        "registry dependency build should succeed"
+    );
+    assert!(
+        dep.join("target").join("include").join("mylib.h").is_file(),
+        "registry dependency headers were not packaged"
+    );
+    assert!(
+        dep.join("target").join("lib").exists(),
+        "registry dependency library directory missing"
+    );
+}
+
+#[test]
+fn dcr_test_runs_without_sandbox_dependency() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping dcr test integration");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("dcr_test_independent");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let envs = [("DCR_CC", compiler)];
+    let out_init = run_dcr_env(&["test", "--init"], &dir, &envs);
+    assert!(out_init.status.success(), "dcr test --init should succeed");
+
+    let out = run_dcr_env(&["test"], &dir, &envs);
+    assert!(out.status.success(), "dcr test should succeed");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stdout.contains("TOTAL: 1"), "TOTAL summary line missing");
+    assert!(
+        stdout.contains("PASS:  1"),
+        "PASS summary line missing\nstdout:\n{}\nstderr:\n{}",
+        stdout,
+        stderr
+    );
+}

tests/cli_errors.rs

@@ -0,0 +1,303 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::Once;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static COUNTER: AtomicUsize = AtomicUsize::new(0);
+static BUILD_ONCE: Once = Once::new();
+
+fn bin_path() -> PathBuf {
+    if let Ok(exe) = std::env::var("CARGO_BIN_EXE_dcr") {
+        return PathBuf::from(exe);
+    }
+    ensure_bin_built();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("target");
+    path.push("debug");
+    path.push(format!("dcr{}", std::env::consts::EXE_SUFFIX));
+    path
+}
+
+fn unique_sandbox_dir(prefix: &str) -> PathBuf {
+    let pid = std::process::id();
+    let n = COUNTER.fetch_add(1, Ordering::SeqCst);
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("sandbox");
+    path.push("cli-tests");
+    path.push(format!("dcr_{prefix}_{pid}_{n}_{now}"));
+    std::fs::create_dir_all(&path).expect("failed to create temp dir");
+    path
+}
+
+fn run_dcr(args: &[&str], cwd: &Path) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    cmd.output().expect("failed to run dcr")
+}
+
+fn run_dcr_env(args: &[&str], cwd: &Path, envs: &[(&str, &str)]) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    for (k, v) in envs {
+        cmd.env(k, v);
+    }
+    cmd.output().expect("failed to run dcr")
+}
+
+fn ensure_bin_built() {
+    BUILD_ONCE.call_once(|| {
+        let status = Command::new("cargo")
+            .arg("build")
+            .current_dir(env!("CARGO_MANIFEST_DIR"))
+            .status()
+            .expect("failed to run cargo build");
+        assert!(status.success(), "cargo build failed");
+    });
+}
+
+fn available_compiler() -> Option<&'static str> {
+    for candidate in ["clang", "gcc", "cc"] {
+        let ok = Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false);
+        if ok {
+            return Some(candidate);
+        }
+    }
+    None
+}
+
+// --- Tests ---
+
+#[test]
+fn no_args_shows_help() {
+    let dir = unique_sandbox_dir("noargs");
+    let out = run_dcr(&[], &dir);
+    // Should succeed (help returns 0) and produce some output
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("DCR") || stdout.contains("dcr") || stdout.contains("USAGE"),
+        "no args should show help text"
+    );
+}
+
+#[test]
+fn unknown_command_fails() {
+    let dir = unique_sandbox_dir("unknown_cmd");
+    let out = run_dcr(&["foobar"], &dir);
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("error") || stdout.contains("Unknown"),
+        "unknown command should print error"
+    );
+}
+
+#[test]
+fn build_without_toml_fails() {
+    let dir = unique_sandbox_dir("build_no_toml");
+    let out = run_dcr(&["build"], &dir);
+    assert!(!out.status.success(), "build without dcr.toml should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("dcr.toml") || stdout.contains("not found"),
+        "should mention missing dcr.toml"
+    );
+}
+
+#[test]
+fn run_without_toml_fails() {
+    let dir = unique_sandbox_dir("run_no_toml");
+    let out = run_dcr(&["run"], &dir);
+    assert!(!out.status.success(), "run without dcr.toml should fail");
+}
+
+#[test]
+fn clean_without_toml_fails() {
+    let dir = unique_sandbox_dir("clean_no_toml");
+    let out = run_dcr(&["clean"], &dir);
+    assert!(!out.status.success(), "clean without dcr.toml should fail");
+}
+
+#[test]
+fn new_existing_dir_fails() {
+    let dir = unique_sandbox_dir("new_exist");
+    // Create the project directory first
+    std::fs::create_dir_all(dir.join("hello")).expect("failed to create dir");
+    let out = run_dcr(&["new", "hello"], &dir);
+    assert!(!out.status.success(), "dcr new on existing dir should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("already exists") || stdout.contains("error"),
+        "should report dir already exists"
+    );
+}
+
+#[test]
+fn init_nonempty_dir_fails() {
+    let dir = unique_sandbox_dir("init_nonempty");
+    // Put a file in the dir so it's not empty
+    std::fs::write(dir.join("dummy.txt"), "x").expect("failed to write");
+    let out = run_dcr(&["init"], &dir);
+    assert!(
+        !out.status.success(),
+        "dcr init in non-empty dir should fail"
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("not empty") || stdout.contains("error"),
+        "should report dir not empty"
+    );
+}
+
+#[test]
+fn build_unknown_flag_fails() {
+    let dir = unique_sandbox_dir("build_badflag");
+    // Init a valid project first
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+    let out = run_dcr(&["build", "--foobar"], &dir);
+    assert!(!out.status.success(), "build with unknown flag should fail");
+}
+
+#[test]
+fn run_library_project_fails() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping run_library test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("run_lib");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    // Edit dcr.toml to set kind = "staticlib"
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).expect("failed to read dcr.toml");
+    let updated = toml.replace("kind = \"bin\"", "kind = \"staticlib\"");
+    std::fs::write(&toml_path, updated).expect("failed to write dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["run"], &dir, &envs);
+    assert!(!out.status.success(), "dcr run on staticlib should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("library") || stdout.contains("Cannot run"),
+        "should report cannot run library"
+    );
+}
+
+#[test]
+fn clean_specific_profile() {
+    let dir = unique_sandbox_dir("clean_profile");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    // Create target/x86_64-unknown-linux-gnu/debug and release dirs
+    let target_base = "target/x86_64-unknown-linux-gnu";
+    std::fs::create_dir_all(dir.join(target_base).join("debug")).expect("create debug");
+    std::fs::write(dir.join(target_base).join("debug").join("dummy.o"), "x").expect("write");
+    std::fs::create_dir_all(dir.join(target_base).join("release")).expect("create release");
+    std::fs::write(dir.join(target_base).join("release").join("dummy.o"), "x").expect("write");
+
+    // Clean only release
+    let out = run_dcr(&["clean", "--release"], &dir);
+    assert!(out.status.success(), "clean --release should succeed");
+    assert!(
+        !dir.join(target_base).join("release").exists(),
+        "target/x86_64-unknown-linux-gnu/release should be removed"
+    );
+    assert!(
+        dir.join("target/x86_64-unknown-linux-gnu")
+            .join("debug")
+            .is_dir(),
+        "target/x86_64-unknown-linux-gnu/debug should remain"
+    );
+}
+
+#[test]
+fn new_no_name_fails() {
+    let dir = unique_sandbox_dir("new_noname");
+    let out = run_dcr(&["new"], &dir);
+    assert!(!out.status.success(), "dcr new without name should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("not specified") || stdout.contains("error"),
+        "should report name not specified"
+    );
+}
+
+#[test]
+fn staticlib_build() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping staticlib test");
+        return;
+    };
+    let dir = unique_sandbox_dir("staticlib");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).expect("read dcr.toml");
+    let updated = toml.replace("kind = \"bin\"", "kind = \"staticlib\"");
+    std::fs::write(&toml_path, updated).expect("write dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    assert!(out.status.success(), "staticlib build should succeed");
+    // Check that a .a file exists
+    let lib_path = dir
+        .join("target")
+        .join("x86_64-unknown-linux-gnu")
+        .join("debug");
+    let has_lib = std::fs::read_dir(&lib_path)
+        .map(|entries| {
+            entries
+                .filter_map(|e| e.ok())
+                .any(|e| e.file_name().to_string_lossy().ends_with(".a"))
+        })
+        .unwrap_or(false);
+    assert!(has_lib, "staticlib should produce a .a file");
+}
+
+#[test]
+fn build_release_profile() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping release build test");
+        return;
+    };
+    let dir = unique_sandbox_dir("release_build");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
+    assert!(out.status.success(), "release build should succeed");
+    assert!(
+        dir.join("target").join("release").is_dir(),
+        "target/release should exist"
+    );
+}
+
+#[test]
+fn version_contains_version_string() {
+    let dir = unique_sandbox_dir("version");
+    let out = run_dcr(&["--version"], &dir);
+    assert!(out.status.success());
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    // Should contain version like "dcr 0.2.8 (target)"
+    assert!(
+        stdout.contains("dcr "),
+        "version output should start with 'dcr '"
+    );
+    assert!(
+        stdout.contains('.'),
+        "version output should contain a version number"
+    );
+}