naisys 1.3.1 → 1.5.0

package/README.md

@@ -73,7 +73,11 @@ dreamModel: claude3opus
 
 # The model to use for llmynx, pre-processing websites to fit into a smaller context (use a cheaper model)
 # defaults to the shellModel if omitted
-webModel: gemini-pro
+webModel: claude3haiku
+
+# The model used by the 'genimg' command. If not defined then the genimg command is not available to the LLM
+# Valid values: dalle2-256, dalle2-512, dalle2-1024, dalle3-1024, dalle3-1024-HD
+imageModel: dalle3-1024
 
 # A system like prompt explaining the agent's role and responsibilities
 # You can use config variables in this string
@@ -108,6 +112,11 @@ spendLimitDollars: 2.00
 #   Auto: All commands are run through the separate LLM instace that will check to see if the command is safe
 commandProtection: "none"
 
+# The max number of subagents allowed to be started and managed. Leave out to disable.
+# Costs by the subagent are applied to the host agent's spend limit
+# Careful: Sub-agents can be chatty, slowing down progress.
+subagentMax: 0
+
 # Run these commands on session start, in the example below the agent will see how to use mail and a list of other agents
 initialCommands:
   - llmail users
@@ -161,10 +170,12 @@ initialCommands:
   - `comment "<note>"` - The LLM is directed to use this for 'thinking out loud' which avoids 'invalid command' errors
   - `endsession "<note>"` - Clear the context and start a new session.
     - The LLM is directed to track it's context size and to end the session with a note before running over the context limit
-  - `pause <seconds>` - Can be used by the debug agent or the LLM to pause execution indefinitely, or until a new message is received from another agent, or for a set number of seconds
+  - `pause <seconds>` - Can be used by the debug agent or the LLM to pause execution for a set number of seconds
 - NAISYS apps
   - `llmail` - A context friendly 'mail system' used for agent to agent communication
   - `llmynx` - A context friendly wrapping on the lynx browser that can use a separate LLM to reduce the size of a large webpage into something that can fit into the LLM's context
+  - `genimg "<description>" <filepath>` - Generates an image with the given description, save at the specified fully qualified path
+  - `subagent` - A way for LLMs to start/stop their own sub-agents. Communicating with each other with `llmail`. Set the `subagentMax` in the agent config to enable.
 
 ## Running NAISYS from Source
 
@@ -185,6 +196,18 @@ initialCommands:
 - Install WSL (Windows Subsystem for Linux)
 - The `NAISYS_FOLDER` and `WEBSITE_FOLDER` should be set to the WSL path
   - So `C:\var\naisys` should be `/mnt/c/var/naisys` in the `.env` file
-- If you want to use NAISYS for a website
-  - Install a local web server, for example [XAMPP](https://www.apachefriends.org/) on Windows
-  - Start the server and put the URL in the `.env` file
+
+#### Using NAISYS for a website
+
+- Many frameworks come with their own dev server
+  - PHP for example can start a server with `php -S localhost:8000 -d display_errors=On -d error_reporting=E_ALL`
+- Start the server and put the URL in the `.env` file
+
+## Changelog
+
+- 1.5: Allow agents to start their own parallel `subagents`
+- 1.4: `genimg` command for generating images
+- 1.3: Post-session 'dreaming' as well as a mail 'blackout' period
+- 1.2: Created stand-in shell commands for custom Naisys commands
+- 1.1: Added command protection settings to prevent unwanted writes
+- 1.0: Initial release

package/bin/genimg

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'genimg' cannot be used with other commands on the same prompt."

package/bin/naisys

@@ -1,19 +1,22 @@
 #!/bin/bash
 
-# Make sure to enable this script for execution with `chmod +x runteam.sh`
+# Make sure to enable this script for execution with `chmod +x naisys`
+
+# Resolves the location of naisys from the bin directory
+SCRIPT=$(readlink -f "$0" || echo "$0")
+SCRIPT_DIR=$(dirname "$SCRIPT")/..
 
 # Check if an argument is provided
 if [ $# -eq 0 ]; then
+  # get version from package.json
+  VERSION=$(node -e "console.log(require('${SCRIPT_DIR}/package.json').version)")
   echo "NAISYS: Node.js Autonomous Intelligence System"
+  echo "  Version: $VERSION"
   echo "  Usage: naisys <path to agent config yaml, or directory>"
   echo "  Note: If a folder is passed then all agents will be started in a tmux session"
   exit 1
 fi
 
-# Resolves the location of naisys from the bin directory
-SCRIPT=$(readlink -f "$0" || echo "$0")
-SCRIPT_DIR=$(dirname "$SCRIPT")/..
-
 # if path is a yaml file then start a single agent
 if [ -f "$1" ]; then
   if [[ "$1" == *".yaml" ]]; then

package/bin/trimsession

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'trimsession' cannot be used with other commands on the same prompt."

package/dist/command/commandHandler.js

@@ -1,11 +1,13 @@
 import chalk from "chalk";
-import * as llmail from "../apps/llmail.js";
-import * as llmynx from "../apps/llmynx.js";
 import * as config from "../config.js";
+import * as genimg from "../features/genimg.js";
+import * as llmail from "../features/llmail.js";
+import * as llmynx from "../features/llmynx.js";
+import * as subagent from "../features/subagent.js";
 import * as contextManager from "../llm/contextManager.js";
-import { ContentSource } from "../llm/contextManager.js";
 import * as costTracker from "../llm/costTracker.js";
 import * as dreamMaker from "../llm/dreamMaker.js";
+import { ContentSource } from "../llm/llmDtos.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
 import * as output from "../utils/output.js";
@@ -64,7 +66,18 @@ export async function processCommand(prompt, consoleInput) {
                 await contextManager.append("Comment noted. Try running commands now to achieve your goal.");
                 break;
             }
+            case "trimsession": {
+                if (!config.trimSessionEnabled) {
+                    throw 'The "trimsession" command is not enabled in this environment.';
+                }
+                const trimSummary = contextManager.trim(cmdArgs);
+                await contextManager.append(trimSummary);
+                break;
+            }
             case "endsession": {
+                if (!config.endSessionEnabled) {
+                    throw 'The "trimsession" command is not enabled in this environment.';
+                }
                 // Don't need to check end line as this is the last command in the context, just read to the end
                 const endSessionNotes = utilities.trimChars(cmdArgs, '"');
                 if (!endSessionNotes) {
@@ -104,8 +117,7 @@ export async function processCommand(prompt, consoleInput) {
                 };
             }
             case "cost": {
-                const totalCost = await costTracker.getTotalCosts();
-                output.comment(`Total cost so far $${totalCost.toFixed(2)} of $${config.agent.spendLimitDollars} limit`);
+                await costTracker.printCosts();
                 break;
             }
             case "llmynx": {
@@ -125,16 +137,24 @@ export async function processCommand(prompt, consoleInput) {
                 }
                 break;
             }
+            case "genimg": {
+                const genimgResponse = await genimg.handleCommand(cmdArgs);
+                await contextManager.append(genimgResponse);
+                break;
+            }
             case "context":
-                contextManager.printContext();
+                output.comment("#####################");
+                output.comment(contextManager.printContext());
+                output.comment("#####################");
+                break;
+            case "subagent": {
+                const subagentResponse = await subagent.handleCommand(cmdArgs);
+                await contextManager.append(subagentResponse);
                 break;
+            }
             default: {
-                const shellResponse = await shellCommand.handleCommand(input);
-                if (shellResponse.hasErrors && nextInput) {
-                    await output.errorAndLog(`Error detected processing shell command:`);
-                    processNextLLMpromptBlock = false;
-                }
-                nextCommandAction = shellResponse.terminate
+                const exitApp = await shellCommand.handleCommand(input);
+                nextCommandAction = exitApp
                     ? NextCommandAction.ExitApplication
                     : NextCommandAction.Continue;
             }
@@ -199,7 +219,11 @@ async function splitMultipleInputCommands(nextInput) {
         }
     }
     // If the LLM forgets the quote on the comment, treat it as a single line comment
-    else if (newLinePos > 0 && nextInput.startsWith("comment ")) {
+    // Not something we want to use for multi-line commands like llmail and subagent
+    else if (newLinePos > 0 &&
+        (nextInput.startsWith("comment ") ||
+            nextInput.startsWith("genimg ") ||
+            nextInput.startsWith("trimsession "))) {
         input = nextInput.slice(0, newLinePos);
         nextInput = nextInput.slice(newLinePos).trim();
     }

package/dist/command/commandLoop.js

@@ -1,17 +1,20 @@
 import chalk from "chalk";
 import * as readline from "readline";
-import * as llmail from "../apps/llmail.js";
-import * as llmynx from "../apps/llmynx.js";
 import * as config from "../config.js";
+import * as llmail from "../features/llmail.js";
+import * as llmynx from "../features/llmynx.js";
+import * as subagent from "../features/subagent.js";
+import * as workspaces from "../features/workspaces.js";
 import * as contextManager from "../llm/contextManager.js";
-import { ContentSource } from "../llm/contextManager.js";
 import * as dreamMaker from "../llm/dreamMaker.js";
-import { LlmRole } from "../llm/llmDtos.js";
+import { ContentSource, LlmRole } from "../llm/llmDtos.js";
 import * as llmService from "../llm/llmService.js";
+import { systemMessage } from "../llm/systemMessage.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
 import * as logService from "../utils/logService.js";
 import * as output from "../utils/output.js";
+import { OutputColor } from "../utils/output.js";
 import * as utilities from "../utils/utilities.js";
 import * as commandHandler from "./commandHandler.js";
 import { NextCommandAction } from "./commandHandler.js";
@@ -22,7 +25,6 @@ export async function run() {
     await output.commentAndLog(`Agent configured to use ${config.agent.shellModel} model`);
     // Show System Message
     await output.commentAndLog("System Message:");
-    const systemMessage = contextManager.getSystemMessage();
     output.write(systemMessage);
     await logService.write({
         role: LlmRole.System,
@@ -31,6 +33,7 @@ export async function run() {
     });
     let nextCommandAction = NextCommandAction.Continue;
     let llmErrorCount = 0;
+    let nextPromptIndex = 0;
     while (nextCommandAction != NextCommandAction.ExitApplication) {
         inputMode.toggle(InputMode.LLM);
         await output.commentAndLog("Starting Context:");
@@ -40,30 +43,34 @@ export async function run() {
             await contextManager.append(latestDream);
         }
         for (const initialCommand of config.agent.initialCommands) {
-            const prompt = await promptBuilder.getPrompt(0, false);
-            await contextManager.append(prompt, ContentSource.ConsolePrompt);
+            let prompt = await promptBuilder.getPrompt(0, false);
+            prompt = setPromptIndex(prompt, ++nextPromptIndex);
+            await contextManager.append(prompt, ContentSource.ConsolePrompt, nextPromptIndex);
             await commandHandler.processCommand(prompt, config.resolveConfigVars(initialCommand));
         }
         inputMode.toggle(InputMode.Debug);
         let pauseSeconds = config.agent.debugPauseSeconds;
         let wakeOnMessage = config.agent.wakeOnMessage;
         while (nextCommandAction == NextCommandAction.Continue) {
-            const prompt = await promptBuilder.getPrompt(pauseSeconds, wakeOnMessage);
+            let prompt = await promptBuilder.getPrompt(pauseSeconds, wakeOnMessage);
             let consoleInput = "";
             // Debug command prompt
             if (inputMode.current === InputMode.Debug) {
+                subagent.unreadContextSummary();
                 consoleInput = await promptBuilder.getInput(`${prompt}`, pauseSeconds, wakeOnMessage);
             }
             // LLM command prompt
             else if (inputMode.current === InputMode.LLM) {
+                prompt = setPromptIndex(prompt, ++nextPromptIndex);
                 const workingMsg = prompt +
-                    chalk[output.OutputColor.loading](`LLM (${config.agent.shellModel}) Working...`);
+                    chalk[OutputColor.loading](`LLM (${config.agent.shellModel}) Working...`);
                 try {
                     await checkNewMailNotification();
                     await checkContextLimitWarning();
-                    await contextManager.append(prompt, ContentSource.ConsolePrompt);
+                    await workspaces.displayActive();
+                    await contextManager.append(prompt, ContentSource.ConsolePrompt, nextPromptIndex);
                     process.stdout.write(workingMsg);
-                    consoleInput = await llmService.query(config.agent.shellModel, contextManager.getSystemMessage(), contextManager.messages, "console");
+                    consoleInput = await llmService.query(config.agent.shellModel, systemMessage, contextManager.getCombinedMessages(), "console");
                     clearPromptMessage(workingMsg);
                 }
                 catch (e) {
@@ -101,6 +108,7 @@ export async function run() {
             llmynx.clear();
             contextManager.clear();
             nextCommandAction = NextCommandAction.Continue;
+            nextPromptIndex = 0;
         }
     }
 }
@@ -178,7 +186,7 @@ async function checkNewMailNotification() {
         for (const unreadThread of unreadThreads) {
             await llmail.markAsRead(unreadThread.threadId);
         }
-        mailBlackoutCountdown = config.mailBlackoutCycles;
+        mailBlackoutCountdown = config.agent.mailBlackoutCycles || 0;
     }
     else if (llmail.simpleMode) {
         await contextManager.append(`You have new mail, but not enough context to read them.\n` +
@@ -196,11 +204,34 @@ async function checkContextLimitWarning() {
     const tokenCount = contextManager.getTokenCount();
     const tokenMax = config.agent.tokenMax;
     if (tokenCount > tokenMax) {
-        await contextManager.append(`The token limit for this session has been exceeded.
-Use \`endsession <note>\` to clear the console and reset the session.
+        let tokenNote = "";
+        if (config.endSessionEnabled) {
+            tokenNote += `\nUse 'endsession <note>' to clear the console and reset the session.
   The note should help you find your bearings in the next session. 
-  The note should contain your next goal, and important things should you remember.
-  Try to keep the note around 400 tokens.`, ContentSource.Console);
+  The note should contain your next goal, and important things should you remember.`;
+        }
+        if (config.trimSessionEnabled) {
+            tokenNote += `\nUse 'trimsession' to reduce the size of the session.
+  Use comments to remember important things from trimmed prompts.`;
+        }
+        await contextManager.append(`The token limit for this session has been exceeded.${tokenNote}`, ContentSource.Console);
+    }
+}
+/** Insert prompt index [Index: 1] before the $.
+ * Insert at the end of the prompt so that 'prompt splitting' still works in the command handler
+ */
+function setPromptIndex(prompt, index) {
+    if (!config.trimSessionEnabled) {
+        return prompt;
+    }
+    let newPrompt = prompt;
+    const endPromptPos = prompt.lastIndexOf("$");
+    if (endPromptPos != -1) {
+        newPrompt =
+            prompt.slice(0, endPromptPos) +
+                ` [Index: ${index}]` +
+                prompt.slice(endPromptPos);
     }
+    return newPrompt;
 }
 //# sourceMappingURL=commandLoop.js.map

package/dist/command/promptBuilder.js

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import * as events from "events";
 import * as readline from "readline";
-import * as llmail from "../apps/llmail.js";
 import * as config from "../config.js";
+import * as llmail from "../features/llmail.js";
 import * as contextManager from "../llm/contextManager.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
@@ -17,6 +17,7 @@ const _outputEmitter = new events.EventEmitter();
 const _originalWrite = process.stdout.write.bind(process.stdout);
 process.stdout.write = (...args) => {
     _outputEmitter.emit(_writeEventName, false, ...args);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return _originalWrite.apply(process.stdout, args);
 };
 const _readlineInterface = readline.createInterface({

package/dist/command/shellCommand.js

@@ -6,49 +6,45 @@ import * as utilities from "../utils/utilities.js";
 import * as shellWrapper from "./shellWrapper.js";
 export async function handleCommand(input) {
     const cmdParams = input.split(" ");
-    const response = {
-        hasErrors: true,
-    };
     // Route user to context friendly edit commands that can read/write the entire file in one go
     // Having EOF in quotes is important as it prevents the shell from replacing $variables with bash values
     if (["nano", "vi", "vim"].includes(cmdParams[0])) {
-        await contextManager.append(`${cmdParams[0]} not supported. Use \`cat\` to read a file and \`cat > filename << 'EOF'\` to write a file`);
-        return response;
+        throw `${cmdParams[0]} not supported. Use \`cat\` to read a file and \`cat > filename << 'EOF'\` to write a file`;
     }
     if (cmdParams[0] == "lynx" && cmdParams[1] != "--dump") {
-        await contextManager.append(`Interactive mode with lynx is not supported. Use --dump with lynx to view a website`);
-        return response;
+        throw `Interactive mode with lynx is not supported. Use --dump with lynx to view a website`;
     }
     if (cmdParams[0] == "exit") {
         if (inputMode.current == InputMode.LLM) {
-            await contextManager.append("Use 'endsession' to end the session and clear the console log.");
+            throw "Use 'endsession' to end the session and clear the console log.";
         }
+        // Only the debug user is allowed to exit the shell
         else if (inputMode.current == InputMode.Debug) {
             await shellWrapper.terminate();
-            response.terminate = true;
+            return true;
         }
-        return response;
     }
-    const output = await shellWrapper.executeCommand(input);
-    if (output.value) {
-        let text = output.value;
-        let outputLimitExceeded = false;
-        const tokenCount = utilities.getTokenCount(text);
-        // Prevent too much output from blowing up the context
-        if (tokenCount > config.shellOutputTokenMax) {
-            outputLimitExceeded = true;
-            const trimLength = (text.length * config.shellOutputTokenMax) / tokenCount;
-            text =
-                text.slice(0, trimLength / 2) +
-                    "\n\n...\n\n" +
-                    text.slice(-trimLength / 2);
-        }
-        await contextManager.append(text);
-        if (outputLimitExceeded) {
-            await contextManager.append(`\nThe shell command generated too much output (${tokenCount} tokens). Only 2,000 tokens worth are shown above.`);
-        }
+    let response = await shellWrapper.executeCommand(input);
+    let outputLimitExceeded = false;
+    const tokenCount = utilities.getTokenCount(response);
+    // Prevent too much output from blowing up the context
+    if (tokenCount > config.shellCommand.outputTokenMax) {
+        outputLimitExceeded = true;
+        const trimLength = (response.length * config.shellCommand.outputTokenMax) / tokenCount;
+        response =
+            response.slice(0, trimLength / 2) +
+                "\n\n...\n\n" +
+                response.slice(-trimLength / 2);
+    }
+    if (outputLimitExceeded) {
+        response += `\nThe shell command generated too much output (${tokenCount} tokens). Only 2,000 tokens worth are shown above.`;
+    }
+    if (response.endsWith(": command not found")) {
+        response +=
+            "Please enter a valid Linux or NAISYS command after the prompt. Use the 'comment' command for thoughts.";
     }
-    response.hasErrors = output.hasErrors;
-    return response;
+    // todo move this into the command handler to remove the context manager dependency
+    await contextManager.append(response);
+    return false;
 }
 //# sourceMappingURL=shellCommand.js.map