@tyvm/knowhow 0.0.83 → 0.0.84

package/src/cli.ts

@@ -35,6 +35,7 @@ import { BaseAgent } from "./agents/base/base";
 import { AskModule } from "./chat/modules/AskModule";
 import { SearchModule } from "./chat/modules/SearchModule";
 import { AgentModule } from "./chat/modules/AgentModule";
+import { SessionsModule } from "./chat/modules/SessionsModule";
 import { readPromptFile } from "./ai";
 import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
@@ -48,22 +49,32 @@ async function setupServices() {
     ...OldTools.getContext(),
   });
 
-  const { Researcher, Developer, Patcher, Setup } = agents({
+  // Build the AgentContext with the fully-populated LazyToolsService so every
+  // agent created (including those in setupAgent) gets all tools registered.
+  const agentContext: import("./agents/base/base").AgentContext = {
     ...services(),
     Tools,
+  };
+
+  const { Researcher, Developer, Patcher, Setup } = agents({
+    ...agentContext,
   });
 
   Agents.registerAgent(Researcher);
   Agents.registerAgent(Patcher);
   Agents.registerAgent(Developer);
   Agents.registerAgent(Setup);
-  Agents.loadAgentsFromConfig(services());
+  Agents.loadAgentsFromConfig(agentContext);
 
   Tools.defineTools(includedTools, allTools);
 
   // Add Mcp service to tool context directly so MCP management tools can access it
   Tools.addContext("Mcp", Mcp);
 
+  // Store the fully-wired AgentContext on AgentService so AgentModule.setupAgent
+  // can retrieve it when creating fresh agent instances via createAgent().
+  Agents.setAgentContext(agentContext);
+
   console.log("🔌 Connecting to MCP...");
   await Mcp.connectToConfigured(Tools);
   console.log("Connecting to clients...");
@@ -322,7 +333,9 @@ async function main() {
     .action(async (options) => {
       try {
         await setupServices();
-        const setupModule = new SetupModule();
+        const agentModule = new AgentModule();
+        await agentModule.initialize(chatService);
+        const setupModule = new SetupModule(agentModule);
         await setupModule.initialize(chatService);
         await setupModule.handleSetupCommand([]);
       } catch (error) {
@@ -367,11 +380,15 @@ async function main() {
   program
     .command("sessions")
     .description("Manage agent sessions from CLI")
-    .action(async () => {
+    .option("--all", "Show all historical sessions (default: current process only)")
+    .option("--csv", "Output sessions as CSV")
+    .action(async (options) => {
       try {
         const agentModule = new AgentModule();
         await agentModule.initialize(chatService);
-        await agentModule.logSessionTable();
+        const sessionsModule = new SessionsModule(agentModule);
+        await sessionsModule.initialize(chatService);
+        await sessionsModule.logSessionTable(options.all || false, options.csv || false, true);
       } catch (error) {
         console.error("Error listing sessions:", error);
         process.exit(1);
@@ -394,6 +411,8 @@ async function main() {
       "--no-sandbox",
       "Run worker directly on host (disable sandbox mode)"
     )
+    .option("--passkey", "Set up passkey authentication for this worker")
+    .option("--passkey-reset", "Remove passkey authentication requirement")
     .action(async (options) => {
       await setupServices();
       await worker(options);

package/src/config.ts

@@ -262,6 +262,21 @@ export async function getConfig() {
   }
 }
 
+export async function getGlobalConfig(): Promise<Config> {
+  const globalConfigDir = getGlobalConfigDir();
+  const globalConfigPath = path.join(globalConfigDir, "knowhow.json");
+  if (!fs.existsSync(globalConfigPath)) {
+    return {} as Config;
+  }
+  try {
+    const config = await readFile(globalConfigPath, "utf8");
+    return JSON.parse(config) as Config;
+  } catch (error) {
+    console.warn("Failed to load global knowhow config:", error);
+    return {} as Config;
+  }
+}
+
 export async function migrateConfig() {
   // Apply migrations, used to keep config structure up to date.
   if (!fs.existsSync(".knowhow/knowhow.json")) {

package/src/plugins/AgentsMdPlugin.ts

@@ -98,7 +98,7 @@ export class AgentsMdPlugin extends PluginBase implements Plugin {
 
       events.emit("agent:msg", alertMessage);
     } catch (error) {
-      console.error("AGENTS-MD PLUGIN: Error handling file event:", error);
+      this.log("AGENTS-MD PLUGIN: Error handling file event: " + error, "error");
     }
   }
 

package/src/plugins/GitPlugin.ts

@@ -110,7 +110,7 @@ Your modifications are automatically tracked separately and won't affect the use
 
       await this.setBranch("main");
     } catch (error) {
-      console.error("Failed to initialize .knowhow git repository:", error);
+      this.log(`Failed to initialize .knowhow git repository: ${error}`, "error");
     }
   }
 
@@ -144,7 +144,7 @@ Your modifications are automatically tracked separately and won't affect the use
     try {
       return this.gitCommand(command, options);
     } catch (error) {
-      console.warn(`Safe git command failed: ${command}`, error);
+      this.log(`Safe git command failed: ${command} - ${error}`, "warn");
       return null;
     }
   }
@@ -235,7 +235,7 @@ Your modifications are automatically tracked separately and won't affect the use
 
       // Get the current HEAD commit hash from the actual repo (if it exists)
       const actualRepoHash = this.getRepoHash();
-      console.log(`GitPlugin: Current branch is ${this.getCurrentBranch()}`);
+      this.log(`Current branch is ${this.getCurrentBranch()}`);
 
       // First, handle any uncommitted changes on the current branch
       const hasChanges = await this.hasChanges();
@@ -246,7 +246,7 @@ Your modifications are automatically tracked separately and won't affect the use
             : `sync ${new Date().toISOString()}`;
           await this.commitAll(message);
         } catch (error) {
-          console.error("Failed to commit uncommitted changes:", error);
+          this.log(`Failed to commit uncommitted changes: ${error}`, "error");
         }
       }
 
@@ -259,7 +259,7 @@ Your modifications are automatically tracked separately and won't affect the use
 
       await this.setBranch("main");
     } catch (error) {
-      console.error("Failed to ensure clean state:", error);
+      this.log(`Failed to ensure clean state: ${error}`, "error");
     }
   }
 
@@ -288,7 +288,7 @@ Your modifications are automatically tracked separately and won't affect the use
         this.gitCommand(`checkout -b ${branchName}`);
       }
     } catch (error) {
-      console.error(`GitPlugin: Failed to set branch ${branchName}:`);
+      this.log(`Failed to set branch ${branchName}`, "error");
     }
   }
 
@@ -298,7 +298,7 @@ Your modifications are automatically tracked separately and won't affect the use
     try {
       this.gitCommand(`checkout -b ${branchName}`);
     } catch (error) {
-      console.error(`GitPlugin: Failed to create branch ${branchName}:`);
+      this.log(`Failed to create branch ${branchName}`, "error");
     }
   }
 
@@ -317,7 +317,7 @@ Your modifications are automatically tracked separately and won't affect the use
         try {
           this.gitCommand(`add "${file}"`);
         } catch (error) {
-          console.warn(`Failed to add file ${file}:`, error);
+          this.log(`Failed to add file ${file}: ${error}`, "warn");
         }
       }
     } else {
@@ -339,7 +339,7 @@ Your modifications are automatically tracked separately and won't affect the use
       this.gitCommand("add -A");
       await this.commitWithEvents(message);
     } catch (error) {
-      console.error("Failed to commit all changes:", error);
+      this.log(`Failed to commit all changes: ${error}`, "error");
     }
   }
 
@@ -389,7 +389,7 @@ Your modifications are automatically tracked separately and won't affect the use
         `
       );
     } catch (error) {
-      console.error("Failed to commit with events:", error);
+      this.log(`Failed to commit with events: ${error}`, "error");
     }
   }
 
@@ -402,7 +402,7 @@ Your modifications are automatically tracked separately and won't affect the use
       try {
         this.gitCommand('commit --allow-empty -m "Initial empty commit"');
       } catch (error) {
-        console.warn("Could not create initial commit:", error);
+        this.log(`Could not create initial commit: ${error}`, "warn");
       }
     }
   }
@@ -424,7 +424,7 @@ Your modifications are automatically tracked separately and won't affect the use
 
       await this.commitAll(message);
     } catch (error) {
-      console.error("Auto-commit failed:", error);
+      this.log(`Auto-commit failed: ${error}`, "error");
     }
   }
 
@@ -455,9 +455,9 @@ Your modifications are automatically tracked separately and won't affect the use
         );
       }
 
-      console.log(`Created new task branch: ${branchName}`);
+      this.log(`Created new task branch: ${branchName}`);
     } catch (error) {
-      console.error("Failed to handle new task:", error);
+      this.log(`Failed to handle new task: ${error}`, "error");
     }
   }
 
@@ -466,7 +466,7 @@ Your modifications are automatically tracked separately and won't affect the use
 
     try {
       if (!this.currentTask) {
-        console.warn("No tasks in progress to complete");
+        this.log("No tasks in progress to complete", "warn");
         return;
       }
 
@@ -488,7 +488,7 @@ Your modifications are automatically tracked separately and won't affect the use
       // Clear current task
       this.currentTask = null;
     } catch (error) {
-      console.error("Failed to handle task completion:", error);
+      this.log(`Failed to handle task completion: ${error}`, "error");
     }
   }
 
@@ -523,9 +523,9 @@ Your modifications are automatically tracked separately and won't affect the use
     try {
       const noteMessage = `[Build Stable] No linting issues found on branch: ${this.getCurrentBranch()}`;
       this.gitCommand(`notes add -f -m "${noteMessage}" ${commitHash}`);
-      console.log(`GitPlugin: Marked commit ${commitHash} as build stable`);
+      this.log(`Marked commit ${commitHash} as build stable`);
     } catch (error) {
-      console.warn(`GitPlugin: Failed to add git note for commit ${commitHash}:`, error);
+      this.log(`Failed to add git note for commit ${commitHash}: ${error}`, "warn");
     }
   }
 
@@ -559,7 +559,7 @@ Your modifications are automatically tracked separately and won't affect the use
         .map((line) => line.replace(/^\*?\s*/, "").trim())
         .filter((line) => line.length > 0);
     } catch (error) {
-      console.error("Error getting branches:", error);
+      this.log(`Error getting branches: ${error}`, "error");
       return [];
     }
   }
@@ -592,7 +592,7 @@ Your modifications are automatically tracked separately and won't affect the use
         this.commitAll(message);
       }
     } catch (error) {
-      console.error(`Failed to merge ${branchName}:`, error);
+      this.log(`Failed to merge ${branchName}: ${error}`, "error");
     }
   }
 }

package/src/plugins/PluginBase.ts

@@ -43,6 +43,17 @@ export abstract class PluginBase implements Plugin {
     return true; // subclasses override if needed
   }
 
+  protected log(message: string, level: "info" | "warn" | "error" = "info"): void {
+    if (this.context.Events) {
+      this.context.Events.log(this.meta.name, message, level);
+    } else {
+      // Fallback to console if no Events service
+      if (level === "error") console.error(`[${this.meta.name}] ${message}`);
+      else if (level === "warn") console.warn(`[${this.meta.name}] ${message}`);
+      else console.log(`[${this.meta.name}] ${message}`);
+    }
+  }
+
   /* ------------------------------------------------------------------ */
   /** Default callMany implementation - delegates to call ------------ */
   /* ------------------------------------------------------------------ */

package/src/plugins/SkillsPlugin.ts

@@ -0,0 +1,150 @@
+import { promises as fs, Dirent } from "fs";
+import * as path from "path";
+import { PluginBase, PluginMeta } from "./PluginBase";
+import { Plugin, PluginContext } from "./types";
+import { MinimalEmbedding } from "../types";
+import { getConfig } from "../config";
+
+interface SkillMeta {
+  name: string;
+  description: string;
+  filePath: string;
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split("\n")) {
+    const [key, ...rest] = line.split(":");
+    if (key && rest.length) result[key.trim()] = rest.join(":").trim();
+  }
+  return result;
+}
+
+export class SkillsPlugin extends PluginBase implements Plugin {
+  static readonly meta: PluginMeta = {
+    key: "skills",
+    name: "Skills Plugin",
+    description:
+      "Scans configured skills directories for SKILL.md files and provides skill content to agents",
+    requires: [],
+  };
+
+  meta = SkillsPlugin.meta;
+
+  constructor(context: PluginContext) {
+    super(context);
+  }
+
+  async call(input?: string): Promise<string> {
+    const result = await this.embed(input || "");
+    return result.map((e) => e.text).join("\n\n");
+  }
+
+  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
+    const config = await getConfig();
+    const skillDirs: string[] = (config as any).skills || [];
+
+    if (skillDirs.length === 0) {
+      return [];
+    }
+
+    const skills = await this.scanSkills(skillDirs);
+
+    if (skills.length === 0) {
+      return [];
+    }
+
+    // Check if any skill name appears in the prompt
+    const matchedSkills = skills.filter((skill) =>
+      userPrompt.toLowerCase().includes(skill.name.toLowerCase())
+    );
+
+    if (matchedSkills.length > 0) {
+      // Return full skill content for matched skills
+      const results: MinimalEmbedding[] = [];
+      for (const skill of matchedSkills) {
+        try {
+          const content = await fs.readFile(skill.filePath, "utf-8");
+          results.push({
+            id: skill.filePath,
+            text: `## Skill: ${skill.name}\nFile: ${skill.filePath}\n\n${content}`,
+            metadata: { filePath: skill.filePath },
+          });
+        } catch {
+          // Skip unreadable files
+        }
+      }
+      return results;
+    }
+
+    // Return skill discovery summary
+    const summary = this.buildSkillSummary(skills);
+    return [
+      {
+        id: "skills:summary",
+        text: summary,
+        metadata: {},
+      },
+    ];
+  }
+
+  private async scanSkills(dirs: string[]): Promise<SkillMeta[]> {
+    const skills: SkillMeta[] = [];
+    for (const dir of dirs) {
+      const resolvedDir = dir.replace(/^~/, process.env.HOME || "");
+      try {
+        const found = await this.findSkillFiles(resolvedDir);
+        skills.push(...found);
+      } catch {
+        // Skip directories that don't exist or can't be read
+      }
+    }
+    return skills;
+  }
+
+  private async findSkillFiles(dir: string): Promise<SkillMeta[]> {
+    const skills: SkillMeta[] = [];
+    let entries: Dirent[];
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return skills;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await this.findSkillFiles(fullPath);
+        skills.push(...nested);
+      } else if (entry.isFile() && entry.name === "SKILL.md") {
+        try {
+          const content = await fs.readFile(fullPath, "utf-8");
+          const frontmatter = parseFrontmatter(content);
+          const name = frontmatter.name;
+          const description = frontmatter.description || "";
+          if (name) {
+            skills.push({ name, description, filePath: fullPath });
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+
+    return skills;
+  }
+
+  private buildSkillSummary(skills: SkillMeta[]): string {
+    const lines = ["Available skills:"];
+    for (const skill of skills) {
+      lines.push(`- ${skill.name} (${skill.filePath}): ${skill.description}`);
+    }
+    lines.push("");
+    lines.push(
+      "To use a skill, reference its name in your request and I will load the full instructions."
+    );
+    return lines.join("\n");
+  }
+}

package/src/plugins/asana.ts

@@ -57,7 +57,7 @@ export class AsanaPlugin extends PluginBase {
     });
 
     const allTasks = tasksEmbeddings.concat(projectTaskEmbeddings);
-    console.log("Found ", allTasks.length, "tasks");
+    this.log(`Found ${allTasks.length} tasks`);
     return allTasks;
   }
 
@@ -92,7 +92,7 @@ export class AsanaPlugin extends PluginBase {
   async getTasksFromProjectUrl(url: string) {
     const urlParts = url.split("/");
     const projectId = urlParts[4];
-    console.log({ projectId });
+    this.log(`Project ID: ${projectId}`);
     if (!projectId) {
       return null;
     }
@@ -113,7 +113,7 @@ export class AsanaPlugin extends PluginBase {
   async getTaskFromUrl(url: string) {
     const taskId = url.split("/").pop();
     if (taskId) {
-      console.log(`Fetching Asana task ${taskId}`);
+      this.log(`Fetching Asana task ${taskId}`);
       return await this.getTaskData(taskId);
     }
     return null;
@@ -124,7 +124,7 @@ export class AsanaPlugin extends PluginBase {
       const task = await this.asanaClient.tasks.findById(taskId);
       return task;
     } catch (error) {
-      console.error("Error fetching Asana task:", error);
+      this.log(`Error fetching Asana task: ${error}`, "error");
       return null;
     }
   }

package/src/plugins/embedding.ts

@@ -41,7 +41,7 @@ export class EmbeddingPlugin extends PluginBase {
       cwd: process.cwd(),
     });
     child.unref();
-    console.log(`EMBEDDING PLUGIN: Started 'knowhow embed' in background (pid: ${child.pid})`);
+    this.log(`Started 'knowhow embed' in background (pid: ${child.pid})`);
     return "Embedding started in background process";
   }
 
@@ -65,13 +65,11 @@ export class EmbeddingPlugin extends PluginBase {
     pruneMetadata(context);
 
     for (const entry of context) {
-      console.log(`EMBEDDING PLUGIN: Reading entry ${entry.id}`);
+      this.log(`Reading entry ${entry.id}`);
     }
 
     const contextLength = JSON.stringify(context).split(" ").length;
-    console.log(
-      `EMBEDDING PLUGIN: Found ${context.length} entries. Loading ${contextLength} words`
-    );
+    this.log(`Found ${context.length} entries. Loading ${contextLength} words`);
 
     return `EMBEDDING PLUGIN: Our knowledgebase contains this information which can be used to answer the question:
     ${JSON.stringify(context)}`;

package/src/plugins/exec.ts

@@ -40,7 +40,7 @@ export class ExecPlugin extends PluginBase {
     }
 
     try {
-      console.log(`EXEC PLUGIN: Executing: ${command}`);
+      this.log(`Executing: ${command}`);
 
       // Execute the command
       const result = execSync(command, {
@@ -55,9 +55,9 @@ export class ExecPlugin extends PluginBase {
       const stderr = error.stderr || "";
       const stdout = error.stdout || "";
 
-      console.error(`EXEC PLUGIN: Command failed: ${errorMessage}`);
+      this.log(`Command failed: ${errorMessage}`, "error");
       if (stderr) {
-        console.error(stderr);
+        this.log(stderr, "error");
       }
 
       return `EXEC PLUGIN: Command \`${command}\` failed:\n\`\`\`\n${stdout}\n${stderr}\n${errorMessage}\n\`\`\``;

package/src/plugins/figma.ts

@@ -64,11 +64,11 @@ export class FigmaPlugin extends PluginBase implements Plugin {
       return null;
     }
     try {
-      console.log("Fetching figma data", { fileId, nodeIds });
+      this.log(`Fetching figma data: ${JSON.stringify({ fileId, nodeIds })}`);
       const response = await this.client.fileImages(fileId, { ids: nodeIds });
       return { id: fileId, ...response.data };
     } catch (error) {
-      console.error("Error fetching Figma file data:", error);
+      this.log(`Error fetching Figma file data: ${error}`, "error");
       return null;
     }
   }
@@ -146,11 +146,7 @@ export class FigmaPlugin extends PluginBase implements Plugin {
           imageUrl,
           `Describe the image with relavant information for this user question: ${userPrompt}`
         );
-
-        console.log(
-          "FIGMA PLUGIN: Image description",
-          imageDescription.choices[0].message.content
-        );
+        this.log(`Image description: ${imageDescription.choices[0].message.content}`);
         responses.push({ nodeId, imageDescription });
       }
     }