npm - @malamute/ai-rules - Versions diffs - 1.0.0 - Mend

@malamute/ai-rules 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/README.md +174 -0
package/bin/cli.js +5 -0
package/configs/_shared/.claude/commands/fix-issue.md +38 -0
package/configs/_shared/.claude/commands/generate-tests.md +49 -0
package/configs/_shared/.claude/commands/review-pr.md +77 -0
package/configs/_shared/.claude/rules/accessibility.md +270 -0
package/configs/_shared/.claude/rules/performance.md +226 -0
package/configs/_shared/.claude/rules/security.md +188 -0
package/configs/_shared/.claude/skills/debug/SKILL.md +118 -0
package/configs/_shared/.claude/skills/learning/SKILL.md +224 -0
package/configs/_shared/.claude/skills/review/SKILL.md +86 -0
package/configs/_shared/.claude/skills/spec/SKILL.md +112 -0
package/configs/_shared/CLAUDE.md +174 -0
package/configs/angular/.claude/rules/components.md +257 -0
package/configs/angular/.claude/rules/state.md +250 -0
package/configs/angular/.claude/rules/testing.md +422 -0
package/configs/angular/.claude/settings.json +31 -0
package/configs/angular/CLAUDE.md +251 -0
package/configs/dotnet/.claude/rules/api.md +370 -0
package/configs/dotnet/.claude/rules/architecture.md +199 -0
package/configs/dotnet/.claude/rules/database/efcore.md +408 -0
package/configs/dotnet/.claude/rules/testing.md +389 -0
package/configs/dotnet/.claude/settings.json +9 -0
package/configs/dotnet/CLAUDE.md +319 -0
package/configs/nestjs/.claude/rules/auth.md +321 -0
package/configs/nestjs/.claude/rules/database/prisma.md +305 -0
package/configs/nestjs/.claude/rules/database/typeorm.md +379 -0
package/configs/nestjs/.claude/rules/modules.md +215 -0
package/configs/nestjs/.claude/rules/testing.md +315 -0
package/configs/nestjs/.claude/rules/validation.md +279 -0
package/configs/nestjs/.claude/settings.json +15 -0
package/configs/nestjs/CLAUDE.md +263 -0
package/configs/nextjs/.claude/rules/components.md +211 -0
package/configs/nextjs/.claude/rules/state/redux-toolkit.md +429 -0
package/configs/nextjs/.claude/rules/state/zustand.md +299 -0
package/configs/nextjs/.claude/rules/testing.md +315 -0
package/configs/nextjs/.claude/settings.json +29 -0
package/configs/nextjs/CLAUDE.md +376 -0
package/configs/python/.claude/rules/database/sqlalchemy.md +355 -0
package/configs/python/.claude/rules/fastapi.md +272 -0
package/configs/python/.claude/rules/flask.md +332 -0
package/configs/python/.claude/rules/testing.md +374 -0
package/configs/python/.claude/settings.json +18 -0
package/configs/python/CLAUDE.md +273 -0
package/package.json +41 -0
package/src/install.js +315 -0

package/configs/nextjs/.claude/rules/state/redux-toolkit.md ADDED Viewed

@@ -0,0 +1,429 @@
+---
+paths:
+  - "**/*slice*.ts"
+  - "**/*store*.ts"
+  - "**/store/**/*.ts"
+  - "**/redux/**/*.ts"
+---
+# Redux Toolkit State Management
+Use Redux Toolkit (RTK) for complex client-side state management.
+## When to Use
+- Large applications with complex state
+- Team already familiar with Redux
+- Need advanced DevTools (time-travel debugging)
+- Using RTK Query for data fetching
+- Complex async logic with middleware
+## Store Structure
+```
+libs/
+  [domain]/
+    data-access/
+      store/
+        index.ts            # Store configuration
+        hooks.ts            # Typed hooks
+      slices/
+        user-slice.ts
+        cart-slice.ts
+      api/
+        user-api.ts         # RTK Query
+```
+## Store Setup
+### Configure Store
+```typescript
+// store/index.ts
+import { configureStore } from '@reduxjs/toolkit';
+import { userSlice } from '../slices/user-slice';
+import { cartSlice } from '../slices/cart-slice';
+import { apiSlice } from '../api/api-slice';
+export const makeStore = () => {
+  return configureStore({
+    reducer: {
+      user: userSlice.reducer,
+      cart: cartSlice.reducer,
+      [apiSlice.reducerPath]: apiSlice.reducer,
+    },
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware().concat(apiSlice.middleware),
+  });
+};
+export type AppStore = ReturnType<typeof makeStore>;
+export type RootState = ReturnType<AppStore['getState']>;
+export type AppDispatch = AppStore['dispatch'];
+```
+### Typed Hooks
+```typescript
+// store/hooks.ts
+import { useDispatch, useSelector, useStore } from 'react-redux';
+import type { AppDispatch, AppStore, RootState } from './index';
+export const useAppDispatch = useDispatch.withTypes<AppDispatch>();
+export const useAppSelector = useSelector.withTypes<RootState>();
+export const useAppStore = useStore.withTypes<AppStore>();
+```
+### Provider Setup
+```tsx
+// app/providers.tsx
+'use client';
+import { useRef } from 'react';
+import { Provider } from 'react-redux';
+import { makeStore, AppStore } from '@/store';
+export function StoreProvider({ children }: { children: React.ReactNode }) {
+  const storeRef = useRef<AppStore>();
+  if (!storeRef.current) {
+    storeRef.current = makeStore();
+  }
+  return <Provider store={storeRef.current}>{children}</Provider>;
+}
+```
+```tsx
+// app/layout.tsx
+import { StoreProvider } from './providers';
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html>
+      <body>
+        <StoreProvider>{children}</StoreProvider>
+      </body>
+    </html>
+  );
+}
+```
+## Creating Slices
+### Basic Slice
+```typescript
+// slices/user-slice.ts
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+interface UserState {
+  currentUser: User | null;
+  isAuthenticated: boolean;
+}
+const initialState: UserState = {
+  currentUser: null,
+  isAuthenticated: false,
+};
+export const userSlice = createSlice({
+  name: 'user',
+  initialState,
+  reducers: {
+    setUser: (state, action: PayloadAction<User>) => {
+      state.currentUser = action.payload;
+      state.isAuthenticated = true;
+    },
+    logout: (state) => {
+      state.currentUser = null;
+      state.isAuthenticated = false;
+    },
+    updateProfile: (state, action: PayloadAction<Partial<User>>) => {
+      if (state.currentUser) {
+        state.currentUser = { ...state.currentUser, ...action.payload };
+      }
+    },
+  },
+});
+export const { setUser, logout, updateProfile } = userSlice.actions;
+// Selectors
+export const selectCurrentUser = (state: RootState) => state.user.currentUser;
+export const selectIsAuthenticated = (state: RootState) => state.user.isAuthenticated;
+```
+### Slice with Async Thunks
+```typescript
+// slices/cart-slice.ts
+import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit';
+interface CartItem {
+  id: string;
+  name: string;
+  price: number;
+  quantity: number;
+}
+interface CartState {
+  items: CartItem[];
+  isLoading: boolean;
+  error: string | null;
+}
+const initialState: CartState = {
+  items: [],
+  isLoading: false,
+  error: null,
+};
+// Async thunk
+export const fetchCart = createAsyncThunk(
+  'cart/fetchCart',
+  async (userId: string, { rejectWithValue }) => {
+    try {
+      const response = await fetch(`/api/cart/${userId}`);
+      if (!response.ok) throw new Error('Failed to fetch cart');
+      return response.json();
+    } catch (error) {
+      return rejectWithValue('Failed to fetch cart');
+    }
+  }
+);
+export const cartSlice = createSlice({
+  name: 'cart',
+  initialState,
+  reducers: {
+    addItem: (state, action: PayloadAction<CartItem>) => {
+      const existingItem = state.items.find((item) => item.id === action.payload.id);
+      if (existingItem) {
+        existingItem.quantity += action.payload.quantity;
+      } else {
+        state.items.push(action.payload);
+      }
+    },
+    removeItem: (state, action: PayloadAction<string>) => {
+      state.items = state.items.filter((item) => item.id !== action.payload);
+    },
+    updateQuantity: (state, action: PayloadAction<{ id: string; quantity: number }>) => {
+      const item = state.items.find((item) => item.id === action.payload.id);
+      if (item) {
+        item.quantity = action.payload.quantity;
+      }
+    },
+    clearCart: (state) => {
+      state.items = [];
+    },
+  },
+  extraReducers: (builder) => {
+    builder
+      .addCase(fetchCart.pending, (state) => {
+        state.isLoading = true;
+        state.error = null;
+      })
+      .addCase(fetchCart.fulfilled, (state, action) => {
+        state.isLoading = false;
+        state.items = action.payload;
+      })
+      .addCase(fetchCart.rejected, (state, action) => {
+        state.isLoading = false;
+        state.error = action.payload as string;
+      });
+  },
+});
+export const { addItem, removeItem, updateQuantity, clearCart } = cartSlice.actions;
+// Selectors
+export const selectCartItems = (state: RootState) => state.cart.items;
+export const selectCartTotal = (state: RootState) =>
+  state.cart.items.reduce((total, item) => total + item.price * item.quantity, 0);
+export const selectCartItemCount = (state: RootState) =>
+  state.cart.items.reduce((count, item) => count + item.quantity, 0);
+```
+## RTK Query (Data Fetching)
+```typescript
+// api/api-slice.ts
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+export const apiSlice = createApi({
+  reducerPath: 'api',
+  baseQuery: fetchBaseQuery({ baseUrl: '/api' }),
+  tagTypes: ['User', 'Product'],
+  endpoints: (builder) => ({
+    // Queries
+    getUsers: builder.query<User[], void>({
+      query: () => '/users',
+      providesTags: ['User'],
+    }),
+    getUser: builder.query<User, string>({
+      query: (id) => `/users/${id}`,
+      providesTags: (result, error, id) => [{ type: 'User', id }],
+    }),
+    // Mutations
+    createUser: builder.mutation<User, Partial<User>>({
+      query: (body) => ({
+        url: '/users',
+        method: 'POST',
+        body,
+      }),
+      invalidatesTags: ['User'],
+    }),
+    updateUser: builder.mutation<User, { id: string; body: Partial<User> }>({
+      query: ({ id, body }) => ({
+        url: `/users/${id}`,
+        method: 'PATCH',
+        body,
+      }),
+      invalidatesTags: (result, error, { id }) => [{ type: 'User', id }],
+    }),
+    deleteUser: builder.mutation<void, string>({
+      query: (id) => ({
+        url: `/users/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['User'],
+    }),
+  }),
+});
+export const {
+  useGetUsersQuery,
+  useGetUserQuery,
+  useCreateUserMutation,
+  useUpdateUserMutation,
+  useDeleteUserMutation,
+} = apiSlice;
+```
+## Using in Components
+### Basic Usage
+```tsx
+'use client';
+import { useAppDispatch, useAppSelector } from '@/store/hooks';
+import { selectCurrentUser, logout } from '@/slices/user-slice';
+export function UserProfile() {
+  const dispatch = useAppDispatch();
+  const user = useAppSelector(selectCurrentUser);
+  if (!user) return null;
+  return (
+    <div>
+      <h1>{user.name}</h1>
+      <p>{user.email}</p>
+      <button onClick={() => dispatch(logout())}>Logout</button>
+    </div>
+  );
+}
+```
+### Using RTK Query
+```tsx
+'use client';
+import { useGetUsersQuery, useDeleteUserMutation } from '@/api/api-slice';
+export function UserList() {
+  const { data: users, isLoading, error } = useGetUsersQuery();
+  const [deleteUser, { isLoading: isDeleting }] = useDeleteUserMutation();
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error loading users</div>;
+  return (
+    <ul>
+      {users?.map((user) => (
+        <li key={user.id}>
+          {user.name}
+          <button
+            onClick={() => deleteUser(user.id)}
+            disabled={isDeleting}
+          >
+            Delete
+          </button>
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+## Testing
+### Slice Testing
+```typescript
+import { userSlice, setUser, logout, selectCurrentUser } from './user-slice';
+describe('userSlice', () => {
+  const initialState = { currentUser: null, isAuthenticated: false };
+  it('should handle setUser', () => {
+    const user = { id: '1', name: 'John', email: 'john@test.com' };
+    const state = userSlice.reducer(initialState, setUser(user));
+    expect(state.currentUser).toEqual(user);
+    expect(state.isAuthenticated).toBe(true);
+  });
+  it('should handle logout', () => {
+    const loggedInState = {
+      currentUser: { id: '1', name: 'John', email: 'john@test.com' },
+      isAuthenticated: true,
+    };
+    const state = userSlice.reducer(loggedInState, logout());
+    expect(state.currentUser).toBeNull();
+    expect(state.isAuthenticated).toBe(false);
+  });
+});
+```
+### Component Testing with Store
+```tsx
+import { render, screen } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { makeStore } from '@/store';
+import { UserProfile } from './user-profile';
+function renderWithStore(ui: React.ReactElement, preloadedState = {}) {
+  const store = makeStore();
+  return render(<Provider store={store}>{ui}</Provider>);
+}
+describe('UserProfile', () => {
+  it('should render user info', () => {
+    renderWithStore(<UserProfile />);
+    // ...
+  });
+});
+```
+## Best Practices
+- Use typed hooks (`useAppDispatch`, `useAppSelector`)
+- Keep slices focused on a single domain
+- Use RTK Query for server state
+- Use selectors for derived state
+- Don't duplicate Server Component data in Redux
+- Use Redux DevTools for debugging

package/configs/nextjs/.claude/rules/state/zustand.md ADDED Viewed

@@ -0,0 +1,299 @@
+---
+paths:
+  - "**/*store*.ts"
+  - "**/*store*.tsx"
+  - "**/stores/**/*.ts"
+---
+# Zustand State Management
+Use Zustand for lightweight client-side state management.
+## When to Use
+- Small to medium projects
+- Simple state logic
+- When you want minimal boilerplate
+- Quick prototyping
+## Store Structure
+```
+libs/
+  [domain]/
+    data-access/
+      stores/
+        user-store.ts
+        cart-store.ts
+      index.ts
+```
+## Creating a Store
+### Basic Store
+```typescript
+// stores/user-store.ts
+import { create } from 'zustand';
+interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+interface UserState {
+  // State
+  user: User | null;
+  isLoading: boolean;
+  error: string | null;
+  // Actions
+  setUser: (user: User | null) => void;
+  fetchUser: (id: string) => Promise<void>;
+  logout: () => void;
+}
+export const useUserStore = create<UserState>((set) => ({
+  // Initial state
+  user: null,
+  isLoading: false,
+  error: null,
+  // Actions
+  setUser: (user) => set({ user }),
+  fetchUser: async (id) => {
+    set({ isLoading: true, error: null });
+    try {
+      const response = await fetch(`/api/users/${id}`);
+      const user = await response.json();
+      set({ user, isLoading: false });
+    } catch (error) {
+      set({ error: 'Failed to fetch user', isLoading: false });
+    }
+  },
+  logout: () => set({ user: null }),
+}));
+```
+### Store with Slices (Large Stores)
+```typescript
+// stores/app-store.ts
+import { create } from 'zustand';
+// User slice
+interface UserSlice {
+  user: User | null;
+  setUser: (user: User | null) => void;
+}
+const createUserSlice = (set: any): UserSlice => ({
+  user: null,
+  setUser: (user) => set({ user }),
+});
+// Cart slice
+interface CartSlice {
+  items: CartItem[];
+  addItem: (item: CartItem) => void;
+  removeItem: (id: string) => void;
+  clearCart: () => void;
+}
+const createCartSlice = (set: any): CartSlice => ({
+  items: [],
+  addItem: (item) => set((state: any) => ({
+    items: [...state.items, item]
+  })),
+  removeItem: (id) => set((state: any) => ({
+    items: state.items.filter((item: CartItem) => item.id !== id)
+  })),
+  clearCart: () => set({ items: [] }),
+});
+// Combined store
+type AppStore = UserSlice & CartSlice;
+export const useAppStore = create<AppStore>((...args) => ({
+  ...createUserSlice(...args),
+  ...createCartSlice(...args),
+}));
+```
+### Store with Persistence
+```typescript
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+interface ThemeState {
+  theme: 'light' | 'dark';
+  toggleTheme: () => void;
+}
+export const useThemeStore = create<ThemeState>()(
+  persist(
+    (set) => ({
+      theme: 'light',
+      toggleTheme: () => set((state) => ({
+        theme: state.theme === 'light' ? 'dark' : 'light'
+      })),
+    }),
+    {
+      name: 'theme-storage', // localStorage key
+    }
+  )
+);
+```
+### Store with Immer (Complex Updates)
+```typescript
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+interface TodoState {
+  todos: Todo[];
+  addTodo: (text: string) => void;
+  toggleTodo: (id: string) => void;
+  updateTodo: (id: string, text: string) => void;
+}
+export const useTodoStore = create<TodoState>()(
+  immer((set) => ({
+    todos: [],
+    addTodo: (text) => set((state) => {
+      state.todos.push({ id: Date.now().toString(), text, done: false });
+    }),
+    toggleTodo: (id) => set((state) => {
+      const todo = state.todos.find((todo) => todo.id === id);
+      if (todo) {
+        todo.done = !todo.done;
+      }
+    }),
+    updateTodo: (id, text) => set((state) => {
+      const todo = state.todos.find((todo) => todo.id === id);
+      if (todo) {
+        todo.text = text;
+      }
+    }),
+  }))
+);
+```
+## Using in Components
+### Basic Usage
+```tsx
+'use client';
+import { useUserStore } from '@/stores/user-store';
+export function UserProfile() {
+  const { user, isLoading, error, fetchUser, logout } = useUserStore();
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error}</div>;
+  if (!user) return <div>Not logged in</div>;
+  return (
+    <div>
+      <h1>{user.name}</h1>
+      <p>{user.email}</p>
+      <button onClick={logout}>Logout</button>
+    </div>
+  );
+}
+```
+### Selecting State (Performance)
+```tsx
+'use client';
+import { useUserStore } from '@/stores/user-store';
+export function UserName() {
+  // Only re-render when user.name changes
+  const userName = useUserStore((state) => state.user?.name);
+  return <span>{userName}</span>;
+}
+```
+### Shallow Comparison for Objects
+```tsx
+'use client';
+import { useShallow } from 'zustand/react/shallow';
+import { useUserStore } from '@/stores/user-store';
+export function UserInfo() {
+  // Prevent re-render if object reference changes but content is same
+  const { name, email } = useUserStore(
+    useShallow((state) => ({
+      name: state.user?.name,
+      email: state.user?.email
+    }))
+  );
+  return (
+    <div>
+      <p>{name}</p>
+      <p>{email}</p>
+    </div>
+  );
+}
+```
+## Testing
+```typescript
+import { act, renderHook } from '@testing-library/react';
+import { useUserStore } from './user-store';
+describe('useUserStore', () => {
+  beforeEach(() => {
+    // Reset store before each test
+    useUserStore.setState({ user: null, isLoading: false, error: null });
+  });
+  it('should set user', () => {
+    const { result } = renderHook(() => useUserStore());
+    act(() => {
+      result.current.setUser({ id: '1', name: 'John', email: 'john@test.com' });
+    });
+    expect(result.current.user?.name).toBe('John');
+  });
+  it('should logout', () => {
+    useUserStore.setState({ user: { id: '1', name: 'John', email: 'john@test.com' } });
+    const { result } = renderHook(() => useUserStore());
+    act(() => {
+      result.current.logout();
+    });
+    expect(result.current.user).toBeNull();
+  });
+});
+```
+## Best Practices
+- Keep stores small and focused
+- Use selectors for performance
+- Don't put Server Component data in stores
+- Use `immer` middleware for complex nested updates
+- Use `persist` middleware for data that should survive page refresh