@codyswann/lisa 1.12.9 → 1.14.0

package/all/copy-overwrite/.claude/skills/project-research/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: project-research
+description: This skill should be used when conducting comprehensive research across the codebase and web relevant to a project. It spawns parallel research agents, documents existing code patterns, testing patterns, and architecture, and compiles findings into a research.md file for the planning phase.
+allowed-tools: ["Read", "Write", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList", "WebSearch", "WebFetch"]
+argument-hint: "<project-directory>"
+---
+
+# Research Codebase
+
+Conduct comprehensive research across the codebase and web to help create an implementation plan for the brief in $ARGUMENTS.
+
+## Goals
+
+1. Determine what existing documentation in the codebase will be needed
+2. Determine any gaps in the spec that would prevent fulfilling acceptance criteria
+3. Determine potential pitfalls (performance, security concerns)
+4. Determine reusable code, functions, and modules in the codebase
+5. Determine testing patterns and locations (frameworks, conventions, examples)
+6. Determine documentation patterns (JSDoc, DB comments, GraphQL descriptions)
+
+## Critical Rule
+
+**THE ONLY JOB IS TO DOCUMENT AND EXPLAIN THE CODEBASE AS IT EXISTS TODAY**
+
+- DO NOT suggest improvements or changes
+- DO NOT perform root cause analysis
+- DO NOT propose future enhancements
+- DO NOT critique or identify problems
+- ONLY describe what exists, where it exists, how it works, and how components interact
+
+## Workflow Tasks
+
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "research" }`:
+
+1. Read mentioned files
+2. Analyze and decompose
+3. Spawn research agents
+4. Wait and synthesize
+5. Generate document
+6. Commit
+
+## Step 1: Read Mentioned Files
+
+Read any directly mentioned files FULLY first (no limit/offset). This ensures full context before spawning sub-tasks.
+
+## Step 2: Analyze and Decompose
+
+- Break down the brief into composable research areas
+- Identify specific components, patterns, or concepts to investigate
+- Consider which directories, files, or architectural patterns are relevant
+
+## Step 3: Spawn Research Agents
+
+Spawn parallel sub-agent tasks for comprehensive research:
+
+**For codebase research:**
+- **codebase-locator**: Find WHERE files and components live
+- **codebase-analyzer**: Understand HOW specific code works
+- **codebase-pattern-finder**: Find examples of existing patterns
+- **git-history-analyzer**: Understand file change history
+
+**For e2e test research:**
+- Find existing e2e tests in `e2e/` or `tests/` directories
+- Document what scenarios each test covers
+- Identify tests needing modification or gaps for new functionality
+
+**For web research:**
+- **web-search-researcher**: External documentation and resources
+- Include LINKS with findings in the final report
+
+Run multiple agents in parallel when searching for different things.
+
+## Step 4: Wait and Synthesize
+
+**CRITICAL**: Wait for ALL sub-agent tasks to complete before proceeding.
+
+- Compile all sub-agent results
+- Prioritize live codebase findings as primary source of truth
+- Connect findings across different components
+- Include specific file paths and line numbers
+- Note any frameworks used (Rails, NestJS, Expo, React, etc.)
+
+## Step 5: Generate Document
+
+Create `$ARGUMENTS/research.md` with this structure:
+
+```markdown
+---
+date: [ISO format with timezone]
+status: complete
+last_updated: [YYYY-MM-DD]
+---
+
+# Research
+
+## Summary
+[High-level documentation of findings]
+
+## Detailed Findings
+### [Component/Area]
+- Description of what exists ([file.ext:line](link))
+- How it connects to other components
+
+## Code References
+- `path/to/file.py:123` - Description
+
+## Reusable Code
+### Existing Functions/Modules
+- `path/to/utils.ts:45` - `functionName()` - description of what it does and how it can be reused
+- `path/to/service.ts:120` - `ClassName` - description of reusable functionality
+
+### Existing Patterns to Follow
+- Similar feature implemented in `path/to/feature/` - follow same structure
+- Existing implementation of X in `path/to/file.ts` - can be extended/adapted
+
+## Architecture Documentation
+[Patterns, conventions, design implementations]
+
+## Testing Patterns
+### Unit Test Patterns
+- **Location**: pattern found
+- **Framework**: Jest/Vitest/etc.
+- **Example to follow**: path:line-range
+- **Conventions**: naming, structure, mocks
+
+### Integration Test Patterns
+[Similar structure]
+
+### E2E Test Patterns
+[Similar structure]
+
+## Impacted Tests
+### Tests Requiring Modification
+- `tests/example.spec.ts` - tests X functionality, will need updates for Y
+- `e2e/feature.spec.ts` - may need new assertions for Z
+
+### Test Gaps
+- No existing tests for X functionality - will need new test file
+- Missing edge case coverage for Y scenario
+
+## Documentation Patterns
+### JSDoc Conventions
+### Database Comments (Backend)
+### GraphQL Descriptions (Backend)
+
+## Open Questions
+
+### Q1: [Short Title]
+**Question**: [Full question]
+**Context**: [Why this arose]
+**Impact**: [What it affects]
+**Recommendation**: [Researcher's best recommendation based on findings]
+**Answer**: _[Human fills before /project-plan]_
+```
+
+## Step 6: Commit
+
+Run `/git-commit`
+
+## Important Notes
+
+- Always use parallel Task agents to maximize efficiency
+- Always run fresh codebase research - never rely solely on existing documents
+- Focus on finding concrete file paths and line numbers
+- Each sub-agent prompt should be specific and focused on read-only documentation
+- **REMEMBER**: Document what IS, not what SHOULD BE

package/all/copy-overwrite/.claude/skills/project-review/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: project-review
+description: This skill should be used when performing extensive code review and optimization on the current project. It runs Claude local code review, CodeRabbit review, implements fixes from both, and performs code simplification optimizations.
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList", "Skill"]
+argument-hint: "<project-directory>"
+---
+
+The current branch is a feature branch with full implementation of the project in $ARGUMENTS.
+
+**IMPORTANT**: Perform each step and move to the next without stopping.
+
+## Setup
+
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
+
+## Create and Execute Tasks
+
+Create workflow tracking tasks with `metadata.project` set to the project name:
+
+```
+TaskCreate:
+  subject: "Perform Claude review"
+  description: "If $ARGUMENTS/claude-review.md already exists, skip this task. Otherwise, run /project-local-code-review $ARGUMENTS"
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Implement Claude review fixes"
+  description: "Read $ARGUMENTS/claude-review.md and fix any suggestions that score above 45."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Perform CodeRabbit review"
+  description: "If $ARGUMENTS/coderabbit-review.md already exists, skip this task. Otherwise, run `/coderabbit:review` and write results to $ARGUMENTS/coderabbit-review.md"
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Implement CodeRabbit review fixes"
+  description: "Evaluate suggestions in $ARGUMENTS/coderabbit-review.md and implement fixes for valid findings."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Perform Claude optimizations"
+  description: "Use the code simplifier agent to clean up code added to the current branch."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.

package/all/copy-overwrite/.claude/skills/project-setup/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: project-setup
+description: This skill should be used when initializing a new project with full requirements analysis, planning, and structure setup. It accepts a file path, JIRA issue, or text description, creates the project directory structure with brief.md and findings.md, and commits the initial setup.
+allowed-tools: ["Read", "Write", "Bash(git*)", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList"]
+argument-hint: "<file-path|jira-issue|text-description>"
+---
+
+## Step 1: Determine Input Type
+
+Examine $ARGUMENTS to determine which type:
+- **Jira issue**: Matches pattern like `SE-123`, `PROJ-456` (letters-dash-numbers)
+- **File path**: Path exists as a file (check with Glob or Read)
+- **Text prompt**: Everything else - a description of work to be done
+
+## Step 2: Get Brief Content
+
+Based on input type:
+
+**If Jira issue:**
+1. Use the atlassian MCP server to Read the issue FULLY
+2. If MCP server not working, STOP and let human know
+
+**If file path:**
+1. Read the file FULLY (no limit/offset)
+
+**If text prompt:**
+1. The prompt IS the brief content - use $ARGUMENTS directly
+
+## Step 3: Create Project Structure
+
+1. Create project directory in `projects/` named `YYYY-MM-DD-<project-name>` where `<project-name>` is derived from:
+   - Jira: the issue key and title (e.g., `2026-01-26-se-123-add-auth`)
+   - File: the filename without extension
+   - Text prompt: a kebab-case summary of the prompt (e.g., `2026-01-26-add-user-authentication`)
+
+2. Create `brief.md` in the project directory:
+   - Jira: populate with issue number, title, and description
+   - File: copy contents of the file to `brief.md`
+   - Text prompt: create `brief.md` with the prompt text as content
+
+3. Create empty `findings.md` in the project directory
+
+4. Create `.claude-active-project` marker file:
+   ```bash
+   echo "YYYY-MM-DD-<project-name>" > .claude-active-project
+   ```
+
+## Step 4: Git and Finalize
+
+1. If Jira issue:
+   - Run /git-commit with branch name including issue number (e.g., `feature/SE-111-<branch-name>`)
+   - Use atlassian MCP server to update issue status to "In Progress"
+2. Otherwise:
+   - Run /git-commit
+
+3. Output: "Project created: `YYYY-MM-DD-<project-name>`"

package/all/copy-overwrite/.claude/skills/project-verify/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: project-verify
+description: This skill should be used when performing comprehensive verification that a feature branch fully implements all project requirements with proper code quality, tests, and documentation. It reviews requirements, verifies implementation, runs task verification commands, and documents any drift.
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList"]
+argument-hint: "<project-directory>"
+---
+
+The current branch is a feature branch with full implementation of the project in $ARGUMENTS.
+
+## Setup
+
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
+
+## Create and Execute Tasks
+
+Create workflow tracking tasks with `metadata.project` set to the project name:
+
+```
+TaskCreate:
+  subject: "Review requirements"
+  description: "Read all requirements for $ARGUMENTS (brief.md, research.md, task files)."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Verify implementation"
+  description: "Verify the implementation completely and fully satisfies all requirements from the brief and research."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Run task verification commands"
+  description: "Read all task files in $ARGUMENTS/tasks/. For each task with verification metadata (JSON: metadata.verification, or Markdown: ## Verification section), create a verification task with subject 'Verify: <original-subject>' and metadata including originalTaskId and verification details. Then execute each verification task: run the command, compare output to expected. If pass, mark completed. If fail, keep in_progress and document failure in $ARGUMENTS/drift.md. Report summary: total tasks, passed, failed, blocked."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Document drift"
+  description: "If there is any divergence from requirements or verification failures, ensure all drift is documented in $ARGUMENTS/drift.md."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.

package/all/copy-overwrite/.claude/skills/pull-request-review/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: pull-request-review
+description: This skill should be used when checking for code review comments on a pull request and implementing them if required. It fetches PR metadata and comments, generates a brief from unresolved feedback, and bootstraps a project to address the review comments.
+allowed-tools: ["Read", "Bash", "Glob", "Grep"]
+argument-hint: "<github-pr-link>"
+---
+
+# Review PR Comments
+
+Target PR: $ARGUMENTS
+
+If no argument provided, prompt the user for a PR link or number.
+
+## Step 1: Gather Requirements
+
+1. **Fetch PR metadata and comments** using the GitHub CLI:
+   ```bash
+   gh pr view $ARGUMENTS --json number,title,body,reviews,comments
+   gh api repos/{owner}/{repo}/pulls/{pr_number}/comments
+   ```
+2. **Extract each unresolved review comment**:
+   - Comment ID
+   - File path
+   - Line number
+   - Comment body
+   - Author
+
+If no unresolved comments exist, report success and exit.
+
+## Step 2: Generate Brief
+
+Compile findings into a detailed brief:
+
+```markdown
+Implement PR review feedback for $ARGUMENTS.
+
+## PR Overview
+- Title: [PR title]
+- Description: [PR description summary]
+
+## Review Comments to Address (ordered by file)
+
+### 1. [file_path]:[line_number] (Comment ID: [id])
+**Reviewer**: [author]
+**Comment**: [full comment body]
+**Action Required**: [brief description of what needs to change]
+
+### 2. [file_path]:[line_number] (Comment ID: [id])
+**Reviewer**: [author]
+**Comment**: [full comment body]
+**Action Required**: [brief description of what needs to change]
+
+...
+
+## Implementation Guidelines
+- Evaluate each comment for validity before implementing
+- If a comment is not valid, document the reasoning
+- Ensure changes follow project coding standards
+- Run relevant tests to verify changes work
+
+## Acceptance Criteria
+- All valid review comments addressed
+- Tests pass after changes
+- `bun run lint` passes
+
+## Verification
+Command: `bun run lint && bun run test`
+Expected: All checks pass
+```
+
+## Step 3: Bootstrap Project
+
+Run `/project-bootstrap` with the generated brief as a text prompt.

package/all/copy-overwrite/.claude/skills/sonarqube-check/SKILL.md

@@ -0,0 +1,11 @@
+---
+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/all/copy-overwrite/.claude/skills/sonarqube-fix/SKILL.md

@@ -0,0 +1,8 @@
+---
+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/all/copy-overwrite/.claude/skills/tasks-load/SKILL.md

@@ -0,0 +1,89 @@
+---
+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"]
+argument-hint: "<project-name>"
+---
+
+# 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/all/copy-overwrite/.claude/skills/tasks-sync/SKILL.md

@@ -0,0 +1,109 @@
+---
+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"]
+argument-hint: "<project-name>"
+---
+
+# 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/cdk/copy-overwrite/jest.cdk.ts

@@ -0,0 +1,71 @@
+/**
+ * This file is managed by Lisa.
+ * Do not edit directly — changes will be overwritten on the next `lisa` run.
+ */
+
+/**
+ * Jest Configuration - CDK Stack
+ *
+ * Provides AWS CDK-specific Jest configuration targeting
+ * the test/ directory with spec and integration-spec patterns.
+ *
+ * Inheritance chain:
+ *   jest.cdk.ts (this file)
+ *   └── jest.base.ts
+ *
+ * @see https://jestjs.io/docs/configuration
+ * @module jest.cdk
+ */
+import type { Config } from "jest";
+
+import {
+  defaultCoverageExclusions,
+  defaultThresholds,
+  mergeConfigs,
+  mergeThresholds,
+} from "./jest.base.ts";
+
+// Re-export base utilities for entry-point configs
+export {
+  defaultCoverageExclusions,
+  defaultThresholds,
+  mergeConfigs,
+  mergeThresholds,
+};
+
+/**
+ * Options for configuring the CDK Jest config factory.
+ */
+interface CdkJestOptions {
+  /** Coverage thresholds (merged defaults + project overrides) */
+  readonly thresholds?: Config["coverageThreshold"];
+}
+
+/**
+ * Creates a Jest configuration for AWS CDK projects.
+ *
+ * @param options - Configuration options for threshold overrides
+ * @param options.thresholds - Coverage thresholds (merged defaults + project overrides)
+ * @returns Jest config object with ts-jest transform, node environment, and CDK-specific paths
+ * @remarks CDK projects typically use CommonJS modules and keep tests in a
+ * separate test/ directory. Coverage is collected only from lib/ and util/
+ * directories since bin/ contains entry-point code with minimal logic.
+ */
+export const getCdkJestConfig = ({
+  thresholds = defaultThresholds,
+}: CdkJestOptions = {}): Config => ({
+  testEnvironment: "node",
+  roots: ["<rootDir>/test"],
+  testRegex: "(.*\\.(spec|integration-spec)\\.ts)$",
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+  moduleFileExtensions: ["js", "json", "ts"],
+  collectCoverageFrom: [
+    "lib/**/*.ts",
+    "util/**/*.ts",
+    ...defaultCoverageExclusions,
+  ],
+  coverageThreshold: thresholds,
+  testTimeout: 10000,
+});