monarchic-agent-protocol 0.1.0

{
  description = "Monarchic AI protocol types and schemas";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  };

  outputs = { self, nixpkgs }:
    let
      systems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
      forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system);
    in
    {
      packages = forAllSystems (system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
        in
        {
          default = self.packages.${system}.rust-lib;
          rust-lib = pkgs.rustPlatform.buildRustPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.0";
            src = ./.;
            cargoLock = {
              lockFile = ./Cargo.lock;
            };
          };

          python-lib = pkgs.python3Packages.buildPythonPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.0";
            format = "pyproject";
            src = ./python;
            nativeBuildInputs = [
              pkgs.protobuf
              pkgs.python3Packages.setuptools
              pkgs.python3Packages.wheel
            ];
            propagatedBuildInputs = [ pkgs.python3Packages.protobuf ];
            preUnpack = ''
              export PROTO_DIR="${./schemas/v1}"
            '';
            preBuild = ''
              protoc -I "$PROTO_DIR" \
                --python_out=monarchic_agent_protocol \
                "$PROTO_DIR/monarchic_agent_protocol.proto"
            '';
          };

          pypi-lib = pkgs.python3Packages.buildPythonPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.0";
            format = "pyproject";
            src = pkgs.fetchPypi {
              pname = "monarchic_agent_protocol";
              version = "0.1.0";
              sha256 = "sha256-4VjrXQX5hw5Q9mF4UJOTewK5OZuMNvKJCyqVC5rbtkE=";
            };
            nativeBuildInputs = [
              pkgs.python3Packages.setuptools
              pkgs.python3Packages.wheel
            ];
            propagatedBuildInputs = [ pkgs.python3Packages.protobuf ];
            doCheck = false;
          };
        });

      checks = forAllSystems (system:
        let
          pkgs = import nixpkgs { inherit system; };
        in
        {
          default = self.packages.${system}.default;
          rust-import = pkgs.runCommand "rust-import" {
            nativeBuildInputs = [ pkgs.rustc ];
          } ''
            set -euo pipefail
            cat > main.rs <<'RS'
            use monarchic_agent_protocol::{AgentRole, Task, PROTOCOL_VERSION};

            fn main() {
                let task = Task {
                    version: PROTOCOL_VERSION.to_string(),
                    task_id: "task-123".to_string(),
                    role: AgentRole::Dev,
                    goal: "hello".to_string(),
                    inputs: None,
                    constraints: None,
                    gates_required: None,
                    run_context: None,
                    extensions: Default::default(),
                };
                println!("{}", task.task_id);
            }
            RS
            rustc main.rs \
              -L ${self.packages.${system}.rust-lib}/lib \
              --extern monarchic_agent_protocol=${self.packages.${system}.rust-lib}/lib/libmonarchic_agent_protocol.rlib \
              -o rust-import
            ./rust-import > /dev/null
            touch $out
          '';

          schema-validation = pkgs.runCommand "schema-validation" {
            nativeBuildInputs = [ pkgs.python3 pkgs.python3Packages.jsonschema ];
          } ''
            set -euo pipefail
            python <<'PY'
            import json
            import os
            from jsonschema import Draft202012Validator

            schema_dir = "${./schemas/v1}"
            schemas = []
            for name in os.listdir(schema_dir):
                if name.endswith(".json"):
                    with open(os.path.join(schema_dir, name), "r", encoding="utf-8") as handle:
                        schemas.append(json.load(handle))

            for schema in schemas:
                Draft202012Validator.check_schema(schema)
            PY
            touch $out
          '';

          proto-validation = pkgs.runCommand "proto-validation" {
            nativeBuildInputs = [
              pkgs.protobuf
            ];
          } ''
            set -euo pipefail
            bash ${./scripts/test-proto.sh} ${./schemas/v1/monarchic_agent_protocol.proto}
            touch $out
          '';

          pypi-import = pkgs.runCommand "pypi-import" {
            nativeBuildInputs = [
              (pkgs.python3.withPackages (ps: [ self.packages.${system}.pypi-lib ]))
            ];
          } ''
            set -euo pipefail
            python - <<'PY'
            import monarchic_agent_protocol
            from monarchic_agent_protocol import monarchic_agent_protocol_pb2 as pb

            task = pb.Task(version="v1", task_id="t1", role=pb.AgentRole.DEV, goal="hello")
            assert task.version == "v1"
            PY
            touch $out
          '';
        });

      devShells = forAllSystems (system:
        let
          pkgs = import nixpkgs { inherit system; };
        in
        {
          default = pkgs.mkShell {
            packages = [
              pkgs.cargo
              pkgs.rustc
              pkgs.rustfmt
              pkgs.protobuf
              pkgs.nodejs
              pkgs.jq
              pkgs.python3
              pkgs.python3Packages.jsonschema
            ];
          };
        });
    };
}