ai-qakit 1.0.0

package/templates/.cursor/commands/devkit/create-table.md

@@ -0,0 +1,251 @@
+---
+description: Generate data table with TanStack Table (sorting, filtering, pagination)
+---
+
+# Create Table
+
+Generate data table component with TanStack Table features.
+
+## Usage
+
+`@create-table [table-name]`
+
+## Ask First
+
+- Data structure/columns?
+- Sorting needed?
+- Filtering needed?
+- Pagination (client/server)?
+- Row selection?
+- Row actions (edit/delete)?
+- Expandable rows?
+
+## Generated Files
+
+```
+src/components/tables/
+├── [TableName]/
+│   ├── [TableName].tsx          # Table component
+│   ├── [TableName].columns.tsx  # Column definitions
+│   ├── [TableName].types.ts     # TypeScript types
+│   └── index.ts                 # Export
+```
+
+## Columns Template
+
+```typescript
+// [TableName].columns.tsx
+import { ColumnDef } from '@tanstack/react-table';
+import { ArrowUpDown, MoreHorizontal } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+
+export const columns: ColumnDef<[RowType]>[] = [
+  {
+    accessorKey: 'name',
+    header: ({ column }) => (
+      <Button
+        variant="ghost"
+        onClick={() => column.toggleSorting()}
+      >
+        Name
+        <ArrowUpDown className="ml-2 h-4 w-4" />
+      </Button>
+    ),
+  },
+  {
+    accessorKey: 'email',
+    header: 'Email',
+  },
+  {
+    accessorKey: 'status',
+    header: 'Status',
+    cell: ({ row }) => (
+      <Badge variant={row.getValue('status')}>
+        {row.getValue('status')}
+      </Badge>
+    ),
+    filterFn: (row, id, value) => value.includes(row.getValue(id)),
+  },
+  {
+    id: 'actions',
+    cell: ({ row }) => (
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="sm">
+            <MoreHorizontal className="h-4 w-4" />
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent>
+          <DropdownMenuItem onClick={() => onEdit(row.original)}>
+            Edit
+          </DropdownMenuItem>
+          <DropdownMenuItem onClick={() => onDelete(row.original)}>
+            Delete
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+    ),
+  },
+];
+```
+
+## Table Template
+
+```typescript
+// [TableName].tsx
+'use client';
+
+import {
+  useReactTable,
+  getCoreRowModel,
+  getSortedRowModel,
+  getFilteredRowModel,
+  getPaginationRowModel,
+  flexRender,
+  SortingState,
+  ColumnFiltersState,
+} from '@tanstack/react-table';
+import { useState } from 'react';
+import { columns } from './[TableName].columns';
+
+interface [TableName]Props {
+  data: [RowType][];
+  onEdit?: (row: [RowType]) => void;
+  onDelete?: (row: [RowType]) => void;
+}
+
+export function [TableName]({ data, onEdit, onDelete }: [TableName]Props) {
+  const [sorting, setSorting] = useState<SortingState>([]);
+  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
+  const [rowSelection, setRowSelection] = useState({});
+
+  const table = useReactTable({
+    data,
+    columns,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    getFilteredRowModel: getFilteredRowModel(),
+    getPaginationRowModel: getPaginationRowModel(),
+    onSortingChange: setSorting,
+    onColumnFiltersChange: setColumnFilters,
+    onRowSelectionChange: setRowSelection,
+    state: {
+      sorting,
+      columnFilters,
+      rowSelection,
+    },
+  });
+
+  return (
+    <div>
+      {/* Filters */}
+      <div className="flex items-center py-4">
+        <Input
+          placeholder="Filter..."
+          value={(table.getColumn('name')?.getFilterValue() as string) ?? ''}
+          onChange={(e) =>
+            table.getColumn('name')?.setFilterValue(e.target.value)
+          }
+          className="max-w-sm"
+        />
+      </div>
+
+      {/* Table */}
+      <div className="rounded-md border">
+        <Table>
+          <TableHeader>
+            {table.getHeaderGroups().map((headerGroup) => (
+              <TableRow key={headerGroup.id}>
+                {headerGroup.headers.map((header) => (
+                  <TableHead key={header.id}>
+                    {flexRender(
+                      header.column.columnDef.header,
+                      header.getContext()
+                    )}
+                  </TableHead>
+                ))}
+              </TableRow>
+            ))}
+          </TableHeader>
+          <TableBody>
+            {table.getRowModel().rows.map((row) => (
+              <TableRow key={row.id}>
+                {row.getVisibleCells().map((cell) => (
+                  <TableCell key={cell.id}>
+                    {flexRender(cell.column.columnDef.cell, cell.getContext())}
+                  </TableCell>
+                ))}
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </div>
+
+      {/* Pagination */}
+      <div className="flex items-center justify-between py-4">
+        <div className="text-sm text-muted-foreground">
+          {table.getFilteredSelectedRowModel().rows.length} of{' '}
+          {table.getFilteredRowModel().rows.length} selected
+        </div>
+        <div className="flex gap-2">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => table.previousPage()}
+            disabled={!table.getCanPreviousPage()}
+          >
+            Previous
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => table.nextPage()}
+            disabled={!table.getCanNextPage()}
+          >
+            Next
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
+```
+
+## Output
+
+```
+════════════════════════════════════════
+✅ TABLE CREATED
+════════════════════════════════════════
+
+TABLE: [TableName]
+
+FEATURES:
+  ✓ Sorting
+  ✓ Filtering
+  ✓ Pagination
+  ✓ Row Selection
+  ✓ Row Actions
+
+FILES CREATED:
+  📄 components/tables/[TableName]/[TableName].tsx
+  📄 components/tables/[TableName]/[TableName].columns.tsx
+  📄 components/tables/[TableName]/index.ts
+
+USAGE:
+  import { [TableName] } from '@/components/tables/[TableName]';
+  
+  <[TableName] 
+    data={data}
+    onEdit={handleEdit}
+    onDelete={handleDelete}
+  />
+════════════════════════════════════════
+```
+

package/templates/.cursor/commands/devkit/create-test.md

@@ -0,0 +1,174 @@
+# Create Tests
+
+Generate comprehensive unit tests targeting 99% coverage.
+
+## ⚠️ Plan Before Executing
+
+**Always create a structured plan and get user approval before making changes.**
+
+1. Analyze the file and show what tests will be created
+2. Present the test plan with scenarios to cover
+3. Ask for confirmation before writing test files
+4. Never generate tests without user approval
+
+## Ask for Clarification
+
+If anything is unclear, **ask the user**:
+- "What specific scenarios should I prioritize testing?"
+- "Are there any edge cases specific to this business logic?"
+- "Should I mock [dependency] or use the real implementation?"
+- "What's the expected behavior when [unclear scenario]?"
+- "Is there existing test setup/fixtures I should use?"
+
+---
+
+## Step 1: Reference Project Profile
+
+Read `@.cursor/rules/project-profile.mdc` to understand:
+- Testing framework (Jest, Vitest, Pytest, etc.)
+- Coverage tool and commands
+- Test directory structure
+- Naming conventions
+- Mock patterns
+
+If project profile doesn't exist, ask user to run `@.cursor/commands/config:init-backend.md` first.
+
+## Step 2: Analyze Current Coverage
+
+Run coverage report for target file:
+
+**JavaScript/TypeScript:**
+```bash
+npm test -- --coverage --collectCoverageFrom='[file]'
+# or
+pnpm test -- --coverage
+```
+
+**Java:**
+```bash
+mvn test jacoco:report
+```
+
+**Python:**
+```bash
+pytest --cov=[module] --cov-report=html
+```
+
+Parse output to identify:
+- Current coverage percentage
+- Uncovered lines
+- Uncovered branches
+
+## Step 3: Analyze Implementation
+
+Read the target file to identify:
+- All public methods/functions
+- Dependencies requiring mocks
+- Branch conditions (if/else, switch, ternary)
+- Error handling paths
+- Edge cases
+- Compound boolean expressions (||, &&)
+
+## Step 4: Present Test Plan
+
+Show plan before generating:
+
+```
+═══════════════════════════════════════════════
+📋 TEST PLAN
+═══════════════════════════════════════════════
+
+File: [target file]
+Current Coverage: [X]%
+Target Coverage: 99%
+
+Tests to Create:
+├── [method1]
+│   ├── ✅ Happy path with valid input
+│   ├── ⚠️ Empty input handling
+│   └── ⚠️ Error case when [condition]
+├── [method2]
+│   ├── ⚠️ Boundary value at [limit]
+│   └── ⚠️ Exception when [scenario]
+
+Mocks Required:
+├── [dependency1] - [why]
+└── [dependency2] - [why]
+
+Proceed with generating tests? (Y/n)
+═══════════════════════════════════════════════
+```
+
+## Step 5: Generate Tests
+
+Create tests following AAA pattern:
+
+```typescript
+describe('[ClassName/ModuleName]', () => {
+  describe('[methodName]', () => {
+    it('should [expected behavior] when [condition]', () => {
+      // Arrange - Set up test data and mocks
+      // Act - Execute the code under test
+      // Assert - Verify the results
+    })
+  })
+})
+```
+
+**Scenarios to Cover:**
+- Happy path (valid inputs)
+- Empty/null input handling
+- Error paths (different error types)
+- Boundary conditions
+- Edge cases in conditionals
+- Exception scenarios
+- Timeout/retry paths
+
+## Step 6: Write Test File
+
+Create or update test file following project conventions:
+- Use correct test directory
+- Follow naming pattern from project profile
+- Import project's test utilities
+- Use project's mock patterns
+
+## Step 7: Verify Coverage
+
+Run tests and display coverage:
+
+```bash
+[test command from project profile]
+```
+
+## Step 8: Report Results
+
+```
+═══════════════════════════════════════════════
+✅ TESTS GENERATED
+═══════════════════════════════════════════════
+
+File: [test file path]
+Tests Added: [count]
+Coverage: [before]% → [after]%
+
+Lines: [covered]/[total]
+Branches: [covered]/[total]
+
+Remaining Gaps:
+├── Line [X]: [reason - e.g., "compound boolean"]
+└── Line [Y]: [reason - e.g., "defensive check"]
+═══════════════════════════════════════════════
+```
+
+## Coverage Interpretation
+
+| Coverage | Quality |
+|----------|---------|
+| < 70% | Poor - needs significant testing |
+| 70-80% | Fair - basic scenarios covered |
+| 80-90% | Good - most paths tested |
+| 90-95% | Excellent - comprehensive testing |
+| 95-99% | Outstanding - near-complete coverage |
+| 99%+ | Exceptional - edge case focused |
+
+**Note:** 94-95% is often excellent due to coverage tool limitations with compound booleans and defensive code.

package/templates/.cursor/commands/devkit/debug.md

@@ -0,0 +1,192 @@
+# Debug Issue
+
+Systematic 7-step process to identify, analyze, and resolve problems.
+
+## ⚠️ Plan Before Executing
+
+**Always create a structured plan and get user approval before making changes.**
+
+1. Gather all context before diagnosing
+2. Present analysis and potential causes
+3. Show resolution options with trade-offs
+4. Ask for approval before implementing fixes
+5. Never make changes without confirmation
+
+## Ask for Clarification
+
+If anything is unclear, **ask the user**:
+- "Can you provide the exact error message or log snippet?"
+- "What are the precise steps to reproduce this issue?"
+- "Are there any recent changes or deployments that might be related?"
+- "What is the expected outcome, and how does it differ from current behavior?"
+- "Which environments are affected (dev, staging, production)?"
+
+---
+
+## The 7-Step Process
+
+### Step 1: Gather Context
+
+**Collect from user:**
+- Brief issue description (what is happening?)
+- Expected behavior (what should happen?)
+- Current behavior and error messages/logs
+- Recent related changes or deployments
+- Scope of impact (users, services, environments)
+
+**Search codebase:**
+- Related files and functions
+- Recent commits to affected area
+- Similar past issues
+
+### Step 2: Clarify Reality vs Expectation
+
+**Document:**
+- Observed behavior vs expected outcome
+- Relevant requirements or tickets
+- Acceptance criteria for the fix (how we know it's resolved)
+
+```
+═══════════════════════════════════════════════
+📋 ISSUE SUMMARY
+═══════════════════════════════════════════════
+
+Issue: [title]
+Reported: [when/by whom]
+Impact: [scope of impact]
+
+Expected: [what should happen]
+Actual: [what is happening]
+
+Acceptance Criteria:
+├── [criterion 1]
+├── [criterion 2]
+└── [criterion 3]
+═══════════════════════════════════════════════
+```
+
+### Step 3: Reproduce & Isolate
+
+**Determine:**
+- Reproducibility (always, intermittent, environment-specific)
+- Reproduction steps or commands
+- Available tests that expose the failure
+- Suspected components, services, or modules
+
+**Create minimal reproduction:**
+```bash
+# Commands to reproduce
+# Expected: [what should happen]
+# Actual: [what happens]
+```
+
+### Step 4: Analyze Potential Causes
+
+**Brainstorm:**
+- Data issues
+- Configuration problems
+- Code regressions
+- External dependency changes
+- Race conditions
+- Resource exhaustion
+
+**Gather evidence:**
+- Logs and metrics
+- Stack traces
+- Recent git commits
+- Deployment history
+
+```
+═══════════════════════════════════════════════
+🔍 ROOT CAUSE ANALYSIS
+═══════════════════════════════════════════════
+
+Potential Causes:
+├── [cause 1] - [evidence]
+├── [cause 2] - [evidence]
+└── [cause 3] - [evidence]
+
+Most Likely: [cause] because [reasoning]
+
+Gaps in Understanding:
+├── [unknown 1]
+└── [unknown 2]
+═══════════════════════════════════════════════
+```
+
+### Step 5: Surface Options
+
+Present resolution paths:
+
+| Option | Approach | Pros | Cons | Risk | Effort |
+|--------|----------|------|------|------|--------|
+| A | Quick fix | Fast | May not address root cause | Low | 1h |
+| B | Deeper refactor | Addresses root cause | Takes longer | Medium | 4h |
+| C | Rollback | Immediate relief | Loses features | Low | 30m |
+| D | Feature flag | Controlled rollout | Complexity | Low | 2h |
+
+For each option:
+- Effort estimate
+- Verification steps
+- Required approvals
+
+### Step 6: Confirm Path Forward
+
+**Ask which option to pursue, then:**
+- Summarize chosen approach
+- List required pre-work
+- Define success criteria
+- Plan validation steps (tests, monitoring)
+
+```
+═══════════════════════════════════════════════
+✅ RESOLUTION PLAN
+═══════════════════════════════════════════════
+
+Chosen Approach: [Option X]
+Reason: [why this option]
+
+Steps:
+1. [step 1]
+2. [step 2]
+3. [step 3]
+
+Success Criteria:
+├── [criterion 1]
+└── [criterion 2]
+
+Proceed with implementation? (Y/n)
+═══════════════════════════════════════════════
+```
+
+### Step 7: Next Actions & Tracking
+
+**Document:**
+- [ ] Specific tasks with owners
+- [ ] Timelines for each task
+- [ ] Follow-up actions after deployment
+- [ ] Monitoring to add
+- [ ] Documentation/tests to update
+
+## Output Format
+
+```markdown
+## Debug Report: [Issue Title]
+
+### Summary
+[1-2 sentence description]
+
+### Root Cause
+[What caused the issue]
+
+### Resolution
+[What was done to fix it]
+
+### Verification
+- [ ] Tests added/updated
+- [ ] Manually verified in [environment]
+- [ ] Monitoring in place
+
+### Follow-up
+- [ ] [Any remaining tasks]
+```