@codyswann/lisa 1.67.2 → 1.68.0

package/plugins/lisa/commands/jira/implement.md

@@ -1,7 +0,0 @@
----
-description: "Implement requirements from a JIRA ticket"
-allowed-tools: ["Skill"]
-argument-hint: "<TICKET-ID-OR-URL>"
----
-
-Use the /lisa:jira-implement skill to implement the requirements in the JIRA ticket. $ARGUMENTS

package/plugins/lisa/commands/sonarqube/check.md

@@ -1,6 +0,0 @@
----
-description: "Uses SonarQube / SonarCloud to get the reason that last pull request failed to pass checks"
-allowed-tools: ["Skill"]
----
-
-Use the /lisa:sonarqube-check skill to check why the last PR failed SonarQube quality gates.

package/plugins/lisa/commands/sonarqube/fix.md

@@ -1,6 +0,0 @@
----
-description: "Run SonarQube check, fix failures, and commit"
-allowed-tools: ["Skill"]
----
-
-Use the /lisa:sonarqube-fix skill to check, fix, and commit SonarQube quality gate failures.

package/plugins/lisa/commands/tasks/load.md

@@ -1,7 +0,0 @@
----
-description: "Load tasks from a project directory into the current session"
-allowed-tools: ["Skill"]
-argument-hint: "<project-name>"
----
-
-Use the /lisa:tasks-load skill to load tasks from a project directory. $ARGUMENTS

package/plugins/lisa/commands/tasks/sync.md

@@ -1,7 +0,0 @@
----
-description: "Sync current session tasks to a project directory"
-allowed-tools: ["Skill"]
-argument-hint: "<project-name>"
----
-
-Use the /lisa:tasks-sync skill to sync current session tasks to a project directory. $ARGUMENTS

package/plugins/lisa/skills/git-commit-and-submit-pr/SKILL.md

@@ -1,8 +0,0 @@
----
-name: git-commit-and-submit-pr
-description: This skill should be used when creating conventional commits for current changes and then submitting the current branch as a pull request for code review. It combines the git:commit and git:submit-pr skills into a single workflow.
-allowed-tools: ["Bash"]
----
-
-1. Run /git-commit $ARGUMENTS
-2. Run /git-submit-pr $ARGUMENTS

package/plugins/lisa/skills/git-commit-submit-pr-and-verify/SKILL.md

@@ -1,7 +0,0 @@
----
-name: git-commit-submit-pr-and-verify
-description: This skill should be used when creating conventional commits for current changes and then submitting the current branch as a pull request for code review. And then verifying the pull request was approved.
-allowed-tools: ["Bash"]
----
-
-Run the /git-commit-and-submit-pr with $ARGUMENTS and set the PR to auto-merge. Fix any pre-commit or pre-push issues and then follow the pr, make sure all checks pass and comments are resolved or addressed. Fix anything that is broken and repeat.

package/plugins/lisa/skills/git-commit-submit-pr-deploy-and-verify/SKILL.md

@@ -1,7 +0,0 @@
----
-name: git-commit-submit-pr-deploy-and-verify
-description: This skill should be used when creating conventional commits for current changes and then submitting the current branch as a pull request for code review. And then verifying the pull request was approved. As well as making sure the resutling deploy succeeds.
-allowed-tools: ["Bash"]
----
-
-Run the /git-commit-submit-pr-and-verify with $ARGUMENTS. Once the merge is complete, follow the resulting deploy and fix anything that breaks with the deploy and then follow this process again with a new PR until the deploy succeeds.

package/plugins/lisa/skills/jira-fix/SKILL.md

@@ -1,16 +0,0 @@
----
-name: jira-fix
-description: This skill should be used when fixing a bug ticket in JIRA
----
-
-1. Use the JIRA/Atlassian MCP or CLI to fully read this issue, including comments and attachments: $ARGUMENTS
-2. Extract sign-in information if available from the ticket (e.g., test credentials, OTP codes)
-3. Use the project's verification method to attempt to reproduce the bug:
-   - For UI projects: Use Playwright MCP browser tools to record a replication
-   - For API projects: Use curl or test commands to reproduce the error
-   - For library projects: Write a minimal reproduction test
-4. If you cannot reproduce the issue, upload the evidence to the JIRA ticket explaining that you can't replicate it and skip the remaining steps
-5. If there have already been attempts to fix this bug, understand the previous attempts by looking for pull requests and git commits related to it
-6. Fix the bug
-7. Verify the fix using the same verification method used in step 3
-8. Upload the evidence to the JIRA ticket and explain the fix

package/plugins/lisa/skills/jira-implement/SKILL.md

@@ -1,18 +0,0 @@
----
-name: jira-implement
-description: This skill should be used when implementing the requirements in a JIRA ticket.
----
-
-Use either the Atlassian MCP or CLI to examine the contents of the JIRA ticket: $ARGUMENTS
-
-If neither is available, stop and report that you cannot access the ticket.
-
-Read all the details in the ticket, including any URLs and attachments.
-
-Make a plan to fulfill the requirements of the ticket.
-
-Important: If this involves UI changes, use Playwright MCP browser tools to access the app and get a better understanding of what needs to be done. Create a verification task using browser tools to confirm the implementation.
-
-Important: If this involves API or backend changes, use curl or test commands to understand current behavior. Create a verification task to confirm the implementation.
-
-If you don't know how to access the app or service, clarify when making the plan.

package/plugins/lisa/skills/sonarqube-check/SKILL.md

@@ -1,11 +0,0 @@
----
-name: sonarqube-check
-description: This skill should be used when checking why the last pull request failed SonarQube/SonarCloud quality gates. It uses the SonarQube MCP server to retrieve failure details and report the reasons.
-allowed-tools: ["mcp__sonarqube__*"]
----
-
-# SonarQube Check
-
-Use the SonarQube MCP server to get the reason the last PR failed checks.
-
-Retrieve the quality gate status and report all failures with their details.

package/plugins/lisa/skills/sonarqube-fix/SKILL.md

@@ -1,8 +0,0 @@
----
-name: sonarqube-fix
-description: This skill should be used when fixing SonarQube quality gate failures. It runs the sonarqube:check skill to identify failures, fixes the identified issues, and then commits the changes using the git:commit skill.
----
-
-1. Run /sonarqube-check
-2. Fix the SonarQube quality gate failures identified in step 1
-3. Run /git-commit

package/plugins/lisa/skills/tasks-load/SKILL.md

@@ -1,88 +0,0 @@
----
-name: tasks-load
-description: This skill should be used when loading tasks from a project directory into the current Claude Code session. It reads task JSON files from session subdirectories, recreates them in the current session, and sets the active project marker.
-allowed-tools: ["Read", "Bash", "TaskCreate", "TaskUpdate", "TaskList"]
----
-
-# Load Project Tasks
-
-Load tasks from `projects/$ARGUMENTS/tasks/` into the current Claude Code session.
-
-Tasks are stored in session subdirectories to preserve history across `/clear` commands:
-```
-projects/$ARGUMENTS/tasks/
-├── {session-1-uuid}/
-│   ├── 1.json
-│   └── 2.json
-└── {session-2-uuid}/
-    ├── 1.json
-    └── 2.json
-```
-
-## Process
-
-### Step 1: Validate Project
-
-Check if the project exists and has task files:
-
-```bash
-find projects/$ARGUMENTS/tasks -name "*.json" 2>/dev/null | head -5
-```
-
-If no task files exist, report: "No tasks found in projects/$ARGUMENTS/tasks/"
-
-List available sessions:
-
-```bash
-ls -dt projects/$ARGUMENTS/tasks/*/ 2>/dev/null | head -10
-```
-
-### Step 2: Set Active Project
-
-Create the active project marker:
-
-```bash
-echo "$ARGUMENTS" > .claude-active-project
-```
-
-This ensures any new tasks created will sync back to this project.
-
-### Step 3: Load Tasks
-
-Find and load all task JSON files from ALL session directories:
-
-```bash
-find projects/$ARGUMENTS/tasks -name "*.json" -type f
-```
-
-For each JSON file found:
-
-1. Read the task JSON file
-2. Use TaskCreate to recreate the task with:
-   - subject from JSON
-   - description from JSON
-   - activeForm from JSON
-   - metadata: `{ "project": "$ARGUMENTS" }`
-3. If the task was already completed (status: "completed"), use TaskUpdate to mark it completed
-
-### Step 4: Report
-
-After loading all tasks, report:
-
-```
-Loaded X tasks from projects/$ARGUMENTS/tasks/
-- Sessions found: N
-- Pending: Y
-- Completed: Z
-
-Active project set to: $ARGUMENTS
-New tasks will automatically sync to this project.
-```
-
-## Notes
-
-- Tasks are recreated with new IDs in the current session
-- The original task IDs from the project are not preserved
-- Tasks from ALL sessions are loaded (full history)
-- Task dependencies (blocks/blockedBy) are NOT currently preserved across load/sync cycles
-- Use TaskList to see the loaded tasks

package/plugins/lisa/skills/tasks-sync/SKILL.md

@@ -1,108 +0,0 @@
----
-name: tasks-sync
-description: This skill should be used when syncing current session tasks to a project directory. It exports all tasks from the current Claude Code session to JSON files in the project's tasks directory, enabling persistence across sessions.
-allowed-tools: ["Read", "Write", "Bash", "TaskList", "TaskGet"]
----
-
-# Sync Tasks to Project
-
-Sync all tasks from the current session to `projects/$ARGUMENTS/tasks/{session-id}/`.
-
-This skill is for manual syncing when work started without setting an active project. Once synced, the automatic hook handles future task updates.
-
-## Process
-
-### Step 1: Validate Project
-
-Check if the project directory exists:
-
-```bash
-ls -d projects/$ARGUMENTS 2>/dev/null
-```
-
-If the project doesn't exist, ask: "Project '$ARGUMENTS' doesn't exist. Create it?"
-
-If yes, create the project structure:
-
-```bash
-mkdir -p projects/$ARGUMENTS/tasks
-```
-
-### Step 2: Determine Session ID
-
-Find the current session by looking for the most recently modified task directory:
-
-```bash
-ls -dt ~/.claude/tasks/*/ 2>/dev/null | head -1 | xargs basename
-```
-
-If no session found, use a timestamp-based identifier:
-
-```bash
-echo "manual-$(date +%Y%m%d-%H%M%S)"
-```
-
-Store the session ID for use in subsequent steps.
-
-### Step 3: Set Active Project
-
-Create/update the active project marker:
-
-```bash
-echo "$ARGUMENTS" > .claude-active-project
-```
-
-### Step 4: Get Current Tasks
-
-Use TaskList to get all tasks in the current session.
-
-### Step 5: Sync Each Task
-
-For each task from TaskList:
-
-1. Use TaskGet to get full task details
-2. Create the session directory:
-
-```bash
-mkdir -p projects/$ARGUMENTS/tasks/{session-id}
-```
-
-3. Create a JSON file with the task data:
-
-```json
-{
-  "id": "<task-id>",
-  "subject": "<subject>",
-  "description": "<description>",
-  "activeForm": "<activeForm>",
-  "status": "<status>",
-  "blocks": [],
-  "blockedBy": []
-}
-```
-
-4. Write to `projects/$ARGUMENTS/tasks/{session-id}/<id>.json`
-
-### Step 6: Stage for Git
-
-```bash
-git add projects/$ARGUMENTS/tasks/{session-id}/*.json
-```
-
-### Step 7: Report
-
-```
-Synced X tasks to projects/$ARGUMENTS/tasks/{session-id}/
-- Pending: Y
-- In Progress: Z
-- Completed: W
-
-Files staged for commit. Run /git-commit when ready.
-```
-
-## Notes
-
-- This skill manually syncs all current tasks to a project
-- Use this when work started without a project context
-- After syncing, the active project is set so future tasks auto-sync via the hook
-- Each sync creates a new session directory to preserve history

package/plugins/src/base/agents/agent-architect.md

@@ -1,310 +0,0 @@
----
-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.