@codyswann/lisa 1.0.0 → 1.0.5

package/all/copy-overwrite/.claude/commands/lisa/review-implementation.md

@@ -0,0 +1,209 @@
+---
+description: Compare project's Lisa-managed files against Lisa source templates and offer to upstream changes
+argument-hint: [lisa-dir]
+---
+
+# Lisa Implementation Review
+
+This command compares the current project's Lisa-managed files against Lisa's source templates to identify drift and offer to upstream improvements back to Lisa.
+
+## Prerequisites
+
+This command requires access to the Lisa installation directory. Either:
+1. Start Claude Code with `--add-dir ~/lisa` (or your Lisa path)
+2. Pass the Lisa directory as an argument: `/lisa:review-implementation ~/lisa`
+
+## Instructions
+
+### Step 1: Locate Lisa Directory
+
+First, determine the Lisa installation directory:
+
+1. If an argument was provided, use that path
+2. Otherwise, check if any `--add-dir` paths contain a `src/core/lisa.ts` file (Lisa's signature file)
+3. Common locations to check: `~/lisa`, `~/workspace/lisa`, `../lisa`
+
+If Lisa directory cannot be found, inform the user:
+```
+Unable to locate Lisa installation directory.
+
+Please either:
+1. Start Claude Code with: claude --add-dir /path/to/lisa
+2. Run this command with the path: /lisa:review-implementation /path/to/lisa
+```
+
+### Step 2: Read the Manifest
+
+Read the project's `.lisa-manifest` file to get the list of managed files.
+
+Parse each line to extract:
+- `strategy`: The copy strategy used (copy-overwrite, copy-contents, merge, create-only)
+- `relativePath`: The file path relative to project root
+
+Skip:
+- Lines starting with `#` (comments)
+- Empty lines
+- Files with `create-only` strategy (these are meant to be customized)
+- Files with `merge` strategy (these are intentionally combined)
+
+### Step 3: Find Source Templates
+
+For each managed file, locate its source in Lisa by checking these directories in order:
+1. `npm-package/copy-overwrite/` and `npm-package/copy-contents/`
+2. `cdk/copy-overwrite/` and `cdk/copy-contents/`
+3. `nestjs/copy-overwrite/` and `nestjs/copy-contents/`
+4. `expo/copy-overwrite/` and `expo/copy-contents/`
+5. `typescript/copy-overwrite/` and `typescript/copy-contents/`
+6. `all/copy-overwrite/` and `all/copy-contents/`
+
+The FIRST match wins (most specific type takes precedence).
+
+Detect which project types apply by checking the project for:
+- `npm-package`: package.json without `"private": true` AND has `main`, `bin`, `exports`, or `files`
+- `cdk`: presence of `cdk.json` or `aws-cdk` in dependencies
+- `nestjs`: presence of `nest-cli.json` or `@nestjs` in dependencies
+- `expo`: presence of `app.json`, `eas.json`, or `expo` in dependencies
+- `typescript`: presence of `tsconfig.json` or `typescript` in dependencies
+
+Only check type directories that match the project.
+
+### Step 4: Compare Files
+
+For each file, compare the project version against the Lisa source:
+
+1. Read both files
+2. If identical, mark as "in sync"
+3. If different, generate a diff summary
+
+Use the Bash tool with `diff` to generate readable diffs:
+```bash
+diff -u "/path/to/lisa/source" "/path/to/project/file" || true
+```
+
+### Step 5: Generate Report
+
+Create a markdown report with these sections:
+
+```markdown
+# Lisa Implementation Review
+
+**Project:** [project name from package.json]
+**Lisa Source:** [lisa directory path]
+**Generated:** [current date/time]
+
+## Summary
+
+- **Total managed files:** X
+- **In sync:** X
+- **Drifted:** X
+- **Source not found:** X
+
+## Drifted Files
+
+### [relative/path/to/file]
+
+**Source:** [lisa-type]/copy-overwrite/[path]
+**Strategy:** copy-overwrite
+
+<details>
+<summary>View diff</summary>
+
+```diff
+[diff output]
+```
+
+</details>
+
+**Recommendation:** [Brief analysis of whether this change should be upstreamed]
+
+---
+
+[Repeat for each drifted file]
+
+## Files Not Found in Lisa
+
+These files are in the manifest but their source templates couldn't be located:
+
+- [list of files]
+
+## In Sync Files
+
+<details>
+<summary>X files are in sync with Lisa</summary>
+
+- [list of files]
+
+</details>
+```
+
+### Step 6: Offer to Upstream Changes
+
+After presenting the report, ask the user which drifted files they want to copy back to Lisa.
+
+For each file the user wants to upstream:
+
+1. Confirm the target path in Lisa (e.g., `typescript/copy-overwrite/.github/workflows/ci.yml`)
+2. Use the Write tool to copy the project's version to Lisa
+3. Report success
+
+Example prompt:
+```
+I found X files that have drifted from Lisa's templates.
+
+Which files would you like to copy back to Lisa?
+1. .github/workflows/ci.yml - [brief description of changes]
+2. .claude/settings.json - [brief description of changes]
+3. All of the above
+4. None - just show me the report
+
+Select an option (or list specific numbers):
+```
+
+### Important Notes
+
+- **Never auto-upstream without confirmation** - always ask the user first
+- **Preserve the most specific type directory** - if a file exists in both `typescript/` and `all/`, upstream to where it currently exists
+- **Handle binary files gracefully** - skip comparison for non-text files
+- **Respect .gitignore patterns** - some generated files shouldn't be compared
+- For `copy-contents` files like `.gitignore`, the comparison is trickier since the project may have additional lines - highlight only if Lisa's required lines are missing
+
+## Example Usage
+
+```
+User: /lisa:review-implementation
+
+Claude: I'll review your project's Lisa-managed files against the Lisa source templates.
+
+[Locates Lisa directory]
+[Reads manifest]
+[Compares files]
+[Generates report]
+
+# Lisa Implementation Review
+
+**Project:** my-awesome-app
+**Lisa Source:** /Users/dev/lisa
+**Generated:** 2026-01-18 10:30:00
+
+## Summary
+
+- **Total managed files:** 45
+- **In sync:** 42
+- **Drifted:** 3
+- **Source not found:** 0
+
+## Drifted Files
+
+### .github/workflows/ci.yml
+
+**Source:** typescript/copy-overwrite/.github/workflows/ci.yml
+**Strategy:** copy-overwrite
+
+[diff details]
+
+**Recommendation:** This adds a new caching step that improves CI performance. Good candidate for upstreaming.
+
+---
+
+I found 3 files that have drifted. Would you like to upstream any of these changes back to Lisa?
+```

package/all/copy-overwrite/.claude/commands/project/add-test-coverage.md

@@ -0,0 +1,58 @@
+---
+description: Increase test coverage to a specified threshold percentage
+allowed-tools: Read, Write, Edit, Bash, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+argument-hint: <threshold-percentage>
+model: sonnet
+---
+
+# Increase Test Coverage
+
+Target threshold: $ARGUMENTS%
+
+If no argument provided, prompt the user for a target.
+
+## Process
+
+### Step 0: Check Project Context
+
+Check if there's an active project for task syncing:
+
+```bash
+cat .claude-active-project 2>/dev/null
+```
+
+If a project is active, include `metadata: { "project": "<project-name>" }` in all TaskCreate calls.
+
+### Step 1: Locate Configuration
+
+Find the test coverage config (jest.config.js, vitest.config.ts, .nycrc, etc.).
+
+### Step 2: Update Thresholds
+
+Set any threshold below $ARGUMENTS% to $ARGUMENTS% (line, branch, function, statement).
+
+### Step 3: Identify Gaps
+
+Run coverage and identify the **20 files** with the lowest coverage.
+
+### Step 4: Create Task List
+
+Create a task for each file needing test coverage, ordered by coverage gap (lowest first).
+
+Each task should have:
+- **subject**: "Add test coverage for [file]" (imperative form)
+- **description**: File path, current coverage %, target threshold, notes about uncovered lines/branches
+- **activeForm**: "Adding tests for [file]" (present continuous)
+- **metadata**: `{ "project": "<active-project>" }` if project context exists
+
+### Step 5: Parallel Execution
+
+Launch **up to 5 sub-agents** using the `test-coverage-agent` subagent to add tests in parallel.
+
+### Step 6: Iterate
+
+Check for remaining pending tasks. Re-run coverage to verify.
+
+If thresholds aren't met, repeat from Step 3.
+
+Continue until all thresholds meet or exceed $ARGUMENTS%.

package/all/copy-overwrite/.claude/commands/project/archive.md

@@ -1,7 +1,7 @@
 ---
 description: Moves a project to the projects/archive directory after it's completed
 argument-hint: <project-directory>
-allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TodoWrite
+allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList
 ---
 
 1. Move $ARGUMENTS to `projects/archive`

package/all/copy-overwrite/.claude/commands/project/complete-task.md

@@ -4,4 +4,56 @@ argument-hint: <task-file>
 ---
 
 1. Read $ARGUMENTS without offset or limit
-2. Follow the instructions literally and specifically
+2. Follow the instructions literally and specifically
+
+## Verification Requirements
+
+**CRITICAL**: Before marking ANY task as complete:
+
+### For JSON Tasks (`.json` files)
+
+If the task file is JSON and contains `metadata.verification`:
+
+1. **Extract verification data**:
+   ```json
+   {
+     "metadata": {
+       "verification": {
+         "type": "manual-check",
+         "command": "the command to run",
+         "expected": "description of expected output"
+       }
+     }
+   }
+   ```
+
+2. **Run the verification command** using Bash tool
+3. **Compare output to expected** - Verify the output matches the `expected` description
+4. **Only mark complete if verification passes**
+
+### For Markdown Tasks (`.md` files)
+
+If the task has a "## Verification" section with "### Proof Command":
+
+1. **Extract the Proof Command** from the markdown
+2. **Run the command** using Bash tool
+3. **Compare output to Expected Output** section
+4. **Only mark complete if verification passes**
+
+### Verification Rules
+
+1. **`manual-check` verification type** - These require actual execution, not just configuration review:
+   - If the check requires Docker and Docker is unavailable → Task is **BLOCKED**, not complete
+   - If the check requires external services → Actually test against them
+   - If the check requires running a command → Run the command and verify output
+2. **Never assume configuration is correct** - Always empirically verify by running the actual tool/service
+3. **If verification cannot be performed**:
+   - Do NOT mark the task as complete
+   - Document the blocker in findings.md
+   - Mark the task status as "blocked: <reason>"
+4. **If verification fails**:
+   - Do NOT mark the task as complete
+   - Fix the issue and re-run verification
+   - Only mark complete when verification passes
+
+The rule "Never make assumptions about whether something worked. Test it empirically to confirm" applies especially to verification tasks.

package/all/copy-overwrite/.claude/commands/project/debrief.md

@@ -1,32 +1,26 @@
 ---
-description: Evaluates findings.md and uses skill-evaluator to decide where each learning belongs (new skill, PROJECT_RULES.md, or omit)
+description: Evaluates findings.md and uses skill-evaluator to decide where each learning belongs (new skill, .claude/rules/PROJECT_RULES.md, or omit)
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, Skill
 ---
 
-## Step 0: MANDATORY SETUP
+## Setup
 
-Use TodoWrite to create workflow tracking todos:
-- Step 1: Read project findings
-- Step 2: Evaluate each finding
-- Step 3: Apply decisions
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "debrief" }`:
 
-⚠️ **CRITICAL**: DO NOT STOP until all 3 todos are marked completed.
+1. Read project findings
+2. Evaluate each finding
+3. Apply decisions
 
 ## Step 1: Read Project Findings
-Mark "Step 1: Read project findings" as in_progress.
 
-Read the `findings.md` file inside $ARGUMENTS FULLY (no limit/offset).
+Read `$ARGUMENTS/findings.md` FULLY (no limit/offset).
 
 Extract each distinct finding/learning as a separate item.
 
-Mark "Step 1: Read project findings" as completed. Proceed to Step 2.
-
 ## Step 2: Evaluate Each Finding
-Mark "Step 2: Evaluate each finding" as in_progress.
-
-For each finding extracted from findings.md:
 
-Use the Task tool with `subagent_type: "skill-evaluator"` to evaluate where (and if) the finding should be recorded:
+For each finding, use the Task tool with `subagent_type: "skill-evaluator"`:
 
 ```
 Evaluate this finding from a project debrief:
@@ -35,30 +29,25 @@ Evaluate this finding from a project debrief:
 
 Determine if this should be:
 1. CREATE SKILL - if it's a complex, reusable pattern
-2. ADD TO RULES - if it's a simple never/always rule for PROJECT_RULES.md
+2. ADD TO RULES - if it's a simple never/always rule for .claude/rules/PROJECT_RULES.md
 3. OMIT ENTIRELY - if it's already covered or too project-specific
 ```
 
 Collect all decisions from the skill-evaluator.
 
-Mark "Step 2: Evaluate each finding" as completed. Proceed to Step 3.
-
 ## Step 3: Apply Decisions
-Mark "Step 3: Apply decisions" as in_progress.
 
 For each finding based on skill-evaluator's decision:
 
 | Decision | Action |
 |----------|--------|
 | CREATE SKILL | Use Task tool: "run /skill-creator with [finding details]" |
-| ADD TO RULES | Add the rule succinctly to @PROJECT_RULES.md |
+| ADD TO RULES | Add the rule succinctly to @.claude/rules/PROJECT_RULES.md |
 | OMIT ENTIRELY | No action needed |
 
-Mark "Step 3: Apply decisions" as completed.
-
 Report summary:
 ```
-📝 Debrief complete:
+Debrief complete:
 - Skills created: [X]
 - Rules added: [Y]
 - Omitted (redundant/narrow): [Z]

package/all/copy-overwrite/.claude/commands/project/execute.md

@@ -1,94 +1,50 @@
 ---
 description: Automated project execution from planning through debrief (requires gap-free research)
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet, Skill
 ---
 
-Execute complete implementation workflow for $ARGUMENTS:
+Execute complete implementation workflow for $ARGUMENTS.
 
-## Step 0: MANDATORY SETUP
+## Execution Rules
 
-### Gap Check
-Read $ARGUMENTS/research.md and locate "## Open Questions" section.
-- If gaps exist: ❌ STOP immediately with "Cannot proceed - research.md has unresolved open questions."
-- If no gaps: ✅ Proceed with setup
+1. **Continuous execution**: After each step completes, immediately invoke the next
+2. **No summaries**: Do not summarize progress between steps
+3. **No waiting**: Do not wait for user confirmation between steps
+4. **Only stop when done**: Only stop when all steps are completed
 
-### Planning Already Complete Check
-Check if planning has already been done:
-1. Check if `$ARGUMENTS/progress.md` exists
-2. Check if `$ARGUMENTS/tasks/` directory exists with task files (task-*.md)
+## Setup
 
-- If BOTH exist: ✅ Planning already complete - skip to "Create Workflow Tracking (Resume Mode)"
-- If either is missing: ✅ Proceed with full workflow
+1. Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+2. Read `$ARGUMENTS/research.md` and check "## Open Questions" section
+   - If gaps exist: STOP with "Cannot proceed - research.md has unresolved open questions"
+3. Check if planning is already complete: `ls $ARGUMENTS/tasks/*.md 2>/dev/null | head -3`
+   - If task files exist: Skip planning, start at implementation
 
-### Create Workflow Tracking (Full Mode)
-Use TodoWrite to create these workflow todos:
-- Step 1: Planning
-- Step 2: Implementation
-- Step 3: Verification
-- Step 4: Debrief
-- Step 5: Archive
+## Workflow Tasks
 
-⚠️ **CRITICAL**: DO NOT STOP until all 5 todos are marked completed.
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "execution" }`:
 
-Proceed to Step 1.
+1. Step 1: Planning
+2. Step 2: Implementation
+3. Step 3: Review
+4. Step 4: Verification
+5. Step 5: Debrief
+6. Step 6: Archive
 
-### Create Workflow Tracking (Resume Mode)
-Use TodoWrite to create these workflow todos (marking Step 1 as already completed):
-- Step 1: Planning ✓ (mark as completed immediately)
-- Step 2: Implementation
-- Step 3: Review
-- Step 4: Verification
-- Step 5: Debrief
-- Step 6: Archive
+## Execution
 
-Report: "📋 Resuming execution - planning already complete with existing progress.md and tasks/"
+Work through each workflow task:
 
-⚠️ **CRITICAL**: DO NOT STOP until all 5 todos are marked completed.
+| Step | Command |
+|------|---------|
+| Planning | `run /project:plan $ARGUMENTS` |
+| Implementation | `run /project:implement $ARGUMENTS` |
+| Review | `run /project:review $ARGUMENTS` |
+| Verification | `run /project:verify $ARGUMENTS` |
+| Debrief | `run /project:debrief $ARGUMENTS` |
+| Archive | `run /project:archive $ARGUMENTS` |
 
-Skip directly to Step 2.
+**CRITICAL**: Use Task tool with subagent for Planning, Implementation, Verification, Debrief, and Archive steps.
 
-## Step 1: Planning
-⚠️ **CRITICAL**: DO NOT STOP use the Plan tool to do this. Use Task tool with prompt: "run /project:plan $ARGUMENTS" as directed below
-
-Mark "Step 1: Planning" as in_progress.
-
-Use Task tool with prompt: "run /project:plan $ARGUMENTS"
-
-Mark "Step 1: Planning" as completed. Proceed to Step 2.
-
-## Step 2: Implementation Loop
-Mark "Step 2: Implementation" as in_progress.
-
-Use Task tool with prompt: "run /project:implement $ARGUMENTS"
-
-Mark "Step 2: Implementation" as completed. Proceed to Step 3.
-
-## Step 3: Review
-Mark "Step 3: Review" as in_progress.
-
-run /project:review $ARGUMENTS
-
-Mark "Step 3: Review" as completed. Proceed to Step 4.
-
-## Step 4: Verification
-Mark "Step 4: Verification" as in_progress.
-
-Use Task tool with prompt: "run /project:verify $ARGUMENTS"
-
-Mark "Step 4: Verification" as completed. Proceed to Step 5.
-
-## Step 5: Debrief
-Mark "Step 5: Debrief" as in_progress.
-
-Use Task tool with prompt: "run /project:debrief $ARGUMENTS"
-
-Mark "Step 5: Debrief" as completed. Proceed to Step 6.
-
-## Step 6: Archive
-Mark "Step 6: Archive" as in_progress.
-
-Use Task tool with prompt: "run /project:archive $ARGUMENTS"
-
-Mark "Step 6: Archive" as completed.
-
-Report: "🎉 Project complete and archived"
+Report "Project complete and archived" when done.

package/all/copy-overwrite/.claude/commands/project/fix-linter-error.md

@@ -0,0 +1,87 @@
+---
+description: Fix all violations of one or more ESLint rules across the codebase
+allowed-tools: Read, Write, Edit, Bash, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+argument-hint: <rule-1> [rule-2] [rule-3] ...
+model: sonnet
+---
+
+# Fix Linter Errors
+
+Target rules: $ARGUMENTS
+
+Parse the arguments as space-separated ESLint rule names. If no arguments provided, prompt the user for at least one lint rule name.
+
+## Setup
+
+Check for active project: `cat .claude-active-project 2>/dev/null`
+
+If active, include `metadata: { "project": "<project-name>" }` in TaskCreate calls.
+
+## Step 1: Parse Rules
+
+Split `$ARGUMENTS` into individual rule names (space-separated).
+
+Example inputs:
+- `sonarjs/cognitive-complexity` → 1 rule
+- `sonarjs/cognitive-complexity @typescript-eslint/no-explicit-any` → 2 rules
+- `react-hooks/exhaustive-deps import/order prefer-const` → 3 rules
+
+## Step 2: Enable Rules
+
+For each rule, find the ESLint config and set it to `"error"` severity if not already enabled. NOTE: Make sure to scan for overrides that need to be changed too. For example eslint.config.local.ts.
+
+## Step 3: Identify Violations
+
+Run linting and collect violations for all target rules:
+
+```bash
+bun run lint 2>&1 | grep -E "(rule-1|rule-2|...)"
+```
+
+Group violations by:
+1. **Rule name** (primary grouping)
+2. **File path** (secondary grouping)
+
+Count violations per file per rule.
+
+## Step 4: Create Tasks
+
+Create tasks organized by rule, then by file:
+
+For each rule:
+- Create a parent task: "Fix all [rule-name] violations ([N] files, [M] total)"
+- Create child tasks for each file with violations, ordered by count (highest first)
+
+Each file task should include:
+- File path and violation count for that specific rule
+- Sample error messages
+- Fix approach based on rule type:
+  - **Complexity rules** (`sonarjs/*`): Extract functions, use early returns, simplify conditions
+  - **Style rules** (`prettier/*`, `import/order`): Apply formatting fixes
+  - **Best practice rules** (`react-hooks/*`, `prefer-const`): Refactor to follow recommended pattern
+  - **Type rules** (`@typescript-eslint/*`): Add proper types, remove `any`
+
+## Step 5: Execute
+
+Process rules sequentially (to avoid conflicts), but parallelize file fixes within each rule:
+
+For each rule:
+1. Launch up to 5 sub-agents to fix files for that rule in parallel
+2. Wait for all files to be fixed
+3. Run `bun run lint` to verify rule is now clean
+4. Commit all fixes for that rule with message: `fix(lint): resolve [rule-name] violations`
+5. Move to next rule
+
+## Step 6: Report
+
+```
+Lint rule fix complete:
+
+| Rule | Files Fixed | Violations Resolved |
+|------|-------------|---------------------|
+| rule-1 | N1 | M1 |
+| rule-2 | N2 | M2 |
+| ... | ... | ... |
+
+Total: [N] files fixed, [M] violations resolved
+```