@dexto/core 1.1.10 → 1.2.0

package/dist/prompts/providers/custom-prompt-provider.js

@@ -0,0 +1,260 @@
+import "../../chunk-C6A6W6XS.js";
+import { logger } from "../../logger/index.js";
+import { expandPlaceholders } from "../utils.js";
+import { PromptError } from "../errors.js";
+const CUSTOM_PROMPT_KEY_PREFIX = "prompt:custom:";
+class CustomPromptProvider {
+  constructor(database, resourceManager) {
+    this.database = database;
+    this.resourceManager = resourceManager;
+  }
+  cacheValid = false;
+  promptsCache = [];
+  promptRecords = /* @__PURE__ */ new Map();
+  getSource() {
+    return "custom";
+  }
+  invalidateCache() {
+    this.cacheValid = false;
+    this.promptsCache = [];
+    this.promptRecords.clear();
+  }
+  async listPrompts(_cursor) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    return { prompts: this.promptsCache };
+  }
+  async getPrompt(name, args) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) {
+      throw PromptError.notFound(name);
+    }
+    if (record.arguments && record.arguments.length > 0) {
+      const requiredArgs = record.arguments.filter((arg) => arg.required);
+      const missingArgs = requiredArgs.filter((arg) => !args || !(arg.name in args)).map((arg) => arg.name);
+      if (missingArgs.length > 0) {
+        throw PromptError.missingRequiredArguments(missingArgs);
+      }
+    }
+    const messages = [];
+    const expanded = expandPlaceholders(record.content, args);
+    const textContent = this.applyArguments(expanded, args, record.arguments);
+    messages.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: textContent
+      }
+    });
+    if (record.resourceUri) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        const blobData = await blobService.retrieve(record.resourceUri, "base64");
+        if (blobData.format === "base64") {
+          messages.push({
+            role: "user",
+            content: {
+              type: "resource",
+              resource: {
+                uri: record.resourceUri,
+                blob: blobData.data,
+                mimeType: record.resourceMetadata?.mimeType || blobData.metadata?.mimeType || "application/octet-stream"
+              }
+            }
+          });
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to load blob resource for custom prompt ${name}: ${String(error)}`
+        );
+      }
+    }
+    return {
+      description: record.description,
+      messages
+    };
+  }
+  async getPromptDefinition(name) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) return null;
+    return {
+      name: record.name,
+      ...record.title && { title: record.title },
+      ...record.description && { description: record.description },
+      ...record.arguments && { arguments: record.arguments }
+    };
+  }
+  async createPrompt(input) {
+    const id = this.slugify(input.name);
+    if (!id) {
+      throw PromptError.nameRequired();
+    }
+    if (!input.content || input.content.trim().length === 0) {
+      throw PromptError.missingText();
+    }
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    if (this.promptRecords.has(id)) {
+      throw PromptError.alreadyExists(id);
+    }
+    let resourceUri;
+    let resourceMetadata;
+    if (input.resource) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        const { base64, mimeType, filename } = input.resource;
+        const blobRef = await blobService.store(base64, {
+          mimeType,
+          originalName: filename,
+          source: "system"
+        });
+        resourceUri = blobRef.uri;
+        const meta = {};
+        const originalName = blobRef.metadata.originalName ?? filename;
+        if (originalName) {
+          meta.originalName = originalName;
+        }
+        if (blobRef.metadata.mimeType) {
+          meta.mimeType = blobRef.metadata.mimeType;
+        }
+        resourceMetadata = Object.keys(meta).length > 0 ? meta : void 0;
+      } catch (error) {
+        logger.warn(`Failed to store custom prompt resource: ${String(error)}`);
+      }
+    }
+    const now = Date.now();
+    const record = {
+      id,
+      name: id,
+      content: input.content,
+      createdAt: now,
+      updatedAt: now,
+      ...input.title ? { title: input.title } : {},
+      ...input.description ? { description: input.description } : {},
+      ...input.arguments ? { arguments: input.arguments } : {},
+      ...resourceUri ? { resourceUri } : {},
+      ...resourceMetadata ? { resourceMetadata } : {}
+    };
+    await this.database.set(this.toKey(id), record);
+    this.invalidateCache();
+    await this.buildCache();
+    const prompt = this.promptsCache.find((p) => p.name === id);
+    if (!prompt) {
+      throw PromptError.notFound(id);
+    }
+    return prompt;
+  }
+  async deletePrompt(name) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) {
+      throw PromptError.notFound(name);
+    }
+    await this.database.delete(this.toKey(name));
+    if (record.resourceUri) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        await blobService.delete(record.resourceUri);
+      } catch (error) {
+        logger.warn(`Failed to delete blob for custom prompt ${name}: ${String(error)}`);
+      }
+    }
+    this.invalidateCache();
+  }
+  async buildCache() {
+    try {
+      const keys = await this.database.list(CUSTOM_PROMPT_KEY_PREFIX);
+      const prompts = [];
+      this.promptRecords.clear();
+      for (const key of keys) {
+        try {
+          const record = await this.database.get(key);
+          if (!record) continue;
+          this.promptRecords.set(record.name, record);
+          const metadata = {
+            originalName: record.resourceMetadata?.originalName && record.resourceMetadata.originalName.trim().length > 0 ? record.resourceMetadata.originalName : record.name
+          };
+          if (record.resourceUri) {
+            metadata.resourceUri = record.resourceUri;
+          }
+          if (record.resourceMetadata?.mimeType) {
+            metadata.mimeType = record.resourceMetadata.mimeType;
+          }
+          metadata.createdAt = record.createdAt;
+          metadata.updatedAt = record.updatedAt;
+          prompts.push({
+            name: record.name,
+            title: record.title,
+            description: record.description,
+            source: "custom",
+            ...record.arguments && { arguments: record.arguments },
+            metadata
+          });
+        } catch (error) {
+          logger.warn(`Failed to load custom prompt from ${key}: ${String(error)}`);
+        }
+      }
+      this.promptsCache = prompts;
+      this.cacheValid = true;
+    } catch (error) {
+      logger.error(`Failed to build custom prompts cache: ${String(error)}`);
+      this.promptsCache = [];
+      this.cacheValid = false;
+    }
+  }
+  toKey(id) {
+    return `${CUSTOM_PROMPT_KEY_PREFIX}${id}`;
+  }
+  slugify(name) {
+    const slug = name.toLowerCase().trim().replace(/[^a-z0-9\s\-_]/g, "").replace(/[\s\-_]+/g, "-").replace(/^-+|-+$/g, "");
+    return slug;
+  }
+  applyArguments(content, args, declaredArgs) {
+    if (!args || Object.keys(args).length === 0) {
+      return content;
+    }
+    let result = content;
+    for (const [key, value] of Object.entries(args)) {
+      if (key.startsWith("_")) continue;
+      const placeholder = `{{${key}}}`;
+      result = result.replaceAll(placeholder, String(value));
+    }
+    const usesPositional = /\$[1-9]/.test(content) || content.includes("$ARGUMENTS");
+    let usesNamed = false;
+    if (declaredArgs && declaredArgs.length > 0) {
+      usesNamed = declaredArgs.some((a) => a.name && content.includes(`{{${a.name}}}`));
+    } else {
+      usesNamed = content.includes("{{") && content.includes("}}");
+    }
+    const placeholdersUsed = usesPositional || usesNamed;
+    if (!placeholdersUsed) {
+      if (args._context) {
+        const contextString = String(args._context);
+        return `${result}
+
+Context: ${contextString}`;
+      }
+      const argEntries = Object.entries(args).filter(([k]) => !k.startsWith("_"));
+      if (argEntries.length > 0) {
+        const formattedArgs = argEntries.map(([k, v]) => `${k}: ${v}`).join(", ");
+        return `${result}
+
+Arguments: ${formattedArgs}`;
+      }
+    }
+    return result;
+  }
+}
+export {
+  CustomPromptProvider
+};

package/dist/prompts/providers/file-prompt-provider.cjs

@@ -0,0 +1,399 @@
+"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 file_prompt_provider_exports = {};
+__export(file_prompt_provider_exports, {
+  FilePromptProvider: () => FilePromptProvider
+});
+module.exports = __toCommonJS(file_prompt_provider_exports);
+var import_utils = require("../utils.js");
+var import_name_validation = require("../name-validation.js");
+var import_logger = require("../../logger/index.js");
+var import_errors = require("../errors.js");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_fs = require("fs");
+var import_os = require("os");
+var import_execution_context = require("../../utils/execution-context.js");
+class FilePromptProvider {
+  // Multiple command directories (local project/repo and global user dir)
+  commandDirs;
+  resourceManager;
+  promptsCache = [];
+  cacheValid = false;
+  promptResources = /* @__PURE__ */ new Map();
+  inlineContent = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.commandDirs = this.resolveDefaultCommandDirs();
+    this.resourceManager = options.resourceManager;
+  }
+  getSource() {
+    return "file";
+  }
+  invalidateCache() {
+    this.cacheValid = false;
+    this.promptsCache = [];
+    this.promptResources.clear();
+    this.inlineContent.clear();
+    import_logger.logger.debug("FilePromptProvider cache invalidated");
+  }
+  async getPrompt(name, args) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    const prompt = this.promptsCache.find((p) => p.name === name);
+    if (!prompt) {
+      throw import_errors.PromptError.notFound(name);
+    }
+    const resourceUri = this.promptResources.get(name);
+    let text = this.inlineContent.get(name) ?? "";
+    if (resourceUri) {
+      try {
+        const result = await this.resourceManager.read(resourceUri);
+        const first = result.contents[0];
+        if (first?.text && typeof first.text === "string") {
+          text = first.text;
+        } else if (first?.blob && typeof first.blob === "string") {
+          text = Buffer.from(first.blob, "base64").toString("utf-8");
+        } else {
+          import_logger.logger.warn(`Prompt ${name} resource ${resourceUri} did not contain text`);
+        }
+      } catch (error) {
+        import_logger.logger.warn(
+          `Failed to load prompt resource ${resourceUri}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (!text) {
+      throw import_errors.PromptError.missingText();
+    }
+    const resolved = this.applyArguments(text, args);
+    return {
+      description: prompt.description,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: resolved
+          }
+        }
+      ]
+    };
+  }
+  async listPrompts(_cursor) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    return {
+      prompts: this.promptsCache
+    };
+  }
+  async getPromptDefinition(name) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    const promptInfo = this.promptsCache.find((p) => p.name === name);
+    if (!promptInfo) {
+      return null;
+    }
+    return {
+      name: promptInfo.name,
+      ...promptInfo.title && { title: promptInfo.title },
+      ...promptInfo.description && { description: promptInfo.description },
+      ...promptInfo.arguments && { arguments: promptInfo.arguments }
+    };
+  }
+  async buildPromptsCache() {
+    const cache = [];
+    const resourceMap = /* @__PURE__ */ new Map();
+    const inlineMap = /* @__PURE__ */ new Map();
+    const seenNames = /* @__PURE__ */ new Set();
+    const scannedDirs = [];
+    for (const dir of this.commandDirs) {
+      if (!(0, import_fs.existsSync)(dir)) {
+        continue;
+      }
+      try {
+        scannedDirs.push(dir);
+        const files = await (0, import_promises.readdir)(dir);
+        const markdownFiles = files.filter((file) => (0, import_path.extname)(file).toLowerCase() === ".md");
+        for (const file of markdownFiles) {
+          try {
+            try {
+              const candidate = (0, import_path.join)(dir, file);
+              const resolvedDir = await (0, import_promises.realpath)(dir);
+              const resolvedFile = await (0, import_promises.realpath)(candidate);
+              const rel = (0, import_path.relative)(resolvedDir, resolvedFile);
+              if (rel.startsWith(".." + import_path.sep) || rel === "..") {
+                import_logger.logger.warn(
+                  `Skipping file '${file}' in '${dir}': path traversal attempt detected (resolved outside directory)`
+                );
+                continue;
+              }
+            } catch (realpathError) {
+              import_logger.logger.warn(
+                `Skipping file '${file}' in '${dir}': unable to resolve path (${realpathError instanceof Error ? realpathError.message : String(realpathError)})`
+              );
+              continue;
+            }
+            const parsed = await this.parsePromptFile(file, dir);
+            if (seenNames.has(parsed.info.name)) {
+              import_logger.logger.debug(
+                `Skipping duplicate prompt name '${parsed.info.name}' from ${(0, import_path.join)(
+                  dir,
+                  file
+                )}`
+              );
+              continue;
+            }
+            const storage = await this.storePromptContent(parsed.content, file);
+            if (storage.resourceUri) {
+              resourceMap.set(parsed.info.name, storage.resourceUri);
+            }
+            if (storage.inlineContent) {
+              inlineMap.set(parsed.info.name, storage.inlineContent);
+            }
+            if (storage.resourceUri || storage.inlineContent) {
+              const metadata = {
+                ...parsed.info.metadata ?? {},
+                ...storage.resourceUri && { resourceUri: storage.resourceUri }
+                // Security: Don't expose absolute sourceDir path
+                // The relative filePath in parsed.info.metadata is sufficient
+              };
+              if (Object.keys(metadata).length > 0) {
+                parsed.info = { ...parsed.info, metadata };
+              } else {
+                parsed.info = { ...parsed.info };
+                delete parsed.info.metadata;
+              }
+            }
+            cache.push(parsed.info);
+            seenNames.add(parsed.info.name);
+          } catch (error) {
+            import_logger.logger.warn(
+              `Failed to process prompt file '${file}' in '${dir}': ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      } catch (error) {
+        import_logger.logger.debug(
+          `Commands directory '${dir}' not accessible: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    import_logger.logger.debug(
+      `\u{1F4DD} Cached ${cache.length} file prompts from directories: ${scannedDirs.join(", ")}`
+    );
+    this.promptsCache = cache;
+    this.promptResources = resourceMap;
+    this.inlineContent = inlineMap;
+    this.cacheValid = true;
+  }
+  async parsePromptFile(fileName, baseDir) {
+    const promptName = fileName.replace(/\.md$/, "");
+    const filePath = (0, import_path.join)(baseDir, fileName);
+    const content = await (0, import_promises.readFile)(filePath, "utf-8");
+    const lines = content.trim().split("\n");
+    let description = `File prompt: ${promptName}`;
+    let title = promptName;
+    let category;
+    let id;
+    let nameOverride;
+    let argumentHint;
+    let contentBody;
+    if (lines[0]?.trim() === "---") {
+      let inFrontmatter = false;
+      let frontmatterEnd = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i]?.trim() === "---") {
+          if (!inFrontmatter) {
+            inFrontmatter = true;
+          } else {
+            frontmatterEnd = i;
+            break;
+          }
+        }
+      }
+      if (frontmatterEnd > 0) {
+        const frontmatterLines = lines.slice(1, frontmatterEnd);
+        contentBody = lines.slice(frontmatterEnd + 1).join("\n");
+        for (const line of frontmatterLines) {
+          if (line.includes("description:")) {
+            const descMatch = line.match(/description:\s*(?:['"](.+)['"]|(.+))/);
+            if (descMatch) {
+              description = (descMatch[1] || descMatch[2] || "").trim();
+            }
+          } else if (line.includes("id:")) {
+            const idMatch = line.match(/id:\s*(?:['"](.+)['"]|(.+))/);
+            if (idMatch) {
+              id = (idMatch[1] || idMatch[2] || "").trim();
+            }
+          } else if (line.includes("name:")) {
+            const nameMatch = line.match(/name:\s*(?:['"](.+)['"]|(.+))/);
+            if (nameMatch) {
+              nameOverride = (nameMatch[1] || nameMatch[2] || "").trim();
+            }
+          } else if (line.includes("category:")) {
+            const categoryMatch = line.match(/category:\s*(?:['"](.+)['"]|(.+))/);
+            if (categoryMatch) {
+              category = (categoryMatch[1] || categoryMatch[2] || "").trim();
+            }
+          } else if (line.includes("argument-hint:")) {
+            const hintMatch = line.match(/argument-hint:\s*(?:['"](.+)['"]|(.+))/);
+            if (hintMatch) {
+              argumentHint = (hintMatch[1] || hintMatch[2] || "").trim();
+            }
+          }
+        }
+      }
+    }
+    if (!contentBody) {
+      contentBody = content;
+    }
+    const bodyLines = contentBody.trim().split("\n");
+    for (const line of bodyLines) {
+      if (line.trim().startsWith("#")) {
+        title = line.trim().replace(/^#+\s*/, "");
+        break;
+      }
+    }
+    const finalName = (nameOverride ?? promptName).trim();
+    (0, import_name_validation.assertValidPromptName)(finalName, {
+      hint: "Use kebab-case in the 'name:' field or file name."
+    });
+    const parsedArguments = argumentHint ? this.parseArgumentHint(argumentHint) : void 0;
+    const relativePath = (0, import_path.relative)(baseDir, filePath);
+    const promptInfo = {
+      name: finalName,
+      title,
+      description,
+      source: "file",
+      ...parsedArguments && { arguments: parsedArguments },
+      metadata: {
+        originalName: promptName,
+        fileName,
+        // Only include relative path within the commands directory (e.g., "my-command.md")
+        // not the full path which could expose ~/.dexto or project structure
+        ...relativePath && { filePath: relativePath },
+        ...id && { id },
+        ...category && { category }
+      }
+    };
+    return { info: promptInfo, content: contentBody };
+  }
+  /**
+   * Parse argument-hint string into structured argument definitions
+   * Format: "[style] [length?]" → [{name: "style", required: true}, {name: "length", required: false}]
+   */
+  parseArgumentHint(hint) {
+    const args = [];
+    const argPattern = /\[([^\]]+)\]/g;
+    let match;
+    while ((match = argPattern.exec(hint)) !== null) {
+      const argText = match[1];
+      if (!argText) continue;
+      const isOptional = argText.endsWith("?");
+      const name = isOptional ? argText.slice(0, -1).trim() : argText.trim();
+      if (name) {
+        args.push({
+          name,
+          required: !isOptional
+        });
+      }
+    }
+    return args;
+  }
+  async storePromptContent(content, fileName) {
+    const blobService = this.resourceManager.getBlobStore();
+    if (!blobService) {
+      import_logger.logger.warn("BlobService not available; storing prompt content in memory");
+      return { inlineContent: content };
+    }
+    const blobInput = Buffer.from(content, "utf-8");
+    const blob = await blobService.store(blobInput, {
+      mimeType: "text/markdown",
+      originalName: fileName,
+      source: "system"
+    });
+    return { resourceUri: blob.uri };
+  }
+  /**
+   * Apply arguments to a file prompt's content.
+   *
+   * Behavior mirrors Claude Code-style file prompts:
+   * - Positional placeholders ($1..$9 and $ARGUMENTS) are expanded first.
+   * - If and only if the template contains explicit placeholders ($1..$9 or $ARGUMENTS),
+   *   then we consider arguments "deconstructed in-template" and DO NOT append them again.
+   * - If the template contains no such placeholders, we append either:
+   *   - `Context: <_context>` above the content when `_context` is provided, or
+   *   - `Arguments: key: value, ...` below the content for plain named args.
+   *
+   * Notes:
+   * - The `$$` sequence is an escape for a literal dollar sign. It MUST NOT be
+   *   treated as a placeholder indicator and should not suppress argument appending.
+   */
+  applyArguments(content, args) {
+    const detectionTarget = content.replaceAll("$$", "");
+    const usesPositionalPlaceholders = /\$[1-9](?!\d)/.test(detectionTarget) || detectionTarget.includes("$ARGUMENTS");
+    const expanded = (0, import_utils.expandPlaceholders)(content, args).trim();
+    if (!args || typeof args !== "object" || Object.keys(args).length === 0) {
+      return expanded;
+    }
+    if (!usesPositionalPlaceholders) {
+      if (args._context) {
+        const contextString = String(args._context);
+        return `${expanded}
+
+Context: ${contextString}`;
+      }
+      const argEntries = Object.entries(args).filter(([key]) => !key.startsWith("_"));
+      if (argEntries.length > 0) {
+        const formattedArgs = argEntries.map(([key, value]) => `${key}: ${value}`).join(", ");
+        return `${expanded}
+
+Arguments: ${formattedArgs}`;
+      }
+    }
+    return expanded;
+  }
+  // Determine default command/prompt directories based on execution context
+  resolveDefaultCommandDirs() {
+    const dirs = [];
+    const sourceRoot = (0, import_execution_context.findDextoSourceRoot)();
+    const projectRoot = (0, import_execution_context.findDextoProjectRoot)();
+    const localRoot = sourceRoot ?? projectRoot ?? null;
+    if (localRoot) {
+      const commandsDir = (0, import_path.resolve)(localRoot, "commands");
+      if ((0, import_fs.existsSync)(commandsDir)) dirs.push(commandsDir);
+    }
+    const globalCommands = (0, import_path.resolve)((0, import_os.homedir)(), ".dexto", "commands");
+    if ((0, import_fs.existsSync)(globalCommands)) dirs.push(globalCommands);
+    if (dirs.length === 0) {
+      if (localRoot) {
+        dirs.push((0, import_path.resolve)(localRoot, "commands"));
+      }
+      dirs.push(globalCommands);
+    }
+    return dirs;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FilePromptProvider
+});

package/dist/prompts/providers/file-prompt-provider.d.ts

@@ -0,0 +1,47 @@
+import type { PromptProvider, PromptDefinition, PromptListResult } from '../types.js';
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ResourceManager } from '../../resources/manager.js';
+interface FilePromptProviderOptions {
+    resourceManager: ResourceManager;
+}
+export declare class FilePromptProvider implements PromptProvider {
+    private readonly commandDirs;
+    private readonly resourceManager;
+    private promptsCache;
+    private cacheValid;
+    private promptResources;
+    private inlineContent;
+    constructor(options: FilePromptProviderOptions);
+    getSource(): string;
+    invalidateCache(): void;
+    getPrompt(name: string, args?: Record<string, unknown>): Promise<GetPromptResult>;
+    listPrompts(_cursor?: string): Promise<PromptListResult>;
+    getPromptDefinition(name: string): Promise<PromptDefinition | null>;
+    private buildPromptsCache;
+    private parsePromptFile;
+    /**
+     * Parse argument-hint string into structured argument definitions
+     * Format: "[style] [length?]" → [{name: "style", required: true}, {name: "length", required: false}]
+     */
+    private parseArgumentHint;
+    private storePromptContent;
+    /**
+     * Apply arguments to a file prompt's content.
+     *
+     * Behavior mirrors Claude Code-style file prompts:
+     * - Positional placeholders ($1..$9 and $ARGUMENTS) are expanded first.
+     * - If and only if the template contains explicit placeholders ($1..$9 or $ARGUMENTS),
+     *   then we consider arguments "deconstructed in-template" and DO NOT append them again.
+     * - If the template contains no such placeholders, we append either:
+     *   - `Context: <_context>` above the content when `_context` is provided, or
+     *   - `Arguments: key: value, ...` below the content for plain named args.
+     *
+     * Notes:
+     * - The `$$` sequence is an escape for a literal dollar sign. It MUST NOT be
+     *   treated as a placeholder indicator and should not suppress argument appending.
+     */
+    private applyArguments;
+    private resolveDefaultCommandDirs;
+}
+export {};
+//# sourceMappingURL=file-prompt-provider.d.ts.map