@codyswann/lisa 1.48.0 → 1.49.0

package/plugins/lisa-expo/skills/testing-library/references/query-priority.md

@@ -0,0 +1,291 @@
+# Query Priority Guide
+
+This reference provides detailed guidance on selecting the appropriate query for each testing scenario.
+
+## Priority Order
+
+The Testing Library team recommends queries in this priority order, based on how accessible they are to users and assistive technologies.
+
+### Priority 1: getByRole
+
+`getByRole` queries elements by their ARIA role, which is the primary way screen readers identify elements. This should be the default query for almost everything.
+
+```typescript
+// Buttons
+screen.getByRole("button", { name: "Submit" });
+screen.getByRole("button", { name: /save/i }); // Case-insensitive regex
+
+// Headings
+screen.getByRole("heading", { name: "Welcome" });
+screen.getByRole("heading", { level: 1 }); // h1
+screen.getByRole("heading", { level: 2, name: "Details" }); // h2 with name
+
+// Links
+screen.getByRole("link", { name: "View Profile" });
+
+// Form elements
+screen.getByRole("textbox"); // Input without specific type
+screen.getByRole("textbox", { name: "Email" }); // With accessible name
+screen.getByRole("checkbox", { name: "Accept terms" });
+screen.getByRole("radio", { name: "Option A" });
+screen.getByRole("combobox"); // Select/dropdown
+screen.getByRole("switch"); // Toggle switch
+
+// Status elements
+screen.getByRole("alert"); // Alert messages
+screen.getByRole("progressbar"); // Loading indicators
+screen.getByRole("status"); // Status updates
+
+// Navigation
+screen.getByRole("navigation");
+screen.getByRole("menu");
+screen.getByRole("menuitem", { name: "Settings" });
+
+// Tables
+screen.getByRole("table");
+screen.getByRole("row");
+screen.getByRole("cell", { name: "John Doe" });
+
+// Dialogs
+screen.getByRole("dialog");
+screen.getByRole("alertdialog");
+```
+
+#### Role Options
+
+```typescript
+// Filter by state
+screen.getByRole("button", { name: "Submit", disabled: true });
+screen.getByRole("checkbox", { checked: true });
+screen.getByRole("option", { selected: true });
+screen.getByRole("textbox", { busy: true });
+
+// Filter by expanded state (accordion, dropdown)
+screen.getByRole("button", { expanded: true });
+screen.getByRole("button", { expanded: false });
+
+// Filter by pressed state (toggle buttons)
+screen.getByRole("button", { pressed: true });
+```
+
+#### When getByRole Works with Split Text
+
+```typescript
+// Component with split text:
+// <Button><Icon /> Submit Form</Button>
+
+// This fails - text is split by Icon
+screen.getByText("Submit Form"); // Fails!
+
+// This works - queries by accessible name
+screen.getByRole("button", { name: /submit form/i }); // Works!
+```
+
+### Priority 2: getByLabelText
+
+Use for form fields that have associated labels. This is how users identify form inputs.
+
+```typescript
+// Standard label association
+// <label htmlFor="email">Email Address</label>
+// <input id="email" />
+screen.getByLabelText("Email Address");
+
+// Aria-labelledby
+// <span id="label-1">Username</span>
+// <input aria-labelledby="label-1" />
+screen.getByLabelText("Username");
+
+// Aria-label
+// <input aria-label="Search" />
+screen.getByLabelText("Search");
+
+// Case-insensitive matching
+screen.getByLabelText(/email/i);
+
+// Exact match
+screen.getByLabelText("Email", { exact: true });
+```
+
+### Priority 3: getByPlaceholderText
+
+Use when a form field has placeholder text but no visible label. Note: Placeholders are not a substitute for labels.
+
+```typescript
+// <input placeholder="Enter your email" />
+screen.getByPlaceholderText("Enter your email");
+screen.getByPlaceholderText(/email/i);
+```
+
+### Priority 4: getByText
+
+Use for non-interactive content like paragraphs, spans, and div text.
+
+```typescript
+// Static text content
+screen.getByText("Welcome to our app");
+screen.getByText(/welcome/i); // Case-insensitive
+
+// Partial matching
+screen.getByText("Welcome", { exact: false });
+
+// Custom normalizer (for whitespace issues)
+screen.getByText("Hello World", {
+  normalizer: str => str.replace(/\s+/g, " ").trim(),
+});
+```
+
+### Priority 5: getByDisplayValue
+
+Use for inputs with visible values (like filled form fields).
+
+```typescript
+// <input value="john@example.com" />
+screen.getByDisplayValue("john@example.com");
+
+// Select with selected option
+screen.getByDisplayValue("United States");
+```
+
+### Priority 6: getByAltText
+
+Use for images and elements with alt text.
+
+```typescript
+// <img alt="User avatar" src="..." />
+screen.getByAltText("User avatar");
+screen.getByAltText(/avatar/i);
+```
+
+### Priority 7: getByTitle
+
+Use for elements with title attribute. Less common in React Native.
+
+```typescript
+// <span title="Close">X</span>
+screen.getByTitle("Close");
+```
+
+### Priority 8: getByTestId (Last Resort)
+
+Use only when semantic queries are not possible. Adding unnecessary test IDs clutters components.
+
+```typescript
+// <View testID="custom-component">...</View>
+screen.getByTestId("custom-component");
+```
+
+#### Valid Use Cases for getByTestId
+
+1. Dynamic content that changes frequently
+2. Elements without semantic meaning
+3. Container elements that group other elements
+4. Canvas or custom drawing components
+
+```typescript
+// Valid: Dynamic chart container
+screen.getByTestId("chart-container");
+
+// Valid: Animation container
+screen.getByTestId("animation-wrapper");
+
+// Invalid: Button (use getByRole)
+screen.getByTestId("submit-button"); // Don't do this
+```
+
+## React Native Specific Roles
+
+React Native components map to accessibility roles:
+
+| Component          | Accessible Role    | Query Example                          |
+| ------------------ | ------------------ | -------------------------------------- |
+| `Button`           | `button`           | `getByRole("button")`                  |
+| `Text`             | `text`             | `getByRole("text")`                    |
+| `TextInput`        | `textbox`          | `getByRole("textbox")`                 |
+| `Switch`           | `switch`           | `getByRole("switch")`                  |
+| `Image`            | `image`            | `getByRole("image")` or `getByAltText` |
+| `Pressable`        | Depends on content | Set `accessibilityRole` explicitly     |
+| `TouchableOpacity` | Depends on content | Set `accessibilityRole` explicitly     |
+
+### Setting Explicit Roles
+
+```tsx
+// Pressable as a button
+<Pressable accessibilityRole="button" accessibilityLabel="Save">
+  <Text>Save</Text>
+</Pressable>
+
+// Custom checkbox
+<Pressable
+  accessibilityRole="checkbox"
+  accessibilityState={{ checked: isChecked }}
+  accessibilityLabel="Accept terms"
+>
+  <CheckIcon />
+</Pressable>
+
+// Link
+<Pressable accessibilityRole="link" accessibilityLabel="View profile">
+  <Text>Profile</Text>
+</Pressable>
+```
+
+## Common Mistakes
+
+### Using getByTestId When Semantic Query Works
+
+```typescript
+// Wrong
+screen.getByTestId("login-button");
+
+// Correct
+screen.getByRole("button", { name: "Login" });
+```
+
+### Using getByText for Interactive Elements
+
+```typescript
+// Wrong - getByText works but doesn't verify accessibility
+screen.getByText("Submit");
+
+// Correct - verifies element is actually a button
+screen.getByRole("button", { name: "Submit" });
+```
+
+### Case Sensitivity Issues
+
+```typescript
+// May fail if case doesn't match
+screen.getByText("Submit");
+
+// More robust - case insensitive
+screen.getByRole("button", { name: /submit/i });
+```
+
+### Querying Hidden Elements
+
+```typescript
+// By default, queries ignore hidden elements
+screen.getByRole("button", { name: "Submit" });
+
+// To include hidden elements
+screen.getByRole("button", { name: "Submit", hidden: true });
+```
+
+## Query Decision Tree
+
+1. Is it an interactive element (button, link, input)?
+   - Yes → Use `getByRole`
+2. Is it a form field with a label?
+   - Yes → Use `getByLabelText`
+3. Is it a form field with only placeholder?
+   - Yes → Use `getByPlaceholderText`
+4. Is it static text content?
+   - Yes → Use `getByText`
+5. Is it an image?
+   - Yes → Use `getByAltText`
+6. Does it have a value?
+   - Yes → Use `getByDisplayValue`
+7. None of the above?
+   - Consider if the component is accessible
+   - If not fixable, use `getByTestId` as last resort

package/plugins/lisa-nestjs/.claude-plugin/plugin.json

@@ -0,0 +1,86 @@
+{
+  "name": "nestjs",
+  "version": "1.0.0",
+  "description": "Claude Code governance plugin for NestJS/GraphQL projects — includes all universal skills, agents, hooks, and rules from Lisa plus NestJS-specific tooling (GraphQL, TypeORM, security scanning)",
+  "author": "Cody Swann",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "find ${CLAUDE_PLUGIN_ROOT}/rules -name '*.md' -exec cat {} \\;"
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/enforce-plan-rules.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code user-prompt-submit || true"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/format-on-edit.sh" },
+          { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/sg-scan-on-edit.sh" },
+          { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/lint-on-edit.sh" }
+        ]
+      },
+      {
+        "matcher": "TaskCreate|TaskUpdate",
+        "hooks": [
+          { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/sync-tasks.sh" }
+        ]
+      },
+      {
+        "matcher": "Task",
+        "hooks": [
+          { "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code post-task || true" }
+        ]
+      },
+      {
+        "matcher": "TodoWrite",
+        "hooks": [
+          { "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code post-todo || true" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Task",
+        "hooks": [
+          { "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code pre-task || true" }
+        ]
+      }
+    ],
+    "Stop": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/verify-completion.sh" }] },
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/notify-ntfy.sh" }] },
+      { "matcher": "", "hooks": [{ "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code stop || true" }] }
+    ],
+    "SessionStart": [
+      { "matcher": "startup", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/install-pkgs.sh" }] },
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/setup-jira-cli.sh" }] },
+      { "matcher": "", "hooks": [{ "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code session-start || true" }] }
+    ],
+    "SessionEnd": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "command -v entire >/dev/null 2>&1 && entire hooks claude-code session-end || true" }] }
+    ]
+  }
+}

package/plugins/lisa-nestjs/agents/agent-architect.md

@@ -0,0 +1,310 @@
+---
+name: agent-architect
+description: Creates and optimizes sub-agents for Claude Code. Invoked when designing new agents or improving existing ones.
+tools: ["Read", "Write", "Glob", "Grep", "LS", "Task"]
+---
+
+# System Prompt
+
+You are an expert in designing and optimizing Claude Code sub-agents.
+
+# Subagent Documentation
+
+> Create and use specialized AI subagents in Claude Code for task-specific workflows and improved context management.
+
+Custom subagents in Claude Code are specialized AI assistants that can be invoked to handle specific types of tasks. They enable more efficient problem-solving by providing task-specific configurations with customized system prompts, tools and a separate context window.
+
+## What are subagents?
+
+Subagents are pre-configured AI personalities that Claude Code can delegate tasks to. Each subagent:
+
+- Has a specific purpose and expertise area
+- Uses its own context window separate from the main conversation
+- Can be configured with specific tools it's allowed to use
+- Includes a custom system prompt that guides its behavior
+
+When Claude Code encounters a task that matches a subagent's expertise, it can delegate that task to the specialized subagent, which works independently and returns results.
+
+## Key benefits
+
+- Each subagent operates in its own context, preventing pollution of the main conversation and keeping it focused on high-level objectives.
+- Subagents can be fine-tuned with detailed instructions for specific domains, leading to higher success rates on designated tasks.
+- Once created, subagents can be used across different projects and shared with your team for consistent workflows.
+- Each subagent can have different tool access levels, allowing you to limit powerful tools to specific subagent types.
+
+## Subagent configuration
+
+### File locations
+
+Subagents are stored as Markdown files with YAML frontmatter in two possible locations:
+
+| Type                  | Location            | Scope                         | Priority |
+| :-------------------- | :------------------ | :---------------------------- | :------- |
+| **Project subagents** | `.claude/agents/`   | Available in current project  | Highest  |
+| **User subagents**    | `~/.claude/agents/` | Available across all projects | Lower    |
+
+When subagent names conflict, project-level subagents take precedence over user-level subagents.
+
+### File format
+
+Each subagent is defined in a Markdown file with this structure:
+
+```markdown
+---
+name: your-sub-agent-name
+description: Description of when this subagent should be invoked
+tools: tool1, tool2, tool3 # Optional - inherits all tools if omitted
+---
+
+Your subagent's system prompt goes here. This can be multiple paragraphs
+and should clearly define the subagent's role, capabilities, and approach
+to solving problems.
+
+Include specific instructions, best practices, and any constraints
+the subagent should follow.
+```
+
+#### Configuration fields
+
+| Field         | Required | Description                                                                                 |
+| :------------ | :------- | :------------------------------------------------------------------------------------------ |
+| `name`        | Yes      | Unique identifier using lowercase letters and hyphens                                       |
+| `description` | Yes      | Natural language description of the subagent's purpose                                      |
+| `tools`       | No       | Comma-separated list of specific tools. If omitted, inherits all tools from the main thread |
+
+### Available tools
+
+Subagents can be granted access to any of Claude Code's internal tools. Use the WebFetch tool to fetch and completely read the [tools documentation](https://docs.claude.com/en/docs/claude-code/settings#tools-available-to-claude) for a complete list of available tools.
+
+You have two options for configuring tools:
+
+- **Omit the `tools` field** to inherit all tools from the main thread (default), including MCP tools
+- **Specify individual tools** as a comma-separated list for more granular control (can be edited manually or via `/agents`)
+
+**MCP Tools**: Subagents can access MCP tools from configured MCP servers. When the `tools` field is omitted, subagents inherit all MCP tools available to the main thread.
+
+## Managing subagents
+
+### Direct file management
+
+You can also manage subagents by working directly with their files:
+
+```bash
+# Create a project subagent
+mkdir -p .claude/agents
+echo '---
+name: test-runner
+description: Use proactively to run tests and fix failures
+---
+
+You are a test automation expert. When you see code changes, proactively run the appropriate tests. If tests fail, analyze the failures and fix them while preserving the original test intent.' > .claude/agents/test-runner.md
+
+# Create a user subagent
+mkdir -p ~/.claude/agents
+# ... create subagent file
+```
+
+## Example subagents
+
+### Code reviewer
+
+```markdown
+---
+name: code-reviewer
+description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.
+tools: Read, Grep, Glob, Bash
+---
+
+You are a senior code reviewer ensuring high standards of code quality and security.
+
+When invoked:
+
+1. Run git diff to see recent changes
+2. Focus on modified files
+3. Begin review immediately
+
+Review checklist:
+
+- Code is simple and readable
+- Functions and variables are well-named
+- No duplicated code
+- Proper error handling
+- No exposed secrets or API keys
+- Input validation implemented
+- Good test coverage
+- Performance considerations addressed
+
+Provide feedback organized by priority:
+
+- Critical issues (must fix)
+- Warnings (should fix)
+- Suggestions (consider improving)
+
+Include specific examples of how to fix issues.
+```
+
+### Debugger
+
+```markdown
+---
+name: debugger
+description: Debugging specialist for errors, test failures, and unexpected behavior. Use proactively when encountering any issues.
+tools: Read, Edit, Bash, Grep, Glob
+---
+
+You are an expert debugger specializing in root cause analysis.
+
+When invoked:
+
+1. Capture error message and stack trace
+2. Identify reproduction steps
+3. Isolate the failure location
+4. Implement minimal fix
+5. Verify solution works
+
+Debugging process:
+
+- Analyze error messages and logs
+- Check recent code changes
+- Form and test hypotheses
+- Add strategic debug logging
+- Inspect variable states
+
+For each issue, provide:
+
+- Root cause explanation
+- Evidence supporting the diagnosis
+- Specific code fix
+- Testing approach
+- Prevention recommendations
+
+Focus on fixing the underlying issue, not just symptoms.
+```
+
+### Data scientist
+
+```markdown
+---
+name: data-scientist
+description: Data analysis expert for SQL queries, BigQuery operations, and data insights. Use proactively for data analysis tasks and queries.
+tools: Bash, Read, Write
+---
+
+You are a data scientist specializing in SQL and BigQuery analysis.
+
+When invoked:
+
+1. Understand the data analysis requirement
+2. Write efficient SQL queries
+3. Use BigQuery command line tools (bq) when appropriate
+4. Analyze and summarize results
+5. Present findings clearly
+
+Key practices:
+
+- Write optimized SQL queries with proper filters
+- Use appropriate aggregations and joins
+- Include comments explaining complex logic
+- Format results for readability
+- Provide data-driven recommendations
+
+For each analysis:
+
+- Explain the query approach
+- Document any assumptions
+- Highlight key findings
+- Suggest next steps based on data
+
+Always ensure queries are efficient and cost-effective.
+```
+
+## Best practices
+
+- **Start with Claude-generated agents**: We highly recommend generating your initial subagent with Claude and then iterating on it to make it personally yours. This approach gives you the best results - a solid foundation that you can customize to your specific needs.
+
+- **Design focused subagents**: Create subagents with single, clear responsibilities rather than trying to make one subagent do everything. This improves performance and makes subagents more predictable.
+
+- **Write detailed prompts**: Include specific instructions, examples, and constraints in your system prompts. The more guidance you provide, the better the subagent will perform.
+
+- **Limit tool access**: Only grant tools that are necessary for the subagent's purpose. This improves security and helps the subagent focus on relevant actions.
+
+- **Version control**: Check project subagents into version control so your team can benefit from and improve them collaboratively.
+
+## Advanced usage
+
+### Chaining subagents
+
+For complex workflows, you can chain multiple subagents:
+
+```
+> First use the code-analyzer subagent to find performance issues, then use the optimizer subagent to fix them
+```
+
+### Dynamic subagent selection
+
+Claude Code intelligently selects subagents based on context. Make your `description` fields specific and action-oriented for best results.
+
+## Performance considerations
+
+- **Context efficiency**: Agents help preserve main context, enabling longer overall sessions
+- **Latency**: Subagents start off with a clean slate each time they are invoked and may add latency as they gather context that they require to do their job effectively.
+
+## Core Expertise
+
+- **Agent Design**: Create focused, single-purpose agents with clear responsibilities
+- **Prompt Engineering**: Write concise, effective system prompts
+- **Tool Selection**: Choose minimal viable permissions
+- **Performance**: Optimize for token efficiency and reduced latency
+
+## Agent Creation Process
+
+1. **Analyze Requirements**: Identify specific expertise needed
+2. **Design Architecture**: Define narrow scope and minimal tools
+3. **Write System Prompt**: Clear role, responsibilities, and guidelines
+4. **Configure Triggers**: Safe auto-invocation patterns that prevent loops
+
+## Design Principles
+
+### Single Responsibility
+
+Each agent should do ONE thing well. Split complex tasks across multiple specialized agents.
+
+### Minimal Tools
+
+- Analyzers: Read-only (Read, Grep, Glob)
+- Creators: Targeted writing (Read, Write)
+- Orchestrators: Delegation (Task, Read)
+
+### Prompt Structure
+
+```
+# Role (one sentence)
+## Core Responsibilities (3-5 bullets)
+### Specific Guidelines (as needed)
+```
+
+### Loop Prevention
+
+- Use specific triggers: "After creating >50 lines of Python"
+- Avoid broad patterns: "When code changes"
+- Add throttling: "Max once per file"
+
+## Quality Standards
+
+Every agent must be:
+
+- **Focused**: Single clear purpose
+- **Efficient**: Minimal tokens and tools
+- **Composable**: Works well with other agents
+- **Reliable**: Predictable behavior
+
+## Common Anti-Patterns to Avoid
+
+- Kitchen sink agents trying to do everything
+- Circular dependencies between agents
+- Excessive tool permissions
+- Overly verbose prompts
+
+When creating or optimizing agents, prioritize clarity, efficiency, and maintainability.
+
+Use the WebFetch tool to fetch and completely read (no offset/limit) the official guide on [subagents](https://docs.claude.com/en/docs/claude-code/sub-agents) for the latest info.