ChangeLog - soartech/jsoar GitHub Wiki

• Fixed debugger token parsing so clicking on WMEs in the trace should work in cases where an attribute or value has a space in it (e.g., the support panel properly updates).
• Dependency updates. In particular, no longer relying on spring-jcl and jcl-over-slf4j, as commons-logging 1.3 natively supports slf4j now.
• Minor code cleanup.

• Added size and trim RHS functions (thank you rezamini!)
• Various updates for Android compatibility. See Android-Support.
• Some minor code cleanup recommended by sonarqube.
• Updated dependencies.

This is a minor bugfix/maintenance release:

• Fixed standalone ("uber") jar builds so they work again. As part of this, the META-INF/services files were added back into jsoar-core. This should make it even easier for other projects to update to JSoar 5.
  • The JSoarDevelopersGuide has been updated with instructions on how to build with maven, including how to build standalone jars.
• Fixed a few code smells identified by sonarqube lint and other minor code cleanup.
• Updated dependencies.

This is a major "behind the scenes" update with a breaking change: JSoar now requires Java 11+ and uses the Java module system.

Depending on your project, you may need to make changes to use JSoar 5+. See some guidance here: Updating-to-JSoar-5.

Other changes include:

• Ported CSoar's capitalize-symbol RHS function.
• Updated dependencies, including some that now require Java 11+.
• Removed deprecated methods and usages.
• An SBOM is now generated for each project.
• Updated to pure JUnit 5 (previously was using JUnit 5 with the JUnit 4 legacy support).
• Lots of formatting fixes (tabs -> spaces and other inconsistencies). As part of this, updated the eclipse formatter settings and introduced eclipse cleanup settings. Checkstyle is now used to enforce a few things.
• Fixed lots of issues identified by sonarqube, ranging from style to actual bugs and minor performance issues. As part of this, a lot of the code was modernized to use features that came out since the original release, which was in Java 5. E.g., try-with-resources is used much more extensively, the diamond operator is used where it makes sense, etc.
• Removed unmaintained jsoar-ruby and jsoar-soar2soar projects, as well as the incomplete JUnit 4 runner for SoarUnit.
• Updated rete saving and loading to not include properties (i.e., to make it like CSoar). If you need certain settings, you should set them in a .soar file that also loads the rete.
• Fixed jsoar-debugger bug related to autocompleting aliases that point to subcommands.
• Fixed many small bugs, warnings, and performance issues.

• Updated numerous dependencies, some of which had vulnerabilities. As part of this, updated how dependency versions are managed so it's easier to ensure that all subprojects are using the same versions of dependencies.
• Improved implementation of the qmemory command
• Fixed an issue where command parameters from previous execution would not be cleared when autocomplete was used (affects command execution in the jsoar debugger). This would sometimes lead to strange results when executing commands.

• Updated a dependency that was preventing javadoc from working on projects that included jsoar as a dependency
• Updated spring-core dependency to resolve security vulnerability
• Fixed security vulnerabilities and bugs identified by SonarQube
• Reduced code duplication between episodic and semantic memory (no functionality changes)

• Added methods to DebuggerProvider to support programmatically getting and closing a jsoar debugger.
• Automatically close an agent's jsoar debugger when the agent is detached (e.g., the agent is programmatically destroyed).
• Improved efficiency of deleting a Tcl agent that has a lot of Tcl objects (e.g., one using incr tcl).
• print @ now works like it does in CSoar.
• Improved the autocomplete and auto help behavior in the jsoar debugger based on feedback. These can now be disabled under the View menu.
• Added configs for graalvm native image. This is the recommended way to run jsoar on Android (via gluon's graalvm Android support). The old Android branch is very outdated and will likely never be revived.
• Updated dependencies.
• Various bug fixes.

• Completed migration of commands to picocli
• Added java 11 module names to manifests so it isn't derived from the file names
• Fixed numerous threading issues in jsoar-debugger -- interactions with Soar need to happen on the Soar thread!
• Fixed debugger issue where if productions were added programmatically the production panel's production counts didn't update
• Fixed handling of InterruptedException in several places, so ThreadedAgents shutdown correctly in various cases.
• Resurrected jsoar-performance-testing project; it works again
• Added new project jsoar-repl, a REPL for jsoar
• Fixed issue where command results were not always flushed to the printer
• Added loadRete method to SoarCommands helper class
• Added additional thread-safe methods to ThreadedAgent to support loading productions, a rete, and passing a Runnable for execution on the Soar thread (to make it possible to use lambdas)
• Added new RHS function set-count <id> <attr> which returns the number of WMEs with the specified identifier and attribute
• Removed transparency from a few places in the debugger since not all environments support it

• Fixed threading issue with stop command view in debugger
• Updated default debugger layout to include the stop command view
• Fixed some minor trace whitespace issues
• Fixed lots of minor javadoc issues
• Fixed the interpreter APIs' load/save rete methods
• Ensured more error message output actually made it to the trace
• Updated javascript support to use the GraalVM js engine, as Nashorn has been removed from the jvm as of JDK 14
• Several other minor fixes and dependency updates

• Fixed issues that prevented JSoar from working in a Java 11 application (the 4.0.0 release only allowed for running with a Java 11 JDK). JSoar should now fully work with Java 11 (or newer) applications.
  • Fixed a split package
  • Changed how resources are loaded through jTcl
• Improved some debugger syntax highlighting regular expressions
• Fixed a debugger issue where it was using a persistent writer instead of a normal writer, which caused some double-printing.
• Vastly improved the performance of rete loading/saving by using buffered streams. Also
• Updated to picocli 4.1.4, which required reworking some of the command infrastructure.
• Updates to several commands to improve performance (probably not noticeable in practice).
• Removed logback dependency, as libraries shouldn't specify the logging implementation.
• Other internal cleanup

An improperly built release, pulled before it made it on maven central.

The theme of this release is support for newer Java versions, CSoar command compatibility, and many debugger enhancements, some of which should make it easier for new users to get into Soar.

• The version number was updated to reflect the maturity of the code base. The version number is based on a review of the changelog:
  • Version 0.9.1 should have been 1.0, because it involved hardening from actual use
  • Version 0.10.0 should have been 2.0, because it added smem
  • Version 0.14.0 should have been 3.0, because it added epmem, WMA, CDPS, etc.
  • The new version should be 4.0 since it introduces major changes to the implementation of commands and significant additions to the debugger.
• Release is now on Maven Central
• Java 8 is now the minimum required version.
• Java 11 compatibility (only affects JSoar Debugger)
• Ported nearly all commands to picocli (https://picocli.info/), which gives provides support for some new features (see help and autocomplete below)
• Reworked commands to match new CSoar 9.6.0 structure
• Numerous JSoar Debugger enhancements
  • Better support for scaling on HiDPI displays
    • With Java 11+, the debugger automatically scales reasonably
    • Can specify a font scale level on the commandline (-DfontScale=1.0) -- useful with Java 8
    • Ctrl+scroll wheel to dynamically change font scaling at runtime -- useful with Java 8
      • Doesn't work over scrolling parts of the debugger, like the trace view, but do it elsewhere and the effects are global
      • Imperfect, but works well enough
  • Trace view enhancements
    • Added support for regex-based syntax highlighting (see context menu to customize)
    • Added support for limiting the number of characters in the trace (see context menu to customize)
    • Improved find support in trace window (prev/next, case sensitive, regex or plain text)
  • help command now actually prints help for each command, as generated by picocli
  • Added command auto-complete with help popups (thanks picocli!)
  • Automatically show help for command while typing it
  • Renamed "Goals" panel to "State Stack" for accuracy
  • Improved filter support in production panel (regex is now optional, plain text is the default)
  • Added stop command panel -- runs a specified command when Soar stops running (to add, View -> Stop Command -- note you can make multiple of these)
  • Added Help -> Quick Help menu item, which brings up debugging hints
• Enhancements to support Soar LSP (https://github.com/soartech/soar-language-server/)
  • Added new SoarException subtypes to make some error details programmatically accessible
  • Added support for "soft" exceptions and an exception manager, which are exceptions that are caught and not passed on. This allows errors to be displayed without stopping the sourcing of the agent.
• Updated the versions of many dependencies to avoid potential problems when using jsoar in projects that are using newer versions of the same dependencies (e.g., Google guava)
• Fixed all warnings in code (as reported by default Eclipse settings)
• Full javadocs and source jars are now built as part of the build process
• Jsoar-build and jsoar-ruby have been removed from the build, although they are still in the repo for those who need them (and jsoar-ruby's zip file is part of the release on github).

• Added rand-int and rand-float RHS functions. Should prefer these over existing random-int and random-float RHS functions, for CSoar compatibility
• Added timestamp RHS function
• Added decide command
• Added support to rl command for a number of parameters that existed but weren't exposed via the command
• Fixes to handle smem/epmem database paths that contain spaces
• Fixes to handle URLs in jar files
• Improvements to maven build process
• SoarUnit compatibility with CSoar 9.6.0 with Tcl

• JsonWmeUtils now has a boolean that toggles automatically converting multi-value attributes to an array
• SQL handling improvements

• Added integer version of make-constant-symbol RHS function
• Put more debug info in SoarBeanException

• Added support for sourcing Soar code from the classpath (e.g., can load from a jar). pushd/popd work, too.
• Added prototype junit runner for SoarUnit
• SoarUnit now supports Tcl with CSoar
• SoarUnit displays long names better
• Added support for numeric comparisons for strings and identifiers (ported from CSoar)
• Added support for custom exception handlers in SoarBeans

• Restored Java 7 compatibility (Java 8 features had leaked into the source)
• Minor updates to JsonWmeUtils

• Maven branch is now the main branch (master is abandoned); builds now done with maven
• Added performance tests
• Added JsonWmeUtils (supports JSON -> WME and WME -> JSON -- for adding JSON to the input-link and converting output WME structures to JSON)

• New helper classes for simple output handling. See OutputCommandManager
• Log command/RHS function improvements. See JSoar Logging
• Bug fixes (some ported from CSoar)
• Memory improvements
• Now requires Java 7

• Ported Episodic Memory from CSoar

• Ported Working Memory Activation from CSoar

• Ported CDPS from CSoar

• Ported updates to Semantic Memory from CSoar

• Implemented Semantic Memory math queries (ported to CSoar)

• Ported updates to Reinforcement Learning from CSoar

• Ported additional commands from CSoar (e.g., rete-net)

• Ported additional RHS functions from CSoar (e.g., cmd)

• Updated Tcl support to jtcl

• Added jsoar-performance-testing project (works with CSoar, too)

• Ported various bug fixes from CSoar

• Various jSoar-specific bug fixes

• Added maven support

• Added experimental features (not yet ported to CSoar)

  • log command/RHS function
  • handler RHS function
  • Episodic Memory deliberate storage
  • epmem --add
  • epmem --set inclusions
  • smem --lastcue : gives performance information about the last smem command

• Known issues

  • An operator must be proposed before the first episodic memory is recorded or else the substate gets recorded as part of the episode. Doesn't seem to be an issue in CSoar or in practice.
  • Not yet tested with Java 8.

• Upgrade CSoar support in SoarUnit to 9.3.1
• Various SoarUnit fixes
• Ported various bug fixes from CSoar

• Introduced JSoarScripting a framework for embedding I/O scripts directly in Soar source files.
• Introduced SoarUnit, a unit testing framework for Soar. It works with both JSoar and CSoar 9.3.0.
• Converted integers and identifier counts to 64-bit values
• Implemented pwatch command
• Implemented pbreak command. Dynamically set match-time interrupts on productions. Same as :interrupt, but there's no need to modify the code.
• Implemented support for :interrupt flag on productions.
• Various memory usage and performance improvements
• Better reporting of files and line numbers for rules and commands. Commands have access to this info now.
• Added a goal stack display to the JSoar debugger
• In debugger, implemented scroll lock in trace.
• Add option to limit trace output in debugger.
• In debugger, pasting to trace window executes commands from clipboard.
• In debugger, double-click identifiers in debugger trace window to print/drill-down
• In debugger, replace FlexDock with DockingFrames
• General debugger cleanup
• Support for partial command matches
• Switched logging from commons-logging to slf4j.

• Ported CSoar 9.3.0's (actually slightly newer, but functionally equivalent) implementation of semantic memory. See JSoarSemanticMemory
• Updated JSoar's reinforcement learning implementation to match that of CSoar 9.3.0
• Implemented org.jsoar.kernel.rete.SimpleMatcher which allows the Soar rete to be used independently of the rest of Soar. We use this to simplify testing of Soar features like GDS.
• Nearly complete implementation of the print command. Only --varprint is missing.
• Numerous new functional/spec tests for kernel (impasses, initial state, gds, etc)
• More complete implementation of run command
• More complete implementation of watch command
• Implemented -a, -v, and -d flags for source command (source details)
• Implemented set-stop-phase command
• Implemented gds-print command
• Implemented explain-backtraces command
• Implemented version command
• Implemented timers command
• Implemented debugger command. Opens new debugger.
• "format" RHS function equivalent to sprintf in C
• "list" RHS function for building linked lists
• Implemented output-link change tracking (!OutputEvent.getChanges())
• Generalized WmeFactory interface used by both RHS functions and input producers
• Performance and memory usage improvements by optimizing MatchSetChange and Slot linked lists.
• Improved, color coded partial match view in debugger.
• Port of soar2soar to JSoar.
• Finer-grained control of GDS WME removal messages
• Removed a number of Soar 7 remnants (preference phase, wm phase, etc)
• Upgraded/switched from now-defunct Google Collections Library to Google Guava libraries

• Code moved to Mercurial (https://jsoar.googlecode.com/hg)
• Improved memory usage by eliminating many cases of long-lived, small objects, especially in linked-list management
• To reduce memory usage, moved Tcl interface into separate, optional library, jsoar-tcl.jar. Set jsoar.agent.interpreter system property to tcl to re-enable Tcl interpreter.
• String symbols are no longer needlessly encased in pipes when they contain capital letters. Yay!
• Ported various fixes from CSoar (thanks Jon Voigt).
• General hardening from actual use.

• Added JSoarLegilimens
• Fixed waitsnc with no args
• Fixed some threading issues where wait RHS function would spuriously wake up even though no new input was available (r542)
• Fixed attribute handling in preferences command (r539)
• Improved handling of unhandled exceptions in agent thread
• Port of various CSoar fixes (r538, r537)
• Major improvements to trace formatting (r572)

• Implemented production-find command. Does not print bindings yet.
• Helper functions for sticking an XML file on input-link from any thread
• Fix for --depth handling in print command

• Made org.jsoar.kernel.symbols.Symbols.NEW_ID play nicer with scripting languages
• Store file info with productions
• implement edit-production command
• implement --filename option of print command
• Incremental, regex search of trace window
• Added openDebuggerAndWait() method for more predictable startup use case.

• Fixed printing of math RHS functions
• Added min and max RHS functions
• Implemented random-int, and random-float RHS functions as discussed in UofM Bugzilla issue 800
• Added exec RHS function for easier transition from SML-based agents
• A number of cleanups to the API driven by some serious dog-fooding
• Various Ruby API improvements
• Added input component that creates a queue of XML messages on the agents input-link
• Strong start on implementation of SML API in JSoar. Currently can run Towers of Hanoi and Missionaries and Cannibals demos without recompiling just by swapping jsoar-sml.jar in for sml.jar

• Implemented "memories" command
• Better error message when JavaScript engine is missing (Mac OS)
• Use 64 bits for counters (decisions, elaborations, etc)
• Fixed major memory leak which caused justifications to never be garbage collected.
• Made ThreadedAgent Adaptable.
• Print "stars" while loading produdtions
• Print errors when loading files from debugger's command-line
• Remember file chooser directory across debugger sessions

• Fix major memory leak which caused instantiations to never be garbage collected. Memory usage is a little less crazy now.
• Implemented "internal-symbols" command
• Added "Run Garbage Collector" command to debugger
• Implemented missing "mod" RHS function

• Ruby work including sample twitter interface for Soar agent's
• Reworked the input API a bit to make it a little friendlier. InputWme.remove() is not thread-safe.
• Eliminated duplicate RHS values
• Cache common RHS values
• Support for reading and writing (mostly) arbitrary XML. Old XML conversions moved to SoarTechWmeToXml, etc.
• Fix lexer crash on unicode characters
• print --rl
• print --exact (thanks Bob!)
• Made QMemory compatible with (wait) function
• Implemented SoarBeans and added output manager based on them
• Cleaned up remaining public members of Agent class
• Made command implementations Tcl neutral
• Replaced int transitive closure markers with real objects (Marker)
• Renamed InputCycleEvent to just InputEvent for consistency
• Full support for sourcing from URLs (includes pushd, popd, etc)
• Remember preferences in debugger
• Major speedup in debugger trace window
• Added Time input component
• Added WME Search view to debugger
• Jon Voigt ported several bug fixes over from CSoar.
• preferences command
• Trace context menu

• Revamped project structure
• Extensive refactoring on public interfaces
• Removed Soar 7 compatibility mode
• Removed support for o-support modes 0 through 3
• Clean up and refinement of agent threading model
• Implemented "debug" RHS function. Opens a debugger.
• Improved interfaces for embedding debugger
• Debugger UI improvements
• Implemented "wait" RHS function. Suspends agent thread until new input is available
• Implemented excise and firing-counts commands
• Implemented "to-xml" and "from-xml" RHS functions. Convert simple XML to working memory.
• Implemented "get-url" RHS function. Requests the contents of a URL.
• Implemented run, stop and init-soar commands
• Added basic URL support to source command

• Very basic implementation of print command. Options must come first, i.e. "print -d 5 s1" rather than "print s1 -d 5"
• Implemented JavaRhsFunction
• Implemented tcl RHS function
• Implemented deep-copy RHS function
• Added APIs to allows RHS functions to create working memory structures, not just return a value
• Implemented int and float RHS functions
• Implemented simple production editor to debugger. Double-click production to edit

Initial public release