This file briefly describes the contents of the JAF distribution. 
There are essentially four categories of files that are provided by
JAF:  libraries containing the JAF architecture, a set of executables
and scripts that help in agent construction and execution,
configuration files controlling what is provided to the agent, and
documentation.

Libraries

  The libraries are contained in the lib directory.  jaf.jar and
  jaf-extensions.jar contain the JAF architecture.  Documentation on
  their contents can be found here:
	http://mas.cs.umass.edu/research/mass/api/agent/
	http://mas.cs.umass.edu/research/mass/api/ihome/

  utilities.zip contains a set of utility classes used by various JAF
  components.
	http://mas.cs.umass.edu/research/mass/api/utilities/

  taems.zip contains the Java Taems implementation.  This is not
  strictly part of the JAF architecture, but MASS-compatible agents
  make extensive use of Taems structures, so it is included here.
	http://mas.cs.umass.edu/research/mass/api/taems/

Executables and Scripts

  These files are contained in the bin directory, with the exception
  of the high-level Makefile.  The Makefile is used to both construct
  and run JAF agents.  It will help compile source files found in the
  src directory (make), create agent .gnt files (make foobar.cfg), and
  run agents (make foobar.gnt).  The makefile is not essential, but
  using it will make it much easier to use JAF.  If you can not use
  makefiles on your system, you can still inspect this file to see
  what it calls under different circumstances.

  Three scripts in the bin directory are used by the Makefile. 
  makeconfig parses .cfg files to produce both the .gnt files used to
  run agents and the .jar files they make use of.  makeagentenv is a
  convenience script that is used to extract environment variables
  which can be passed to agents on the java command line.  It will
  extract all variables prepended with "AGENT_" and convert them to
  java system properties (e.g.  a variable named AGENT_Port which has
  a value of 12345 would become -DPort="12345").  Finally, the
  makemanifest script is used when generating jar files to process the
  header manifest tags that agent components should have.

  Also in the bin directory are a number of dtc executables for
  various platforms.  dtc is a Taems-based design-to-criteria
  planner/scheduler, which is used by the agent.mass.Scheduler
  component.
	http://mas.cs.umass.edu/research/dtc.html

Configuration Files

  Configuration files are stored in the config directory.  The primary
  configuration file will end in .cfg, which will contain both a set
  of agent configuration properties, including the agent component
  list, and a few commands used to produce the .gnt and .jar files
  needed to run a JAF agent.  The .gnt file itself is just a listing
  of configuration properties, so although it is almost always
  automatically generated, you may still edit or create this file by
  hand.  When creating them by hand, it will help to look at an
  existing .gnt file to learn the syntax.

  An agent's configuration directory may also contain other files
  which the agent might need at runtime.  For instance, if your
  component required a data file to run, it would be placed here.  To
  reduce clutter in a deployed agent, these files are usually combined
  into a single extended entry data file, specified with the ExtConfig
  agent property, and created with the JAR command in the agent's .cfg
  file.

  Note:  You can view the contents of an existing extended entry data
  file (which is just a jar file) using the following command:
	jar tvf config/example/example.jar

Documentation

  The README file is a good place to start if you just want to get a
  JAF agent up and running.  It has information on generating and
  running an agent, specifically using the included example agent. 
  The CONTENTS file (which you are reading) details the contents of
  the JAF distribution.  The doc directory contains the
  Javadoc-generated documentation for the included example source
  files.  Load the file doc/index.html in a web browser to view them. 
  These can be regenerated at any time using the 'make doc' command,
  which will also generate the Javadoc files for any other source
  files you have placed in the src directory.

The JAF distribution also includes an example agent component in
src/agent/example/ExampleProblemSolver.java.  This component shows how
a typical component is designed, and demonstrates the use of some
common JAF functionality.

The example agent's configuration directory in config/example.  The
configuration file is example.cfg, which when interpreted (make
config/example/example.cfg) will produce both example.gnt and
example.jar.  The example.jar is the agent's extended entry data file,
which is just a compressed file containing other data files the agent
might need at runtime.  In this example, it contains the file
example.ttaems, which is used at runtime to define the agent's plan. 
While default example agent is designed to be used with the Mass
simulator, the same configuration file also produces
standalone-example.gnt, which is a version of the same agent designed
to run independently.
