deepstack

# Deep Stack Research Prompt Generator

Deep stack analysis tool.

Arguments: $ARGUMENTS

## Instructions

Generate a comprehensive deep research prompt for the topic **"$ARGUMENTS"** tailored to the current project's technology stack.

**If no topic is provided**, ask the user what topic they want to research (e.g., security, performance, maintainability, scalability, testing, deployment, accessibility).

---

## Phase 1: Detect the Technology Stack

Analyze the current project to identify all technologies and their versions. Check these files:

### Backend Detection

| File | Technology |
|------|------------|
| `composer.json` | PHP ecosystem (Laravel, Symfony, etc.) — check `require` for framework and PHP version |
| `package.json` | Node.js ecosystem (Express, Fastify, NestJS, etc.) — check for server-side frameworks |
| `requirements.txt` / `pyproject.toml` / `Pipfile` | Python (Django, Flask, FastAPI) |
| `Gemfile` | Ruby (Rails, Sinatra) |
| `go.mod` | Go (Gin, Echo, Fiber) |
| `Cargo.toml` | Rust (Actix, Axum, Rocket) |
| `pom.xml` / `build.gradle` | Java (Spring Boot) |
| `*.csproj` / `*.sln` | .NET (ASP.NET Core) |

### Frontend Detection

Check `package.json` dependencies for:
- **Frameworks**: React, Vue, Svelte, Angular, Solid, Preact, Qwik
- **Meta-frameworks**: Next.js, Nuxt, SvelteKit, Remix, Astro
- **Build tools**: Vite, Webpack, Parcel, esbuild, Turbopack
- **CSS**: Tailwind CSS, Bootstrap, styled-components, Sass, PostCSS

### Integration/Middleware Layer

Look for glue technologies:
- **Inertia.js** (`@inertiajs/vue3`, `@inertiajs/react`, etc.)
- **Livewire** (in `composer.json`)
- **HTMX** (in `package.json` or HTML files)
- **Turbo/Hotwire** (in `package.json` or `Gemfile`)
- **Alpine.js** (often paired with Livewire/HTMX)

### Database Detection

Check these locations:
- `.env` file: `DB_CONNECTION`, `DATABASE_URL`
- `docker-compose.yml`: Database service definitions
- `config/database.php` (Laravel), `settings.py` (Django), etc.
- ORM configs: Prisma (`schema.prisma`), Drizzle, TypeORM, Eloquent

Common databases: MySQL, PostgreSQL, SQLite, MongoDB, Redis, Elasticsearch

### Infrastructure/Other Tools

- **Caching**: Redis, Memcached
- **Search**: Elasticsearch, Meilisearch, Algolia
- **Queues**: Redis, RabbitMQ, SQS
- **Storage**: S3, local filesystem
- **Auth**: Sanctum, Passport, NextAuth, Auth0, Clerk

### Version Detection

For each technology found, extract the version:
- `package.json`: Check `dependencies` and `devDependencies` for exact versions
- `composer.json`: Check `require` section
- Lock files (`package-lock.json`, `composer.lock`) have exact versions
- `.env` or Docker configs may specify database versions

---

## Phase 2: Confirm Stack with User

**IMPORTANT: First output the detected stack as a text message to the user.** Do NOT put the stack details inside the AskUserQuestion tool — the tool has limited space for display.

### Step 1: Display the stack as text output

Output a message like this (with actual detected values):

```
I detected the following technology stack for this project:

**Backend:**
- Rust 1.75
- Tauri 2.0

**Frontend:**
- TypeScript 5.3
- React 18.2
- Vite 5.0
- Tailwind CSS 3.4

**Database:**
- SQLite (via Tauri)

**Desktop:**
- Tauri 2.0 (Rust backend, webview frontend)

**Other:**
- pnpm (package manager)
```

### Step 2: Then ask for confirmation

AFTER displaying the stack details above, use the AskUserQuestion tool with a simple confirmation question:

- Question: "Does this detected stack look correct?"
- Options: "Yes, looks correct" / "Need corrections"

**Wait for user confirmation before proceeding.** If the user provides corrections, incorporate them into the stack.

---

## Phase 3: Generate the Deep Research Prompt

Once the stack is confirmed, generate a comprehensive research prompt. The prompt should be structured for a deep research tool (like Claude, Perplexity, or similar).

### Prompt Template

Generate output in this format (replace placeholders with actual stack details):

---

**START OF GENERATED PROMPT**

I'm working on a web application with the following technology stack:

**Backend:**
- [List each backend technology with version]

**Frontend:**
- [List each frontend technology with version]

**Integration:**
- [List integration/middleware if applicable]

**Database:**
- [List databases and data stores with versions]

**Other:**
- [List other notable tools]

I need comprehensive research on **[TOPIC from $ARGUMENTS]** best practices, patterns, and considerations for this specific stack.

## Research Scope

### 1. Individual Technology Analysis

For each technology in my stack, research:
- **[TOPIC]** best practices specific to this version
- Known issues, vulnerabilities, or limitations related to **[TOPIC]**
- Configuration options that affect **[TOPIC]**
- Common mistakes developers make regarding **[TOPIC]**
- Version-specific considerations (what changed in recent versions)

### 2. Integration Points

Research **[TOPIC]** considerations for these technology combinations:
- [Backend framework] + [Frontend framework] (data flow, state management)
- [Backend] + [Database] (query patterns, connection handling)
- [Integration layer] specifics (if applicable)
- [Any other relevant combinations based on the stack]

Focus on issues that arise specifically from these technologies working together, not just individual concerns.

### 3. Stack-Specific Patterns

Identify **[TOPIC]** patterns and architectures that are:
- Recommended for this exact stack combination
- Anti-patterns to avoid with this stack
- Trade-offs specific to these technology choices

### 4. Real-World Considerations

Research:
- Common **[TOPIC]** issues reported by developers using this stack
- Production lessons learned
- Scaling considerations related to **[TOPIC]**
- Monitoring and observability for **[TOPIC]**

## Requested Output Format

Please provide your findings organized as:

1. **Executive Summary**
   - Top 10 most critical **[TOPIC]** considerations for this stack
   - Priority-ranked action items

2. **Per-Technology Guidelines**
   - Organized by each technology in the stack
   - Specific, actionable recommendations
   - Code examples where helpful

3. **Integration Guidelines**
   - **[TOPIC]** at the boundaries between technologies
   - Data flow considerations
   - Common pitfalls when technologies interact

4. **Known Issues & Gotchas**
   - Version-specific bugs or limitations
   - Documented vulnerabilities (for security topics)
   - Edge cases to watch for

5. **Checklist**
   - Actionable audit checklist for **[TOPIC]**
   - Can be used to review existing code

6. **Anti-Patterns**
   - What NOT to do
   - Common mistakes with this stack
   - Why they're problematic

7. **Resources**
   - Official documentation links
   - Recommended articles, tutorials, talks
   - Tools that help with **[TOPIC]** for this stack

**END OF GENERATED PROMPT**

---

## Phase 4: Present the Output

Output the generated prompt as plain text that the user can easily copy.

Before the prompt, add:

> **Here's your deep research prompt for "[TOPIC]" tailored to your stack. Copy this and paste it into your preferred research tool:**

After the prompt, add:

> **Tip:** This prompt works well with Claude, ChatGPT, Perplexity, or similar AI research tools. For best results, use a tool that can search the web for current information.

---

## Topic-Specific Additions

Depending on the topic provided in `$ARGUMENTS`, emphasize different aspects:

### If topic is "security":
- Emphasize CVEs, OWASP Top 10, authentication, authorization, input validation
- Include encryption, secrets management, dependency vulnerabilities
- Request exploit examples and mitigation strategies

### If topic is "performance":
- Emphasize profiling, caching strategies, database optimization, lazy loading
- Include bundle size, Core Web Vitals, memory management
- Request benchmarking approaches and monitoring tools

### If topic is "testing":
- Emphasize unit, integration, e2e testing strategies for the stack
- Include mocking strategies, test data management, CI/CD integration
- Request coverage goals and testing anti-patterns

### If topic is "maintainability":
- Emphasize code organization, naming conventions, documentation
- Include refactoring patterns, technical debt management
- Request code review checklists and architecture patterns

### If topic is "scalability":
- Emphasize horizontal/vertical scaling, load balancing, caching
- Include database sharding, microservices considerations
- Request capacity planning and bottleneck identification

### If topic is "deployment":
- Emphasize CI/CD, containerization, environment management
- Include rollback strategies, zero-downtime deployments
- Request infrastructure as code and monitoring setup

### If topic is "accessibility":
- Emphasize WCAG compliance, screen reader support, keyboard navigation
- Include ARIA patterns, color contrast, focus management
- Request testing tools and audit approaches

---

## Notes

- Always include version numbers — they matter for accurate research
- If you can't detect a version, note it as "[version unknown]" and ask the user
- The generated prompt should be self-contained and not require additional context
- Tailor the integration section to the actual technologies detected (don't include generic examples)