Merge pull request #16 from rasulkireev/prompt-improvements

refactor: optimize prompts and project details structure

Author: rasulkireev

.cursor/rules/backend.mdc

@@ -0,0 +1,45 @@
+---
+description: Rules for working with the Backend (Django in this case)
+globs: *.py
+alwaysApply: false
+---
+## Key Principles
+- We will only have one django app, called 'core'. Everything about our webapp will be here
+- Use Django's built-in features and tools wherever possible
+- Prioritize readability and maintainability; follow PEP 8
+- Use descriptive variable/function names with underscores
+- Use Django templates for HTML, django-ninja for APIs
+- Keep business logic in models/forms
+- Keep views focused on request handling
+- Implement comprehensive logging
+- Use double quotes instead of single quotes
+
+
+## Django/Python
+- Use CBVs for complex views; FBVs for simpler logic
+- Leverage Django's ORM; avoid raw SQL when possible
+- Use Django's built-in user model and authentication
+- Utilize Django form/model form classes
+- Follow MVT pattern strictly
+
+## Logging and Error Handling
+- Use Python's logging module (structlog) extensively
+- Include context in log messages:
+logger.warning(
+    "Error occurred during profile update",
+    error=str(e),
+    profile_id=profile.id
+)
+- Use appropriate log levels (INFO, WARNING, ERROR)
+- Use Django's validation framework
+- Use try-except blocks for specific erros, try to avoid excepting Exception
+- Customize error pages (404, 500)
+
+## API Development
+- Use django-ninja instead of DRF
+- django-ninja generate openapi documentation, so make sure to populate views with relevant data in order for it to hsow up in the OpenAPI docs.
+- Use Pydantic models for schema validation
+- Use django-ninja's authentication classes
+
+## Workers
+- Use django-q2 syntax for workers

.cursor/rules/frontend.mdc

@@ -0,0 +1,15 @@
+---
+description: Frontend related rule (HTML Template and Stimulus.js)
+globs: *.js, *.html
+alwaysApply: false
+---
+## Frontend Development
+- Prefer Stimulus JS for adding interactivity to Django templates instead of raw script elements
+- Use Stimulus controllers to encapsulate JavaScript behavior and keep it separate from HTML structure
+- Leverage Stimulus data attributes to connect HTML elements with JavaScript functionality
+- Utilize Stimulus targets to reference specific elements within a controller
+- Employ Stimulus actions to handle user interactions and events
+
+## Stimulusjs Specific Guidelines
+- Add semicolons at the end of statements
+- Use double quotes instead of single quotes

.cursor/rules/project-conventions.mdc

@@ -0,0 +1,85 @@
+---
+description: This rule explains the project's tech stack and code conventions
+globs:
+alwaysApply: true
+---
+This rule serves as high-level documentation for how the codebase is structured.
+
+## Rules for AI
+
+- Use this file to understand how the codebase works
+- Treat this rule/file as your "source of truth" when making code recommendations
+- When creating migrations, always use `dm makemigrations` instead of creating the file yourself
+
+## Project Tech Stack
+
+- Web framework: Django
+  - Django's built-in testing framework
+  - Django Ninja for API development
+  - Django Q2 for background tasks
+  - Stimulus JS for frontend interactivity
+  - TailwindCSS for styles
+- Database: PostgreSQL
+- Background tasks: Django Q2
+- External
+  - Payments: Stripe
+  - [Other external services your project uses]
+
+## Project conventions
+
+These conventions should be used when writing code for the project.
+
+### Convention 1: Minimize dependencies, vanilla Django is plenty
+
+Dependencies are a natural part of building software, but we aim to minimize them when possible to keep this codebase easy to understand, maintain, and contribute to.
+
+- Push Django to its limits before adding new dependencies
+- When a new dependency is added, there must be a strong technical or business reason to add it
+- When adding dependencies, you should favor old and reliable over new and flashy
+
+### Convention 2: Leverage models and mixins over separate service layers
+
+This codebase adopts a "skinny views, fat models" convention following Django's MVT pattern. We put business logic in models and avoid separate folders for business logic.
+
+- Organize large pieces of business logic into Django models and mixins
+- While a mixin _may_ offer shared functionality, it can also be a "one-off" mixin that is only included in one place for better organization and readability
+- When mixins are used for code organization, they should be organized around the "traits" of a model; not for simply moving code to another spot in the codebase
+- When possible, models should answer questions about themselves—for example, we might have a method, `account.balance_series` that returns a time-series of the account's most recent balances
+
+### Convention 3: Prefer server-side solutions over client-side solutions
+
+- When possible, leverage Django templates over complex, JS-driven client-side solutions
+- When writing a client-side solution, use Stimulus controllers and keep it simple!
+- Keep client-side code for where it truly shines. For example, bulk selection is a case where server-side solutions would degrade the user experience significantly
+
+### Convention 4: Sacrifice performance, optimize for simplicitly and clarity
+
+This codebase is still young. We are still rapidly iterating on domain designs and features. Because of this, code should be optimized for simplicitly and clarity over performance.
+
+- Focus on good OOP design first, performance second
+- Be mindful of large performance bottlenecks, but don't sweat the small stuff
+
+### Convention 5: Prefer semantic, native HTML features
+
+The HTML spec has improved tremendously over the years and offers a ton of functionality out of the box. We prefer semantic, native HTML solutions over JS-based ones. A few examples of this include:
+
+- Using the `dialog` element for modals
+- Using `summary` / `details` elements for disclosures (or `popover` attribute)
+
+Stimulus works very well with these native elements and we optimize for this.
+
+### Convention 6: Use Django's testing framework and fixtures
+
+Due to the open-source nature of this project, we have chosen Django's testing framework and fixtures for testing to maximize familiarity and predictability.
+
+- Always use Django's testing framework and fixtures for testing
+- Keep fixtures to a minimum. Most models should have 2-3 fixtures maximum that represent the "base cases" for that model
+- "Edge cases" should be created on the fly, within the context of the test which it is needed
+- For tests that require a large number of fixture records to be created, use test helpers to act as a "factory" for creating these
+
+### Convention 7: Use Django models for complex validations, DB for simple ones, keep business logic out of DB
+
+- Enforce `null` checks, unique constraints, and other simple validations in the DB
+- Django model validations _may_ mirror the DB level ones, but not 100% necessary
+- These are for convenience when error handling in forms. Always prefer client-side form validation when possible
+- Complex validations and business logic should remain in Django models

.cursor/rules/ui-ux-design-guidelines.mdc

@@ -0,0 +1,12 @@
+---
+description: This file describes Marketing Agent's design system and how views should be styled
+globs: *.html, views.py, *.js, *.css
+alwaysApply: false
+---
+Use this rule whenever you are writing html, css, or even styles in Stimulus controllers that use D3.js.
+
+The codebase uses TailwindCSS v3.x with no custom design system defined.
+
+- Always generate semantic HTML
+- Never create new styles without explicitly receiving permission to do so
+- Always favor the "utility first" Tailwind approach.  Reusable style classes should not be created often.  Code should be reused primarily through template components.

.gitignore

@@ -1,3 +1,6 @@
+.logfire/
+.ruff_cache/
+
 # DB
 backup-dbs/
 media/

CLAUDE.md

@@ -0,0 +1,28 @@
+# Commands
+- Build/Run: `make serve` (docker-compose up -d --build)
+- Test: `make test` (docker compose run --rm backend pytest)
+- Test single file: `docker compose run --rm backend pytest path/to/test.py::TestClass::test_method -v`
+- Shell: `make shell` (Django shell_plus with IPython)
+- Stripe sync: `make stripe-sync`
+- Frontend: `npm run build`, `npm start`, `npm run watch`
+
+# Code Style
+## Python
+- Line length: 120
+- Formatting: black
+- Imports: isort (Django profile, combine_as_imports, trailing_comma)
+- Linting: ruff
+- Django templates: djlint (profile=django)
+- Error handling: Proper exception catching and logging
+
+## Frontend
+- StimulusJS: Use controllers for all interactive elements
+- TailwindCSS: Use for styling (with @tailwindcss/forms, @tailwindcss/typography)
+- JavaScript: @babel/eslint-parser, eslint:recommended, required semicolons
+- SCSS: stylelint-config-standard-scss
+
+## Naming & Structure
+- Follow Django conventions for models, views
+- Use type hints in Python
+- Follow existing pattern in codebase for component structure
+- Document complex functions and classes

core/models.py

@@ -176,24 +176,6 @@ class Project(BaseModel):
     def __str__(self):
         return self.name
 
-    @property
-    def project_details_string(self):
-        return f"""
-            - Today's Date: {timezone.now().strftime("%Y-%m-%d")}
-            - Project URL: {self.url}
-            - Project Name: {self.name}
-            - Project Type: {self.type}
-            - Project Summary: {self.summary}
-            - Blog Theme: {self.blog_theme}
-            - Founders: {self.founders}
-            - Key Features: {self.key_features}
-            - Target Audience: {self.target_audience_summary}
-            - Pain Points: {self.pain_points}
-            - Product Usage: {self.product_usage}
-            - Language: {self.language}
-            - Links: {self.links}
-        """
-
     @property
     def project_details(self):
         return ProjectDetails(
@@ -218,19 +200,6 @@ def liked_title_suggestions(self):
     def disliked_title_suggestions(self):
         return self.blog_post_title_suggestions.filter(user_score__lt=0).all()
 
-    @property
-    def get_liked_disliked_title_suggestions_string(self):
-        liked_titles = "\n".join(f"- {suggestion.title}" for suggestion in self.liked_title_suggestions)
-        disliked_titles = "\n".join(f"- {suggestion.title}" for suggestion in self.disliked_title_suggestions)
-
-        return f"""
-            Liked Title Suggestions:
-            {liked_titles}
-
-            Disliked Title Suggestions:
-            {disliked_titles}
-        """
-
     def get_page_content(self):
         """
         Fetch page content using Jina Reader API and update the project.
@@ -291,7 +260,7 @@ def get_page_content(self):
 
     def analyze_content(self):
         """
-        Analyze the page content using Claude via PydanticAI and update project details.
+        Analyze the page content using PydanticAI and update project details.
         Should be called after get_page_content().
         """
         agent = Agent(
@@ -370,15 +339,15 @@ def add_project_details(ctx: RunContext[TitleSuggestionContext]) -> str:
             """
 
         @agent.system_prompt
-        def add_language_specification(ctx: RunContext[TitleSuggestionContext]) -> str:
+        def add_number_of_titles_to_generate(ctx: RunContext[TitleSuggestionContext]) -> str:
             return f"""IMPORTANT: Generate only {ctx.deps.num_titles} titles."""
 
         @agent.system_prompt
-        def add_number_of_titles_to_generate(ctx: RunContext[TitleSuggestionContext]) -> str:
+        def add_language_specification(ctx: RunContext[TitleSuggestionContext]) -> str:
             project = ctx.deps.project_details
             return f"""
                 IMPORTANT: Generate all titles in {project.language} language.
-                Make sure the titles are grammatically correct and culturally appropriate for {self.language}-speaking audiences.
+                Make sure the titles are grammatically correct and culturally appropriate for {project.language}-speaking audiences.
             """
 
         @agent.system_prompt
@@ -513,12 +482,12 @@ def generate_content(self, content_type=ContentType.SHARING):
             The generated blog post
         """
         agent = Agent(
-            "anthropic:claude-3-7-sonnet-latest",
+            "google-gla:gemini-2.0-flash",
             result_type=BlogPostContent,
             deps_type=BlogPostGenerationContext,
             system_prompt=GENERATE_CONTENT_SYSTEM_PROMPTS[content_type],
             retries=2,
-            model_settings={"max_tokens": 8000, "temperature": 0.4},
+            model_settings={"max_tokens": 8192, "temperature": 0.4},
         )
 
         @agent.system_prompt