@tyvm/knowhow 0.0.35 → 0.0.37

package/src/agents/vim/vim.ts

@@ -1,152 +0,0 @@
-import * as fs from "fs";
-import { Message } from "../../clients/types";
-import { AgentContext, BaseAgent } from "../base/base";
-import { readFile, writeFile, execAsync, mkdir } from "../../utils";
-import { openai, singlePrompt, Models } from "../../ai";
-import { BASE_PROMPT } from "../base/prompt";
-
-export class VimAgent extends BaseAgent {
-  name = "Vimmer";
-  description = `This agent is prepared to modify files in the codebase by using vim`;
-
-  toolPath = ".knowhow/tools/vim";
-
-  constructor(context: AgentContext) {
-    super(context);
-    // this.disableTool("patchFile");
-    this.setModelPreferences([
-      { model: Models.anthropic.Sonnet4, provider: "anthropic" },
-    ]);
-  }
-
-  async saveVimGuide() {
-    const vimrc = await execAsync("cat ~/.vim/vimrc");
-    await 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 singlePrompt(vimRcPrompt);
-    await writeFile(".knowhow/tools/vim/guide.md", extraction);
-  }
-
-  async getVimGuide() {
-    if (!fs.existsSync(".knowhow/tools/vim/guide.md")) {
-      await this.saveVimGuide();
-    }
-
-    const guide = await readFile(".knowhow/tools/vim/guide.md");
-    return guide;
-  }
-
-  async getInitialMessages(userInput: string) {
-    return [
-      {
-        role: "system",
-        content: `
-          ${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 },
-    ] as Message[];
-  }
-}
-

package/src/chat2.ts

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * New Modular Chat Interface - Simplified and cleaner than original chat.ts
- */
-
-import { CliChatService } from "./chat/CliChatService.js";
-import { InternalChatModule } from "./chat/modules/InternalChatModule.js";
-import { getConfig } from "./config.js";
-
-async function main() {
-  try {
-    // Load configuration and plugins
-    let config;
-    try {
-      config = await getConfig();
-    } catch (configError) {
-      console.warn(
-        "Warning: Could not load config, using default plugins:",
-        configError
-      );
-      config = {
-        plugins: [
-          "embeddings",
-          "language",
-          "vim",
-          "github",
-          "asana",
-          "jira",
-          "linear",
-          "download",
-          "figma",
-          "url",
-        ],
-      };
-    }
-
-    // Create chat service with plugins
-    const chatService = new CliChatService(config.plugins);
-
-    // Load internal chat module (includes all core functionality)
-    const internalModule = new InternalChatModule();
-    await internalModule.initialize(chatService);
-
-    // Start the chat loop
-    await chatService.startChatLoop();
-  } catch (error) {
-    console.error("Error starting chat:", error);
-    process.exit(1);
-  }
-}
-
-// Check if this file is being run directly
-const isMainModule =
-  (process.argv[1] && process.argv[1].endsWith("chat2.ts")) ||
-  (process.argv[1] && process.argv[1].endsWith("chat2.js"));
-
-if (isMainModule) {
-  main().catch(console.error);
-}
-
-export { main as startChat2 };