proagents 1.0.0

package/proagents/prompts/performance/analyze.md

@@ -0,0 +1,265 @@
+# Performance Analysis
+
+Systematic approach to identifying performance issues.
+
+---
+
+## Prompt Template
+
+```
+Analyze the performance of this code:
+
+{code}
+
+Context:
+- This code runs: {frequency - once/per request/continuously}
+- Expected data size: {size}
+- Current performance: {metrics if available}
+- Target performance: {target}
+
+Please analyze:
+1. Time complexity (Big O)
+2. Space complexity
+3. Potential bottlenecks
+4. Unnecessary operations
+5. Optimization opportunities
+
+Provide:
+- Performance assessment
+- Specific issues found
+- Optimized version with explanations
+- Benchmarking approach
+```
+
+---
+
+## Analysis Categories
+
+### Time Complexity
+
+```typescript
+// ❌ O(n²) - Nested loops
+function findDuplicates(arr: number[]) {
+  const duplicates = [];
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      if (arr[i] === arr[j]) {
+        duplicates.push(arr[i]);
+      }
+    }
+  }
+  return duplicates;
+}
+
+// ✅ O(n) - Using Set
+function findDuplicates(arr: number[]) {
+  const seen = new Set();
+  const duplicates = new Set();
+
+  for (const num of arr) {
+    if (seen.has(num)) {
+      duplicates.add(num);
+    }
+    seen.add(num);
+  }
+
+  return [...duplicates];
+}
+```
+
+### Space Complexity
+
+```typescript
+// ❌ O(n) space - Creating new arrays
+function transform(arr: number[]) {
+  return arr
+    .filter(x => x > 0)    // New array
+    .map(x => x * 2)       // New array
+    .filter(x => x < 100); // New array
+}
+
+// ✅ O(1) space - In-place or single pass
+function* transform(arr: number[]) {
+  for (const x of arr) {
+    if (x > 0) {
+      const doubled = x * 2;
+      if (doubled < 100) {
+        yield doubled;
+      }
+    }
+  }
+}
+```
+
+### Memory Leaks
+
+```typescript
+// ❌ Memory leak - Event listener not removed
+useEffect(() => {
+  window.addEventListener('resize', handleResize);
+  // Missing cleanup!
+}, []);
+
+// ✅ Proper cleanup
+useEffect(() => {
+  window.addEventListener('resize', handleResize);
+  return () => {
+    window.removeEventListener('resize', handleResize);
+  };
+}, []);
+```
+
+### Unnecessary Renders
+
+```typescript
+// ❌ Rerenders on every parent render
+function Child({ items, onClick }) {
+  return items.map(item => (
+    <button onClick={() => onClick(item.id)}> // New function each render
+      {item.name}
+    </button>
+  ));
+}
+
+// ✅ Memoized callback
+const Child = memo(function Child({ items, onClick }) {
+  const handleClick = useCallback((id: string) => {
+    onClick(id);
+  }, [onClick]);
+
+  return items.map(item => (
+    <button onClick={() => handleClick(item.id)}>
+      {item.name}
+    </button>
+  ));
+});
+```
+
+---
+
+## Optimization Techniques
+
+### Caching/Memoization
+
+```typescript
+// Cache expensive computations
+const expensiveResult = useMemo(() => {
+  return items.reduce((acc, item) => {
+    // Complex calculation
+    return acc + complexCalculation(item);
+  }, 0);
+}, [items]);
+
+// Cache function references
+const handleSubmit = useCallback((data) => {
+  submitForm(data);
+}, [submitForm]);
+```
+
+### Lazy Loading
+
+```typescript
+// Lazy load components
+const HeavyComponent = lazy(() => import('./HeavyComponent'));
+
+function App() {
+  return (
+    <Suspense fallback={<Loading />}>
+      <HeavyComponent />
+    </Suspense>
+  );
+}
+
+// Lazy load data
+function useData() {
+  const [data, setData] = useState(null);
+
+  useEffect(() => {
+    // Only load when needed
+    if (shouldLoadData) {
+      fetchData().then(setData);
+    }
+  }, [shouldLoadData]);
+}
+```
+
+### Debouncing/Throttling
+
+```typescript
+// Debounce search input
+const debouncedSearch = useMemo(
+  () => debounce((query: string) => {
+    searchApi(query);
+  }, 300),
+  []
+);
+
+// Throttle scroll handler
+const throttledScroll = useMemo(
+  () => throttle(() => {
+    updateScrollPosition();
+  }, 100),
+  []
+);
+```
+
+### Virtualization
+
+```typescript
+// Virtual list for large datasets
+import { FixedSizeList } from 'react-window';
+
+function VirtualList({ items }) {
+  return (
+    <FixedSizeList
+      height={400}
+      width={300}
+      itemCount={items.length}
+      itemSize={50}
+    >
+      {({ index, style }) => (
+        <div style={style}>{items[index].name}</div>
+      )}
+    </FixedSizeList>
+  );
+}
+```
+
+---
+
+## Benchmarking
+
+```typescript
+// Simple benchmark
+function benchmark(fn: () => void, iterations = 1000) {
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    fn();
+  }
+  const end = performance.now();
+  return (end - start) / iterations;
+}
+
+// Compare implementations
+const timeA = benchmark(() => implementationA(testData));
+const timeB = benchmark(() => implementationB(testData));
+console.log(`A: ${timeA}ms, B: ${timeB}ms`);
+```
+
+---
+
+## Performance Commands
+
+```bash
+# Analyze function complexity
+/perf complexity <function>
+
+# Find memory leaks
+/perf memory-leak <component>
+
+# Suggest optimizations
+/perf optimize <code>
+
+# Generate benchmark
+/perf benchmark <function>
+```

package/proagents/prompts/performance/optimize.md

@@ -0,0 +1,347 @@
+# Performance Optimization Prompt
+
+Identify and fix performance issues in code.
+
+---
+
+## Prompt Template
+
+```markdown
+## Performance Optimization Review
+
+Analyze the following code for performance issues:
+
+```{{language}}
+{{code}}
+```
+
+### Check For:
+
+**Rendering Performance (React)**
+- [ ] Unnecessary re-renders
+- [ ] Missing memoization
+- [ ] Expensive calculations in render
+- [ ] Large component trees
+
+**Data Fetching**
+- [ ] N+1 queries
+- [ ] Missing caching
+- [ ] Unoptimized payloads
+- [ ] Waterfall requests
+
+**Memory**
+- [ ] Memory leaks
+- [ ] Large object retention
+- [ ] Event listener cleanup
+
+**Bundle Size**
+- [ ] Large imports
+- [ ] Tree shaking issues
+- [ ] Unnecessary dependencies
+
+### Output Format:
+For each issue:
+1. Performance impact (High/Medium/Low)
+2. Current behavior
+3. Issue explanation
+4. Optimized solution
+5. Expected improvement
+```
+
+---
+
+## React Optimization Patterns
+
+### Prevent Unnecessary Re-renders
+
+```tsx
+// ❌ Re-renders on every parent render
+function UserList({ users }) {
+  return users.map(user => <UserCard user={user} />);
+}
+
+// ✅ Memoized - only re-renders when user changes
+const UserCard = memo(function UserCard({ user }) {
+  return <div>{user.name}</div>;
+});
+
+// ✅ With custom comparison
+const UserCard = memo(
+  function UserCard({ user }) {
+    return <div>{user.name}</div>;
+  },
+  (prevProps, nextProps) => prevProps.user.id === nextProps.user.id
+);
+```
+
+### Memoize Expensive Calculations
+
+```tsx
+// ❌ Recalculates on every render
+function DataTable({ data, filter }) {
+  const filteredData = data.filter(item =>
+    item.name.toLowerCase().includes(filter.toLowerCase())
+  );
+
+  return <Table data={filteredData} />;
+}
+
+// ✅ Only recalculates when dependencies change
+function DataTable({ data, filter }) {
+  const filteredData = useMemo(
+    () => data.filter(item =>
+      item.name.toLowerCase().includes(filter.toLowerCase())
+    ),
+    [data, filter]
+  );
+
+  return <Table data={filteredData} />;
+}
+```
+
+### Stable Callback References
+
+```tsx
+// ❌ New function on every render
+function SearchForm({ onSearch }) {
+  return (
+    <input onChange={(e) => onSearch(e.target.value)} />
+  );
+}
+
+// ✅ Stable reference
+function SearchForm({ onSearch }) {
+  const handleChange = useCallback(
+    (e: ChangeEvent<HTMLInputElement>) => onSearch(e.target.value),
+    [onSearch]
+  );
+
+  return <input onChange={handleChange} />;
+}
+```
+
+### Virtualize Long Lists
+
+```tsx
+// ❌ Renders all 10,000 items
+function UserList({ users }) {
+  return (
+    <div>
+      {users.map(user => <UserCard key={user.id} user={user} />)}
+    </div>
+  );
+}
+
+// ✅ Only renders visible items
+import { FixedSizeList } from 'react-window';
+
+function UserList({ users }) {
+  return (
+    <FixedSizeList
+      height={400}
+      itemCount={users.length}
+      itemSize={50}
+    >
+      {({ index, style }) => (
+        <div style={style}>
+          <UserCard user={users[index]} />
+        </div>
+      )}
+    </FixedSizeList>
+  );
+}
+```
+
+---
+
+## Data Fetching Optimization
+
+### Avoid N+1 Queries
+
+```typescript
+// ❌ N+1 queries
+async function getPostsWithAuthors() {
+  const posts = await db.post.findMany();
+  for (const post of posts) {
+    post.author = await db.user.findUnique({
+      where: { id: post.authorId }
+    });
+  }
+  return posts;
+}
+
+// ✅ Single query with include
+async function getPostsWithAuthors() {
+  return db.post.findMany({
+    include: { author: true }
+  });
+}
+```
+
+### Parallel Fetching
+
+```typescript
+// ❌ Sequential - slow
+async function getDashboardData() {
+  const users = await getUsers();
+  const orders = await getOrders();
+  const stats = await getStats();
+  return { users, orders, stats };
+}
+
+// ✅ Parallel - fast
+async function getDashboardData() {
+  const [users, orders, stats] = await Promise.all([
+    getUsers(),
+    getOrders(),
+    getStats()
+  ]);
+  return { users, orders, stats };
+}
+```
+
+### Response Caching
+
+```typescript
+// React Query with caching
+const { data } = useQuery({
+  queryKey: ['users'],
+  queryFn: fetchUsers,
+  staleTime: 5 * 60 * 1000, // 5 minutes
+  cacheTime: 30 * 60 * 1000, // 30 minutes
+});
+
+// Server-side caching
+import { unstable_cache } from 'next/cache';
+
+const getCachedUsers = unstable_cache(
+  async () => db.user.findMany(),
+  ['users'],
+  { revalidate: 60 } // 1 minute
+);
+```
+
+---
+
+## Bundle Optimization
+
+### Dynamic Imports
+
+```tsx
+// ❌ Loads on initial bundle
+import { HeavyChart } from 'heavy-chart-library';
+
+// ✅ Loads only when needed
+const HeavyChart = dynamic(() => import('heavy-chart-library'), {
+  loading: () => <Spinner />,
+  ssr: false
+});
+```
+
+### Tree Shaking
+
+```typescript
+// ❌ Imports entire library
+import _ from 'lodash';
+const result = _.debounce(fn, 300);
+
+// ✅ Imports only needed function
+import debounce from 'lodash/debounce';
+const result = debounce(fn, 300);
+
+// ✅ Or use lodash-es for better tree shaking
+import { debounce } from 'lodash-es';
+```
+
+### Analyze Bundle
+
+```bash
+# Next.js bundle analyzer
+npm install @next/bundle-analyzer
+
+# next.config.js
+const withBundleAnalyzer = require('@next/bundle-analyzer')({
+  enabled: process.env.ANALYZE === 'true',
+});
+
+module.exports = withBundleAnalyzer({});
+
+# Run analysis
+ANALYZE=true npm run build
+```
+
+---
+
+## Memory Optimization
+
+### Cleanup Effects
+
+```tsx
+// ❌ Memory leak - no cleanup
+useEffect(() => {
+  window.addEventListener('resize', handleResize);
+}, []);
+
+// ✅ Proper cleanup
+useEffect(() => {
+  window.addEventListener('resize', handleResize);
+  return () => window.removeEventListener('resize', handleResize);
+}, []);
+```
+
+### Avoid Closures Over Large Objects
+
+```tsx
+// ❌ Keeps large array in memory
+function DataProcessor({ largeData }) {
+  const processedData = useMemo(() => {
+    return largeData.map(item => ({ ...item, processed: true }));
+  }, [largeData]);
+
+  // Handler keeps reference to largeData
+  const handleClick = () => {
+    console.log(largeData.length);
+  };
+
+  return <button onClick={handleClick}>Process</button>;
+}
+
+// ✅ Only store what's needed
+function DataProcessor({ largeData }) {
+  const dataLength = largeData.length;
+
+  const handleClick = () => {
+    console.log(dataLength);
+  };
+
+  return <button onClick={handleClick}>Process</button>;
+}
+```
+
+---
+
+## Performance Testing
+
+```typescript
+// Measure component render time
+import { Profiler } from 'react';
+
+function onRender(id, phase, actualDuration) {
+  console.log(`${id} ${phase}: ${actualDuration}ms`);
+}
+
+<Profiler id="UserList" onRender={onRender}>
+  <UserList users={users} />
+</Profiler>
+
+// Benchmark test
+describe('Performance', () => {
+  it('should render 1000 items in under 100ms', () => {
+    const start = performance.now();
+    render(<UserList users={generateUsers(1000)} />);
+    const duration = performance.now() - start;
+
+    expect(duration).toBeLessThan(100);
+  });
+});
+```

package/proagents/prompts/refactoring/README.md

@@ -0,0 +1,51 @@
+# Refactoring Prompts
+
+AI-assisted code refactoring workflows.
+
+---
+
+## Available Prompts
+
+| Prompt | Use Case |
+|--------|----------|
+| [code-smells.md](./code-smells.md) | Identify and fix code smells |
+| [extract-patterns.md](./extract-patterns.md) | Extract reusable patterns |
+| [modernize.md](./modernize.md) | Update to modern patterns |
+| [simplify.md](./simplify.md) | Reduce complexity |
+
+---
+
+## Quick Commands
+
+```bash
+/refactor identify    # Find refactoring opportunities
+/refactor plan        # Create refactoring plan
+/refactor execute     # Perform refactoring
+/refactor validate    # Verify refactoring
+```
+
+---
+
+## Refactoring Workflow
+
+```
+1. Identify Opportunities
+   - Code smells
+   - Duplications
+   - Complex functions
+
+2. Plan Refactoring
+   - Prioritize changes
+   - Identify risks
+   - Plan tests
+
+3. Execute Incrementally
+   - Small, focused changes
+   - Maintain tests
+   - Preserve behavior
+
+4. Validate
+   - Run tests
+   - Compare behavior
+   - Review changes
+```