@tyvm/knowhow 0.0.159 → 0.0.161

package/src/prompts/KnowhowConfigExamples.ts

@@ -1,376 +0,0 @@
-export default `
-
-Here is an overview of examples from various \`.knowhow/knowhow.json\` configuration files found, illustrating the configuration capabilities that Knowhow supports:
-
----
-
-## General Configuration Template
-
-\`\`\`json
-{
-  "promptsDir": ".knowhow/prompts",
-  "plugins": [
-    "embeddings",
-    "language",
-    "vim",
-    "github",
-    "asana",
-    "jira",
-    "linear",
-    "download",
-    "figma"
-  ],
-  "sources": [
-    {
-      "input": "src/**/*.mdx",
-      "output": ".knowhow/docs/",
-      "prompt": "BasicCodeDocumenter"
-    }
-  ],
-
-  // Generate embeddings from a series of files on your machine
-  // Remote knowhow with the kb id allows you to leverage knowhow upload
-  "embedSources": [
-    {
-      "input": ".knowhow/docs/**/*.mdx",
-      "output": ".knowhow/embeddings",
-      "chunkSize": 2000,
-      "remoteType": "knowhow",
-      "remoteId": "141d9c4d-1589-4ccc-bf39-031f4259b89f"
-    }
-  ],
-
-  // Define aditional agents you can interact with via chat
-  "agents": [
-    {
-      "name": "linter",
-      "description": "Clean up your code",
-      "instructions": "Read the files that are loaded via vim plugin and provide debugging and linter suggestions"
-    }
-    {
-      "name": "Codebase Helper",
-      "description": "Helps you code",
-      "instructions": "Codebase helper, use files and tools to help us code",
-      "model": "gpt-4-1106-preview",
-      "tools": [
-        {
-          "type": "code_interpreter"
-        }
-      ],
-      "files": [
-        ".knowhow/docs/**/*.mdx"
-      ]
-    }
-  ]
-}
-\`\`\`
-
-## Video Download Support
-\`\`\`json
-  "embedSources": [
-    {
-      "input": "https://www.youtube.com/shorts/BYuMBK5Ll-s",
-      "output": ".knowhow/embeddings/video.json",
-      "chunkSize": 2000,
-      "kind": "download"
-    }
-  ],
-\`\`\`
-
-## MCP Setup
-
-\`\`\`json
-  "mcps": [
-    {
-      "name": "browser",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
-    }
-  ],
-\`\`\`
-
-## Expose Tools to Knowhow Site via workers
-After you've connected via \`knowhow login\` you can connect tools from your local machine
-Run \`knowhow worker\` to generate a block like below. Edit it to include the tools you want to expose.
-Then run \`knowhow worker\` again to connect
-\`\`\`json
-  "worker": {
-    "allowedTools": [
-      "embeddingSearch",
-      "finalAnswer",
-      "callPlugin",
-      "readFile",
-      "readBlocks",
-      "patchFile",
-      "lintFile",
-      "textSearch",
-      "fileSearch",
-      "writeFileChunk",
-      "createAiCompletion",
-      "listAllModels",
-      "listAllProviders",
-      "getPullRequest",
-      "getPullRequestBuildStatuses",
-      "getRunLogs",
-      "getPullRequestBuildFailureLogs",
-      "addLanguageTerm",
-      "getAllLanguageTerms",
-      "lookupLanguageTerm",
-      "mcp_0_puppeteer_navigate",
-      "mcp_0_puppeteer_screenshot",
-      "mcp_0_puppeteer_click",
-      "mcp_0_puppeteer_fill",
-      "mcp_0_puppeteer_select",
-      "mcp_0_puppeteer_hover",
-      "mcp_0_puppeteer_evaluate"
-    ]
-  },
-\`\`\`
-
-## Custom Models Via LMS Studio
-\`\`\`json
-  "modelProviders": [
-    {
-      "url": "http://localhost:1234",
-      "provider": "lms"
-    }
-  ],
-\`\`\`
-
-## Agent Tasks: rename all video files in a folder
-\`\`\`
-  "sources": [
-    {
-      "input": ".knowhow/downloads/**/*.webm",
-      "output": ".knowhow/organized/",
-      "prompt": "FSOrganizer",
-      "agent": "Developer"
-    }
-  ],
-\`\`\`
-
-Prompt Example:
-
-\`\`\`
-We have this file, we want to generate a nice name for it, please copy the file to .knowhow/org/{better file name}
-
- {text}
-\`\`\`
-
-## knowhow generate: meeting transcripts
-\`\`\`json
-  "sources": [
-    {
-      "input": "./meetings/**/*.mov",
-      "output": "./meetings/ai-notes/",
-      "prompt": "MeetingNotes"
-    },
-    {
-      "input": "./meetings/TaskRelatedCall/transcript.txt",
-      "output": "./meetings/tasks/RewardsTasks.txt",
-      "prompt": "AsanaTasks"
-    },
-    {
-      "input": "./meetings/EngineeringCall/transcript.txt",
-      "output": "./meetings/tasks/SchemaChanges.txt",
-      "prompt": "Schema"
-    }
-  ],
-\`\`\`
-
-
-Use the source block alongside \`knowhow generate\` to process a pipeline of files, applying prompts to generate documentation or other artifacts. This example demonstrates the configuration for processing meeting recordings, and then running prompts on the resulting transcripts.
-
-I've been using \`CMD+SHIFT+5\` to record meetings and then using the \`sources\` block to process the recordings into notes and tasks.
-
-When a .mov or audio file is an input, it will automatically create a transcript.txt in the same directory, so we can leverage that txt input in the next step. The pipeline is useful for apply one or more prompts to one or more input files.
-
-## knowhow embed: documentation embeddings
-\`\`\`json
-  "embedSources": [
-    {
-      "input": "./documentation/docusaurus/docs/dev-docs/**/*.md",
-      "output": ".knowhow/embeddings/strapi-docs.json",
-      "chunkSize": 2000
-    }
-  ]
-\`\`\`
-
-## knowhow embed: codebase embeddings
-\`\`\`json
-
-  "embedSources": [
-    {
-      "input": "./packages/p2p/src/**/*.ts",
-      "output": ".knowhow/embeddings/p2p.json",
-      "chunkSize": 2000
-    },
-    {
-      "input": "./packages/openai_proxy/src/**/*.ts",
-      "output": ".knowhow/embeddings/openai_proxy.json",
-      "chunkSize": 2000
-    },
-    {
-      "input": "./packages/contracts/src/**/*.sol",
-      "output": ".knowhow/embeddings/contracts.json",
-      "chunkSize": 2000
-    }
-  ],
-\`\`\`
-You can use \`knowhow embed\` to generate json embeddings from a set of files. If you want to run a prompt on the input, before embedding, you set an optional \`prompt\` field to match the filename of the prompt stored in your \`.knowhow/prompts\` directory.
-
-These embeddings are leveraged by the chat in \`knowhow chat\` or by the agents to accomplish their tasks
-
-## knowhow embed: asana tasks
-\`\`\`
-  "embedSources": [
-    {
-      "input": "https://app.asana.com/0/111111111111111/list",
-      "output": ".knowhow/embeddings/asana.json",
-      "remote": "mybucket",
-      "remoteType": "s3",
-      "kind": "asana",
-      "chunkSize": 2000
-    }
-  ],
-\`\`\`
-
-
-Any plugin that implements the embedding function, can generate embeddings if you set the \`kind\` field to the plugin name. The \`remote\` field is optional, and if set, the embeddings will be uploaded to the specified S3 bucket via \`knowhow upload\`.
-
-You can download remote embeddings via \`knowhow download\` and use them in your local environment.
-
-For downloads we support the following remote options:
-- s3
-- github* - downloads files
-
-For uploads we support the following remote options:
-- s3
-- github* - use git lfs to commit the embeddings to your repository
-
-
-## knowhow embed: github embeddings
-\`\`\`
-  "embedSources": [
-    {
-      "input": "./src/**/*.ts",
-      "output": ".knowhow/embeddings/knowhow.json",
-      "chunkSize": 2000,
-      "remote": "micahriggan/knowhow",
-      "remoteType": "github"
-    }
-  ],
-\`\`\`
-Here's an example where you could download embeddings from github. As the code updates occasionally I'll run \`knowhow embed\` and commit the updated embeddings.
-
-## Plugins
-\`\`\`json
-{
-  "plugins": [
-    "embeddings",
-    "language",
-    "vim",
-    "github",
-    "asana",
-    "jira",
-    "linear",
-    "download",
-    "figma",
-    "notion"
-  ],
-}
-\`\`\`
-Plugins are used to resolve urls or other references to data that the AI can use. For example, the \`asana\` plugin can be used to resolve tasks and projects from Asana, and the \`figma\` plugin can be used to resolve design files from Figma.
-
-The language plugin allows you to define hotkeys that resolve to larger blocks of texts or files, or urls. For example, you can define a language entry \`#asana\` that resolves to a link to your current asana task, so that you can easily load that without pasting the link each time.
-
-
-## knowhow chat:
-After generating embeddings, you can use \`knowhow chat\` to speak with a base agent, that does not have any tools, but does have plugins.
-
-You can use \`agent\` once you're in a chat to start talking to a Developer agent, that has a prompt and tools designed to help develop software.
-You can use \`agents\` to see a list of configured agents you can speak with.
-If you need multi-line input you can use \`multi\` to open a multi-line editor.
-
-There are many commands you can call from a chat session, try TAB to see a list of available options.
-
-
-### knowhow chat: custom agents
-\`\`\`json
-  "assistants": [
-    {
-      "name": "linter",
-      "description": "Clean up your code",
-      "instructions": "Read the files that are loaded via vim plugin and provide debugging and linter suggestions"
-    }
-  ]
-\`\`\`
-You can configure new agents via the config above. This would create a new option when you use \`agents\` in a chat session.
-
-## Lint Commands
-
-\`\`\`json
-{
-  "lintCommands": {
-    "js": "eslint",
-    "ts": "tslint $1 && tsc -p tsconfig.json"
-  }
-}
-\`\`\`
-lintCommands are automatically run after an agent successfully patches a file, if the file extension matches. So you can configure the AI to receive feedback from tsc and the linter after modifying a TypeScript file. $1 will be replaced with the filepath that was patched.
-
-
-
-## Language Plugin
-
-Configured in \`.knowhow/language.json\`
-
-Knowhow has a language file, which allows you to define additional context that is included when you use certain phrases in your messages. For instance, you could load a Pull Request when you say "My PR", or load a file from the codebase when you reference it. Languages have "terms" which then load various sources into context. Sources currently can be files, text, or github links.
-
-I primarily use this to define terms like "frontend" or "backend" to load prompt files
-
-## Example Language Definition
-
-\`\`\`
-{
-  "ui,frontend,component,page": {
-    "sources": [
-      {
-        "data": [
-          "./.knowhow/prompts/frontend.mdx"
-        ],
-        "kind": "file"
-      }
-    ]
-  }
-}
-\`\`\`
-
-
-Here's and example of having a language term that triggers a plugin.
-This example would load the diff of a PR every time we said "my pr"
-\`\`\`
-{
-  "knowhow config": {
-    "sources": [
-      {
-        "kind": "file",
-        "data": [
-          ".knowhow/knowhow.json"
-        ]
-      }
-    ]
-  },
-  "My PR": {
-    "sources": [
-      {
-        "kind": "github",
-        "data": [
-          "https://github.com/tyvm-ai/knowhow/pulls/1"
-        ]
-      }
-    ]
-  }
-}
-\`\`\`
-`

package/src/prompts/index.ts

@@ -1,9 +0,0 @@
-import BasicCodeDocumenter from "./BasicCodeDocumenter";
-import BasicProjectDocumenter from "./BasicProjectDocumenter";
-import BasicEmbeddingExplainer from "./EmbeddingSeachHelper";
-
-export const Prompts = [
-  { BasicCodeDocumenter },
-  { BasicProjectDocumenter },
-  { BasicEmbeddingExplainer },
-];

package/src/remotes.ts

@@ -1,110 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Config, KnowhowRemote } from "./types";
-
-export const DEFAULT_REMOTE_NAME = "origin";
-export const DEFAULT_API_URL = "https://api.knowhow.tyvm.ai";
-
-export function normalizeApiUrl(apiUrl: string): string {
-  const trimmed = apiUrl.trim().replace(/\/+$/, "");
-  const url = new URL(trimmed);
-  if (!/^https?:$/.test(url.protocol)) {
-    throw new Error(`Remote URL must use http or https: ${apiUrl}`);
-  }
-  return url.toString().replace(/\/$/, "");
-}
-
-export function defaultJwtPath(apiUrl: string): string {
-  const normalized = normalizeApiUrl(apiUrl);
-  if (normalized === DEFAULT_API_URL) return ".knowhow/.jwt";
-  const { hostname, port } = new URL(normalized);
-  let suffix: string;
-  if (hostname === "localhost" || hostname === "::1" || hostname.startsWith("127.")) {
-    suffix = "local";
-  } else if (hostname === "api.dev.knowhow.tyvm.ai" || hostname.includes(".dev.")) {
-    suffix = "dev";
-  } else {
-    suffix = `${hostname}${port ? `-${port}` : ""}`
-      .toLowerCase()
-      .replace(/[^a-z0-9.-]+/g, "-")
-      .replace(/^-+|-+$/g, "");
-  }
-  return `.knowhow/.jwt.${suffix}`;
-}
-
-export function createRemote(name: string, apiUrl: string): KnowhowRemote {
-  if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
-    throw new Error("Remote names may only contain letters, numbers, '.', '_' and '-'.");
-  }
-  const normalizedUrl = normalizeApiUrl(apiUrl);
-  return { name, apiUrl: normalizedUrl, jwtPath: defaultJwtPath(normalizedUrl) };
-}
-
-export function getConfiguredRemotes(config: Config): Record<string, KnowhowRemote> {
-  return config.remotes ?? {};
-}
-
-export function findRemoteForApi(config: Config, apiUrl: string): KnowhowRemote | undefined {
-  const normalizedUrl = normalizeApiUrl(apiUrl);
-  return Object.values(getConfiguredRemotes(config)).find(
-    (remote) => normalizeApiUrl(remote.apiUrl) === normalizedUrl
-  );
-}
-
-export function findRemoteForApiSync(apiUrl: string): KnowhowRemote | undefined {
-  try {
-    const config = JSON.parse(
-      fs.readFileSync(path.join(process.cwd(), ".knowhow", "knowhow.json"), "utf8")
-    ) as Config;
-    return findRemoteForApi(config, apiUrl);
-  } catch {
-    return undefined;
-  }
-}
-
-export function getActiveRemote(config: Config): KnowhowRemote {
-  const envUrl = process.env.KNOWHOW_API_URL;
-  if (envUrl) {
-    return findRemoteForApi(config, envUrl) ?? createRemote(inferRemoteName(envUrl), envUrl);
-  }
-  const name = config.activeRemote ?? DEFAULT_REMOTE_NAME;
-  return config.remotes?.[name] ?? createRemote(DEFAULT_REMOTE_NAME, DEFAULT_API_URL);
-}
-
-export function getActiveRemoteSync(): KnowhowRemote {
-  try {
-    const config = JSON.parse(
-      fs.readFileSync(path.join(process.cwd(), ".knowhow", "knowhow.json"), "utf8")
-    ) as Config;
-    return getActiveRemote(config);
-  } catch {
-    const apiUrl = process.env.KNOWHOW_API_URL ?? DEFAULT_API_URL;
-    return createRemote(inferRemoteName(apiUrl), apiUrl);
-  }
-}
-
-export function registerRemote(config: Config, remote: KnowhowRemote): void {
-  const migratedRemotes: Record<string, KnowhowRemote> = {};
-  for (const [apiUrl, orgId] of Object.entries(config.orgIds ?? {})) {
-    const name = inferRemoteName(apiUrl);
-    migratedRemotes[name] = {
-      ...createRemote(name, apiUrl),
-      orgId,
-    };
-  }
-  config.remotes = { ...migratedRemotes, ...(config.remotes ?? {}), [remote.name]: remote };
-  delete config.orgIds;
-}
-
-export function inferRemoteName(apiUrl: string): string {
-  const normalized = normalizeApiUrl(apiUrl);
-  if (normalized === DEFAULT_API_URL) return DEFAULT_REMOTE_NAME;
-  const { hostname } = new URL(normalized);
-  if (hostname === "localhost" || hostname === "::1" || hostname.startsWith("127.")) return "local";
-  if (hostname === "api.dev.knowhow.tyvm.ai" || hostname.includes(".dev.")) return "dev";
-  return hostname.toLowerCase().replace(/[^a-z0-9.-]+/g, "-");
-}
-
-export function resolveJwtPath(jwtPath: string): string {
-  return path.resolve(process.cwd(), jwtPath);
-}

package/src/server/index.ts

@@ -1,16 +0,0 @@
-import express from "express";
-
-const app = express();
-const port = 4545;
-
-
-app.use((req, res) => {
-  const { path, body, query } = req;
-  console.log({ path, body, query });
-  res.send("Hello World!");
-});
-
-
-app.listen(port, () => {
-  console.log(`Server started at http://localhost:${port}`);
-});

package/src/services/AgentService.ts

@@ -1,134 +0,0 @@
-import { getConfigSync } from "../config";
-import { IAgent } from "../agents/interface";
-import { EventService } from "./EventService";
-import { ToolsService } from "./Tools";
-import { ConfigAgent } from "../agents/configurable/ConfigAgent";
-import { TraceAll } from "../util/Trace";
-import { AgentContext } from "../agents/base/base";
-
-@TraceAll()
-export class AgentService {
-  private agents: Map<string, IAgent> = new Map();
-  private agentContext: AgentContext | null = null;
-
-  constructor(private tools: ToolsService, private events: EventService) {
-    this.wireUp();
-  }
-
-  public wireUp() {
-    this.tools.addTool({
-      type: "function",
-      function: {
-        name: "agentCall",
-        description: `Allows an agent to ask another agent a question. Useful for getting help from agents that are configured for specific goals.
-        ${this.getAgentDescriptions()}`,
-        parameters: {
-          type: "object",
-          positional: true,
-          properties: {
-            agentName: {
-              type: "string",
-              description: `The name of the agent to call. Available agents: ${this.listAgents()}`,
-            },
-            query: {
-              type: "string",
-              description: `The query to send to the agent`,
-            },
-          },
-          required: ["agentName", "query"],
-        },
-      },
-    });
-    this.events.on("agents:register", (data) => {
-      console.log(`Agent registered: ${data.name}`);
-      const { name, agent } = data;
-      this.registerAgentByName(name, agent);
-    });
-
-    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);
-    });
-  }
-
-  public registerAgent(agent: IAgent): void {
-    this.registerAgentByName(agent.name, agent);
-  }
-
-  public registerAgentByName(name: string, agent: IAgent): void {
-    this.agents.set(name, agent);
-  }
-
-  /**
-   * Set the AgentContext that will be used when creating new agent instances.
-   * Should be called from cli.ts after all services are wired up (including LazyToolsService).
-   */
-  public setAgentContext(context: AgentContext): void {
-    this.agentContext = context;
-  }
-
-  /**
-   * Get the current AgentContext. Falls back to a minimal context using this service's
-   * own tools/events if none has been explicitly set.
-   */
-  public getAgentContext(): AgentContext {
-    return this.agentContext ?? { Tools: this.tools, Events: this.events };
-  }
-
-  public getAgent<T extends IAgent = IAgent>(name: string): T {
-    const agent = this.agents.get(name);
-    if (!agent) {
-      throw new Error(
-        `Agent ${name} not found. Options are: ${this.listAgents()}`
-      );
-    }
-    return agent as T;
-  }
-
-  public listAgents(): string[] {
-    return Array.from(this.agents.keys());
-  }
-
-  public getAgentDescriptions() {
-    return Object.keys(this.agents).map((key) => {
-      const agent = this.getAgent(key);
-      return `name: ${agent.name} \n description: ${agent.description}`;
-    });
-  }
-
-  public loadAgentsFromConfig(context: AgentContext) {
-    const config = getConfigSync();
-    const agents = config.agents || [];
-
-    for (const agent of agents) {
-      this.registerAgent(new ConfigAgent(agent, context));
-    }
-  }
-
-  /**
-   * Run a registered agent and return both its final answer and the cost it
-   * incurred. Returning cost (from the agent's own `getTotalCostUsd()`) lets
-   * callers — notably the script sandbox — account subagent spend against a
-   * budget. The `answer` string preserves the previous plain-string behavior
-   * for consumers that only care about the response.
-   */
-  public async callAgent(
-    name: string,
-    query: string
-  ): Promise<{ answer: string; costUsd: number }> {
-    const agent = this.agents.get(name);
-    if (!agent) {
-      return {
-        answer: `Agent ${name} not found. Options are: ${this.listAgents()}`,
-        costUsd: 0,
-      };
-    }
-    const answer = await agent.call(query);
-    const costUsd =
-      typeof (agent as any).getTotalCostUsd === "function"
-        ? (agent as any).getTotalCostUsd()
-        : 0;
-    return { answer, costUsd };
-  }
-}