@codyswann/lisa 1.48.0 → 1.49.0

package/package.json

@@ -18,7 +18,11 @@
     "expo",
     "nestjs",
     "cdk",
-    "rails"
+    "rails",
+    "tsconfig",
+    "scripts",
+    "plugins",
+    ".claude-plugin"
   ],
   "trustedDependencies": [
     "@ast-grep/cli",
@@ -38,7 +42,8 @@
     "knip": "knip",
     "knip:fix": "knip --fix",
     "sg:scan": "ast-grep scan",
-    "build": "tsc",
+    "build": "tsc && bun run build:plugins",
+    "build:plugins": "bash scripts/build-plugins.sh",
     "prepare": "$npm_execpath run build || husky install || true",
     "lisa:update": "npx @codyswann/lisa@latest .",
     "start": "node dist/index.js",
@@ -51,44 +56,8 @@
     "setup:deploy-key": "bash scripts/setup-deploy-key.sh",
     "lisa:update:local": "bash scripts/lisa-update-local.sh",
     "lisa:commit-and-pr:local": "bash scripts/lisa-commit-and-pr-local.sh",
-    "prepublishOnly": "$npm_execpath run build"
-  },
-  "devDependencies": {
-    "@ast-grep/cli": "^0.40.4",
-    "@commitlint/cli": "^20.3.1",
-    "@commitlint/config-conventional": "^20.3.1",
-    "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
-    "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.39.0",
-    "@jest/globals": "^30.0.0",
-    "@jest/test-sequencer": "^30.2.0",
-    "@types/fs-extra": "^11.0.0",
-    "@types/jest": "^30.0.0",
-    "@types/lodash.merge": "^4.6.0",
-    "@types/node": "^22.0.0",
-    "esbuild-register": "^3.6.0",
-    "eslint": "^9.39.0",
-    "eslint-config-prettier": "^10.0.0",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "@codyswann/eslint-plugin-code-organization": "^1.0.0",
-    "eslint-plugin-functional": "^9.0.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^61.5.0",
-    "eslint-plugin-prettier": "^5.5.0",
-    "eslint-plugin-sonarjs": "^3.0.0",
-    "husky": "^8.0.0",
-    "jest": "^30.0.0",
-    "jiti": "^2.4.0",
-    "jscodeshift": "0.15.2",
-    "knip": "^5.0.0",
-    "lint-staged": "^16.2.7",
-    "prettier": "^3.3.3",
-    "standard-version": "^9.5.0",
-    "ts-jest": "^29.4.6",
-    "ts-morph": "^27.0.2",
-    "tsx": "^4.0.0",
-    "typescript": "~5.7.0",
-    "typescript-eslint": "^8.0.0"
+    "prepublishOnly": "$npm_execpath run build",
+    "postinstall": "bash ./scripts/install-claude-plugins.sh || true"
   },
   "resolutions": {
     "@isaacs/brace-expansion": "^5.0.1",
@@ -99,11 +68,36 @@
     "axios": ">=1.13.5"
   },
   "name": "@codyswann/lisa",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "description": "Claude Code governance framework that applies guardrails, guidance, and automated enforcement to projects",
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./eslint": "./dist/configs/eslint/index.js",
+    "./eslint/base": "./dist/configs/eslint/base.js",
+    "./eslint/typescript": "./dist/configs/eslint/typescript.js",
+    "./eslint/nestjs": "./dist/configs/eslint/nestjs.js",
+    "./eslint/expo": "./dist/configs/eslint/expo.js",
+    "./eslint/cdk": "./dist/configs/eslint/cdk.js",
+    "./eslint/slow": "./dist/configs/eslint/slow.js",
+    "./jest": "./dist/configs/jest/index.js",
+    "./jest/base": "./dist/configs/jest/base.js",
+    "./jest/typescript": "./dist/configs/jest/typescript.js",
+    "./jest/nestjs": "./dist/configs/jest/nestjs.js",
+    "./jest/expo": "./dist/configs/jest/expo.js",
+    "./jest/cdk": "./dist/configs/jest/cdk.js",
+    "./tsconfig/base": "./tsconfig/base.json",
+    "./tsconfig/typescript": "./tsconfig/typescript.json",
+    "./tsconfig/nestjs": "./tsconfig/nestjs.json",
+    "./tsconfig/expo": "./tsconfig/expo.json",
+    "./tsconfig/cdk": "./tsconfig/cdk.json",
+    "./tsconfig/eslint": "./tsconfig/eslint.json",
+    "./tsconfig/build": "./tsconfig/build.json",
+    "./tsconfig/spec": "./tsconfig/spec.json"
+  },
   "bin": {
-    "lisa": "dist/index.js"
+    "lisa": "dist/index.js",
+    "setup-deploy-key": "scripts/setup-deploy-key.sh"
   },
   "keywords": [
     "claude",
@@ -123,12 +117,57 @@
   },
   "homepage": "https://github.com/CodySwannGT/lisa#readme",
   "dependencies": {
+    "@ast-grep/cli": "^0.40.4",
+    "@codyswann/eslint-plugin-code-organization": "^1.0.0",
+    "@codyswann/eslint-plugin-component-structure": "^1.0.0",
+    "@codyswann/eslint-plugin-ui-standards": "^1.0.0",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.39.0",
     "@inquirer/prompts": "^7.0.0",
+    "@jest/globals": "^30.0.0",
+    "@jest/test-sequencer": "^30.2.0",
+    "@types/fs-extra": "^11.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.merge": "^4.6.0",
+    "@types/node": "^22.0.0",
     "commander": "^12.0.0",
+    "esbuild-register": "^3.6.0",
+    "eslint": "^9.39.0",
+    "eslint-config-expo": "^10.0.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-functional": "^9.0.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^61.5.0",
+    "eslint-plugin-jsx-a11y": "^6.10.0",
+    "eslint-plugin-prettier": "^5.5.0",
+    "eslint-plugin-react": "^7.37.0",
+    "eslint-plugin-react-compiler": "^19.1.0-rc.2",
+    "eslint-plugin-react-hooks": "^7.0.0",
+    "eslint-plugin-react-perf": "^3.3.0",
+    "eslint-plugin-sonarjs": "^3.0.0",
+    "eslint-plugin-tailwindcss": "^3.18.0",
     "fs-extra": "^11.0.0",
+    "globals": "^16.0.0",
+    "husky": "^8.0.0",
+    "jest": "^30.0.0",
+    "jiti": "^2.4.0",
+    "jscodeshift": "0.15.2",
+    "knip": "^5.0.0",
+    "lint-staged": "^16.2.7",
     "lodash.merge": "^4.6.2",
     "minimatch": "^10.2.1",
-    "picocolors": "^1.0.0"
+    "picocolors": "^1.0.0",
+    "prettier": "^3.3.3",
+    "standard-version": "^9.5.0",
+    "ts-jest": "^29.4.6",
+    "ts-morph": "^27.0.2",
+    "tsx": "^4.0.0",
+    "typescript": "~5.7.0",
+    "typescript-eslint": "^8.0.0"
   },
   "type": "module"
 }

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

@@ -0,0 +1,86 @@
+{
+  "name": "cdk",
+  "version": "1.0.0",
+  "description": "Claude Code governance plugin for AWS CDK projects — includes all universal skills, agents, hooks, and rules from Lisa plus TypeScript tooling",
+  "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-cdk/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.

package/plugins/lisa-cdk/agents/architecture-specialist.md

@@ -0,0 +1,53 @@
+---
+name: architecture-specialist
+description: Architecture specialist agent. Designs implementation approaches, traces data flow, identifies files to modify, maps dependencies, finds reusable code, evaluates design patterns, and flags breaking changes.
+tools: Read, Grep, Glob, Bash
+---
+
+# Architecture Specialist Agent
+
+You are a technical architecture specialist who designs implementation approaches and evaluates structural impact of code changes.
+
+## Analysis Process
+
+1. **Read referenced files** -- understand current architecture before proposing changes
+2. **Trace data flow** -- follow the path from entry point to output for the affected feature
+3. **Identify modification points** -- which files, functions, and interfaces need changes
+4. **Map dependencies** -- what depends on the code being changed, and what it depends on
+5. **Check for reusable code** -- existing utilities, helpers, or patterns that apply
+6. **Evaluate design patterns** -- match the codebase's existing patterns (don't introduce new ones without reason)
+
+## Output Format
+
+Structure your findings as:
+
+```
+## Architecture Analysis
+
+### Files to Create
+- `path/to/file.ts` -- purpose
+
+### Files to Modify
+- `path/to/file.ts:L42-L68` -- what changes and why
+
+### Dependency Graph
+- [file A] → [file B] → [file C] (modification order)
+
+### Design Decisions
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+
+### Reusable Code
+- `path/to/util.ts:functionName` -- how it applies
+
+### Risks
+- [risk description] -- [mitigation]
+```
+
+## Rules
+
+- Always read files before recommending changes to them
+- Follow existing patterns in the codebase -- do not introduce new architectural patterns unless explicitly required
+- Include file:line references for all recommendations
+- Flag breaking changes explicitly
+- Keep the modification surface area as small as possible