skalara-core/lib/prompts.ts

export const generateProjectQuestions = (
  project_name: string,
  project_description: string,
  project_stack: string[]
): string => {
  return `As an expert product/project manager with extensive experience in agile methodologies, you will be helping to generate features and tasks for a software project. Your role involves careful planning, defining project scopes, and breaking down complex tasks into manageable units of work. You will be using your expertise to guide the development process effectively.\n
  
  Given the following information about the software project:\n

    1. Project Name: ${project_name}\n
    2. Project Description: ${project_description}\n
    3. Tech Stack: ${project_stack.join(", ")}\n
  
  Please generate three critical questions that an agile product/project manager would ask to ensure a comprehensive understanding of the project. These questions should be aimed at extracting additional, crucial details that are necessary for:\n
  
    - Defining the product backlog,\n
    - Planning sprints with a clear vision of deliverables,\n
    - Identifying potential impediments and dependencies early in the process.\n

  Consider the provided information insufficient for a detailed planning phase—you are seeking to uncover layers of requirements and considerations that have not been addressed yet.
  `;
};

type Question = {
  question: string;
  answer: string;
};

export const generateFeatures = (
  project_name: string,
  project_description: string,
  project_stack: string[],
  qa: Question[]
): string => {
  return `As a product/project manager specializing in agile methodologies and MVP development, you are now entering the crucial phase of defining the core features for the Minimum Viable Product of our new software project. The MVP must include just enough features to satisfy early adopters and provide feedback for future product development. Using the insights gathered from a previous analysis and Q&A session, your task is to propose an MVP feature list that aligns with the project's initial goals and constraints.\n
  
  Utilize the following inputs to create the MVP feature list:\n

    1. Project Name: ${project_name}\n
    2. Project Description: ${project_description}\n
    3. Tech Stack: ${project_stack.join(", ")}\n
    4. Q&A Insights:\n
       ${qa.map((q) => `- Q: ${q.question}\n- A: ${q.answer}\n`).join("")}

  With a focus on the core functionality that provides value, propose features that are essential for the initial phase, bearing in mind the constraints of time and resources typical of MVPs. Prioritize features based on user needs, potential impact, and strategic importance as indicated by the answers from the Q&A. Consider the balance between the necessity for the end-user and the feasibility of implementation with the current tech stack.
  `;
};

type Feature = {
  name: string;
  description: string;
};

type FeatureDeps = {
  uid: string;
  name: string;
  description: string;
};

export const generateFeatureDeps = (
  project_name: string,
  project_description: string,
  project_stack: string[],
  features: Feature[]
): string => {
  return `As an experienced product/project manager with a deep understanding of software development processes and interdependencies among features, your task is to analyze a list of features for a software project and determine the dependencies for each feature. A dependency in this context refers to a situation where one feature must be completed before another can effectively be worked on.\n
  
  Given the list of features for our software project, please assess and identify the dependencies for each feature. Your analysis should consider factors like the logical flow of the project, technical constraints, and the user experience journey.\n
  
    1. Project Name: ${project_name}\n
    2. Project Description: ${project_description}\n
    3. Tech Stack: ${project_stack.join(", ")}\n
    4. List of Features:\n
        ${features.map((f) => `- ${f.name}: ${f.description}\n`).join("")}
        
  For each feature, determine:\n

    - Which other features (if any) it is dependent on.\n
    - A brief explanation of why this dependency exists (e.g., technical prerequisite, user flow, data dependency).\n
    
  This assessment should lead to a clearer understanding of the order in which the features should ideally be developed. The goal is to ensure an efficient and logical progression in the project's development phase, aligning with the technical capabilities and the project's overall objectives.
  `;
};

export const generateTasks = (
  project_name: string,
  project_description: string,
  project_stack: string[],
  feature: any,
  feature_deps: any[]
): string => {
  return `As a detail-oriented product/project manager with a strong background in agile methodologies, you are tasked with breaking down a specific feature of a software project into actionable tasks. Your objective is to ensure that each task is clearly defined and contributes directly to the development of the specified feature, avoiding overlap with tasks that would have been created for other dependent features.\n
  
  Please generate a task list for a feature of our software project, considering the following information:\n
  
    1. Project Name: ${project_name}\n
    2. Project Description: ${project_description}\n
    3. Tech Stack: ${project_stack.join(", ")}\n
    4. Target Feature Name: ${feature.name}\n
    5. Target Feature Description: ${feature.description}\n
    6. Feature Dependencies: ${feature_deps.length === 0 ? "N/A" : ""}\n
        ${feature_deps.map((f) => `- ${f.name}: ${f.description}\n`).join("")}
        
  Given the dependencies, focus on tasks unique to the target feature. Assume that tasks essential for the dependent features are already being handled or completed, thereby requiring no repetition. Your tasks should align with the unique aspects and requirements of the target feature, reflecting its specific role and functionality within the project.\n
  
  Tasks should be broken down into clear, actionable items that consider the following:\n
    
    - Specific coding or development work needed for this feature, not covered by the dependencies.\n
    - Integration points with the dependent features.\n
    - Testing and quality assurance specific to this feature.\n
    - Any documentation or resource preparation exclusive to this feature.\n

  Ensure each task is concise, achievable, and relevant, aiding the development team in focusing their efforts effectively and efficiently on this particular aspect of the project.
  `;
};