@stackguide/mcp-server 1.0.0

package/data/knowledge/react-node/common-issues/common-issues.md

@@ -0,0 +1,262 @@
+# React/Node Common Issues and Solutions
+
+Solutions to frequently encountered problems in React and Node.js development.
+
+## React Issues
+
+### State Not Updating
+
+**Problem**: State doesn't update as expected.
+
+**Solution**:
+```tsx
+// State updates are asynchronous and batched
+const [count, setCount] = useState(0);
+
+// Wrong - uses stale value
+setCount(count + 1);
+setCount(count + 1); // Still increments by 1
+
+// Correct - use functional update
+setCount(prev => prev + 1);
+setCount(prev => prev + 1); // Increments by 2
+```
+
+### useEffect Running Twice
+
+**Problem**: Effect runs twice in development.
+
+**Solution**:
+```tsx
+// React 18+ Strict Mode intentionally double-invokes effects
+// to help find bugs. Don't disable Strict Mode - fix the code.
+
+// Ensure cleanup handles this
+useEffect(() => {
+  const controller = new AbortController();
+  
+  fetchData({ signal: controller.signal });
+  
+  return () => controller.abort(); // Cleanup
+}, []);
+
+// For subscriptions
+useEffect(() => {
+  const unsubscribe = subscribe(handler);
+  return () => unsubscribe();
+}, []);
+```
+
+### Memory Leaks in Components
+
+**Problem**: "Can't perform a React state update on an unmounted component"
+
+**Solution**:
+```tsx
+// Use AbortController for fetch
+useEffect(() => {
+  const controller = new AbortController();
+  
+  async function fetchData() {
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      const data = await res.json();
+      setData(data);
+    } catch (err) {
+      if (err.name !== 'AbortError') {
+        setError(err);
+      }
+    }
+  }
+  
+  fetchData();
+  return () => controller.abort();
+}, [url]);
+
+// Or use ref to track mount state (less preferred)
+const isMounted = useRef(true);
+useEffect(() => {
+  return () => { isMounted.current = false; };
+}, []);
+```
+
+### Prop Drilling
+
+**Problem**: Passing props through many levels.
+
+**Solution**:
+```tsx
+// Use Context for truly global state
+const ThemeContext = createContext<Theme>('light');
+
+function App() {
+  const [theme, setTheme] = useState<Theme>('light');
+  return (
+    <ThemeContext.Provider value={theme}>
+      <Page />
+    </ThemeContext.Provider>
+  );
+}
+
+// Any nested component can access
+function DeepComponent() {
+  const theme = useContext(ThemeContext);
+}
+
+// Or use composition
+function Page() {
+  const user = useUser();
+  return <Layout header={<Header user={user} />} />;
+}
+```
+
+## Node.js Issues
+
+### Callback Hell
+
+**Problem**: Deeply nested callbacks.
+
+**Solution**:
+```typescript
+// Convert to promises
+import { promisify } from 'util';
+const readFile = promisify(fs.readFile);
+
+// Use async/await
+async function processFile(path: string) {
+  const content = await readFile(path, 'utf-8');
+  const parsed = JSON.parse(content);
+  return transform(parsed);
+}
+
+// Handle errors properly
+try {
+  const result = await processFile('./data.json');
+} catch (error) {
+  logger.error('Failed to process file', { error });
+}
+```
+
+### Unhandled Promise Rejections
+
+**Problem**: Crash due to unhandled rejection.
+
+**Solution**:
+```typescript
+// Global handler
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection', { reason, promise });
+  // Optionally exit
+  process.exit(1);
+});
+
+// Always handle promises
+async function riskyOperation() {
+  try {
+    await mightFail();
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// Or with .catch()
+mightFail().catch(handleError);
+```
+
+### Event Loop Blocking
+
+**Problem**: Long-running sync operation blocks the server.
+
+**Solution**:
+```typescript
+// Bad - blocks event loop
+app.get('/hash', (req, res) => {
+  const hash = bcrypt.hashSync(req.body.password, 12); // Blocks!
+  res.json({ hash });
+});
+
+// Good - use async version
+app.get('/hash', async (req, res) => {
+  const hash = await bcrypt.hash(req.body.password, 12);
+  res.json({ hash });
+});
+
+// For CPU-intensive work, use worker threads
+import { Worker } from 'worker_threads';
+
+function runHeavyTask(data) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker('./worker.js', { workerData: data });
+    worker.on('message', resolve);
+    worker.on('error', reject);
+  });
+}
+```
+
+### Memory Leaks
+
+**Problem**: Node.js process memory keeps growing.
+
+**Solution**:
+```typescript
+// Check for common causes:
+
+// 1. Growing arrays/maps without cleanup
+const cache = new Map();
+// Add max size limit
+function set(key: string, value: any) {
+  if (cache.size >= MAX_SIZE) {
+    const firstKey = cache.keys().next().value;
+    cache.delete(firstKey);
+  }
+  cache.set(key, value);
+}
+
+// 2. Event listeners not removed
+const handler = () => {};
+emitter.on('event', handler);
+// Later...
+emitter.off('event', handler);
+
+// 3. Closures holding references
+function createHandler(bigData) {
+  // bigData is retained in closure
+  return () => console.log(bigData.length);
+}
+// Solution: extract only needed data
+function createHandler(dataLength) {
+  return () => console.log(dataLength);
+}
+```
+
+### Database Connection Issues
+
+**Problem**: Too many connections or connection timeouts.
+
+**Solution**:
+```typescript
+// Use connection pooling
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  max: 20,
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 2000,
+});
+
+// Use single client for transactions
+async function transfer(from: string, to: string, amount: number) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    await client.query('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, from]);
+    await client.query('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, to]);
+    await client.query('COMMIT');
+  } catch (e) {
+    await client.query('ROLLBACK');
+    throw e;
+  } finally {
+    client.release(); // Always release!
+  }
+}
+```

package/data/knowledge/react-node/patterns/react-patterns.md

@@ -0,0 +1,244 @@
+# React Component Patterns
+
+Common patterns for building scalable React components.
+
+## Compound Components
+
+```tsx
+import { createContext, useContext, useState, ReactNode } from 'react';
+
+// Context for compound component
+const TabsContext = createContext<{
+  activeTab: string;
+  setActiveTab: (id: string) => void;
+} | null>(null);
+
+// Hook to access context
+const useTabsContext = () => {
+  const context = useContext(TabsContext);
+  if (!context) throw new Error('Tab components must be used within Tabs');
+  return context;
+};
+
+// Main component
+interface TabsProps {
+  defaultTab: string;
+  children: ReactNode;
+}
+
+function Tabs({ defaultTab, children }: TabsProps) {
+  const [activeTab, setActiveTab] = useState(defaultTab);
+  
+  return (
+    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
+      <div className="tabs">{children}</div>
+    </TabsContext.Provider>
+  );
+}
+
+// Sub-components
+function TabList({ children }: { children: ReactNode }) {
+  return <div className="tab-list" role="tablist">{children}</div>;
+}
+
+function Tab({ id, children }: { id: string; children: ReactNode }) {
+  const { activeTab, setActiveTab } = useTabsContext();
+  
+  return (
+    <button
+      role="tab"
+      aria-selected={activeTab === id}
+      onClick={() => setActiveTab(id)}
+      className={activeTab === id ? 'active' : ''}
+    >
+      {children}
+    </button>
+  );
+}
+
+function TabPanel({ id, children }: { id: string; children: ReactNode }) {
+  const { activeTab } = useTabsContext();
+  if (activeTab !== id) return null;
+  return <div role="tabpanel">{children}</div>;
+}
+
+// Attach sub-components
+Tabs.List = TabList;
+Tabs.Tab = Tab;
+Tabs.Panel = TabPanel;
+
+// Usage
+<Tabs defaultTab="overview">
+  <Tabs.List>
+    <Tabs.Tab id="overview">Overview</Tabs.Tab>
+    <Tabs.Tab id="details">Details</Tabs.Tab>
+  </Tabs.List>
+  <Tabs.Panel id="overview">Overview content</Tabs.Panel>
+  <Tabs.Panel id="details">Details content</Tabs.Panel>
+</Tabs>
+```
+
+## Render Props
+
+```tsx
+interface MousePosition {
+  x: number;
+  y: number;
+}
+
+interface MouseTrackerProps {
+  render: (position: MousePosition) => ReactNode;
+}
+
+function MouseTracker({ render }: MouseTrackerProps) {
+  const [position, setPosition] = useState({ x: 0, y: 0 });
+  
+  useEffect(() => {
+    const handleMove = (e: MouseEvent) => {
+      setPosition({ x: e.clientX, y: e.clientY });
+    };
+    window.addEventListener('mousemove', handleMove);
+    return () => window.removeEventListener('mousemove', handleMove);
+  }, []);
+  
+  return <>{render(position)}</>;
+}
+
+// Usage
+<MouseTracker
+  render={({ x, y }) => (
+    <div>Mouse is at ({x}, {y})</div>
+  )}
+/>
+```
+
+## Higher-Order Components (HOC)
+
+```tsx
+interface WithLoadingProps {
+  isLoading: boolean;
+}
+
+function withLoading<P extends object>(
+  WrappedComponent: React.ComponentType<P>
+) {
+  return function WithLoadingComponent({ 
+    isLoading, 
+    ...props 
+  }: P & WithLoadingProps) {
+    if (isLoading) return <LoadingSpinner />;
+    return <WrappedComponent {...(props as P)} />;
+  };
+}
+
+// Usage
+const UserListWithLoading = withLoading(UserList);
+<UserListWithLoading isLoading={loading} users={users} />
+```
+
+## Custom Hooks for Shared Logic
+
+```tsx
+// useAsync hook for data fetching
+function useAsync<T>(asyncFn: () => Promise<T>, deps: any[] = []) {
+  const [state, setState] = useState<{
+    status: 'idle' | 'pending' | 'success' | 'error';
+    data?: T;
+    error?: Error;
+  }>({ status: 'idle' });
+  
+  const execute = useCallback(async () => {
+    setState({ status: 'pending' });
+    try {
+      const data = await asyncFn();
+      setState({ status: 'success', data });
+    } catch (error) {
+      setState({ status: 'error', error: error as Error });
+    }
+  }, deps);
+  
+  useEffect(() => {
+    execute();
+  }, [execute]);
+  
+  return { ...state, execute };
+}
+
+// Usage
+const { data, status, error } = useAsync(
+  () => fetchUsers(),
+  []
+);
+```
+
+## Controlled vs Uncontrolled
+
+```tsx
+interface InputProps {
+  // Controlled
+  value?: string;
+  onChange?: (value: string) => void;
+  // Uncontrolled
+  defaultValue?: string;
+}
+
+function Input({ value, onChange, defaultValue }: InputProps) {
+  const [internalValue, setInternalValue] = useState(defaultValue ?? '');
+  
+  const isControlled = value !== undefined;
+  const currentValue = isControlled ? value : internalValue;
+  
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newValue = e.target.value;
+    if (!isControlled) {
+      setInternalValue(newValue);
+    }
+    onChange?.(newValue);
+  };
+  
+  return <input value={currentValue} onChange={handleChange} />;
+}
+```
+
+## Polymorphic Components
+
+```tsx
+type AsProp<C extends React.ElementType> = {
+  as?: C;
+};
+
+type PropsToOmit<C extends React.ElementType, P> = keyof (AsProp<C> & P);
+
+type PolymorphicComponentProp<
+  C extends React.ElementType,
+  Props = {}
+> = React.PropsWithChildren<Props & AsProp<C>> &
+  Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit<C, Props>>;
+
+interface TextOwnProps {
+  color?: 'primary' | 'secondary';
+  size?: 'sm' | 'md' | 'lg';
+}
+
+type TextProps<C extends React.ElementType> = PolymorphicComponentProp<C, TextOwnProps>;
+
+function Text<C extends React.ElementType = 'span'>({
+  as,
+  color = 'primary',
+  size = 'md',
+  children,
+  ...props
+}: TextProps<C>) {
+  const Component = as || 'span';
+  return (
+    <Component className={`text-${color} text-${size}`} {...props}>
+      {children}
+    </Component>
+  );
+}
+
+// Usage
+<Text>Default span</Text>
+<Text as="h1" size="lg">Heading</Text>
+<Text as="a" href="/link">Link text</Text>
+```

package/data/rules/python-django/best-practices/django-best-practices.md

@@ -0,0 +1,120 @@
+# Django Best Practices
+
+Essential best practices for building robust Django applications.
+
+## Settings Management
+
+Use environment variables and split settings:
+
+```python
+# config/settings/base.py
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY")
+DEBUG = False
+ALLOWED_HOSTS = []
+
+# config/settings/development.py
+from .base import *
+
+DEBUG = True
+ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
+```
+
+## Database Optimization
+
+### Use select_related and prefetch_related
+
+```python
+# Bad - N+1 queries
+articles = Article.objects.all()
+for article in articles:
+    print(article.author.name)  # Each iteration queries DB
+
+# Good - Single query with join
+articles = Article.objects.select_related("author").all()
+
+# For many-to-many or reverse foreign keys
+articles = Article.objects.prefetch_related("tags", "comments").all()
+```
+
+### Use QuerySet methods efficiently
+
+```python
+# Use exists() instead of count() for existence checks
+if Article.objects.filter(slug=slug).exists():
+    pass
+
+# Use only() or defer() for partial model loading
+Article.objects.only("title", "slug").all()
+
+# Use values() or values_list() when you don't need model instances
+Article.objects.values_list("id", "title")
+```
+
+## Caching Strategies
+
+```python
+from django.core.cache import cache
+from django.views.decorators.cache import cache_page
+
+# View caching
+@cache_page(60 * 15)  # Cache for 15 minutes
+def article_list(request):
+    pass
+
+# Low-level caching
+def get_article(slug):
+    key = f"article:{slug}"
+    article = cache.get(key)
+    if article is None:
+        article = Article.objects.get(slug=slug)
+        cache.set(key, article, timeout=3600)
+    return article
+```
+
+## Form and Validation
+
+```python
+from django import forms
+from django.core.exceptions import ValidationError
+
+class ArticleForm(forms.ModelForm):
+    class Meta:
+        model = Article
+        fields = ["title", "content", "tags"]
+    
+    def clean_title(self):
+        title = self.cleaned_data["title"]
+        if len(title) < 5:
+            raise ValidationError("Title must be at least 5 characters.")
+        return title
+```
+
+## Signals - Use Sparingly
+
+```python
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+@receiver(post_save, sender=Article)
+def notify_subscribers(sender, instance, created, **kwargs):
+    if created:
+        # Send notification
+        pass
+```
+
+## Custom Managers
+
+```python
+class PublishedManager(models.Manager):
+    def get_queryset(self):
+        return super().get_queryset().filter(status="published")
+
+class Article(models.Model):
+    objects = models.Manager()  # Default manager
+    published = PublishedManager()  # Custom manager
+```