@tyvm/knowhow 0.0.93 → 0.0.94

package/ts_build/src/agents/tools/github/index.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPullRequestBuildFailureLogs = exports.getRunLogs = exports.getPullRequestBuildStatuses = exports.getPullRequest = void 0;
-const rest_1 = require("@octokit/rest");
-const execCommand_1 = require("../execCommand");
-const octokit = new rest_1.Octokit({
-    auth: process.env.GITHUB_TOKEN,
-});
-async function getPullRequest(url) {
-    const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
-    const pullRequest = await octokit.rest.pulls.get({
-        owner,
-        repo,
-        pull_number: parseInt(pullNumber, 10),
-    });
-    return pullRequest;
-}
-exports.getPullRequest = getPullRequest;
-async function getPullRequestBuildStatuses(url) {
-    const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
-    const pullRequest = await octokit.rest.pulls.get({
-        owner,
-        repo,
-        pull_number: parseInt(pullNumber, 10),
-    });
-    const { data: statuses } = await octokit.rest.checks.listForRef({
-        owner,
-        repo,
-        ref: pullRequest.data.head.sha,
-    });
-    return statuses;
-}
-exports.getPullRequestBuildStatuses = getPullRequestBuildStatuses;
-async function getRunLogs(runId, owner, repo) {
-    const logs = await (0, execCommand_1.execCommand)(`gh run view ${runId} -R ${owner}/${repo} --log`);
-    return logs;
-}
-exports.getRunLogs = getRunLogs;
-async function getPullRequestBuildFailureLogs(url) {
-    const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
-    const statuses = await getPullRequestBuildStatuses(url);
-    const failures = statuses.check_runs.filter((status) => status.conclusion === "failure");
-    if (failures.length === 0) {
-        return "No failures found";
-    }
-    const allLogs = [];
-    for (const fail of failures) {
-        const [runId, __, jobId] = fail.details_url.split("/").slice(-3);
-        const logs = await (0, execCommand_1.execCommand)(`gh run view ${runId} -R ${owner}/${repo} --log | grep -E 'FAIL|ERROR' -A 25 -B 25`);
-        return logs;
-        allLogs.push(logs);
-    }
-    return allLogs;
-}
-exports.getPullRequestBuildFailureLogs = getPullRequestBuildFailureLogs;
-//# sourceMappingURL=index.js.map

package/ts_build/src/agents/tools/github/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/agents/tools/github/index.ts"],"names":[],"mappings":";;;AAAA,wCAAwC;AAExC,gDAA6C;AAE7C,MAAM,OAAO,GAAG,IAAI,cAAO,CAAC;IAC1B,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY;CAC/B,CAAC,CAAC;AAEI,KAAK,UAAU,cAAc,CAAC,GAAW;IAC9C,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;QAC/C,KAAK;QACL,IAAI;QACJ,WAAW,EAAE,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC;KACtC,CAAC,CAAC;IAEH,OAAO,WAAW,CAAC;AACrB,CAAC;AATD,wCASC;AAEM,KAAK,UAAU,2BAA2B,CAAC,GAAW;IAC3D,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;QAC/C,KAAK;QACL,IAAI;QACJ,WAAW,EAAE,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC;KACtC,CAAC,CAAC;IAEH,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAC9D,KAAK;QACL,IAAI;QACJ,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;KAC/B,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAhBD,kEAgBC;AAEM,KAAK,UAAU,UAAU,CAAC,KAAa,EAAE,KAAa,EAAE,IAAY;IACzE,MAAM,IAAI,GAAG,MAAM,IAAA,yBAAW,EAC5B,eAAe,KAAK,OAAO,KAAK,IAAI,IAAI,QAAQ,CACjD,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC;AALD,gCAKC;AAEM,KAAK,UAAU,8BAA8B,CAAC,GAAW;IAC9D,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,MAAM,QAAQ,GAAG,MAAM,2BAA2B,CAAC,GAAG,CAAC,CAAC;IACxD,MAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CACzC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAC5C,CAAC;IAEF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACzB,OAAO,mBAAmB,CAAC;KAC5B;IAED,MAAM,OAAO,GAAG,EAAE,CAAC;IACnB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE;QAC3B,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,MAAM,IAAI,GAAG,MAAM,IAAA,yBAAW,EAC5B,eAAe,KAAK,OAAO,KAAK,IAAI,IAAI,2CAA2C,CACpF,CAAC;QACF,OAAO,IAAI,CAAC;QACZ,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACpB;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAtBD,wEAsBC"}

package/ts_build/src/agents/tools/startChatTask.d.ts

@@ -1,13 +0,0 @@
-import { Tool } from "../../clients/types";
-interface StartAgentTaskParams {
-    messageId: string;
-    prompt: string;
-    provider?: string;
-    model?: string;
-    agentName?: string;
-    maxTimeLimit?: number;
-    maxSpendLimit?: number;
-}
-export declare function startAgentTask(params: StartAgentTaskParams): Promise<string>;
-export declare const startAgentTaskDefinition: Tool;
-export {};

package/ts_build/src/agents/tools/startChatTask.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startAgentTaskDefinition = exports.startAgentTask = void 0;
-const execCommand_1 = require("./execCommand");
-async function startAgentTask(params) {
-    const { messageId, prompt, provider, model, agentName, maxTimeLimit, maxSpendLimit, } = params;
-    if (!messageId) {
-        throw new Error("messageId is required to create a chat task");
-    }
-    if (!prompt) {
-        throw new Error("prompt is required to create a chat task");
-    }
-    let command = `knowhow agent --input "${prompt}" --message-id ${messageId}`;
-    if (provider) {
-        command += ` --provider ${provider}`;
-    }
-    if (model) {
-        command += ` --model "${model}"`;
-    }
-    if (agentName) {
-        command += ` --agent-name "${agentName}"`;
-    }
-    if (maxTimeLimit !== undefined) {
-        command += ` --max-time-limit ${maxTimeLimit}`;
-    }
-    if (maxSpendLimit !== undefined) {
-        command += ` --max-spend-limit ${maxSpendLimit}`;
-    }
-    return (0, execCommand_1.execCommand)(command, 60000, true);
-}
-exports.startAgentTask = startAgentTask;
-exports.startAgentTaskDefinition = {
-    type: "function",
-    function: {
-        name: "startAgentTask",
-        description: "Create a new chat task in Knowhow based on a message ID and prompt. This allows worker agents to start tasks and update knowhow's backend with all CLI agent options",
-        parameters: {
-            type: "object",
-            properties: {
-                messageId: {
-                    type: "string",
-                    description: "The ID of the message in Knowhow to associate with this task",
-                },
-                prompt: {
-                    type: "string",
-                    description: "The prompt or description for the task to be created",
-                },
-                provider: {
-                    type: "string",
-                    description: "AI provider (openai, anthropic, google, xai). Default: openai",
-                },
-                model: {
-                    type: "string",
-                    description: "Specific model for the provider",
-                },
-                agentName: {
-                    type: "string",
-                    description: "Which agent to use. Default: Patcher",
-                },
-                maxTimeLimit: {
-                    type: "number",
-                    description: "Time limit for agent execution in minutes. Default: 30",
-                },
-                maxSpendLimit: {
-                    type: "number",
-                    description: "Cost limit for agent execution in dollars. Default: 10",
-                },
-            },
-            required: ["messageId", "prompt"],
-        },
-    },
-};
-//# sourceMappingURL=startChatTask.js.map

package/ts_build/src/agents/tools/startChatTask.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"startChatTask.js","sourceRoot":"","sources":["../../../../src/agents/tools/startChatTask.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAgBrC,KAAK,UAAU,cAAc,CAAC,MAA4B;IAC/D,MAAM,EACJ,SAAS,EACT,MAAM,EACN,QAAQ,EACR,KAAK,EACL,SAAS,EACT,YAAY,EACZ,aAAa,GACd,GAAG,MAAM,CAAC;IAEX,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;KAChE;IAED,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;KAC7D;IAGD,IAAI,OAAO,GAAG,0BAA0B,MAAM,kBAAkB,SAAS,EAAE,CAAC;IAE5E,IAAI,QAAQ,EAAE;QACZ,OAAO,IAAI,eAAe,QAAQ,EAAE,CAAC;KACtC;IAED,IAAI,KAAK,EAAE;QACT,OAAO,IAAI,aAAa,KAAK,GAAG,CAAC;KAClC;IAED,IAAI,SAAS,EAAE;QACb,OAAO,IAAI,kBAAkB,SAAS,GAAG,CAAC;KAC3C;IAED,IAAI,YAAY,KAAK,SAAS,EAAE;QAC9B,OAAO,IAAI,qBAAqB,YAAY,EAAE,CAAC;KAChD;IAED,IAAI,aAAa,KAAK,SAAS,EAAE;QAC/B,OAAO,IAAI,sBAAsB,aAAa,EAAE,CAAC;KAClD;IAED,OAAO,IAAA,yBAAW,EAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AA3CD,wCA2CC;AAEY,QAAA,wBAAwB,GAAS;IAC5C,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE;QACR,IAAI,EAAE,gBAAgB;QACtB,WAAW,EACT,sKAAsK;QACxK,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,SAAS,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,8DAA8D;iBACjE;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,sDAAsD;iBACpE;gBACD,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,+DAA+D;iBAClE;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,iCAAiC;iBAC/C;gBACD,SAAS,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,sCAAsC;iBACpD;gBACD,YAAY,EAAE;oBACZ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,wDAAwD;iBACtE;gBACD,aAAa,EAAE;oBACb,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,wDAAwD;iBACtE;aACF;YACD,QAAQ,EAAE,CAAC,WAAW,EAAE,QAAQ,CAAC;SAClC;KACF;CACF,CAAC"}

package/ts_build/src/agents/vim/vim.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Message } from "../../clients/types";
-import { AgentContext, BaseAgent } from "../base/base";
-export declare class VimAgent extends BaseAgent {
-    name: string;
-    description: string;
-    toolPath: string;
-    constructor(context: AgentContext);
-    saveVimGuide(): Promise<void>;
-    getVimGuide(): Promise<Buffer>;
-    getInitialMessages(userInput: string): Promise<Message[]>;
-}

package/ts_build/src/agents/vim/vim.js

@@ -1,170 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VimAgent = void 0;
-const fs = __importStar(require("fs"));
-const base_1 = require("../base/base");
-const utils_1 = require("../../utils");
-const ai_1 = require("../../ai");
-const prompt_1 = require("../base/prompt");
-class VimAgent extends base_1.BaseAgent {
-    name = "Vimmer";
-    description = `This agent is prepared to modify files in the codebase by using vim`;
-    toolPath = ".knowhow/tools/vim";
-    constructor(context) {
-        super(context);
-        this.setModelPreferences([
-            { model: ai_1.Models.anthropic.Sonnet4, provider: "anthropic" },
-        ]);
-    }
-    async saveVimGuide() {
-        const vimrc = await (0, utils_1.execAsync)("cat ~/.vim/vimrc");
-        await (0, utils_1.mkdir)(this.toolPath, { recursive: true });
-        const vimRcPrompt = `Extract a minimal format of commands and hotkeys that an ai could leverage from this vimrc ${vimrc.stdout}. Only output the hotkeys and commands you see, nothing else`;
-        const extraction = await (0, ai_1.singlePrompt)(vimRcPrompt);
-        await (0, utils_1.writeFile)(".knowhow/tools/vim/guide.md", extraction);
-    }
-    async getVimGuide() {
-        if (!fs.existsSync(".knowhow/tools/vim/guide.md")) {
-            await this.saveVimGuide();
-        }
-        const guide = await (0, utils_1.readFile)(".knowhow/tools/vim/guide.md");
-        return guide;
-    }
-    async getInitialMessages(userInput) {
-        return [
-            {
-                role: "system",
-                content: `
-          ${prompt_1.BASE_PROMPT}
-
-          Specialization: Vim Agent, ${this.description}
-
-					# General Instructions
-
-					You are a software engineering agent. You use tools to gather context on a user's request, answer questions, and create modifications to files in order to help the user work on a codebase.
-					Some user requests require you to investigate many files, and gather context before attempting to modify anything. If a user asks a question about the codebase or if you need more context on something before making modifications, you should ask the Researcher agent for help by using the agentCall tool.
-
-					You are a vim specialist, and you primarily use the VIM tools (sendVimInput) to make edits to files. You are primarily operating as a terminal app that the user runs from their current working directory.
-					The sendVimInput function will open a blank vim process in the user's working directory.
-					Make sure to open the file you are working on at the beginning, as you are in a blank vim session.
-					Use :e <filename>\\n to open a file, and <ESCAPE>:w\\n to save it.
-					Make sure to send the proper escape ('<ESCAPE>') and save commands after modifying a file.
-					Make sure to use ESCAPE to exit insert mode before attempting to execute commands like (<ESCAPE>:w\\n).
-					When executing commands, make sure you actually execute them by including a newline character after the command.
-					If you do not include the newline, it will not actually execute the command.
-					Make sure you use the typical vim keys to move and enter modes, <ESCAPE> and <ENTER> are specially supported tags, but the rest of the inputs should be the normally supported vim keys that you would press on the keyboard.
-
-
-
-					# Interaction Loop
-					Using the editor should follow an interaction loop:
-					1. First open the editor.
-					2. Attempt to open the file you want to edit.
-							 2.a IMPORTANT: DO NOT SEND ANY OTHER COMMANDS, VERIFY THE FILE HAS OPENED CORRECTLY.
-							 2.b If the file did not open correctly, you will need to close vim and re-open it to try again.
-							 2.c If you expect a file to have text, and you do not get any text in the terminal output after attempting to open it, there is a high likelihood the file was not opened correctly and you should try again. If you see [No Name] that also may indicate the file was not opened correctly.
-							 2.d After opening a file, verify that you are in the correct buffer by checking for the expected file name in the terminal output. If the output shows [No Name] or another buffer name, close Vim and retry opening the correct file.
-					3. Inspect the response from openFileInVim to determine if the file was opened.
-						 * Check for any errors or prompts that may have occurred, respond to them if so.
-					4. Use sendVimInput to modify the file in vim.
-						 * Do not use <ESCAPE> while typing, unless you want to exit insert mode.
-					5. Save your changes via <ESCAPE>:w\\n or saveVimFile .
-						 * From the returned terminal outputs, determine if the changes went as expected.
-					6. ALWAYS use readFile tool to check your work after saving.
-						 * Based off the results, you may need to undo and then save.
-						 * As long as vim has not been closed, you can send :u0 or use u to undo
-						 * You may also leverage git diff
-					7. If you discover there were errors to your changes, attempt to fix them by repeating steps 4-6,
-            * After failing a twice, you should enter paste mode and output the expected contents of the file to vim.
-					8. After completing your task and checking your work, you MUST call finalAnswer.
-
-
-
-					After each sendVimInput, the function response will contain the changes in the vim terminal. Inspect that response to get an understanding of what is happening in the editor.
-
-					The vim process will remain open, and you can correct your current state by responding to the state of the terminal.
-					It may help to execute fewer commands up front until you're confident you have opened the file you want to edit.
-					If you check a file after your changes and find that some input has messed it up, and you've saved, you can undo your changes with :u0, or use the undo command to go back one change at a time.
-
-					Use multiple interactions with sendVimInput to make changes to the file, inspecting the response each time to ensure the current state of vim is as expected.
-					Since vim is interactive, you may be required to respond to prompts the program asks in order to proceed, you will need to monitor the response from sendVimInput to know when and how to respond to these prompts.
-
-					# Using ESCAPE to change modes
-					<ESCAPE> should only be used to change vim modes.
-					Once you are in insert mode, be careful not to send <ESCAPE> as part of the text you are entering.
-					When you go to exit insert mode, to save, or run some other :command, you MUST send <ESCAPE> before the command.
-
-					# User's active vim plugins
-					Here's a guide on what plugins and features are currently enabled in vim:
-					START VIM GUIDE
-					${await this.getVimGuide()}
-					END VIM GUIDE
-
-					# Programming Instructions
-					After modifying source code, you must run the auto-format before saving with gg=G or any plugin commands for formatting.
-          All inserted code should be properly indented and styled consistently with the surrounding code.
-					Ensure that you follow programming best practices, style best practices, and ensure that the syntax of the file is correct.
-					Pay very close attention to text around your changes, as you may inadvertently affect or break the surrounding code if you inserted code in the wrong place.
-
-					The vim plugins may include auto-completes, auto-indents etc that will impact bulk inserting of lines of text.
-					If you do not need to leverage those features, then you should enable paste mode via :set paste and :set nopaste to disable it after inserting your fully formatted text.
-					The editor may assume comments continue on the next line, or do other syntax auto completions, so make sure to check the actual state of a file, and make corrections if the editor over-corrected your input, or use paste mode to ensure your input goes in unaffected.
-					Commenting out code: You may want to use I to begin inserting at the beginning of a line, that way you ensure you're commenting out the entire line.
-					Searching to insert: Keep in mind that when you search, your cursor will be at the first character of what you searched for, so you may need to start inserting on the line below, or at the start of a line, or use movement keys after the search to ensure the cursor is in the correct location before inserting.
-					Make sure you append <ENTER> when searching or executing commands otherwise they won't be executed.
-					IMPORTANT: You MUST enable paste mode when inserting comments, otherwise you'll end up commenting out all your inserted code.
-
-					## Navigating / Inserting Code
-				1. After saving, you may see some QuickFix suggestions in the terminal output. If so, you should check your changes and see if that feedback needs to be addressed before finalizing your work.
-						 1.a If you make unintended changes you should undo via :u0 and save to get back to a clean state before making corrections.
-						 1.b If you see QuickFix suggestions, you likely need to close the QuickFix menu before you can save again, as that buffer will start intercepting your save requests and lead you to believe the buffer is no longer modifiable.
-
-					## Handling Quickfix Buffers
-					When working with Vim, if a Quickfix buffer opens (e.g., after saving a file), ensure you are in the correct buffer before executing further commands. Quickfix buffers are usually non-modifiable and can intercept commands like saving, leading to errors.
-					- Use :cclose to close the Quickfix buffer before proceeding if it opens unexpectedly.
-					- Always verify the current buffer before making modifications by checking the filename displayed in the terminal output.
-
-					# Error Handling and Recovery
-					- If an error is encountered (e.g., "modifiable" is off), pause and diagnose the issue. Do not continue sending commands that might exacerbate the problem.
-					- Use :u to undo the last change if it was executed incorrectly. If you’ve saved incorrect changes, use :u0 to reset to the last saved state before retrying.
-					- If Vim enters an unexpected state (e.g., Quickfix buffer intercepts commands), close Vim and restart from a clean state to avoid compounding errors.
-
-					Some QuickFix hints are only shown after saving a file. So a trick to see if a file has any suggestions, would be to open it, and then immediately save without making any changes, that way you can review the QuickFix suggestions.
-
-					# Completing a task
-					When you have completed your task make sure to call closeVim before calling finalAnswer.
-					You may use the execCommand tool to navigate the filesystem and to create new folders if needed.
-					You MUST eventually call finalAnswer when you are done.
-					Accomplish the user's goal with the tools at hand, good luck!
-
-				`,
-            },
-            { role: "user", content: userInput },
-        ];
-    }
-}
-exports.VimAgent = VimAgent;
-//# sourceMappingURL=vim.js.map

package/ts_build/src/agents/vim/vim.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vim.js","sourceRoot":"","sources":["../../../../src/agents/vim/vim.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyB;AAEzB,uCAAuD;AACvD,uCAAoE;AACpE,iCAAwD;AACxD,2CAA6C;AAE7C,MAAa,QAAS,SAAQ,gBAAS;IACrC,IAAI,GAAG,QAAQ,CAAC;IAChB,WAAW,GAAG,qEAAqE,CAAC;IAEpF,QAAQ,GAAG,oBAAoB,CAAC;IAEhC,YAAY,OAAqB;QAC/B,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,mBAAmB,CAAC;YACvB,EAAE,KAAK,EAAE,WAAM,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE;SAC3D,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,YAAY;QAChB,MAAM,KAAK,GAAG,MAAM,IAAA,iBAAS,EAAC,kBAAkB,CAAC,CAAC;QAClD,MAAM,IAAA,aAAK,EAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,MAAM,WAAW,GAAG,8FAA8F,KAAK,CAAC,MAAM,8DAA8D,CAAC;QAC7L,MAAM,UAAU,GAAG,MAAM,IAAA,iBAAY,EAAC,WAAW,CAAC,CAAC;QACnD,MAAM,IAAA,iBAAS,EAAC,6BAA6B,EAAE,UAAU,CAAC,CAAC;IAC7D,CAAC;IAED,KAAK,CAAC,WAAW;QACf,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC,EAAE;YACjD,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;SAC3B;QAED,MAAM,KAAK,GAAG,MAAM,IAAA,gBAAQ,EAAC,6BAA6B,CAAC,CAAC;QAC5D,OAAO,KAAK,CAAC;IACf,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,SAAiB;QACxC,OAAO;YACL;gBACE,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE;YACL,oBAAW;;uCAEgB,IAAI,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4DhD,MAAM,IAAI,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwC1B;aACE;YACD,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE;SACxB,CAAC;IACjB,CAAC;CACF;AA/ID,4BA+IC"}

package/ts_build/src/chat/ChatCommandHandler.d.ts

@@ -1,36 +0,0 @@
-import { ChatSessionManager } from "./ChatSessionManager";
-import { ChatStateManager } from "./ChatStateManager";
-import { ChatSession } from "./ChatSession";
-export interface ChatCommand {
-    name: string;
-    description: string;
-    usage: string;
-    execute: (args: string[], context: ChatCommandContext) => Promise<ChatCommandResult>;
-}
-export interface ChatCommandContext {
-    sessionManager: ChatSessionManager;
-    stateManager: ChatStateManager;
-    currentSession?: ChatSession;
-}
-export interface ChatCommandResult {
-    success: boolean;
-    message: string;
-    data?: any;
-}
-export declare class ChatCommandHandler {
-    private _commands;
-    constructor();
-    executeCommand(input: string, context: ChatCommandContext): Promise<ChatCommandResult>;
-    getAvailableCommands(): ChatCommand[];
-    isCommand(input: string): boolean;
-    private _registerCommands;
-    private _helpCommand;
-    private _sessionsCommand;
-    private _loadCommand;
-    private _saveCommand;
-    private _newCommand;
-    private _deleteCommand;
-    private _statusCommand;
-    private _clearCommand;
-    private _resumeCommand;
-}

package/ts_build/src/chat/ChatCommandHandler.js

@@ -1,268 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatCommandHandler = void 0;
-class ChatCommandHandler {
-    _commands = new Map();
-    constructor() {
-        this._registerCommands();
-    }
-    async executeCommand(input, context) {
-        const parts = input.trim().split(/\s+/);
-        const commandName = parts[0].toLowerCase();
-        const args = parts.slice(1);
-        const command = this._commands.get(commandName);
-        if (!command) {
-            return {
-                success: false,
-                message: `Unknown command: ${commandName}. Type 'help' for available commands.`
-            };
-        }
-        try {
-            return await command.execute(args, context);
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: `Command failed: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    getAvailableCommands() {
-        return Array.from(this._commands.values());
-    }
-    isCommand(input) {
-        return input.trim().startsWith('/') || input.trim().startsWith('\\');
-    }
-    _registerCommands() {
-        this._commands.set('help', {
-            name: 'help',
-            description: 'Show available commands',
-            usage: 'help [command]',
-            execute: this._helpCommand.bind(this)
-        });
-        this._commands.set('sessions', {
-            name: 'sessions',
-            description: 'List recent chat sessions',
-            usage: 'sessions [limit]',
-            execute: this._sessionsCommand.bind(this)
-        });
-        this._commands.set('load', {
-            name: 'load',
-            description: 'Load a previous chat session',
-            usage: 'load <sessionId>',
-            execute: this._loadCommand.bind(this)
-        });
-        this._commands.set('save', {
-            name: 'save',
-            description: 'Save current session with optional title',
-            usage: 'save [title]',
-            execute: this._saveCommand.bind(this)
-        });
-        this._commands.set('new', {
-            name: 'new',
-            description: 'Start a new chat session',
-            usage: 'new [title]',
-            execute: this._newCommand.bind(this)
-        });
-        this._commands.set('delete', {
-            name: 'delete',
-            description: 'Delete a chat session',
-            usage: 'delete <sessionId>',
-            execute: this._deleteCommand.bind(this)
-        });
-        this._commands.set('status', {
-            name: 'status',
-            description: 'Show current chat status',
-            usage: 'status',
-            execute: this._statusCommand.bind(this)
-        });
-        this._commands.set('clear', {
-            name: 'clear',
-            description: 'Clear current session and start fresh',
-            usage: 'clear',
-            execute: this._clearCommand.bind(this)
-        });
-        this._commands.set('resume', {
-            name: 'resume',
-            description: 'Resume paused agent (if any)',
-            usage: 'resume',
-            execute: this._resumeCommand.bind(this)
-        });
-    }
-    async _helpCommand(args, context) {
-        if (args.length > 0) {
-            const commandName = args[0].toLowerCase();
-            const command = this._commands.get(commandName);
-            if (command) {
-                return {
-                    success: true,
-                    message: `${command.name}: ${command.description}\nUsage: ${command.usage}`
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    message: `Unknown command: ${commandName}`
-                };
-            }
-        }
-        const commands = Array.from(this._commands.values());
-        const helpText = [
-            'Available chat commands:',
-            '',
-            ...commands.map(cmd => `  ${cmd.name.padEnd(10)} - ${cmd.description}`),
-            '',
-            'Type "help <command>" for detailed usage information.'
-        ].join('\n');
-        return {
-            success: true,
-            message: helpText
-        };
-    }
-    async _sessionsCommand(args, context) {
-        const limit = args.length > 0 ? parseInt(args[0], 10) : 10;
-        if (isNaN(limit) || limit < 1) {
-            return {
-                success: false,
-                message: 'Invalid limit. Please provide a positive number.'
-            };
-        }
-        const sessions = await context.sessionManager.listSessions(limit);
-        if (sessions.length === 0) {
-            return {
-                success: true,
-                message: 'No chat sessions found.'
-            };
-        }
-        const sessionList = sessions.map((session, index) => {
-            const date = session.lastActive.toLocaleDateString();
-            const time = session.lastActive.toLocaleTimeString();
-            return `  ${(index + 1).toString().padStart(2)}. ${session.sessionId} - "${session.title}" (${date} ${time})`;
-        }).join('\n');
-        return {
-            success: true,
-            message: `Recent chat sessions:\n\n${sessionList}\n\nUse "load <sessionId>" to resume a session.`,
-            data: sessions
-        };
-    }
-    async _loadCommand(args, context) {
-        if (args.length === 0) {
-            return {
-                success: false,
-                message: 'Usage: load <sessionId>'
-            };
-        }
-        const sessionId = args[0];
-        const session = await context.sessionManager.loadSession(sessionId);
-        if (!session) {
-            return {
-                success: false,
-                message: `Session "${sessionId}" not found.`
-            };
-        }
-        context.stateManager.reset();
-        return {
-            success: true,
-            message: `Loaded session "${session.title}" with ${session.threads.length} threads and ${session.chatHistory.length} interactions.`,
-            data: session
-        };
-    }
-    async _saveCommand(args, context) {
-        if (!context.currentSession) {
-            return {
-                success: false,
-                message: 'No active session to save.'
-            };
-        }
-        const title = args.length > 0 ? args.join(' ') : context.currentSession.title;
-        context.currentSession.title = title;
-        await context.sessionManager.saveSession(context.currentSession);
-        return {
-            success: true,
-            message: `Session saved as "${title}"`
-        };
-    }
-    async _newCommand(args, context) {
-        const title = args.length > 0 ? args.join(' ') : 'New Chat Session';
-        const session = await context.sessionManager.createSession(title);
-        context.stateManager.reset();
-        return {
-            success: true,
-            message: `Started new session "${title}" (${session.sessionId})`,
-            data: session
-        };
-    }
-    async _deleteCommand(args, context) {
-        if (args.length === 0) {
-            return {
-                success: false,
-                message: 'Usage: delete <sessionId>'
-            };
-        }
-        const sessionId = args[0];
-        const success = await context.sessionManager.deleteSession(sessionId);
-        if (success) {
-            return {
-                success: true,
-                message: `Session "${sessionId}" deleted.`
-            };
-        }
-        else {
-            return {
-                success: false,
-                message: `Failed to delete session "${sessionId}". It may not exist.`
-            };
-        }
-    }
-    async _statusCommand(args, context) {
-        const state = context.stateManager.state;
-        const stateContext = context.stateManager.context;
-        const session = context.currentSession;
-        const statusLines = [
-            `Chat State: ${context.stateManager.getStateDescription()}`,
-            `Current Session: ${session ? `"${session.title}" (${session.sessionId})` : 'None'}`,
-            `Active Thread: ${stateContext.currentThreadId || 'None'}`,
-            `Current Agent: ${stateContext.currentAgentName || 'None'}`,
-            `Pending Messages: ${stateContext.pendingMessages.length}`,
-            `Waiting for Input: ${stateContext.isWaitingForInput ? 'Yes' : 'No'}`
-        ];
-        if (session) {
-            statusLines.push(`Threads: ${session.threads.length}`);
-            statusLines.push(`Chat History: ${session.chatHistory.length} interactions`);
-        }
-        return {
-            success: true,
-            message: statusLines.join('\n')
-        };
-    }
-    async _clearCommand(args, context) {
-        context.stateManager.reset();
-        return {
-            success: true,
-            message: 'Session cleared. Ready for new task.'
-        };
-    }
-    async _resumeCommand(args, context) {
-        if (!context.stateManager.canResumeAgent) {
-            return {
-                success: false,
-                message: `Cannot resume agent. Current state: ${context.stateManager.getStateDescription()}`
-            };
-        }
-        const success = context.stateManager.transition({ type: 'AGENT_RESUME' });
-        if (success) {
-            return {
-                success: true,
-                message: `Resumed agent "${context.stateManager.context.currentAgentName}"`
-            };
-        }
-        else {
-            return {
-                success: false,
-                message: 'Failed to resume agent'
-            };
-        }
-    }
-}
-exports.ChatCommandHandler = ChatCommandHandler;
-//# sourceMappingURL=ChatCommandHandler.js.map