kairos-planner 1.0.3__tar.gz

kairos_planner-1.0.3/.github/scripts/ros_deb.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Copyright 2026 Intelligent Robotics Lab
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# As the ROS buildfarm's binarydeb job: bloom-generate rosdebian, dpkg-buildpackage with nocheck,
+# then install the package and run the installed kairos
+set -e
+export DEBIAN_FRONTEND=noninteractive
+apt-get update -qq >/dev/null
+apt-get install -y -qq python3-bloom python3-rosdep fakeroot debhelper dpkg-dev g++ cmake >/dev/null 2>&1
+[ -f /etc/ros/rosdep/sources.list.d/20-default.list ] || rosdep init >/dev/null 2>&1 || true
+rosdep update --rosdistro $ROS_DISTRO >/dev/null 2>&1
+g++ --version | head -1; cmake --version | head -1
+cp -r /src /tmp/kairos && cd /tmp/kairos
+bloom-generate rosdebian --ros-distro $ROS_DISTRO > /tmp/bloom.log 2>&1 || { tail -30 /tmp/bloom.log; exit 1; }
+head -3 debian/changelog
+export DEB_BUILD_OPTIONS=nocheck DEB_BUILD_PROFILES=nocheck
+dpkg-buildpackage -b -us -uc -Pnocheck > /tmp/dpkg.log 2>&1 || { grep -E "error|Error" /tmp/dpkg.log | head -30; tail -20 /tmp/dpkg.log; exit 1; }
+grep -cE "_deps/googletest|FetchContent" /tmp/dpkg.log || true
+ls /tmp/*.deb
+apt-get install -y -qq /tmp/*.deb >/dev/null 2>&1 || dpkg -i /tmp/*.deb
+dpkg -L $(dpkg-deb -f /tmp/*.deb Package) | grep -E "bin/kairos$|libkairos|kairosConfig|completion" | head
+ls /opt/ros/$ROS_DISTRO/lib/libkairos.so.1
+env -i /opt/ros/$ROS_DISTRO/bin/kairos --version
+env -i /opt/ros/$ROS_DISTRO/bin/kairos /tmp/kairos/docs/examples/pddls/cooking_domain.pddl /tmp/kairos/docs/examples/pddls/cooking_problem_simple.pddl --timeout 5 --no-anytime | tail -2
+# A program that uses the library, as PlanSys2's plugin does (the ROS environment: lib only)
+cmake -S /tmp/kairos/tests/install -B /tmp/consumer -DCMAKE_PREFIX_PATH=/opt/ros/$ROS_DISTRO > /tmp/consumer.log 2>&1 && cmake --build /tmp/consumer >> /tmp/consumer.log 2>&1 || { tail -20 /tmp/consumer.log; exit 1; }
+env -i LD_LIBRARY_PATH=/opt/ros/$ROS_DISTRO/lib /tmp/consumer/kairos_consumer && echo CONSUMER OK
+echo PACKAGE OK

kairos_planner-1.0.3/.github/scripts/ros_rpm.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Copyright 2026 Intelligent Robotics Lab
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# As the ROS buildfarm's binaryrpm job: bloom-generate rosrpm, rpmbuild without tests, then install
+set -e
+grep -q almalinux /etc/os-release && sed -i 's/^mirrorlist/#mirrorlist/; s/^# *baseurl/baseurl/' /etc/yum.repos.d/*.repo
+dnf install -y -q python3-pip rpm-build cmake gcc-c++ make git tar >/dev/null 2>&1
+grep -q almalinux /etc/os-release && dnf install -y -q 'dnf-command(config-manager)' >/dev/null 2>&1 || true
+pip3 install -q bloom rosdep >/dev/null 2>&1
+rosdep init >/dev/null 2>&1 || true
+rosdep update --rosdistro $ROS_DISTRO >/dev/null 2>&1
+g++ --version | head -1; cmake --version | head -1
+cp -r /src /tmp/kairos && cd /tmp/kairos
+. /etc/os-release
+OSN=$ID; [ "$ID" = almalinux ] && OSN=rhel
+bloom-generate rosrpm --ros-distro $ROS_DISTRO --os-name $OSN --os-version ${VERSION_ID%%.*} > /tmp/bloom.log 2>&1 || { tail -30 /tmp/bloom.log; exit 1; }
+SPEC=rpm/template.spec
+NAME=$(rpmspec -q --qf '%{name}\n' --define "_sourcedir /tmp" $SPEC 2>/dev/null | head -1)
+VER=$(rpmspec -q --qf '%{version}\n' $SPEC 2>/dev/null | head -1)
+echo "$NAME $VER"
+mkdir -p ~/rpmbuild/SOURCES
+SRC=$(grep -E "^Source0:" $SPEC | awk '{print $2}' | sed "s/%{name}/$NAME/g; s/%{version}/$VER/g")
+echo "Source0: $SRC"
+cd /tmp && tar czf ~/rpmbuild/SOURCES/$(basename $SRC) --transform "s,^kairos,$NAME-$VER," kairos
+rpmbuild -bb --without tests /tmp/kairos/$SPEC > /tmp/rpm.log 2>&1 || { grep -E "error|Error|Installed \(but unpackaged\)" -A5 /tmp/rpm.log | head -40; tail -15 /tmp/rpm.log; exit 1; }
+RPM=$(ls ~/rpmbuild/RPMS/*/*.rpm | grep -v debug | head -1); echo $RPM
+dnf install -y -q $RPM >/dev/null 2>&1 || rpm -i --nodeps $RPM
+rpm -ql $(rpm -qp --qf '%{name}' $RPM) | grep -E "bin/kairos$|libkairos|kairosConfig" | head
+ls /opt/ros/$ROS_DISTRO/lib/libkairos.so.1
+env -i /opt/ros/$ROS_DISTRO/bin/kairos --version
+env -i /opt/ros/$ROS_DISTRO/bin/kairos /tmp/kairos/docs/examples/pddls/cooking_domain.pddl /tmp/kairos/docs/examples/pddls/cooking_problem_simple.pddl --timeout 5 --no-anytime | tail -2
+# A program that uses the library, as PlanSys2's plugin does (the ROS environment: lib only)
+cmake -S /tmp/kairos/tests/install -B /tmp/consumer -DCMAKE_PREFIX_PATH=/opt/ros/$ROS_DISTRO > /tmp/consumer.log 2>&1 && cmake --build /tmp/consumer >> /tmp/consumer.log 2>&1 || { tail -20 /tmp/consumer.log; exit 1; }
+env -i LD_LIBRARY_PATH=/opt/ros/$ROS_DISTRO/lib /tmp/consumer/kairos_consumer && echo CONSUMER OK
+echo PACKAGE OK

kairos_planner-1.0.3/.github/workflows/ci.yml

@@ -0,0 +1,234 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build-test:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: gcc-release
+            os: ubuntu-24.04
+            cxx: g++
+            build_type: Release
+            sanitize: ""
+          - name: clang-release
+            os: ubuntu-24.04
+            cxx: clang++
+            build_type: Release
+            sanitize: ""
+          - name: gcc-asan-ubsan
+            os: ubuntu-24.04
+            cxx: g++
+            build_type: Debug
+            sanitize: "address;undefined"
+          - name: clang-tsan
+            os: ubuntu-24.04
+            cxx: clang++
+            build_type: Debug
+            sanitize: "thread"
+          - name: gcc-arm64
+            os: ubuntu-24.04-arm
+            cxx: g++
+            build_type: Release
+            sanitize: ""
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build libgtest-dev uncrustify python3 clang
+
+      - name: Configure
+        run: >
+          cmake -S . -B build -G Ninja
+          -DCMAKE_CXX_COMPILER=${{ matrix.cxx }}
+          -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          -DKAIROS_WARNINGS_AS_ERRORS=ON
+          "-DKAIROS_SANITIZE=${{ matrix.sanitize }}"
+
+      - name: Build
+        run: cmake --build build
+
+      # A failed test runs once more: a load spike of the runner should not fail the CI, a real
+      # regression fails both times
+      - name: Test
+        env:
+          UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1
+        run: ctest --test-dir build --output-on-failure --repeat until-pass:2
+
+      - name: Install and use from another project
+        if: matrix.sanitize == ''
+        run: |
+          cmake --install build --prefix "$PWD/install"
+          cmake -S tests/install -B build-consumer -G Ninja \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} -DCMAKE_PREFIX_PATH="$PWD/install"
+          cmake --build build-consumer
+          LD_LIBRARY_PATH="$PWD/install/lib" ./build-consumer/kairos_consumer
+
+  memory-limited:
+    name: tests in a 512 MB cgroup
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build libgtest-dev uncrustify python3
+      - name: Build
+        run: |
+          cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
+          cmake --build build
+      - name: Test under MemoryMax=512M
+        run: >
+          sudo systemd-run --scope -p MemoryMax=512M -p MemorySwapMax=0
+          ctest --test-dir build --output-on-failure --repeat until-pass:2 -LE lint
+
+  coverage:
+    name: coverage (lines >= 90 %)
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write  # the badge, on the badges branch
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build libgtest-dev uncrustify python3 pipx
+          pipx install gcovr==8.6
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+      - name: Build with coverage
+        run: |
+          cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug -DKAIROS_COVERAGE=ON
+          cmake --build build
+      - name: Test
+        run: ctest --test-dir build --output-on-failure --repeat until-pass:2 -LE lint --parallel 4
+      - name: Report (gcovr.cfg sets the threshold)
+        run: |
+          mkdir -p coverage
+          status=0
+          gcovr build --html-details coverage/index.html --markdown coverage/report.md \
+            --cobertura coverage/coverage.xml || status=$?
+          cat coverage/report.md >> "$GITHUB_STEP_SUMMARY"
+          exit $status
+      - name: Upload the report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage/
+      - name: Publish the badge (main only)
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        env:
+          TOKEN: ${{ github.token }}
+        run: |
+          # Shields.io endpoint JSON on an orphan branch with a single commit
+          python3 - <<'PY'
+          import json
+          import xml.etree.ElementTree as ET
+          rate = float(ET.parse('coverage/coverage.xml').getroot().get('line-rate')) * 100
+          color = 'brightgreen' if rate >= 90 else 'yellow' if rate >= 80 else 'red'
+          badge = {'schemaVersion': 1, 'label': 'coverage', 'message': '%.1f%%' % rate,
+                   'color': color}
+          json.dump(badge, open('coverage.json', 'w'))
+          PY
+          mkdir badge && mv coverage.json badge/ && cd badge
+          git init -q -b badges
+          git add coverage.json
+          git -c user.name=github-actions -c user.email=github-actions@users.noreply.github.com \
+            commit -q -m "Coverage badge for ${GITHUB_SHA}"
+          git push -q -f "https://x-access-token:${TOKEN}@github.com/${GITHUB_REPOSITORY}.git" \
+            badges
+
+  conda:
+    name: conda package with pixi (${{ matrix.arch }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: x86-64
+            os: ubuntu-24.04
+          - arch: arm64
+            os: ubuntu-24.04-arm
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install pixi
+        run: |
+          curl -fsSL https://pixi.sh/install.sh | PIXI_VERSION=v0.81.0 bash
+          echo "$HOME/.pixi/bin" >> "$GITHUB_PATH"
+      - name: Build the package (pixi-build-cmake)
+        run: pixi publish --target-channel "file://$PWD/channel"
+      - name: Install it and plan with it
+        run: |
+          run="pixi exec -c file://$PWD/channel -c https://prefix.dev/conda-forge -s kairos"
+          $run kairos --version
+          $run kairos tests/data/plansys2/plansys2_executor__suave_domain.pddl \
+            tests/data/plansys2/plansys2_executor__suave_problem.pddl
+      - name: Upload the package
+        uses: actions/upload-artifact@v4
+        with:
+          name: kairos-conda-${{ matrix.arch }}
+          path: channel/*/*.conda
+
+  ros-package:
+    # As the ROS 2 buildfarm's binary jobs: bloom generates the package, it builds without tests,
+    # installs in /opt/ros/DISTRO, runs, and a program that uses the library builds against it
+    name: ROS package ${{ matrix.distro }} (${{ matrix.image }}, ${{ matrix.arch }})
+    runs-on: ${{ matrix.arch == 'arm64' && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {distro: humble, image: 'ros:humble-ros-core', kind: deb, arch: amd64}
+          - {distro: humble, image: 'ros:humble-ros-core', kind: deb, arch: arm64}
+          - {distro: jazzy, image: 'ros:jazzy-ros-core', kind: deb, arch: amd64}
+          - {distro: jazzy, image: 'ros:jazzy-ros-core', kind: deb, arch: arm64}
+          - {distro: kilted, image: 'ros:kilted-ros-core', kind: deb, arch: amd64}
+          - {distro: kilted, image: 'ros:kilted-ros-core', kind: deb, arch: arm64}
+          - {distro: lyrical, image: 'ros:lyrical-ros-core', kind: deb, arch: amd64}
+          - {distro: lyrical, image: 'ros:lyrical-ros-core', kind: deb, arch: arm64}
+          - {distro: jazzy, image: 'almalinux:9', kind: rpm, arch: amd64}
+          - {distro: kilted, image: 'almalinux:9', kind: rpm, arch: amd64}
+          - {distro: lyrical, image: 'almalinux:10', kind: rpm, arch: amd64}
+          - {distro: lyrical, image: 'fedora:43', kind: rpm, arch: amd64}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Build, install and use the package
+        run: |
+          docker run --rm -e ROS_DISTRO=${{ matrix.distro }} -v "$PWD:/src:ro" \
+            ${{ matrix.image }} bash /src/.github/scripts/ros_${{ matrix.kind }}.sh
+
+  fuzz:
+    name: libFuzzer (2 min per target)
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build clang
+      - name: Build fuzzers
+        run: |
+          cmake -S . -B build -G Ninja -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_BUILD_TYPE=RelWithDebInfo -DKAIROS_BUILD_TESTS=OFF -DKAIROS_BUILD_FUZZERS=ON
+          cmake --build build --target lexer_fuzzer parser_fuzzer plan_fuzzer
+      - name: Fuzz the lexer
+        run: |
+          mkdir -p corpus-work
+          ./build/fuzz/lexer_fuzzer -max_total_time=120 -max_len=4096 corpus-work fuzz/corpus/lexer
+      - name: Fuzz the parser
+        run: |
+          mkdir -p corpus-parser
+          ./build/fuzz/parser_fuzzer -max_total_time=120 -max_len=8192 corpus-parser fuzz/corpus/parser
+      - name: Fuzz the plan reader
+        run: |
+          mkdir -p corpus-plan
+          ./build/fuzz/plan_fuzzer -max_total_time=60 -max_len=4096 corpus-plan fuzz/corpus/plan

kairos_planner-1.0.3/.github/workflows/wheels.yml

@@ -0,0 +1,49 @@
+name: Python wheels
+
+# kairos-planner: wheels for Linux (x86-64, arm64, manylinux_2_28), each tested with the
+# Python suite; a version tag (e.g. 1.0.3) also publishes them on PyPI (trusted publishing)
+on:
+  push:
+    branches: [main]
+    tags: ['[0-9]+.[0-9]+.[0-9]+']
+  pull_request:
+
+jobs:
+  wheels:
+    name: wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, ubuntu-24.04-arm]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: pypa/cibuildwheel@v3.2.1
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [wheels, sdist]
+    runs-on: ubuntu-24.04
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

kairos_planner-1.0.3/.gitignore

@@ -0,0 +1,12 @@
+/build/
+/build-*/
+/install/
+/log/
+.cache/
+compile_commands.json
+__pycache__/
+*.pyc
+/coverage/
+/.pixi/
+/dist/
+/wheelhouse/

kairos_planner-1.0.3/CHANGELOG.rst

@@ -0,0 +1,99 @@
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Changelog for package kairos
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+1.0.3 (2026-10-18)
+------------------
+* Python: ``pip install kairos-planner`` (wheels for Linux x86-64 and arm64): parse, check,
+  plan (blocking, in the background or as an iterator of better plans) and validate, with the
+  diagnostics; planning releases the GIL and Ctrl-C stops it. The wheel has the ``kairos``
+  command too.
+* A search stopped by the caller while the steps of time were still searching after M3 ran out
+  of states is cancelled, not "no plan found".
+* The static ``libkairos`` is position independent (it links into shared objects).
+* The goal holds after the last timed initial literal too, as VAL and the validator check it:
+  M3 took a goal state as a plan before later literals, and every plan it found could fail
+  validation (an internal error). A goal state of M3 with timed literals counts once its plan
+  is valid; the search goes on otherwise.
+* Reads the PDDL that UPF's writer gives: several constraints in ``:constraints`` without
+  ``and``, and timed initial fluents as ``(at t (assign (f) v))`` (with a warning).
+* Python: ``SearchOptions`` given to ``solve`` (what ``SolveOptions`` has).
+* Contributors: Francisco Martín Rico
+
+1.0.2 (2026-10-18)
+------------------
+* Proofs that a temporal task has no plan: the timed initial literals take away what the goal
+  needs too soon (from the initial state, ignoring deletes, with the shortest durations), or the
+  task without durations nor times has no path to the goal (when M3 runs out of states).
+* Steps of time: the time is kept only with timed initial literals, until the last one, and
+  epsilon passes only right after a happening; tiny tasks that ran to the timeout end in ms.
+* With several threads, the phases for when there is no plan stop once another finds one.
+* M3 out of states while the steps of time run out of time is a timeout, not "no plan found".
+* The deadlines of M3 no longer take durations that change as bounds, nor over all conditions
+  an action's start gives itself as needed before it.
+* Contributors: Francisco Martín Rico
+
+1.0.1 (2026-10-17)
+------------------
+* Builds on Ubuntu 22.04 and ROS 2 Humble: CMake 3.22 is enough (nothing needed 3.24), and the
+  CI builds the Humble packages as the buildfarm does.
+* The style test is disabled, with a warning, when uncrustify is older than its configuration
+  (0.78).
+* Why there is no plan: an unreachable goal is now traced to the static fact that is really
+  missing (the initial facts that grounding leaves out of the task count as reachable).
+* Contributors: Francisco Martín Rico
+
+1.0.0 (2026-10-14)
+------------------
+* PDDL+: processes, events, global constraints and continuous effects (linear and non-linear),
+  planned in steps of time and validated in continuous time.
+* Durations between their bounds and non-linear numeric conditions in the heuristics.
+* Planning without grounding: a lifted engine for tasks with millions of ground actions.
+* Status ``NoPlanFound`` (exit code 14): ``Unsolvable`` now needs a proof.
+* A bank of benchmarks per PDDL feature (https://github.com/PlanSys2/kairos-benchmarks), and the
+  bugs it found fixed: object fluents without a value, timed initial fluents in M2 and M3,
+  required concurrency between two variables, deadlines with derived atoms, waits longer than
+  2000 s, incremental goals that must break a goal true from the start.
+* Every PDDL feature that ``kairos --features`` lists is fully supported.
+* Without a plan, a note says why and which option could change it (``orchestrator.why``).
+* Builds as a ROS 2 package for Jazzy, Kilted and Lyrical on every buildfarm target (Ubuntu
+  amd64 and arm64, RHEL 9 and 10, Fedora): no ``<format>`` (GCC 11), no whole-archive linking
+  (CMake 3.28), the library in ``lib`` under ``/opt/ros`` and the command with a relative
+  RUNPATH; the tests follow ``BUILD_TESTING``. A CI job builds the packages as the buildfarm.
+* The library's SONAME is ``libkairos.so.1``: the ABI is stable within a major version.
+* Contributors: Francisco Martín Rico
+
+0.5.0 (2026-10-13)
+------------------
+* Ahead of LAMA and of the winners of the IPC 2023 on classical planning.
+* PDDL3 preferences and trajectory constraints; changing object fluents everywhere.
+* Resources in the schedule; temporal landmarks and invariants.
+* The memory limit kept while grounding, and the real peak in the statistics.
+* Contributors: Francisco Martín Rico
+
+0.4.0 (2026-10-12)
+------------------
+* Temporal planning: engine M2 (durative actions compressed and rescheduled) and engine M3 (snap
+  actions over a temporal network, as POPF); duration inequalities and continuous effects.
+* The phases of the search in parallel; scaling to large PlanSys2 problems.
+* Why the goal cannot be reached; shell completion; documentation of the command and examples.
+* Conda package with pixi.
+* Contributors: Francisco Martín Rico
+
+0.3.0 (2026-10-11)
+------------------
+* Landmarks, novelty and other heuristics in the search; test coverage in the CI.
+* Contributors: Francisco Martín Rico
+
+0.2.0 (2026-10-11)
+------------------
+* PDDL lexer, parser, printer, semantic checks and diagnostics; plan validator.
+* Normalization, grounding in Datalog, SAS+ translation with invariant synthesis.
+* Packed states, heuristics (hmax, hadd, FF), searches (GBFS, WA*, EHC, anytime).
+* The planner API, the orchestrator and the ``kairos`` executable.
+* Contributors: Francisco Martín Rico
+
+0.1.0 (2026-10-10)
+------------------
+* Project skeleton and core infrastructure.
+* Contributors: Francisco Martín Rico

kairos_planner-1.0.3/CMakeLists.txt

@@ -0,0 +1,108 @@
+# Copyright 2026 Intelligent Robotics Lab
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+cmake_minimum_required(VERSION 3.22)
+
+project(kairos
+  VERSION 1.0.3
+  DESCRIPTION "Modern temporal and numeric PDDL planner"
+  LANGUAGES CXX)
+
+# The version lives in package.xml and pixi.toml too
+foreach(manifest package.xml pixi.toml)
+  file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${manifest}" _text)
+  if(manifest STREQUAL "package.xml")
+    string(REGEX MATCH "<version>([^<]+)</version>" _found "${_text}")
+  else()
+    string(REGEX MATCH "\nversion = \"([^\"]+)\"" _found "${_text}")
+  endif()
+  if(NOT CMAKE_MATCH_1 STREQUAL PROJECT_VERSION)
+    message(FATAL_ERROR
+      "${manifest} has version '${CMAKE_MATCH_1}', CMakeLists.txt has ${PROJECT_VERSION}")
+  endif()
+endforeach()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+# The tests follow BUILD_TESTING when it is given (packaging builds turn it off: nothing to
+# download, no lint)
+if(DEFINED BUILD_TESTING)
+  set(_kairos_tests_default ${BUILD_TESTING})
+else()
+  set(_kairos_tests_default ON)
+endif()
+option(KAIROS_BUILD_TESTS "Build the gtest suites and lint tests" ${_kairos_tests_default})
+option(KAIROS_BUILD_CLI "Build the kairos executable" ON)
+option(KAIROS_BUILD_PYTHON "Build the Python module (nanobind)" OFF)
+option(KAIROS_BUILD_FUZZERS "Build libFuzzer targets (requires Clang)" OFF)
+option(KAIROS_COVERAGE "Instrument for coverage" OFF)
+option(KAIROS_WARNINGS_AS_ERRORS "Treat warnings as errors" OFF)
+set(KAIROS_SANITIZE "" CACHE STRING "Sanitizers: empty, 'address;undefined' or 'thread'")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include(KairosCompilerOptions)
+# A ROS install (the buildfarm's packages, /opt/ros/DISTRO) finds libraries in lib only, not in
+# lib64 (RHEL, Fedora) or lib/<multiarch> (Debian)
+if(CMAKE_INSTALL_PREFIX MATCHES "^/opt/ros/")
+  set(CMAKE_INSTALL_LIBDIR lib)  # over the cache (packaging tools pass their own)
+endif()
+include(GNUInstallDirs)
+
+add_subdirectory(src)
+
+if(KAIROS_BUILD_TESTS)
+  include(CTest)  # also writes DartConfiguration.tcl, expected by colcon test
+  add_subdirectory(tests)
+  include(KairosLint)
+endif()
+
+if(KAIROS_BUILD_PYTHON)
+  add_subdirectory(python)
+endif()
+
+if(KAIROS_BUILD_TESTS OR KAIROS_BUILD_FUZZERS)
+  add_subdirectory(fuzz)
+endif()
+
+# Installation and package config
+include(CMakePackageConfigHelpers)
+
+install(DIRECTORY include/kairos DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  PATTERN "*.in" EXCLUDE)
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/include/kairos/version.hpp
+  ${CMAKE_CURRENT_BINARY_DIR}/include/kairos/export.hpp
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/kairos)
+
+install(EXPORT kairosTargets
+  NAMESPACE kairos::
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kairos)
+
+configure_package_config_file(cmake/kairosConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/kairosConfig.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kairos)
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/kairosConfigVersion.cmake
+  COMPATIBILITY SameMajorVersion)
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/kairosConfig.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/kairosConfigVersion.cmake
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kairos)