prompts.chat 0.0.6 → 0.0.7

package/dist/index.mjs

@@ -3230,6 +3230,219 @@ var templates = {
       "If you don't know the answer, say so",
       "Cite relevant parts of the context if applicable"
     ]);
+  },
+  /**
+   * Create a debugging prompt
+   */
+  debug: (options = {}) => {
+    const b = builder().role("expert software debugger").task("Analyze the code and error, identify the root cause, and provide a fix.").variable("code", { required: true, description: "The code with the bug" }).variable("error", { required: false, description: "Error message or unexpected behavior" });
+    if (options.language) {
+      b.context(`Debugging ${options.language} code.`);
+    }
+    if (options.errorType) {
+      b.context(`The error appears to be related to: ${options.errorType}`);
+    }
+    return b.constraints([
+      "Identify the root cause, not just symptoms",
+      "Explain why the bug occurs",
+      "Provide a working fix with explanation"
+    ]).output("1. Root cause analysis\n2. Explanation\n3. Fixed code\n4. Prevention tips");
+  },
+  /**
+   * Create a writing assistant prompt
+   */
+  write: (options = {}) => {
+    const typeDescriptions = {
+      blog: "engaging blog post",
+      email: "professional email",
+      essay: "well-structured essay",
+      story: "creative story",
+      documentation: "clear technical documentation"
+    };
+    const b = builder().role("skilled writer").task(`Write a ${typeDescriptions[options.type || "blog"] || "piece of content"} based on the given topic or outline.`).variable("topic", { required: true, description: "Topic or outline to write about" });
+    if (options.tone) {
+      b.constraint(`Use a ${options.tone} tone throughout`);
+    }
+    return b.constraints([
+      "Use clear and engaging language",
+      "Structure content logically",
+      "Maintain consistent voice and style"
+    ]);
+  },
+  /**
+   * Create an explanation/teaching prompt
+   */
+  explain: (options = {}) => {
+    const levelDescriptions = {
+      beginner: "someone new to the topic with no prior knowledge",
+      intermediate: "someone with basic understanding who wants to go deeper",
+      expert: "an expert who wants technical precision and nuance"
+    };
+    const b = builder().role("expert teacher and communicator").task("Explain the concept clearly and thoroughly.").variable("concept", { required: true, description: "The concept to explain" });
+    if (options.level) {
+      b.context(`Target audience: ${levelDescriptions[options.level]}`);
+    }
+    if (options.useAnalogies) {
+      b.constraint("Use relatable analogies and real-world examples");
+    }
+    return b.constraints([
+      "Break down complex ideas into digestible parts",
+      "Build understanding progressively",
+      "Anticipate and address common misconceptions"
+    ]);
+  },
+  /**
+   * Create a data extraction prompt
+   */
+  extract: (options = {}) => {
+    const b = builder().role("data extraction specialist").task("Extract structured data from the provided text.").variable("text", { required: true, description: "Text to extract data from" });
+    if (options.fields && options.fields.length > 0) {
+      b.context(`Fields to extract: ${options.fields.join(", ")}`);
+    }
+    if (options.format) {
+      b.output(`Return extracted data in ${options.format.toUpperCase()} format`);
+    }
+    return b.constraints([
+      "Extract only factual information present in the text",
+      "Use null or empty values for missing fields",
+      "Maintain consistent formatting"
+    ]);
+  },
+  /**
+   * Create a brainstorming prompt
+   */
+  brainstorm: (options = {}) => {
+    const b = builder().role("creative strategist and ideation expert").task("Generate diverse and innovative ideas based on the given topic or challenge.").variable("topic", { required: true, description: "Topic or challenge to brainstorm about" });
+    if (options.count) {
+      b.constraint(`Generate exactly ${options.count} ideas`);
+    }
+    if (options.creative) {
+      b.constraint("Include unconventional and out-of-the-box ideas");
+    }
+    return b.constraints([
+      "Ensure ideas are distinct and varied",
+      "Consider different perspectives and approaches",
+      "Make ideas actionable when possible"
+    ]).output("List each idea with a brief description and potential benefits");
+  },
+  /**
+   * Create a code refactoring prompt
+   */
+  refactor: (options = {}) => {
+    const goalDescriptions = {
+      readability: "improving code readability and clarity",
+      performance: "optimizing performance and efficiency",
+      maintainability: "enhancing maintainability and extensibility",
+      all: "overall code quality improvement"
+    };
+    const b = builder().role("senior software engineer specializing in code quality").task(`Refactor the code with focus on ${goalDescriptions[options.goal || "all"]}.`).variable("code", { required: true, description: "Code to refactor" });
+    if (options.language) {
+      b.context(`The code is written in ${options.language}.`);
+    }
+    return b.constraints([
+      "Preserve existing functionality",
+      "Follow language best practices and idioms",
+      "Explain each significant change"
+    ]).output("1. Refactored code\n2. List of changes made\n3. Explanation of improvements");
+  },
+  /**
+   * Create an API documentation prompt
+   */
+  apiDocs: (options = {}) => {
+    const b = builder().role("technical documentation writer").task("Generate comprehensive API documentation for the provided code or endpoint.").variable("code", { required: true, description: "API code or endpoint definition" });
+    if (options.style) {
+      b.output(`Format documentation in ${options.style.toUpperCase()} style`);
+    }
+    if (options.includeExamples) {
+      b.constraint("Include request/response examples for each endpoint");
+    }
+    return b.constraints([
+      "Document all parameters with types and descriptions",
+      "Include error responses and status codes",
+      "Be precise and developer-friendly"
+    ]);
+  },
+  /**
+   * Create a unit test generation prompt
+   */
+  unitTest: (options = {}) => {
+    const b = builder().role("test automation engineer").task("Generate unit tests for the provided code.").variable("code", { required: true, description: "Code to generate tests for" });
+    if (options.framework) {
+      b.context(`Use ${options.framework} testing framework.`);
+    }
+    const coverageConstraints = options.coverage === "comprehensive" ? ["Cover all code paths including edge cases", "Test error handling scenarios", "Include boundary value tests"] : ["Cover main functionality", "Include basic edge cases"];
+    return b.constraints([
+      ...coverageConstraints,
+      "Write clear, descriptive test names",
+      "Follow AAA pattern (Arrange, Act, Assert)"
+    ]).output("Complete, runnable test file");
+  },
+  /**
+   * Create a commit message prompt
+   */
+  commitMessage: (options = {}) => {
+    const b = builder().role("developer with excellent communication skills").task("Generate a clear and descriptive commit message for the provided code changes.").variable("diff", { required: true, description: "Git diff or description of changes" });
+    if (options.style === "conventional") {
+      b.constraints([
+        "Follow Conventional Commits format (type(scope): description)",
+        "Use appropriate type: feat, fix, docs, style, refactor, test, chore"
+      ]);
+    }
+    if (options.includeBody) {
+      b.constraint("Include a detailed body explaining the why behind changes");
+    }
+    return b.constraints([
+      "Keep subject line under 72 characters",
+      "Use imperative mood (Add, Fix, Update, not Added, Fixed, Updated)"
+    ]);
+  },
+  /**
+   * Create a code review comment prompt
+   */
+  reviewComment: (options = {}) => {
+    const b = builder().role("thoughtful code reviewer").task("Write a helpful code review comment for the provided code snippet.").variable("code", { required: true, description: "Code to comment on" }).variable("issue", { required: true, description: "The issue or improvement to address" });
+    if (options.tone === "constructive") {
+      b.constraint("Frame feedback positively and suggest improvements rather than just pointing out problems");
+    }
+    if (options.severity) {
+      b.constraint("Indicate severity level: nitpick, suggestion, important, or blocker");
+    }
+    return b.constraints([
+      "Be specific and actionable",
+      "Explain the reasoning behind the suggestion",
+      "Provide an example of the improved code when helpful"
+    ]);
+  },
+  /**
+   * Create a regex generator prompt
+   */
+  regex: (options = {}) => {
+    const b = builder().role("regex expert").task("Create a regular expression that matches the described pattern.").variable("pattern", { required: true, description: "Description of the pattern to match" }).variable("examples", { required: false, description: "Example strings that should match" });
+    if (options.flavor) {
+      b.context(`Use ${options.flavor} regex flavor/syntax.`);
+    }
+    return b.constraints([
+      "Provide the regex pattern",
+      "Explain each part of the pattern",
+      "Include test cases showing matches and non-matches"
+    ]).output("1. Regex pattern\n2. Explanation\n3. Test cases");
+  },
+  /**
+   * Create a SQL query prompt
+   */
+  sql: (options = {}) => {
+    const b = builder().role("database expert").task("Write an SQL query based on the requirements.").variable("requirement", { required: true, description: "What the query should accomplish" }).variable("schema", { required: false, description: "Database schema or table definitions" });
+    if (options.dialect) {
+      b.context(`Use ${options.dialect.toUpperCase()} syntax.`);
+    }
+    if (options.optimize) {
+      b.constraint("Optimize for performance and include index recommendations if applicable");
+    }
+    return b.constraints([
+      "Write clean, readable SQL",
+      "Use appropriate JOINs and avoid N+1 patterns",
+      "Include comments explaining complex logic"
+    ]);
   }
 };
 export {