@burdenoff/vibe-plugin-ai 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,7 +1,420 @@
 // @bun
 // src/index.ts
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { Elysia as Elysia2 } from "elysia";
+
+// src/db/prompts.ts
+import { Database } from "bun:sqlite";
 import { join } from "path";
+import os from "os";
+import { existsSync, mkdirSync } from "fs";
+var VALID_CATEGORIES = [
+  "GENERAL",
+  "CODING",
+  "DEBUGGING",
+  "REVIEW",
+  "DOCUMENTATION",
+  "TESTING",
+  "DEPLOYMENT",
+  "CUSTOM"
+];
+
+class PromptDatabase {
+  db;
+  constructor(dbPath) {
+    const dir = join(os.homedir(), ".vibecontrols");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const path = dbPath || join(dir, "ai-prompts.db");
+    this.db = new Database(path);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA busy_timeout = 5000");
+    this.db.exec("PRAGMA synchronous = NORMAL");
+    this.initializeSchema();
+  }
+  initializeSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        content TEXT NOT NULL,
+        category TEXT CHECK(category IS NULL OR category IN ('GENERAL','CODING','DEBUGGING','REVIEW','DOCUMENTATION','TESTING','DEPLOYMENT','CUSTOM')),
+        tags TEXT DEFAULT '[]',
+        variables TEXT DEFAULT '[]',
+        is_shared INTEGER DEFAULT 0,
+        created_by TEXT NOT NULL DEFAULT 'local',
+        usage_count INTEGER DEFAULT 0,
+        last_used TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        deleted_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_prompts_category ON prompts(category);
+      CREATE INDEX IF NOT EXISTS idx_prompts_is_shared ON prompts(is_shared);
+      CREATE INDEX IF NOT EXISTS idx_prompts_created_by ON prompts(created_by);
+      CREATE INDEX IF NOT EXISTS idx_prompts_deleted_at ON prompts(deleted_at);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_prompts_name ON prompts(name) WHERE deleted_at IS NULL;
+    `);
+  }
+  generateId() {
+    return crypto.randomUUID();
+  }
+  rowToPrompt(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      content: row.content,
+      category: row.category,
+      tags: JSON.parse(row.tags || "[]"),
+      variables: JSON.parse(row.variables || "[]"),
+      isShared: row.is_shared === 1,
+      createdBy: row.created_by,
+      usageCount: row.usage_count,
+      lastUsed: row.last_used,
+      metadata: JSON.parse(row.metadata || "{}"),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      deletedAt: row.deleted_at
+    };
+  }
+  extractVariables(content) {
+    const variableRegex = /\{\{(\w+)\}\}/g;
+    const variables = [];
+    let match;
+    while ((match = variableRegex.exec(content)) !== null) {
+      if (match[1] && !variables.includes(match[1])) {
+        variables.push(match[1]);
+      }
+    }
+    return variables;
+  }
+  create(input) {
+    const id = this.generateId();
+    const now = new Date().toISOString();
+    const variables = input.variables || this.extractVariables(input.content);
+    const category = input.category && VALID_CATEGORIES.includes(input.category) ? input.category : null;
+    const stmt = this.db.prepare(`
+      INSERT INTO prompts (id, name, content, category, tags, variables, is_shared, created_by, usage_count, metadata, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'local', 0, ?, ?, ?)
+    `);
+    stmt.run(id, input.name, input.content, category, JSON.stringify(input.tags || []), JSON.stringify(variables), input.isShared ? 1 : 0, JSON.stringify(input.metadata || {}), now, now);
+    return this.getById(id);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM prompts WHERE id = ? AND deleted_at IS NULL").get(id);
+    return row ? this.rowToPrompt(row) : null;
+  }
+  list(filter, pagination) {
+    const conditions = ["deleted_at IS NULL"];
+    const params = [];
+    if (filter?.category) {
+      conditions.push("category = ?");
+      params.push(filter.category);
+    }
+    if (filter?.isShared !== undefined) {
+      conditions.push("is_shared = ?");
+      params.push(filter.isShared ? 1 : 0);
+    }
+    if (filter?.createdBy) {
+      conditions.push("created_by = ?");
+      params.push(filter.createdBy);
+    }
+    const whereClause = conditions.join(" AND ");
+    const limit = pagination?.limit || 50;
+    const offset = pagination?.offset || 0;
+    const countRow = this.db.prepare(`SELECT COUNT(*) as count FROM prompts WHERE ${whereClause}`).get(...params);
+    const rows = this.db.prepare(`SELECT * FROM prompts WHERE ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+    let items = rows.map((r) => this.rowToPrompt(r));
+    let total = countRow.count;
+    if (filter?.tags && filter.tags.length > 0) {
+      items = items.filter((prompt) => filter.tags.some((tag) => prompt.tags.includes(tag)));
+      total = items.length;
+    }
+    return {
+      items,
+      total,
+      hasMore: offset + items.length < total
+    };
+  }
+  search(query, category, limit) {
+    const conditions = [
+      "deleted_at IS NULL",
+      "(LOWER(name) LIKE ? OR LOWER(content) LIKE ?)"
+    ];
+    const pattern = `%${query.toLowerCase()}%`;
+    const params = [pattern, pattern];
+    if (category) {
+      conditions.push("category = ?");
+      params.push(category);
+    }
+    const rows = this.db.prepare(`SELECT * FROM prompts WHERE ${conditions.join(" AND ")} ORDER BY usage_count DESC LIMIT ?`).all(...params, limit || 20);
+    return rows.map((r) => this.rowToPrompt(r));
+  }
+  getPopular(limit) {
+    const rows = this.db.prepare("SELECT * FROM prompts WHERE deleted_at IS NULL ORDER BY usage_count DESC LIMIT ?").all(limit || 10);
+    return rows.map((r) => this.rowToPrompt(r));
+  }
+  update(id, input) {
+    const existing = this.getById(id);
+    if (!existing)
+      return null;
+    const sets = ["updated_at = ?"];
+    const now = new Date().toISOString();
+    const params = [now];
+    if (input.name !== undefined) {
+      sets.push("name = ?");
+      params.push(input.name);
+    }
+    if (input.content !== undefined) {
+      sets.push("content = ?");
+      params.push(input.content);
+      const variables = input.variables || this.extractVariables(input.content);
+      sets.push("variables = ?");
+      params.push(JSON.stringify(variables));
+    }
+    if (input.category !== undefined) {
+      sets.push("category = ?");
+      params.push(input.category);
+    }
+    if (input.tags !== undefined) {
+      sets.push("tags = ?");
+      params.push(JSON.stringify(input.tags));
+    }
+    if (input.variables !== undefined && input.content === undefined) {
+      sets.push("variables = ?");
+      params.push(JSON.stringify(input.variables));
+    }
+    if (input.isShared !== undefined) {
+      sets.push("is_shared = ?");
+      params.push(input.isShared ? 1 : 0);
+    }
+    if (input.metadata !== undefined) {
+      sets.push("metadata = ?");
+      params.push(JSON.stringify(input.metadata));
+    }
+    params.push(id);
+    this.db.prepare(`UPDATE prompts SET ${sets.join(", ")} WHERE id = ? AND deleted_at IS NULL`).run(...params);
+    return this.getById(id);
+  }
+  delete(id) {
+    const result = this.db.prepare("UPDATE prompts SET deleted_at = datetime('now'), updated_at = datetime('now') WHERE id = ? AND deleted_at IS NULL").run(id);
+    return result.changes > 0;
+  }
+  use(id) {
+    const existing = this.getById(id);
+    if (!existing)
+      return null;
+    this.db.prepare("UPDATE prompts SET usage_count = usage_count + 1, last_used = datetime('now'), updated_at = datetime('now') WHERE id = ?").run(id);
+    return this.getById(id);
+  }
+  duplicate(id, newName) {
+    const original = this.getById(id);
+    if (!original)
+      return null;
+    return this.create({
+      name: newName,
+      content: original.content,
+      category: original.category || undefined,
+      tags: original.tags,
+      variables: original.variables,
+      isShared: original.isShared,
+      metadata: original.metadata
+    });
+  }
+  renderPrompt(content, variables) {
+    let rendered = content;
+    for (const [key, value] of Object.entries(variables)) {
+      const placeholder = `{{${key}}}`;
+      while (rendered.includes(placeholder)) {
+        rendered = rendered.replace(placeholder, String(value));
+      }
+    }
+    return rendered;
+  }
+  renderById(id, variables) {
+    const prompt = this.getById(id);
+    if (!prompt)
+      return null;
+    return this.renderPrompt(prompt.content, variables);
+  }
+  close() {
+    this.db.close();
+  }
+}
+
+// src/routes/prompts.ts
+import { Elysia, t } from "elysia";
+var PromptCategoryEnum = t.Optional(t.Union([
+  t.Literal("GENERAL"),
+  t.Literal("CODING"),
+  t.Literal("DEBUGGING"),
+  t.Literal("REVIEW"),
+  t.Literal("DOCUMENTATION"),
+  t.Literal("TESTING"),
+  t.Literal("DEPLOYMENT"),
+  t.Literal("CUSTOM")
+]));
+function createPromptRoutes(promptDb) {
+  return new Elysia({ prefix: "/prompts" }).get("/", ({ query }) => {
+    const filter = {};
+    if (query.category) {
+      filter.category = query.category;
+    }
+    if (query.tags) {
+      filter.tags = query.tags.split(",").map((t2) => t2.trim());
+    }
+    if (query.isShared !== undefined) {
+      filter.isShared = query.isShared === "true";
+    }
+    if (query.createdBy) {
+      filter.createdBy = query.createdBy;
+    }
+    const pagination = {
+      limit: query.limit ? parseInt(query.limit, 10) : 50,
+      offset: query.offset ? parseInt(query.offset, 10) : 0
+    };
+    return promptDb.list(Object.keys(filter).length > 0 ? filter : undefined, pagination);
+  }, {
+    query: t.Object({
+      category: t.Optional(t.String()),
+      tags: t.Optional(t.String()),
+      isShared: t.Optional(t.String()),
+      createdBy: t.Optional(t.String()),
+      limit: t.Optional(t.String()),
+      offset: t.Optional(t.String())
+    })
+  }).get("/search", ({ query }) => {
+    const results = promptDb.search(query.q, query.category, query.limit ? parseInt(query.limit, 10) : undefined);
+    return { items: results, total: results.length };
+  }, {
+    query: t.Object({
+      q: t.String(),
+      category: t.Optional(t.String()),
+      limit: t.Optional(t.String())
+    })
+  }).get("/popular", ({ query }) => {
+    const results = promptDb.getPopular(query.limit ? parseInt(query.limit, 10) : undefined);
+    return { items: results, total: results.length };
+  }, {
+    query: t.Object({
+      limit: t.Optional(t.String())
+    })
+  }).get("/:id", ({ params, set }) => {
+    const prompt = promptDb.getById(params.id);
+    if (!prompt) {
+      set.status = 404;
+      return { error: "Prompt not found" };
+    }
+    return prompt;
+  }, {
+    params: t.Object({ id: t.String() })
+  }).post("/", ({ body, set }) => {
+    try {
+      const prompt = promptDb.create(body);
+      set.status = 201;
+      return prompt;
+    } catch (err) {
+      set.status = 400;
+      return {
+        error: err instanceof Error ? err.message : "Failed to create prompt"
+      };
+    }
+  }, {
+    body: t.Object({
+      name: t.String({ minLength: 1 }),
+      content: t.String({ minLength: 1 }),
+      category: PromptCategoryEnum,
+      tags: t.Optional(t.Array(t.String())),
+      variables: t.Optional(t.Array(t.String())),
+      isShared: t.Optional(t.Boolean()),
+      metadata: t.Optional(t.Record(t.String(), t.Any()))
+    })
+  }).put("/:id", ({ params, body, set }) => {
+    const updated = promptDb.update(params.id, body);
+    if (!updated) {
+      set.status = 404;
+      return { error: "Prompt not found" };
+    }
+    return updated;
+  }, {
+    params: t.Object({ id: t.String() }),
+    body: t.Object({
+      name: t.Optional(t.String({ minLength: 1 })),
+      content: t.Optional(t.String({ minLength: 1 })),
+      category: t.Optional(t.Union([
+        t.Literal("GENERAL"),
+        t.Literal("CODING"),
+        t.Literal("DEBUGGING"),
+        t.Literal("REVIEW"),
+        t.Literal("DOCUMENTATION"),
+        t.Literal("TESTING"),
+        t.Literal("DEPLOYMENT"),
+        t.Literal("CUSTOM"),
+        t.Null()
+      ])),
+      tags: t.Optional(t.Array(t.String())),
+      variables: t.Optional(t.Array(t.String())),
+      isShared: t.Optional(t.Boolean()),
+      metadata: t.Optional(t.Record(t.String(), t.Any()))
+    })
+  }).delete("/:id", ({ params, set }) => {
+    const deleted = promptDb.delete(params.id);
+    if (!deleted) {
+      set.status = 404;
+      return { error: "Prompt not found" };
+    }
+    return { success: true };
+  }, {
+    params: t.Object({ id: t.String() })
+  }).post("/:id/use", ({ params, set }) => {
+    const prompt = promptDb.use(params.id);
+    if (!prompt) {
+      set.status = 404;
+      return { error: "Prompt not found" };
+    }
+    return prompt;
+  }, {
+    params: t.Object({ id: t.String() })
+  }).post("/:id/duplicate", ({ params, body, set }) => {
+    try {
+      const prompt = promptDb.duplicate(params.id, body.name);
+      if (!prompt) {
+        set.status = 404;
+        return { error: "Prompt not found" };
+      }
+      set.status = 201;
+      return prompt;
+    } catch (err) {
+      set.status = 400;
+      return {
+        error: err instanceof Error ? err.message : "Failed to duplicate prompt"
+      };
+    }
+  }, {
+    params: t.Object({ id: t.String() }),
+    body: t.Object({
+      name: t.String({ minLength: 1 })
+    })
+  }).post("/:id/render", ({ params, body, set }) => {
+    const rendered = promptDb.renderById(params.id, body.variables);
+    if (rendered === null) {
+      set.status = 404;
+      return { error: "Prompt not found" };
+    }
+    return { rendered };
+  }, {
+    params: t.Object({ id: t.String() }),
+    body: t.Object({
+      variables: t.Record(t.String(), t.Any())
+    })
+  });
+}
+
+// src/index.ts
 var AI_TOOLS = [
   {
     name: "claude-code",
@@ -69,16 +482,62 @@ function runInstallCommand(command) {
   return proc.exitCode === 0;
 }
 function findConfigFiles(tool, directory) {
-  return tool.configFiles.filter((f) => existsSync(join(directory, f)));
+  return tool.configFiles.filter((f) => {
+    try {
+      return Bun.file(join2(directory, f)).size > 0;
+    } catch {
+      return false;
+    }
+  });
+}
+var promptDb = null;
+function getPromptDb() {
+  if (!promptDb) {
+    promptDb = new PromptDatabase;
+  }
+  return promptDb;
 }
 var vibePlugin = {
   name: "ai",
-  version: "2.0.0",
-  description: "AI tool management and integration",
-  tags: ["cli", "integration"],
+  version: "3.0.0",
+  description: "AI tool management, prompt templates, and integration",
+  tags: ["backend", "cli", "integration"],
   cliCommand: "ai",
+  apiPrefix: "/api/ai",
+  createRoutes() {
+    const db = getPromptDb();
+    return new Elysia2().get("/tools", () => {
+      return {
+        tools: AI_TOOLS.map((tool) => {
+          const { installed, version } = isToolInstalled(tool);
+          const configs = findConfigFiles(tool, process.cwd());
+          return {
+            name: tool.name,
+            displayName: tool.displayName,
+            description: tool.description,
+            installed,
+            version: installed ? version.split(`
+`)[0] : "",
+            configFiles: tool.configFiles,
+            foundConfigs: configs,
+            installCommand: tool.installCommand
+          };
+        })
+      };
+    }).use(createPromptRoutes(db));
+  },
+  onServerStart(_app, hostServices) {
+    getPromptDb();
+    hostServices?.logger?.info("ai-plugin", "AI plugin started \u2014 prompt database initialized");
+  },
+  onServerStop() {
+    if (promptDb) {
+      promptDb.close();
+      promptDb = null;
+    }
+  },
   onCliSetup(program, _hostServices) {
-    const aiCmd = program.command("ai").description("Manage AI coding tools and configurations");
+    const aiCmd = program.command("ai").description("Manage AI coding tools and prompt templates");
     aiCmd.command("list").description("List all supported AI tools and their status").option("--cwd <dir>", "Project directory to check configs", process.cwd()).action((options) => {
       console.log(`
   \x1B[1m\u2500\u2500 AI Tools \u2500\u2500\x1B[0m
@@ -99,10 +558,10 @@ var vibePlugin = {
         console.log();
       }
     });
-    aiCmd.command("install").description("Install an AI tool").argument("<tool>", `Tool name (${AI_TOOLS.map((t) => t.name).join(", ")})`).action((toolName) => {
-      const tool = AI_TOOLS.find((t) => t.name === toolName);
+    aiCmd.command("install").description("Install an AI tool").argument("<tool>", `Tool name (${AI_TOOLS.map((t2) => t2.name).join(", ")})`).action((toolName) => {
+      const tool = AI_TOOLS.find((t2) => t2.name === toolName);
       if (!tool) {
-        console.error(`\x1B[31mError:\x1B[0m Unknown tool '${toolName}'. Available: ${AI_TOOLS.map((t) => t.name).join(", ")}`);
+        console.error(`\x1B[31mError:\x1B[0m Unknown tool '${toolName}'. Available: ${AI_TOOLS.map((t2) => t2.name).join(", ")}`);
         process.exit(1);
       }
       if (!tool.installCommand) {
@@ -128,26 +587,28 @@ var vibePlugin = {
         process.exit(1);
       }
     });
-    aiCmd.command("init").description("Initialize AI tool config in the current project").argument("<tool>", "Tool name").option("--cwd <dir>", "Project directory", process.cwd()).action((toolName, options) => {
-      const tool = AI_TOOLS.find((t) => t.name === toolName);
+    aiCmd.command("init").description("Initialize AI tool config in the current project").argument("<tool>", "Tool name").option("--cwd <dir>", "Project directory", process.cwd()).action(async (toolName, options) => {
+      const tool = AI_TOOLS.find((t2) => t2.name === toolName);
       if (!tool) {
-        console.error(`\x1B[31mError:\x1B[0m Unknown tool '${toolName}'. Available: ${AI_TOOLS.map((t) => t.name).join(", ")}`);
+        console.error(`\x1B[31mError:\x1B[0m Unknown tool '${toolName}'. Available: ${AI_TOOLS.map((t2) => t2.name).join(", ")}`);
         process.exit(1);
       }
       const dir = options.cwd;
       const primaryConfig = tool.configFiles[0];
-      const configPath = join(dir, primaryConfig);
-      if (existsSync(configPath)) {
-        console.log(`  \x1B[33m\u26A0\x1B[0m  ${primaryConfig} already exists in ${dir}`);
-        return;
-      }
+      const configPath = join2(dir, primaryConfig);
+      try {
+        if (Bun.file(configPath).size >= 0) {
+          console.log(`  \x1B[33m\u26A0\x1B[0m  ${primaryConfig} already exists in ${dir}`);
+          return;
+        }
+      } catch {}
       const segments = primaryConfig.split("/");
       if (segments.length > 1) {
-        const parentDir = join(dir, ...segments.slice(0, -1));
-        mkdirSync(parentDir, { recursive: true });
+        const parentDir = join2(dir, ...segments.slice(0, -1));
+        mkdirSync2(parentDir, { recursive: true });
       }
       const content = generateStarterConfig(tool);
-      writeFileSync(configPath, content);
+      await Bun.write(configPath, content);
       console.log(`
   \x1B[32m\u2713 Created ${primaryConfig}\x1B[0m in ${dir}
 `);
@@ -171,6 +632,71 @@ var vibePlugin = {
 `);
       }
     });
+    const promptsCmd = aiCmd.command("prompts").description("Manage prompt templates");
+    promptsCmd.command("list").description("List all prompt templates").option("--shared", "Show only shared prompts").option("--category <cat>", "Filter by category").option("--limit <n>", "Max results", "20").action((options) => {
+      const db = getPromptDb();
+      const result = db.list({
+        isShared: options.shared !== undefined ? options.shared : undefined,
+        category: options.category
+      }, { limit: parseInt(options.limit, 10) });
+      if (result.items.length === 0) {
+        console.log(`
+  No prompts found.
+`);
+        return;
+      }
+      console.log(`
+  \x1B[1m\u2500\u2500 Prompts (${result.total}) \u2500\u2500\x1B[0m
+`);
+      for (const prompt of result.items) {
+        const shared = prompt.isShared ? " \x1B[36m[shared]\x1B[0m" : "";
+        const tags = prompt.tags.length > 0 ? ` \x1B[33m[${prompt.tags.join(", ")}]\x1B[0m` : "";
+        const uses = prompt.usageCount > 0 ? ` \x1B[90m(${prompt.usageCount} uses)\x1B[0m` : "";
+        console.log(`  \x1B[1m${prompt.name}\x1B[0m${shared}${tags}${uses}`);
+        const preview = prompt.content.replace(/\n/g, " ").slice(0, 60).trim();
+        console.log(`    ${preview}${prompt.content.length > 60 ? "..." : ""}`);
+        console.log();
+      }
+    });
+    promptsCmd.command("search").description("Search prompts by name or content").argument("<query>", "Search query").option("--limit <n>", "Max results", "10").action((query, options) => {
+      const db = getPromptDb();
+      const results = db.search(query, undefined, parseInt(options.limit, 10));
+      if (results.length === 0) {
+        console.log(`
+  No prompts matching "${query}".
+`);
+        return;
+      }
+      console.log(`
+  \x1B[1m\u2500\u2500 Search: "${query}" (${results.length} results) \u2500\u2500\x1B[0m
+`);
+      for (const prompt of results) {
+        console.log(`  \x1B[1m${prompt.name}\x1B[0m \x1B[90m(${prompt.usageCount} uses)\x1B[0m`);
+        const preview = prompt.content.replace(/\n/g, " ").slice(0, 60).trim();
+        console.log(`    ${preview}${prompt.content.length > 60 ? "..." : ""}`);
+        console.log();
+      }
+    });
+    promptsCmd.command("show").description("Show a prompt by ID").argument("<id>", "Prompt ID").action((id) => {
+      const db = getPromptDb();
+      const prompt = db.getById(id);
+      if (!prompt) {
+        console.error(`\x1B[31mError:\x1B[0m Prompt not found: ${id}`);
+        process.exit(1);
+      }
+      console.log(`
+  \x1B[1m${prompt.name}\x1B[0m`);
+      if (prompt.tags.length > 0) {
+        console.log(`  Tags: ${prompt.tags.join(", ")}`);
+      }
+      if (prompt.variables.length > 0) {
+        console.log(`  Variables: ${prompt.variables.map((v) => `{{${v}}}`).join(", ")}`);
+      }
+      console.log(`  Shared: ${prompt.isShared ? "yes" : "no"} | Uses: ${prompt.usageCount}`);
+      console.log(`
+${prompt.content}
+`);
+    });
   }
 };
 function generateStarterConfig(tool) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@burdenoff/vibe-plugin-ai",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "main": "./dist/index.js",
   "type": "module",
   "engines": {
     "bun": ">=1.3.0"
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --external elysia",
     "lint": "eslint ./src",
     "format": "bunx prettier . --write",
     "format:check": "bunx prettier . --check",
@@ -35,14 +35,21 @@
     "url": "https://github.com/tvvignesh"
   },
   "license": "SEE LICENSE IN LICENSE",
-  "description": "AI tool management plugin for VibeControls Agent — manage Claude Code, OpenCode, Codex, Copilot, and more (Bun runtime)",
+  "description": "AI tool management and prompt templates plugin for VibeControls Agent — manage AI tools, prompt templates with variables (Bun runtime)",
+  "dependencies": {
+    "elysia": "^1.3.0"
+  },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/bun": "^1.2.16",
+    "bun-types": "^1.3.9",
     "commander": "^14.0.3",
     "eslint": "^9.30.1",
+    "globals": "^17.3.0",
     "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.56.0"
   },
   "peerDependencies": {
     "@burdenoff/vibe-agent": ">=2.0.0"