Building from Source

🛠️ Building from Source

Requirements

Dependency	Notes
Go ≥ 1.25	Only needed to build from source — prebuilt binaries need nothing.
Market data	An FMP API key (free tier works), optionally an EODHD key as fallback — or neither, using simulation mode.
LLM	A local Ollama instance, or an API key for Gemini / Claude / OpenAI / MiniMax / any OpenAI-compatible endpoint.

None of these are needed just to build the binary — only to run it against real data/models afterwards.

Build from source

git clone https://github.com/fuchicar/auris-ai.git
cd auris-ai
go build -o auris ./cmd/auris
./auris

Or install straight into your $GOPATH/bin:

go install github.com/fuchicar/auris-ai/cmd/auris@latest

CGO_ENABLED=0 throughout — the binary is a single static executable with no runtime C dependencies, which is what makes the cross-compilation below trivial.

Prebuilt binaries and the release pipeline

Tagged releases (vX.Y.Z) publish prebuilt binaries on GitHub Releases, built by GoReleaser from .goreleaser.yaml (schema v2) whenever a tag is pushed (.github/workflows/release.yml).

The current build matrix is:

OS	Architectures
Linux	amd64, arm64
macOS (darwin)	amd64, arm64
FreeBSD	amd64 only

ℹ️ Windows is not currently in the release matrix — it was dropped in favour of adding FreeBSD coverage. If you need a Windows build, go build ./cmd/auris cross-compiles cleanly (GOOS=windows GOARCH=amd64 go build ./cmd/auris); it's just not part of the automated release artifacts.

auris -version reports the exact version/commit/build date it was built from — GoReleaser injects those at link time via its own default ldflags template, so a release binary is always traceable back to a commit. A plain go build/go install (no GoReleaser) instead falls back to Go's automatic VCS stamping, so auris -version still shows a real commit hash (with a -dirty suffix if your tree has uncommitted changes) rather than a bare placeholder.

Nix & NixOS

The repository ships a shell.nix (dev environment: go, gopls, golangci-lint, gotools, git) and a default.nix (reproducible package build) for anyone who wants a fully pinned, reproducible build rather than relying on whatever Go toolchain happens to be on $PATH.

nix-shell        # development shell (or `direnv allow` if you use direnv)
nix-build        # build → ./result/bin/auris
nix-env -if .    # install into your user profile (uninstall: nix-env -e auris)

To add Auris to a NixOS or home-manager configuration, import the derivation directly:

{ config, pkgs, ... }:
let
  auris = pkgs.callPackage (builtins.fetchGit {
    url = "https://github.com/fuchicar/auris-ai.git";
    ref = "main";
  } + "/default.nix") {};
in {
  environment.systemPackages = [ auris ];   # NixOS
  # home.packages = [ auris ];              # home-manager
}

Classic Nix resolves nixpkgs from your system channel; to pin a version for fully reproducible builds, use a pinfile or migrate to a flake.nix (both .nix files are written to be importable from a flake without duplication).

Running the test suite

go build ./...                  # build all packages
go vet ./...                    # static analysis
go test ./... -timeout 120s     # full test suite

This is hermetic by default — no network access, no API keys required. Driver test suites run against httptest servers, and any test that genuinely needs a live credential calls t.Skip automatically when the corresponding key file is absent, so go test ./... never fails (or costs API quota) on a fresh checkout.

Run one test in isolation:

go test ./pkg/drivers/fmp/... -run TestGetQuote_AAPL -v -timeout 30s

Run only the tests that don't need any credentials:

go test ./pkg/drivers/fmp/... -run TestInterfaceCompliance -v

Where integration credentials live

Driver	Credential file
FMP (market)	pkg/drivers/fmp/test_data/fmp_api_key
Ollama (LLM)	requires a local Ollama instance running — no key file

The EODHD exception

pkg/drivers/eodhd is the one driver that deliberately doesn't follow the "live integration test, skip if no key" pattern above. Its default eodhd_test.go is fully hermetic — httptest + eodhd.WithBaseURL, zero network calls, zero key needed — specifically because EODHD's free tier has too tight a daily quota to survive a live test suite running on every single go test ./... invocation across every contributor and every CI run.

The real-network suite still exists, for manual sanity checks against the actual API, but it's gated behind a build tag so it never runs by accident:

go test -tags=integration ./pkg/drivers/eodhd/... -run TestLive

It still t.Skips per-test if pkg/drivers/eodhd/test_data/eodhd_api_key is absent — same discipline as every other driver, just opt-in rather than opt-out.

Continuous integration

.github/workflows/ci.yml runs go build ./... / go vet ./... / go test ./... -timeout 120s on every push and pull request to main — the exact three commands above. If they pass locally, they'll pass in CI.