@tyvm/knowhow 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/plugins/PluginBase.ts

@@ -0,0 +1,48 @@
+import { MinimalEmbedding } from "../types";
+import { Plugin, PluginMeta } from "./types";
+
+export abstract class PluginBase implements Plugin {
+  /** Manual on/off toggle (default ON) */
+  private active = true;
+
+  constructor(public readonly meta: PluginMeta) {}
+
+  /* ------------------------------------------------------------------ */
+  /** Public helpers called by PluginService -------------------------- */
+  /* ------------------------------------------------------------------ */
+  enable(): void {
+    this.active = true;
+  }
+
+  disable(): void {
+    this.active = false;
+  }
+
+  async isEnabled(): Promise<boolean> {
+    if (!this.active) return false;
+
+    const envOk = this.hasRequiredEnv();
+
+    const extraOk = await this.customEnableCheck();
+    return envOk && extraOk;
+  }
+
+  protected hasRequiredEnv(): boolean {
+    return (
+      !this.meta.requires ||
+      this.meta.requires.every((k) => process.env[k] && process.env[k] !== "")
+    );
+  }
+
+  protected customEnableCheck(): boolean | Promise<boolean> {
+    return true; // subclasses override if needed
+  }
+
+  /* ------------------------------------------------------------------ */
+  /** Mandatory plugin actions ---------------------------------------- */
+  /* ------------------------------------------------------------------ */
+  abstract call(input?: string): Promise<string>;
+  abstract embed(input: string): Promise<MinimalEmbedding[]>;
+}
+
+export { PluginMeta, Plugin } from "./types";

package/src/plugins/asana.ts

@@ -1,10 +1,20 @@
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { Embeddable, MinimalEmbedding } from "../types";
 
-export class AsanaPlugin implements Plugin {
+export class AsanaPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "asana",
+    name: "Asana Plugin",
+    requires: ["ASANA_TOKEN"]
+  };
+
   private asanaClient = require("asana").ApiClient.instance;
 
   constructor() {
+    super(AsanaPlugin.meta);
+    
+    if (!this.isEnabled()) return;
+    
     this.asanaClient.authentications.token = process.env.ASANA_TOKEN;
     this.asanaClient.defaultHeaders = {
       "Asana-Enable": "new_user_task_lists,new_goal_memberships",

package/src/plugins/downloader/plugin.ts

@@ -1,10 +1,20 @@
 import fs from "fs";
-import { Plugin } from "../types";
+import { PluginBase, PluginMeta } from "../PluginBase";
 import { MinimalEmbedding } from "../../types";
 import { convertToText, processVideo } from "../../conversion";
 import { Downloader } from "./downloader";
 
-export class DownloaderPlugin implements Plugin {
+export class DownloaderPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "downloader",
+    name: "Downloader Plugin",
+    requires: []
+  };
+
+  constructor() {
+    super(DownloaderPlugin.meta);
+  }
+
   skipExt = ["jpg", "jpeg", "png", "gif"];
 
   extractUrls(userInput: string): string[] {

package/src/plugins/embedding.ts

@@ -6,9 +6,19 @@ import {
   pruneMetadata,
 } from "../embeddings";
 
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
+
+export class EmbeddingPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "embeddings",
+    name: "Embedding Plugin",
+    requires: []
+  };
+
+  constructor() {
+    super(EmbeddingPlugin.meta);
+  }
 
-export class EmbeddingPlugin implements Plugin {
   async embed() {
     return [];
   }

package/src/plugins/figma.ts

@@ -1,5 +1,6 @@
 import { Client } from "figma-js";
 import qs from "qs"; // Assumed to be installed
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin } from "./types";
 import { MinimalEmbedding } from "../types";
 import { askGptVision } from "../ai";
@@ -30,13 +31,28 @@ interface FigmaApiResponse {
   nodes: Record<string, FigmaNodeData>;
 }
 
-export class FigmaPlugin implements Plugin {
+export class FigmaPlugin extends PluginBase implements Plugin {
   private figmaToken: string;
   private client: ReturnType<typeof Client>;
 
+  static readonly meta: PluginMeta = {
+    key: "figma",
+    name: "Figma Plugin",
+    requires: ["FIGMA_API_KEY"],
+  };
+
   constructor() {
+    super(FigmaPlugin.meta);
+    if (!this.isEnabled()) return;
+
     this.figmaToken = process.env.FIGMA_API_KEY;
-    this.client = Client({ personalAccessToken: this.figmaToken });
+    this.client = this.figmaToken
+      ? Client({ personalAccessToken: this.figmaToken })
+      : null;
+  }
+
+  customEnableCheck(): boolean {
+    return !!this.figmaToken && !!this.client;
   }
 
   async loadFigmaData(url: string) {

package/src/plugins/github.ts

@@ -1,15 +1,44 @@
 import { Octokit } from "@octokit/rest";
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { parseHunks, hunksToPatch } from "../agents/tools/patch";
 import { MinimalEmbedding } from "../types";
 
-export class GitHubPlugin implements Plugin {
+export class GitHubPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "github",
+    name: "GitHub Plugin",
+    requires: ["GITHUB_TOKEN"],
+  };
+
   octokit: Octokit;
 
   constructor() {
-    this.octokit = new Octokit({
-      auth: process.env.GITHUB_TOKEN,
-    });
+    super(GitHubPlugin.meta);
+
+    const key = process.env.GITHUB_TOKEN;
+    if (key && this.isEnabled()) {
+      this.octokit = new Octokit({
+        auth: key,
+      });
+    }
+  }
+
+  protected customEnableCheck(): boolean {
+    // Additional check: ensure we can create the Octokit client
+    try {
+      const key = process.env.GITHUB_TOKEN;
+      if (key) {
+        this.octokit = new Octokit({ auth: key });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error(
+        "GITHUB PLUGIN: Failed to initialize Octokit client",
+        error
+      );
+      return false;
+    }
   }
 
   async embed(userPrompt: string): Promise<MinimalEmbedding[]> {

package/src/plugins/jira.ts

@@ -1,11 +1,20 @@
 import JiraClient from "jira-client";
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { MinimalEmbedding } from "../types";
 
-export class JiraPlugin implements Plugin {
+export class JiraPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "jira",
+    name: "Jira Plugin",
+    requires: ["JIRA_HOST", "JIRA_USER", "JIRA_PASSWORD"]
+  };
+
   jiraClient: JiraClient;
 
   constructor() {
+    super(JiraPlugin.meta);
+    
+    if (!this.isEnabled()) return;
     this.jiraClient = new JiraClient({
       protocol: "https",
       host: process.env.JIRA_HOST,

package/src/plugins/language.ts

@@ -1,6 +1,7 @@
 import { readFile, fileExists, fileStat } from "../utils";
 import { Language } from "../types";
 import { getConfig, getLanguageConfig } from "../config";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin } from "./types";
 import { GitHubPlugin } from "./github";
 import { AsanaPlugin } from "./asana";
@@ -8,8 +9,16 @@ import { JiraPlugin } from "./jira";
 import { LinearPlugin } from "./linear";
 import { PluginService } from "./plugins";
 
-export class LanguagePlugin implements Plugin {
-  constructor(private pluginService: PluginService) {}
+export class LanguagePlugin extends PluginBase implements Plugin {
+  static readonly meta: PluginMeta = {
+    key: "language",
+    name: "Language Plugin",
+    requires: []
+  };
+
+  constructor(private pluginService: PluginService) {
+    super(LanguagePlugin.meta);
+  }
 
   async embed(userPrompt: string) {
     return [];

package/src/plugins/linear.ts

@@ -1,11 +1,20 @@
 import { LinearClient } from "@linear/sdk";
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { MinimalEmbedding } from "../types";
 
-export class LinearPlugin implements Plugin {
+export class LinearPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "linear",
+    name: "Linear Plugin",
+    requires: ["LINEAR_API_KEY"],
+  };
+
   linearClient: LinearClient;
 
   constructor() {
+    super(LinearPlugin.meta);
+
+    if (!this.isEnabled()) return;
     this.linearClient = new LinearClient({
       apiKey: process.env.LINEAR_API_KEY,
     });

package/src/plugins/notion.ts

@@ -1,12 +1,21 @@
 import { Client } from "@notionhq/client";
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { PageObjectResponse } from "@notionhq/client/build/src/api-endpoints";
 import { Embeddable, MinimalEmbedding } from "../types";
 
-export class NotionPlugin implements Plugin {
+export class NotionPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "notion",
+    name: "Notion Plugin",
+    requires: ["NOTION_TOKEN"]
+  };
+
   notionClient: Client;
 
   constructor() {
+    super(NotionPlugin.meta);
+    
+    if (!this.isEnabled()) return;
     this.notionClient = new Client({
       auth: process.env.NOTION_TOKEN,
     });

package/src/plugins/plugins.ts

@@ -13,43 +13,109 @@ import { FigmaPlugin } from "./figma";
 import { UrlPlugin } from "./url";
 
 export class PluginService {
-  plugins = {
-    embeddings: new EmbeddingPlugin(),
-    vim: new VimPlugin(),
-    github: new GitHubPlugin(),
-    asana: new AsanaPlugin(),
-    linear: new LinearPlugin(),
-    jira: new JiraPlugin(),
-    notion: new NotionPlugin(),
-    download: new DownloaderPlugin(),
-    figma: new FigmaPlugin(),
-    language: new LanguagePlugin(this),
-    url: new UrlPlugin(),
-  } as Record<string, Plugin>;
+  private pluginMap = new Map<string, Plugin>();
+
+  constructor() {
+    // Register migrated PluginBase plugins
+    this.pluginMap.set("embeddings", new EmbeddingPlugin());
+    this.pluginMap.set("vim", new VimPlugin());
+    this.pluginMap.set("github", new GitHubPlugin());
+    this.pluginMap.set("asana", new AsanaPlugin());
+    this.pluginMap.set("linear", new LinearPlugin());
+    this.pluginMap.set("jira", new JiraPlugin());
+    this.pluginMap.set("notion", new NotionPlugin());
+    this.pluginMap.set("download", new DownloaderPlugin());
+    this.pluginMap.set("figma", new FigmaPlugin());
+    this.pluginMap.set("language", new LanguagePlugin(this));
+    this.pluginMap.set("url", new UrlPlugin());
+
+    // Keep legacy plugins for backward compatibility
+    // These will be removed once all consumers are updated
+  }
+
+  /* -------- lifecycle helpers ------------------------------------ */
+
+  /**
+   * Dynamically import a package / file and register it.
+   * @param spec ESM import specifier, e.g. "my-linear-plugin" or "./plugins/foo"
+   * @returns the key under which it was stored
+   */
+  async loadPlugin(spec: string): Promise<string> {
+    const { default: PluginCtor } = await import(spec);
+    const instance: Plugin = new PluginCtor(this); // assumes default export
+    this.pluginMap.set(instance.meta.key, instance);
+    return instance.meta.key;
+  }
+
+  /** Disable a plugin by its key; returns `true` if found. */
+  disablePlugin(key: string): boolean {
+    const p = this.pluginMap.get(key);
+    if (!p) return false;
+    p.disable();
+    return true;
+  }
+
+  /** Enable a plugin by its key; returns `true` if found. */
+  enablePlugin(key: string): boolean {
+    const p = this.pluginMap.get(key);
+    if (!p) return false;
+    p.enable();
+    return true;
+  }
+
+  /* -------- existing public API (updated for compatibility) ---------------------- */
 
   listPlugins() {
-    return Object.keys(this.plugins);
+    const newPlugins = [...this.pluginMap.keys()];
+    return newPlugins;
   }
 
   isPlugin(name: string) {
-    return name in this.plugins;
+    return this.pluginMap.has(name);
   }
 
-  registerPlugin(name, plugin: Plugin) {
-    this.plugins[name] = plugin;
+  registerPlugin(name: string, plugin: Plugin) {
+    this.pluginMap.set(name, plugin);
   }
 
-  async callMany(plugins: string[], user_input?: string) {
-    const calls = plugins.map((p) => this.plugins[p].call(user_input));
-    return (await Promise.all(calls)).join("\n\n");
+  async callMany(plugins: string[], userInput?: string) {
+    const calls = plugins.map(async (p) => {
+      return this.call(p, userInput);
+    });
+
+    const results = await Promise.all(calls);
+    return results.filter((result) => result !== "").join("\n\n");
   }
 
-  async call(kind: string, user_input?: string) {
-    return this.plugins[kind].call(user_input);
+  async call(kind: string, userInput?: string) {
+    // Check new plugin system first
+    const newPlugin = this.pluginMap.get(kind);
+
+    if (!newPlugin) {
+      throw new Error(`Plugin ${kind} not found`);
+    }
+
+    const enabled = await newPlugin.isEnabled();
+    if (!enabled) {
+      console.log(`Plugin ${kind} is disabled, skipping`);
+      return "";
+    }
+    return newPlugin.call(userInput);
   }
 
-  async embed(kind: string, user_input: string) {
-    return this.plugins[kind].embed(user_input);
+  async embed(kind: string, userInput: string) {
+    // Check new plugin system first
+    const newPlugin = this.pluginMap.get(kind);
+    if (!newPlugin) {
+      throw new Error(`Plugin ${kind} not found`);
+    }
+
+    const enabled = await newPlugin.isEnabled();
+    if (!enabled) {
+      console.log(`Plugin ${kind} is disabled, skipping`);
+      return [];
+    }
+    return newPlugin.embed ? newPlugin.embed(userInput) : [];
   }
 }
 

package/src/plugins/types.ts

@@ -1,5 +1,18 @@
 import { Embeddable, MinimalEmbedding } from "../types";
+
+export interface PluginMeta {
+  key: string;
+  name: string;
+  description?: string;
+  requires?: string[]; // Environment variables required
+}
+
 export interface Plugin {
-  call(user_input?: string): Promise<string>;
-  embed(user_input?: string): Promise<MinimalEmbedding[]>;
+  call(userInput?: string): Promise<string>;
+  embed(userInput?: string): Promise<MinimalEmbedding[]>;
+  enable(): void;
+  disable(): void;
+  isEnabled(): Promise<boolean>;
+
+  meta: PluginMeta;
 }

package/src/plugins/url.ts

@@ -1,10 +1,21 @@
+import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin } from "./types";
 import { MinimalEmbedding } from "../types";
 import axios from "axios";
 import * as cheerio from "cheerio";
 import loadWebpage from "../agents/tools/loadWebpage";
 
-export class UrlPlugin implements Plugin {
+export class UrlPlugin extends PluginBase implements Plugin {
+  static readonly meta: PluginMeta = {
+    key: "url",
+    name: "URL Plugin",
+    requires: []
+  };
+
+  constructor() {
+    super(UrlPlugin.meta);
+  }
+
   async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
     const urls = this.extractUrls(userPrompt);
     const embeddings = await Promise.all(urls.map(this.fetchAndParseUrl));

package/src/plugins/vim.ts

@@ -1,8 +1,18 @@
 import glob from "glob";
 import { readFile, fileExists, fileStat } from "../utils";
-import { Plugin } from "./types";
+import { PluginBase, PluginMeta } from "./PluginBase";
+
+export class VimPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "vim",
+    name: "Vim Plugin",
+    requires: []
+  };
+
+  constructor() {
+    super(VimPlugin.meta);
+  }
 
-export class VimPlugin implements Plugin {
   async embed(userPrompt: string) {
     return [];
   }

package/ts_build/src/plugins/EmbeddingPluginV2.d.ts

@@ -0,0 +1,7 @@
+import { PluginBase } from "./PluginBase";
+import { MinimalEmbedding } from "../types";
+export declare class EmbeddingPluginV2 extends PluginBase {
+    constructor();
+    embed(): Promise<MinimalEmbedding[]>;
+    call(userPrompt?: string): Promise<string>;
+}

package/ts_build/src/plugins/EmbeddingPluginV2.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingPluginV2 = void 0;
+const PluginBase_1 = require("./PluginBase");
+const config_1 = require("../config");
+const embeddings_1 = require("../embeddings");
+class EmbeddingPluginV2 extends PluginBase_1.PluginBase {
+    constructor() {
+        const meta = {
+            key: "embeddings-v2",
+            name: "Embeddings Plugin V2",
+            description: "Enhanced embedding plugin with enable/disable support",
+            requires: [],
+        };
+        super(meta);
+    }
+    async embed() {
+        return [];
+    }
+    async call(userPrompt) {
+        if (!userPrompt) {
+            return "EMBEDDING PLUGIN V2: No prompt provided";
+        }
+        const count = 7;
+        const embeddings = await (0, embeddings_1.getConfiguredEmbeddings)();
+        const config = await (0, config_1.getConfig)();
+        const results = await (0, embeddings_1.queryEmbedding)(userPrompt, embeddings, config.embeddingModel);
+        const context = results.slice(0, count);
+        (0, embeddings_1.pruneVector)(context);
+        (0, embeddings_1.pruneMetadata)(context);
+        for (const entry of context) {
+            console.log(`EMBEDDING PLUGIN V2: Reading entry ${entry.id}`);
+        }
+        const contextLength = JSON.stringify(context).split(" ").length;
+        console.log(`EMBEDDING PLUGIN V2: Found ${context.length} entries. Loading ${contextLength} words`);
+        return `EMBEDDING PLUGIN V2: Our knowledgebase contains this information which can be used to answer the question:
+    ${JSON.stringify(context)}`;
+    }
+}
+exports.EmbeddingPluginV2 = EmbeddingPluginV2;
+//# sourceMappingURL=EmbeddingPluginV2.js.map

package/ts_build/src/plugins/EmbeddingPluginV2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddingPluginV2.js","sourceRoot":"","sources":["../../../src/plugins/EmbeddingPluginV2.ts"],"names":[],"mappings":";;;AAAA,6CAAsD;AAEtD,sCAAsC;AACtC,8CAKuB;AAEvB,MAAa,iBAAkB,SAAQ,uBAAU;IAC/C;QACE,MAAM,IAAI,GAAe;YACvB,GAAG,EAAE,eAAe;YACpB,IAAI,EAAE,sBAAsB;YAC5B,WAAW,EAAE,uDAAuD;YACpE,QAAQ,EAAE,EAAE;SACb,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAED,KAAK,CAAC,KAAK;QACT,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,UAAmB;QAC5B,IAAI,CAAC,UAAU,EAAE;YACf,OAAO,yCAAyC,CAAC;SAClD;QAED,MAAM,KAAK,GAAG,CAAC,CAAC;QAChB,MAAM,UAAU,GAAG,MAAM,IAAA,oCAAuB,GAAE,CAAC;QACnD,MAAM,MAAM,GAAG,MAAM,IAAA,kBAAS,GAAE,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,IAAA,2BAAc,EAClC,UAAU,EACV,UAAU,EACV,MAAM,CAAC,cAAc,CACtB,CAAC;QACF,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAExC,IAAA,wBAAW,EAAC,OAAO,CAAC,CAAC;QACrB,IAAA,0BAAa,EAAC,OAAO,CAAC,CAAC;QAEvB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YAC3B,OAAO,CAAC,GAAG,CAAC,sCAAsC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/D;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QAChE,OAAO,CAAC,GAAG,CACT,8BAA8B,OAAO,CAAC,MAAM,qBAAqB,aAAa,QAAQ,CACvF,CAAC;QAEF,OAAO;MACL,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,CAAC;CACF;AA7CD,8CA6CC"}

package/ts_build/src/plugins/GitHubPluginV2.d.ts

@@ -0,0 +1,10 @@
+import { PluginBase } from "./PluginBase";
+import { MinimalEmbedding } from "../types";
+export declare class GitHubPluginV2 extends PluginBase {
+    private octokit?;
+    constructor();
+    protected customEnableCheck(): boolean;
+    embed(userPrompt: string): Promise<MinimalEmbedding[]>;
+    extractUrls(userPrompt: string): string[];
+    call(userPrompt?: string): Promise<string>;
+}

package/ts_build/src/plugins/GitHubPluginV2.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubPluginV2 = void 0;
+const PluginBase_1 = require("./PluginBase");
+const rest_1 = require("@octokit/rest");
+class GitHubPluginV2 extends PluginBase_1.PluginBase {
+    octokit;
+    constructor() {
+        const meta = {
+            key: "github-v2",
+            name: "GitHub Plugin V2",
+            description: "Enhanced GitHub plugin with automatic enable/disable based on token availability",
+            requires: ["GITHUB_TOKEN"],
+        };
+        super(meta);
+    }
+    customEnableCheck() {
+        try {
+            const key = process.env.GITHUB_TOKEN;
+            if (key) {
+                this.octokit = new rest_1.Octokit({ auth: key });
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error("GITHUB PLUGIN V2: Failed to initialize Octokit client", error);
+            return false;
+        }
+    }
+    async embed(userPrompt) {
+        const urls = this.extractUrls(userPrompt);
+        if (!urls.length)
+            return [];
+        return [];
+    }
+    extractUrls(userPrompt) {
+        const prUrlRegex = /https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/pull\/(\d+)/g;
+        const matches = userPrompt.match(prUrlRegex);
+        return matches || [];
+    }
+    async call(userPrompt) {
+        if (!userPrompt) {
+            return "GITHUB PLUGIN V2: No prompt provided";
+        }
+        if (!this.octokit) {
+            return "GITHUB PLUGIN V2: GitHub client not initialized";
+        }
+        const urls = this.extractUrls(userPrompt);
+        if (!urls.length) {
+            return "GITHUB PLUGIN V2: No pull request URLs detected.";
+        }
+        return `GITHUB PLUGIN V2: Found ${urls.length} GitHub URLs. Enhanced processing with enable/disable support.`;
+    }
+}
+exports.GitHubPluginV2 = GitHubPluginV2;
+//# sourceMappingURL=GitHubPluginV2.js.map

package/ts_build/src/plugins/GitHubPluginV2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubPluginV2.js","sourceRoot":"","sources":["../../../src/plugins/GitHubPluginV2.ts"],"names":[],"mappings":";;;AAAA,6CAAsD;AAEtD,wCAAwC;AAExC,MAAa,cAAe,SAAQ,uBAAU;IACpC,OAAO,CAAW;IAE1B;QACE,MAAM,IAAI,GAAe;YACvB,GAAG,EAAE,WAAW;YAChB,IAAI,EAAE,kBAAkB;YACxB,WAAW,EAAE,kFAAkF;YAC/F,QAAQ,EAAE,CAAC,cAAc,CAAC;SAC3B,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAES,iBAAiB;QAEzB,IAAI;YACF,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;YACrC,IAAI,GAAG,EAAE;gBACP,IAAI,CAAC,OAAO,GAAG,IAAI,cAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;gBAC1C,OAAO,IAAI,CAAC;aACb;YACD,OAAO,KAAK,CAAC;SACd;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,uDAAuD,EAAE,KAAK,CAAC,CAAC;YAC9E,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,UAAkB;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QAG5B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,WAAW,CAAC,UAAkB;QAC5B,MAAM,UAAU,GACd,yDAAyD,CAAC;QAC5D,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7C,OAAO,OAAO,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,UAAmB;QAC5B,IAAI,CAAC,UAAU,EAAE;YACf,OAAO,sCAAsC,CAAC;SAC/C;QAED,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACjB,OAAO,iDAAiD,CAAC;SAC1D;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAE1C,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,OAAO,kDAAkD,CAAC;SAC3D;QAED,OAAO,2BAA2B,IAAI,CAAC,MAAM,gEAAgE,CAAC;IAChH,CAAC;CACF;AA5DD,wCA4DC"}

package/ts_build/src/plugins/PluginBase.d.ts

@@ -0,0 +1,15 @@
+import { MinimalEmbedding } from "../types";
+import { Plugin, PluginMeta } from "./types";
+export declare abstract class PluginBase implements Plugin {
+    readonly meta: PluginMeta;
+    private active;
+    constructor(meta: PluginMeta);
+    enable(): void;
+    disable(): void;
+    isEnabled(): Promise<boolean>;
+    protected hasRequiredEnv(): boolean;
+    protected customEnableCheck(): boolean | Promise<boolean>;
+    abstract call(input?: string): Promise<string>;
+    abstract embed(input: string): Promise<MinimalEmbedding[]>;
+}
+export { PluginMeta, Plugin } from "./types";