@tyvm/knowhow 0.0.21 → 0.0.23

package/src/agents/vim/vim.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import { Message } from "../../clients/types";
-import { BaseAgent } from "../base/base";
+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";
@@ -11,8 +11,8 @@ export class VimAgent extends BaseAgent {
 
   toolPath = ".knowhow/tools/vim";
 
-  constructor() {
-    super();
+  constructor(context: AgentContext) {
+    super(context);
     // this.disableTool("patchFile");
     this.setModelPreferences([
       { model: Models.anthropic.Sonnet4, provider: "anthropic" },
@@ -150,4 +150,3 @@ export class VimAgent extends BaseAgent {
   }
 }
 
-export const Vimmer = new VimAgent();

package/src/ai.ts

@@ -11,7 +11,7 @@ const config = getConfigSync();
 const OPENAI_KEY = process.env.OPENAI_KEY;
 
 import { Models } from "./types";
-import { Agents } from "./services";
+import { services } from "./services";
 export { Models };
 
 export const openai = new OpenAI({
@@ -20,6 +20,7 @@ export const openai = new OpenAI({
 });
 
 export async function singlePrompt(userPrompt: string, model = "", agent = "") {
+  const { Agents } = services();
   if (agent) {
     const agentConfig = await Agents.getAgent(agent);
     if (!agentConfig) {

package/src/chat.ts

@@ -13,10 +13,10 @@ import { Marked } from "./utils";
 import { ask } from "./utils";
 import { Plugins } from "./plugins/plugins";
 import { queryEmbedding, getConfiguredEmbeddingMap } from "./embeddings";
-import { Agents } from "./services/AgentService";
+import { services } from "./services/";
 import { FlagsService } from "./services/flags";
 import { IAgent } from "./agents/interface";
-import { Clients, Message } from "./clients";
+import { Message } from "./clients";
 import { recordAudio, voiceToText } from "./microphone";
 import { Models } from "./ai";
 import { BaseAgent } from "./agents";
@@ -129,6 +129,7 @@ The user has asked:
     { role: "user", content: gptPrompt },
   ] as Message[];
 
+  const { Clients } = services();
   const response = await Clients.createCompletion(provider, {
     messages: thread,
     model,
@@ -182,6 +183,7 @@ export async function chatLoop<E extends GptQuestionEmbedding>(
   embeddings: Embeddable<E>[],
   plugins: string[] = []
 ) {
+  const { Agents, Clients } = services();
   let activeAgent = Agents.getAgent("Developer") as BaseAgent;
   let provider = "openai" as keyof typeof Clients.clients;
   let model = ChatModelDefaults[provider];

package/src/cli.ts

@@ -4,32 +4,24 @@ import { generate, embed, upload, chat } from "./index";
 import { init } from "./config";
 
 import { download, purge } from ".";
-import { Agents } from "./services/AgentService";
-import { Researcher } from "./agents/researcher/researcher";
-import { Patcher } from "./agents/patcher/patcher";
-import { Vimmer } from "./agents/vim/vim";
-import { Developer } from "./agents/developer/developer";
-import { Tools } from "./services";
 import { includedTools } from "./agents/tools/list";
-import * as allTools from "./agents/tools/index";
-import { Mcp } from "./services/Mcp";
+import * as allTools from "./agents/tools";
+import { services } from "./services";
 import { login } from "./login";
 import { worker } from "./worker";
-import { Clients } from "./clients";
+import { agents } from "./agents";
 
 const command = process.argv[2];
 
 async function main() {
+  const { Tools, Agents, Mcp, Clients } = services();
+  const { Researcher, Developer, Patcher } = agents();
   Agents.registerAgent(Researcher);
   Agents.registerAgent(Patcher);
   Agents.registerAgent(Developer);
-  Agents.loadAgentsFromConfig();
-  Tools.addTools(includedTools);
+  Agents.loadAgentsFromConfig(services());
 
-  const toolFunctions = Object.entries(allTools)
-    .filter(([_, value]) => typeof value === 'function')
-    .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-  Tools.addFunctions(toolFunctions);
+  Tools.defineTools(includedTools, allTools);
 
   await Mcp.connectToConfigured(Tools);
   await Clients.registerConfiguredModels();

package/src/clients/index.ts

@@ -153,13 +153,24 @@ export class AIClient {
     );
   }
 
-  private providerHasModel(provider: string, model: string): boolean {
+  providerHasModel(provider: string, model: string): boolean {
     const models = this.clientModels[provider];
     if (!models) return false;
     return models.includes(model);
   }
 
-  private detectProviderModel(provider: string, model?: string) {
+  findModel(modelPrefix: string) {
+    for (const provider of Object.keys(this.clientModels)) {
+      const models = this.clientModels[provider];
+      const foundModel = models.find((m) => m.startsWith(modelPrefix));
+      if (foundModel) {
+        return { provider, model: foundModel };
+      }
+    }
+    return undefined;
+  }
+
+  detectProviderModel(provider: string, model?: string) {
     if (this.providerHasModel(provider, model)) {
       return { provider, model };
     }
@@ -170,18 +181,21 @@ export class AIClient {
       const inferredProvider = split[0];
       const inferredModel = split.slice(1).join("/");
 
+      // Exact match
       if (this.providerHasModel(inferredProvider, inferredModel)) {
         return { provider: inferredProvider, model: inferredModel };
       }
-    }
 
-    const providers = Object.keys(this.clientModels);
-    const foundProvider = providers.find((p) =>
-      this.providerHasModel(p, model)
-    );
+      // Starts with match
+      const foundBySplit = this.findModel(inferredModel);
+      if (foundBySplit) {
+        return foundBySplit;
+      }
+    }
 
-    if (foundProvider) {
-      return { provider: foundProvider, model };
+    const foundByModel = this.findModel(model);
+    if (foundByModel) {
+      return foundByModel;
     }
 
     return { provider, model };

package/src/dataset/diffs/test.ts

@@ -15,6 +15,7 @@ import {
   hunksToPatch,
 } from "../../agents/tools/patch";
 import { md5Hash } from "../../hashes";
+import { services } from "../../services";
 const dataset = [];
 
 class PatchTestAgent extends PatchingAgent {
@@ -44,7 +45,7 @@ class PatchTestAgent extends PatchingAgent {
 }
 
 async function testDataset() {
-  const patchAgent = new PatchTestAgent();
+  const patchAgent = new PatchTestAgent(services());
 
   let successCount = 0;
   let attempts = 0;

package/src/index.ts

@@ -42,10 +42,8 @@ import { abort } from "process";
 import { chatLoop } from "./chat";
 import { convertToText } from "./conversion";
 import { Plugins } from "./plugins/plugins";
-import { AwsS3 } from "./services/S3";
-import { GitHub } from "./services/GitHub";
 import { knowhowMcpClient } from "./services/Mcp";
-import { knowhowApiClient } from "./services/KnowhowClient";
+import { services } from "./services/";
 import { Models } from "./types";
 
 export * as clients from "./clients";
@@ -96,6 +94,7 @@ export async function purge(globPath: string) {
 
 export async function upload() {
   const config = await getConfig();
+  const { AwsS3, knowhowApiClient } = services();
 
   for (const source of config.embedSources) {
     const bucketName = source.remote;
@@ -324,6 +323,7 @@ export async function chat() {
 
 export async function download() {
   const config = await getConfig();
+  const { AwsS3, GitHub, knowhowApiClient } = services();
 
   for (const source of config.embedSources) {
     const { remote, remoteType } = source;

package/src/services/AgentService.ts

@@ -1,18 +1,19 @@
 import { getConfigSync } from "../config";
 import { IAgent } from "../agents/interface";
+import { EventService } from "./EventService";
+import { ToolsService } from "./Tools";
 import { ConfigAgent } from "../agents/configurable/ConfigAgent";
-import { Events } from "./EventService";
-import { Tools } from "./Tools";
+import { AgentContext } from "src/agents/base/base";
 
 export class AgentService {
   private agents: Map<string, IAgent> = new Map();
 
-  constructor() {
+  constructor(private tools: ToolsService, private events: EventService) {
     this.wireUp();
   }
 
   public wireUp() {
-    Tools.addTool({
+    this.tools.addTool({
       type: "function",
       function: {
         name: "agentCall",
@@ -35,13 +36,13 @@ export class AgentService {
         },
       },
     });
-    Events.on("agents:register", (data) => {
+    this.events.on("agents:register", (data) => {
       console.log(`Agent registered: ${data.name}`);
       const { name, agent } = data;
       this.registerAgentByName(name, agent);
     });
 
-    Events.on("agents:call", (data) => {
+    this.events.on("agents:call", (data) => {
       console.log(`Agent called: ${data.name}`);
       const { name, query, resolve, reject } = data;
       this.callAgent(name, query).then(resolve).catch(reject);
@@ -77,12 +78,12 @@ export class AgentService {
     });
   }
 
-  public loadAgentsFromConfig() {
+  public loadAgentsFromConfig(context: AgentContext) {
     const config = getConfigSync();
     const agents = config.agents || [];
 
     for (const agent of agents) {
-      this.registerAgent(new ConfigAgent(agent));
+      this.registerAgent(new ConfigAgent(agent, context));
     }
   }
 
@@ -94,5 +95,3 @@ export class AgentService {
     return agent.call(query);
   }
 }
-
-export const Agents = new AgentService();

package/src/services/EventService.ts

@@ -16,5 +16,3 @@ export class EventService extends EventEmitter {
     });
   }
 }
-
-export const Events = new EventService();

package/src/services/GitHub.ts

@@ -57,4 +57,3 @@ export class GitHubService {
   }
 }
 
-export const GitHub = new GitHubService();

package/src/services/KnowhowClient.ts

@@ -108,6 +108,3 @@ export class KnowhowSimpleClient {
   }
 }
 
-export const knowhowApiClient = new KnowhowSimpleClient(
-  process.env.KNOWHOW_API_URL
-);

package/src/services/Mcp.ts

@@ -286,5 +286,3 @@ export class McpService {
     return transformed;
   }
 }
-
-export const Mcp = new McpService();

package/src/services/S3.ts

@@ -123,4 +123,3 @@ export class S3Service {
   }
 }
 
-export const AwsS3 = new S3Service();

package/src/services/Tools.ts

@@ -1,6 +1,9 @@
 import { ChatCompletionTool } from "openai/resources/chat";
 import { replaceEscapedNewLines, restoreEscapedNewLines } from "../utils";
 import { includedTools } from "../agents/tools/list";
+import { AgentService } from "./AgentService";
+import { EventService } from "./EventService";
+import { AIClient } from "../clients";
 import { Tool, ToolCall } from "../clients/types";
 import {
   ToolOverrideRegistration,
@@ -9,8 +12,20 @@ import {
   ToolWrapper,
   createPatternMatcher,
 } from "./types";
+import { PluginService } from "../plugins/plugins";
+
+export interface ToolContext {
+  Agents?: AgentService;
+  Events?: EventService;
+  Clients?: AIClient;
+  Tools?: ToolsService;
+  Plugins?: PluginService;
+  metadata?: { [key: string]: any };
+}
 
 export class ToolsService {
+  private context: ToolContext = {};
+
   tools = [] as Tool[];
   private overrides: ToolOverrideRegistration[] = [];
   private wrappers: ToolWrapperRegistration[] = [];
@@ -18,6 +33,29 @@ export class ToolsService {
 
   functions = {};
 
+  constructor(context?: ToolContext) {
+    if (context) {
+      this.context = { ...context, Tools: this };
+    } else {
+      this.context = { Tools: this };
+    }
+  }
+
+  getContext(): ToolContext {
+    return this.context;
+  }
+
+  setContext(context: ToolContext): void {
+    this.context = { ...context, Tools: this };
+  }
+
+  addContext<K extends keyof ToolContext, V extends ToolContext[K]>(
+    key: K,
+    value: V
+  ): void {
+    this.context[key] = value;
+  }
+
   getTools() {
     return this.tools;
   }
@@ -54,6 +92,9 @@ export class ToolsService {
       this.originalFunctions[name] = func;
     }
 
+    // Auto-bind function to this ToolsService instance
+    const boundFunc = func.bind(this);
+
     // Check for overrides first
     const override = this.findMatchingOverride(name);
     if (override) {
@@ -67,7 +108,7 @@ export class ToolsService {
     // Check for wrappers
     const wrappers = this.findMatchingWrappers(name);
     if (wrappers.length > 0) {
-      let wrappedFunction = func;
+      let wrappedFunction = boundFunc;
 
       // Apply wrappers in priority order
       for (const wrapperReg of wrappers) {
@@ -82,8 +123,8 @@ export class ToolsService {
       return;
     }
 
-    // No overrides or wrappers, use original function
-    this.functions[name] = func;
+    // No overrides or wrappers, use bound function
+    this.functions[name] = boundFunc;
   }
 
   setFunctions(names: string[], funcs: ((...args: any) => any)[]) {
@@ -97,23 +138,39 @@ export class ToolsService {
   }
 
   addTools(tools: Tool[]) {
-    this.tools.push(...tools);
+    // Prevent duplicate tool names
+    const existingTools = this.getToolNames();
+    const filteredTools = tools.filter(
+      (tool) => !existingTools.includes(tool.function.name)
+    );
+
+    this.tools.push(...filteredTools);
   }
 
   addFunctions(fns: { [fnName: string]: (...args: any) => any }) {
     for (const fnName of Object.keys(fns)) {
+      if (typeof fns[fnName] !== "function") {
+        // Skip non-function entries
+        continue;
+      }
       this.setFunction(fnName, fns[fnName]);
     }
   }
 
+  defineTools(
+    tools: Tool[],
+    functions: { [fnName: string]: ((...args: any) => any) | any }
+  ) {
+    this.addTools(tools);
+    this.addFunctions(functions);
+  }
+
   async callTool(toolCall: ToolCall, enabledTools = this.getToolNames()) {
     const functionName = toolCall.function.name;
     const functionArgs = JSON.parse(
       restoreEscapedNewLines(toolCall.function.arguments)
     );
 
-    console.log(toolCall);
-
     try {
       // Check if tool is enabled
       if (!enabledTools.includes(functionName)) {
@@ -285,5 +342,3 @@ export class ToolsService {
     }
   }
 }
-
-export const Tools = new ToolsService();

package/src/services/flags.ts

@@ -49,4 +49,3 @@ export class FlagsService {
   }
 }
 
-export const Flags = new FlagsService();

package/src/services/index.ts

@@ -1,3 +1,14 @@
+import { Clients } from "../clients";
+import { Plugins } from "../plugins/plugins";
+import { AgentService } from "./AgentService";
+import { EventService } from "./EventService";
+import { FlagsService } from "./flags";
+import { GitHubService } from "./GitHub";
+import { KnowhowSimpleClient } from "./KnowhowClient";
+import { McpService } from "./Mcp";
+import { S3Service } from "./S3";
+import { ToolsService } from "./Tools";
+
 export * from "./AgentService";
 export * from "./EventService";
 export * from "./flags";
@@ -6,3 +17,48 @@ export * from "./S3";
 export * from "./Tools";
 export * as MCP from "./Mcp";
 export * from "./EmbeddingService";
+export { Clients } from "../clients";
+export { Plugins };
+
+let Singletons = {} as {
+  Tools: ToolsService;
+  Events: EventService;
+  Agents: AgentService;
+  Flags: FlagsService;
+  GitHub: GitHubService;
+  Mcp: McpService;
+  AwsS3: S3Service;
+  knowhowApiClient: KnowhowSimpleClient;
+  Plugins: typeof Plugins;
+  Clients: typeof Clients;
+};
+
+export const services = (): typeof Singletons => {
+  if (Object.keys(Singletons).length === 0) {
+    const Tools = new ToolsService();
+    const Events = new EventService();
+    const Agents = new AgentService(Tools, Events);
+    Singletons = {
+      Tools,
+      Events,
+      Agents,
+
+      Flags: new FlagsService(),
+      GitHub: new GitHubService(),
+      Mcp: new McpService(),
+      AwsS3: new S3Service(),
+      knowhowApiClient: new KnowhowSimpleClient(process.env.KNOWHOW_API_URL),
+      Plugins,
+      Clients,
+    };
+
+    Singletons.Tools.setContext({
+      Agents,
+      Events,
+      Plugins,
+      Clients,
+    });
+  }
+
+  return Singletons;
+};

package/src/services/modules/index.ts

@@ -0,0 +1,53 @@
+import { getConfig } from "../../config";
+import { KnowhowModule, ModuleContext } from "./types";
+import { ToolsService } from "../Tools";
+import { services } from "../";
+import { EventService } from "../EventService";
+
+export class ModulesService {
+  async loadModulesFromConfig(context?: ModuleContext) {
+    const config = await getConfig();
+
+    // If no context provided, fall back to global singletons
+    if (!context) {
+      const { Clients, Plugins, Agents, Tools } = services();
+      context = {
+        Agents,
+        Plugins,
+        Clients,
+        Tools,
+      };
+    }
+
+    // Use the toolsService from context
+    const toolsService = context.Tools;
+    const agentService = context.Agents;
+    const pluginService = context.Plugins;
+    const clients = context.Clients;
+
+    const modules = config.modules || [];
+
+    for (const modulePath of modules) {
+      const importedModule = require(modulePath) as KnowhowModule;
+      await importedModule.init({ config, cwd: process.cwd() });
+
+      for (const agent of importedModule.agents) {
+        agentService.registerAgent(agent);
+      }
+
+      for (const tool of importedModule.tools) {
+        toolsService.addTool(tool.definition);
+        toolsService.setFunction(tool.definition.function.name, tool.handler);
+      }
+
+      for (const plugin of importedModule.plugins) {
+        pluginService.registerPlugin(plugin.name, plugin.plugin);
+      }
+
+      for (const client of importedModule.clients) {
+        clients.registerClient(client.provider, client.client);
+        clients.registerModels(client.provider, client.models);
+      }
+    }
+  }
+}

package/src/{modules → services/modules}/types.ts

@@ -1,8 +1,12 @@
-import { Plugin } from "../plugins/types";
-import { IAgent } from "../agents/interface";
-import { Tool } from "../clients/types";
-import { Config } from "../types";
-import { GenericClient } from "../clients/types";
+import { Plugin } from "../../plugins/types";
+import { IAgent } from "../../agents/interface";
+import { Tool } from "../../clients/types";
+import { Config } from "../../types";
+import { GenericClient } from "../../clients/types";
+import { AgentService } from "../AgentService";
+import { PluginService } from "../../plugins/plugins";
+import { AIClient } from "../../clients";
+import { ToolsService } from "../Tools";
 
 /*
  *
@@ -38,6 +42,13 @@ export type InitParams = {
   cwd: string;
 };
 
+export interface ModuleContext {
+  Agents: AgentService;
+  Plugins: PluginService;
+  Clients: AIClient;
+  Tools: ToolsService;
+}
+
 export interface KnowhowModule {
   init: (params: InitParams) => Promise<void>;
   commands: ModuleChatCommand[];