@dexto/core 1.1.10 → 1.2.0

package/dist/prompts/prompt-manager.cjs

@@ -0,0 +1,374 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prompt_manager_exports = {};
+__export(prompt_manager_exports, {
+  PromptManager: () => PromptManager
+});
+module.exports = __toCommonJS(prompt_manager_exports);
+var import_mcp_prompt_provider = require("./providers/mcp-prompt-provider.js");
+var import_file_prompt_provider = require("./providers/file-prompt-provider.js");
+var import_starter_prompt_provider = require("./providers/starter-prompt-provider.js");
+var import_custom_prompt_provider = require("./providers/custom-prompt-provider.js");
+var import_errors = require("./errors.js");
+var import_logger = require("../logger/index.js");
+var import_utils = require("./utils.js");
+class PromptManager {
+  constructor(mcpManager, resourceManager, agentConfig, eventBus, database) {
+    this.eventBus = eventBus;
+    this.database = database;
+    this.providers.set("mcp", new import_mcp_prompt_provider.MCPPromptProvider(mcpManager));
+    this.providers.set("file", new import_file_prompt_provider.FilePromptProvider({ resourceManager }));
+    this.providers.set("starter", new import_starter_prompt_provider.StarterPromptProvider(agentConfig));
+    this.providers.set("custom", new import_custom_prompt_provider.CustomPromptProvider(this.database, resourceManager));
+    import_logger.logger.debug(
+      `PromptManager initialized with providers: ${Array.from(this.providers.keys()).join(", ")}`
+    );
+    const refresh = async (reason) => {
+      import_logger.logger.debug(`PromptManager refreshing due to: ${reason}`);
+      await this.refresh();
+    };
+    this.eventBus.on("dexto:mcpServerConnected", async (p) => {
+      if (p.success) {
+        await refresh(`mcpServerConnected:${p.name}`);
+      }
+    });
+    this.eventBus.on("dexto:mcpServerRemoved", async (p) => {
+      await refresh(`mcpServerRemoved:${p.serverName}`);
+    });
+    this.eventBus.on("dexto:mcpServerUpdated", async (p) => {
+      await refresh(`mcpServerUpdated:${p.serverName}`);
+    });
+    this.eventBus.on("dexto:mcpPromptsListChanged", async (p) => {
+      await this.updatePromptsForServer(p.serverName, p.prompts);
+      import_logger.logger.debug(
+        `\u{1F504} Surgically updated prompts for server '${p.serverName}': [${p.prompts.join(", ")}]`
+      );
+    });
+  }
+  providers = /* @__PURE__ */ new Map();
+  promptIndex;
+  aliasMap = /* @__PURE__ */ new Map();
+  buildPromise = null;
+  async initialize() {
+    await this.ensureCache();
+    import_logger.logger.debug("PromptManager initialization complete");
+  }
+  async list() {
+    await this.ensureCache();
+    const index = this.promptIndex ?? /* @__PURE__ */ new Map();
+    const result = {};
+    for (const [key, entry] of index.entries()) {
+      result[key] = entry.info;
+    }
+    return result;
+  }
+  async has(name) {
+    const entry = await this.findEntry(name);
+    return entry !== void 0;
+  }
+  async getPromptDefinition(name) {
+    const entry = await this.findEntry(name);
+    if (!entry) return null;
+    const { info } = entry;
+    return {
+      name: info.name,
+      ...info.title && { title: info.title },
+      ...info.description && { description: info.description },
+      ...info.arguments && { arguments: info.arguments }
+    };
+  }
+  /**
+   * Retrieve a prompt from the appropriate provider.
+   *
+   * Responsibilities:
+   * - Resolve the correct provider by prompt name (post-cache lookup)
+   * - Map positional arguments (`args._positional: string[]`) to named arguments based
+   *   on the prompt's declared `arguments` schema (order-based mapping)
+   * - Forward `_context` and any named args to the provider
+   *
+   * Mapping rules:
+   * - If `PromptInfo.arguments` is defined (e.g., MCP or file prompts with `argument-hint:`),
+   *   then each position in `_positional` fills the corresponding named arg if not already set.
+   * - Named arguments already present in `args` are not overwritten by positional tokens.
+   */
+  async getPrompt(name, args) {
+    const entry = await this.findEntry(name);
+    if (!entry) {
+      throw import_errors.PromptError.notFound(name);
+    }
+    const provider = this.providers.get(entry.providerName);
+    if (!provider) {
+      throw import_errors.PromptError.providerNotFound(entry.providerName);
+    }
+    let finalArgs = args;
+    if (args?._positional && Array.isArray(args._positional) && args._positional.length > 0) {
+      const promptArgs = entry.info.arguments;
+      if (promptArgs && promptArgs.length > 0) {
+        finalArgs = { ...args };
+        const positionalArgs = args._positional;
+        promptArgs.forEach((argDef, index) => {
+          if (index < positionalArgs.length && !finalArgs[argDef.name]) {
+            const value = positionalArgs[index];
+            finalArgs[argDef.name] = typeof value === "string" ? value : String(value);
+          }
+        });
+      }
+    }
+    let providerArgs = finalArgs;
+    if (entry.providerName === "mcp") {
+      const declared = new Set((entry.info.arguments ?? []).map((a) => a.name));
+      const filtered = {};
+      for (const [key, value] of Object.entries(finalArgs ?? {})) {
+        if (key.startsWith("_")) continue;
+        if (declared.size === 0 || declared.has(key)) {
+          filtered[key] = value;
+        }
+      }
+      providerArgs = filtered;
+    }
+    return await provider.getPrompt(entry.providerPromptName, providerArgs);
+  }
+  async resolvePromptKey(nameOrAlias) {
+    await this.ensureCache();
+    if (!this.promptIndex) return null;
+    if (this.promptIndex.has(nameOrAlias)) {
+      return nameOrAlias;
+    }
+    const normalized = nameOrAlias.startsWith("/") ? nameOrAlias.slice(1) : nameOrAlias;
+    const aliasMatch = this.aliasMap.get(nameOrAlias) ?? this.aliasMap.get(normalized);
+    return aliasMatch ?? null;
+  }
+  async createCustomPrompt(input) {
+    const provider = this.providers.get("custom");
+    if (!provider || !(provider instanceof import_custom_prompt_provider.CustomPromptProvider)) {
+      throw import_errors.PromptError.providerNotFound("custom");
+    }
+    const prompt = await provider.createPrompt(input);
+    await this.refresh();
+    return prompt;
+  }
+  async deleteCustomPrompt(name) {
+    const provider = this.providers.get("custom");
+    if (!provider || !(provider instanceof import_custom_prompt_provider.CustomPromptProvider)) {
+      throw import_errors.PromptError.providerNotFound("custom");
+    }
+    await provider.deletePrompt(name);
+    await this.refresh();
+  }
+  /**
+   * Resolves a prompt to its text content with all arguments applied.
+   * This is a high-level method that handles:
+   * - Prompt key resolution (resolving aliases)
+   * - Argument normalization (including special `_context` field)
+   * - Passing `_context` through to providers so they can decide whether to append it
+   *   (e.g., file prompts without placeholders will append `Context: ...`)
+   * - Prompt execution and flattening
+   *
+   * @param name The prompt name or alias
+   * @param options Optional configuration for prompt resolution
+   * @returns Promise resolving to the resolved text and resource URIs
+   */
+  async resolvePrompt(name, options = {}) {
+    const args = { ...options.args };
+    if (options.context?.trim()) args._context = options.context.trim();
+    const resolvedName = await this.resolvePromptKey(name) ?? name;
+    const normalized = (0, import_utils.normalizePromptArgs)(args);
+    const providerArgs = normalized.context ? { ...normalized.args, _context: normalized.context } : normalized.args;
+    const promptResult = await this.getPrompt(resolvedName, providerArgs);
+    const flattened = (0, import_utils.flattenPromptResult)(promptResult);
+    if (!flattened.text && flattened.resourceUris.length === 0) {
+      throw import_errors.PromptError.emptyResolvedContent(resolvedName);
+    }
+    return { text: flattened.text, resources: flattened.resourceUris };
+  }
+  async refresh() {
+    this.promptIndex = void 0;
+    this.aliasMap.clear();
+    for (const provider of this.providers.values()) {
+      provider.invalidateCache();
+    }
+    await this.ensureCache();
+    import_logger.logger.info("PromptManager refreshed");
+  }
+  /**
+   * Surgically update prompts for a specific MCP server instead of full cache rebuild
+   */
+  async updatePromptsForServer(serverName, _newPrompts) {
+    await this.ensureCache();
+    if (!this.promptIndex) return;
+    this.removePromptsForServer(serverName);
+    const mcpProvider = this.providers.get("mcp");
+    if (mcpProvider) {
+      try {
+        const { prompts } = await mcpProvider.listPrompts();
+        const serverPrompts = prompts.filter(
+          (p) => p.metadata && typeof p.metadata === "object" && "serverName" in p.metadata && p.metadata.serverName === serverName
+        );
+        for (const prompt of serverPrompts) {
+          this.insertPrompt(this.promptIndex, this.aliasMap, "mcp", prompt);
+        }
+      } catch (error) {
+        import_logger.logger.debug(`Failed to get updated prompts for server '${serverName}': ${error}`);
+      }
+    }
+  }
+  /**
+   * Remove all prompts from a specific server
+   */
+  removePromptsForServer(serverName) {
+    if (!this.promptIndex) return;
+    const keysToRemove = [];
+    for (const [key, entry] of this.promptIndex.entries()) {
+      if (entry.providerName === "mcp" && entry.info.metadata && typeof entry.info.metadata === "object" && "serverName" in entry.info.metadata && entry.info.metadata.serverName === serverName) {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      const entry = this.promptIndex.get(key);
+      if (entry) {
+        this.promptIndex.delete(key);
+        for (const [aliasKey, aliasValue] of Array.from(this.aliasMap.entries())) {
+          if (aliasValue === key) {
+            this.aliasMap.delete(aliasKey);
+          }
+        }
+      }
+    }
+  }
+  sanitizePromptInfo(prompt, providerName) {
+    const metadata = { ...prompt.metadata ?? {} };
+    delete metadata.content;
+    delete metadata.prompt;
+    delete metadata.filePath;
+    delete metadata.messages;
+    if (!metadata.originalName) {
+      metadata.originalName = prompt.name;
+    }
+    metadata.provider = providerName;
+    const sanitized = { ...prompt };
+    if (Object.keys(metadata).length > 0) {
+      sanitized.metadata = metadata;
+    } else {
+      delete sanitized.metadata;
+    }
+    return sanitized;
+  }
+  async ensureCache() {
+    if (this.promptIndex) {
+      return;
+    }
+    if (this.buildPromise) {
+      await this.buildPromise;
+      return;
+    }
+    this.buildPromise = this.buildCache();
+    try {
+      await this.buildPromise;
+    } finally {
+      this.buildPromise = null;
+    }
+  }
+  async buildCache() {
+    const index = /* @__PURE__ */ new Map();
+    const aliases = /* @__PURE__ */ new Map();
+    for (const [providerName, provider] of this.providers) {
+      try {
+        const { prompts } = await provider.listPrompts();
+        for (const prompt of prompts) {
+          this.insertPrompt(index, aliases, providerName, prompt);
+        }
+      } catch (error) {
+        import_logger.logger.error(
+          `Failed to get prompts from ${providerName} provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.promptIndex = index;
+    this.aliasMap = aliases;
+    if (index.size > 0) {
+      const sample = Array.from(index.keys()).slice(0, 5);
+      import_logger.logger.debug(
+        `\u{1F4CB} Prompt discovery: ${index.size} prompts. Sample: ${sample.join(", ")}`
+      );
+    }
+  }
+  insertPrompt(index, aliases, providerName, prompt) {
+    const providerPromptName = prompt.name;
+    const prepared = this.sanitizePromptInfo(prompt, providerName);
+    let key = providerPromptName;
+    const originalName = providerPromptName;
+    if (index.has(key)) {
+      const existing = index.get(key);
+      index.delete(key);
+      const existingKey = `${existing.providerName}:${existing.originalName}`;
+      const updatedExisting = {
+        ...existing,
+        info: existing.info.name === existingKey ? existing.info : { ...existing.info, name: existingKey }
+      };
+      index.set(existingKey, updatedExisting);
+      aliases.set(existing.originalName, existingKey);
+      key = `${providerName}:${originalName}`;
+    }
+    const entryInfo = prepared.name === key ? prepared : { ...prepared, name: key };
+    const entry = {
+      providerName,
+      providerPromptName,
+      originalName,
+      info: entryInfo
+    };
+    index.set(key, entry);
+    aliases.set(originalName, key);
+    const metadata = entryInfo.metadata;
+    if (metadata) {
+      const aliasCandidates = /* @__PURE__ */ new Set();
+      if (typeof metadata.originalName === "string") {
+        aliasCandidates.add(metadata.originalName);
+      }
+      if (typeof metadata.command === "string") {
+        const command = metadata.command;
+        aliasCandidates.add(command);
+        if (command.startsWith("/")) {
+          aliasCandidates.add(command.slice(1));
+        }
+      }
+      for (const candidate of aliasCandidates) {
+        if (candidate && !aliases.has(candidate)) {
+          aliases.set(candidate, key);
+        }
+      }
+    }
+  }
+  async findEntry(name) {
+    await this.ensureCache();
+    if (!this.promptIndex) return void 0;
+    if (this.promptIndex.has(name)) {
+      return this.promptIndex.get(name);
+    }
+    const normalized = name.startsWith("/") ? name.slice(1) : name;
+    const alias = this.aliasMap.get(name) ?? this.aliasMap.get(normalized);
+    if (alias && this.promptIndex.has(alias)) {
+      return this.promptIndex.get(alias);
+    }
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromptManager
+});

package/dist/prompts/prompt-manager.d.ts

@@ -0,0 +1,74 @@
+import type { MCPManager } from '../mcp/manager.js';
+import type { PromptSet, PromptInfo } from './types.js';
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ValidatedAgentConfig } from '../agent/schemas.js';
+import type { AgentEventBus } from '../events/index.js';
+import { type CreateCustomPromptInput } from './providers/custom-prompt-provider.js';
+import type { ResourceManager } from '../resources/manager.js';
+import type { Database } from '../storage/database/types.js';
+export declare class PromptManager {
+    private readonly eventBus;
+    private readonly database;
+    private providers;
+    private promptIndex;
+    private aliasMap;
+    private buildPromise;
+    constructor(mcpManager: MCPManager, resourceManager: ResourceManager, agentConfig: ValidatedAgentConfig, eventBus: AgentEventBus, database: Database);
+    initialize(): Promise<void>;
+    list(): Promise<PromptSet>;
+    has(name: string): Promise<boolean>;
+    getPromptDefinition(name: string): Promise<import('./types.js').PromptDefinition | null>;
+    /**
+     * Retrieve a prompt from the appropriate provider.
+     *
+     * Responsibilities:
+     * - Resolve the correct provider by prompt name (post-cache lookup)
+     * - Map positional arguments (`args._positional: string[]`) to named arguments based
+     *   on the prompt's declared `arguments` schema (order-based mapping)
+     * - Forward `_context` and any named args to the provider
+     *
+     * Mapping rules:
+     * - If `PromptInfo.arguments` is defined (e.g., MCP or file prompts with `argument-hint:`),
+     *   then each position in `_positional` fills the corresponding named arg if not already set.
+     * - Named arguments already present in `args` are not overwritten by positional tokens.
+     */
+    getPrompt(name: string, args?: Record<string, unknown>): Promise<GetPromptResult>;
+    resolvePromptKey(nameOrAlias: string): Promise<string | null>;
+    createCustomPrompt(input: CreateCustomPromptInput): Promise<PromptInfo>;
+    deleteCustomPrompt(name: string): Promise<void>;
+    /**
+     * Resolves a prompt to its text content with all arguments applied.
+     * This is a high-level method that handles:
+     * - Prompt key resolution (resolving aliases)
+     * - Argument normalization (including special `_context` field)
+     * - Passing `_context` through to providers so they can decide whether to append it
+     *   (e.g., file prompts without placeholders will append `Context: ...`)
+     * - Prompt execution and flattening
+     *
+     * @param name The prompt name or alias
+     * @param options Optional configuration for prompt resolution
+     * @returns Promise resolving to the resolved text and resource URIs
+     */
+    resolvePrompt(name: string, options?: {
+        context?: string;
+        args?: Record<string, unknown>;
+    }): Promise<{
+        text: string;
+        resources: string[];
+    }>;
+    refresh(): Promise<void>;
+    /**
+     * Surgically update prompts for a specific MCP server instead of full cache rebuild
+     */
+    private updatePromptsForServer;
+    /**
+     * Remove all prompts from a specific server
+     */
+    private removePromptsForServer;
+    private sanitizePromptInfo;
+    private ensureCache;
+    private buildCache;
+    private insertPrompt;
+    private findEntry;
+}
+//# sourceMappingURL=prompt-manager.d.ts.map

package/dist/prompts/prompt-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-manager.d.ts","sourceRoot":"","sources":["../../src/prompts/prompt-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAkB,UAAU,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAIxD,OAAO,EAEH,KAAK,uBAAuB,EAC/B,MAAM,uCAAuC,CAAC;AAG/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAU7D,qBAAa,aAAa;IAUlB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV7B,OAAO,CAAC,SAAS,CAA0C;IAC3D,OAAO,CAAC,WAAW,CAA4C;IAC/D,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,YAAY,CAA8B;gBAG9C,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,oBAAoB,EAChB,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,QAAQ;IAqCjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,IAAI,IAAI,OAAO,CAAC,SAAS,CAAC;IAU1B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAY9F;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAkDjF,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAa7D,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;IAUvE,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASrD;;;;;;;;;;;;OAYG;IACG,aAAa,CACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC7B,GACP,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAiC3C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;OAEG;YACW,sBAAsB;IA6BpC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA+B9B,OAAO,CAAC,kBAAkB;YAqBZ,WAAW;YAgBX,UAAU;IA4BxB,OAAO,CAAC,YAAY;YA8DN,SAAS;CAgB1B"}