@codyswann/lisa 1.0.0 → 1.0.5

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

@@ -1,42 +1,38 @@
 ---
 description: Systematically implements all tasks in a specified project
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet, Skill
 ---
 
-### Get Task State
+## Setup
 
-Read $ARGUMENTS/progress.md
+1. Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+2. Extract `<project-name>` from the last segment of `$ARGUMENTS`
+3. Use **TaskList** to verify tasks exist for this project (check metadata.project)
+4. If no tasks found, error: "No tasks found. Run /project:plan first"
 
-If the file does not exist or is empty, report an error: "Error: $ARGUMENTS/progress.md not found or empty. Run /project:plan first to create the task list."
+## Implementation
 
-If the file contains no task items (checkbox items), report an error: "Error: No tasks found in $ARGUMENTS/progress.md. The file should contain markdown checklist items."
+Use **TaskList** to get current task status.
 
-Count tasks: total=X, completed=Y, remaining=X-Y
+For each pending, unblocked task (filter by `metadata.project` = `<project-name>`):
 
-### Create Workflow Tracking for all tasks
-Use TodoWrite to create workflow todos for each task using the following format:
-- Step <task-number>: <task-name>
+1. Use **TaskUpdate** to mark it `in_progress`
+2. Use **TaskGet** to retrieve full task details (description contains all instructions)
+3. Launch a subagent to complete the task:
+   - Pass the task's full description (includes skills to invoke, verification, etc.)
+   - Subagent should follow the instructions in the description
+   - Subagent runs the verification command and confirms expected output
+4. When subagent completes successfully, use **TaskUpdate** to mark it `completed`
+5. If verification fails, keep task `in_progress` and report the failure
+6. Check **TaskList** for newly unblocked tasks
 
-### Sync with progress file
+Continue until all tasks are completed.
 
-If any of the tasks are marked as completed in $ARGUMENTS/progress.md, mark them as completed in the Workflow Tracking
+## Complete
 
-If any of the tasks are marked as in_progress in $ARGUMENTS/progress.md, mark them as in_progress in the Workflow Tracking
+Use **TaskList** to generate a summary showing:
+- Total tasks completed
+- Any tasks that failed or remain in progress
 
-### Complete the outstanding Workflow items
-
-Work on the non-completed tasks in sequence
-
-⚠️ **CRITICAL**: DO NOT STOP until all todos are marked completed.
-
-For each non-completed task:
-
-1. mark the task as in_progress in $ARGUMENTS/progress.md
-2. mark the task as in_progress in Workflow Tracking
-3. Use Task tool with subagent_type "general-purpose" and prompt: "run /project:complete-task <task-markdown-file>"
-4. Wait for the subagent to finish the task
-5. After subagent finishes with the task, mark the task as completed in $ARGUMENTS/progress.md
-6. After subagent finishes with the task, mark the task as completed in Workflow Tracking
-7. CRITICAL. DO NOT STOP. Move on to the next non-completed task
-
-Repeat until all tasks are marked completed
+Suggest running `/project:review`.

package/all/copy-overwrite/.claude/commands/project/lower-code-complexity.md

@@ -1,74 +1,49 @@
 ---
 description: Reduces the code complexity of the codebase by 2 on each run
-allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TodoWrite
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
 ---
 
-## Step 0: MANDATORY SETUP
+## Setup
 
-Create workflow tracking todos:
-- Step 1: Lower complexity threshold
-- Step 2: Run lint
-- Step 3: Save spec file
-- Step 4: Bootstrap project
-- Step 5: Resolve questions
-- Step 6: Execute project
+Check for active project: `cat .claude-active-project 2>/dev/null`
 
-⚠️ **CRITICAL**: DO NOT STOP until all 7 todos are marked completed.
+If active, include `metadata: { "project": "<project-name>" }` in TaskCreate calls.
 
-## Step 1: Lower Complexity Threshold
-Mark "Step 1: Lower complexity threshold" as in_progress.
+## Step 1: Lower Threshold
 
-In @eslint.config.mjs, lower the active cognitive complexity rule by two.
-Save the file.
+1. Read the eslint config to find the current `cognitive-complexity` threshold
+2. Lower the threshold by 2 (e.g., 15 → 13)
 
-Mark "Step 1: Lower complexity threshold" as completed. Proceed to Step 2.
+## Step 2: Identify Violations
 
-## Step 2: Run Lint
-Mark "Step 2: Run lint" as in_progress.
+Run lint to find all cognitive complexity violations. Note file path, function name, and complexity score.
 
-Run the lint command from @package.json.
+If no violations, report success and exit.
 
-Mark "Step 2: Run lint" as completed. Proceed to Step 3.
+## Step 3: Create Tasks
 
-## Step 3: Save Spec File
-Mark "Step 3: Save spec file" as in_progress.
+Create a task for each function needing refactoring, ordered by complexity score (highest first).
 
-Save the output of the lint command to `specs/reduce-cognitive-complexity.md` along with the following instructions:
+Each task should include:
+- File path and function name
+- Current complexity score and target threshold
+- Refactoring strategies:
+  - **Extract functions**: Break complex logic into smaller, named functions
+  - **Early returns**: Reduce nesting with guard clauses
+  - **Extract conditions**: Move complex boolean logic into named variables
+  - **Use lookup tables**: Replace complex switch/if-else chains with object maps
 
-```text
+## Step 4: Execute
 
-Refactor the <files> to adhere to the cognitive complexity rule.
+Launch up to 5 sub-agents using `code-simplifier` to refactor in parallel.
 
-Common Solutions
+Work through all tasks until complete.
 
-1. Extract functions: Break complex logic into smaller, named functions
-2. Early returns: Reduce nesting with guard clauses
-3. Extract conditions: Move complex boolean logic into named variables
-4. Use lookup tables: Replace complex switch/if-else chains
-5. Break larger components into smaller components with their own View/Container pattern
-```
-
-Mark "Step 3: Save spec file" as completed. Proceed to Step 4.
-
-## Step 4: Bootstrap Project
-Mark "Step 4: Bootstrap project" as in_progress.
-
-Run /project:bootstrap @specs/reduce-cognitive-complexity.md
-
-Mark "Step 4: Bootstrap project" as completed. Proceed to Step 5.
-
-## Step 5: Resolve Questions
-Mark "Step 5: Resolve questions" as in_progress.
-
-Answer any unresolved questions in the new project's `research.md` file.
+## Step 5: Report
 
-Mark "Step 5: Resolve questions" as completed. Proceed to Step 6.
-
-## Step 6: Execute Project
-Mark "Step 6: Execute project" as in_progress.
-
-Run /project:execute [project-dir] where [project-dir] is the directory created from Step 4.
-
-Mark "Step 6: Execute project" as completed.
-
-Report: "🎉 Code complexity reduction complete"
+```
+Code complexity reduction complete:
+- Previous threshold: [X]
+- New threshold: [Y]
+- Functions simplified: [list]
+```

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

@@ -1,314 +1,159 @@
 ---
 description: Uses the research.md and brief.md file in the specified directory to create a detailed list of tasks to implement the project
 argument-hint: <project-directory>
+allowed-tools: Read, Bash, Glob, Grep, TaskCreate, TaskUpdate, TaskList, Skill
 ---
 
-## Step 0: MANDATORY SETUP
+## Setup
 
-Use TodoWrite to create workflow tracking todos:
-- Step 1: Read project files
-- Step 2: Validate research
-- Step 3: Discover skills
-- Step 4: Create task list
-- Step 5: Create task files
-- Step 6: Commit plan
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
 
-⚠️ **CRITICAL**: DO NOT STOP until all 6 todos are marked completed.
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
 
 ## Step 1: Read Project Files
-Mark "Step 1: Read project files" as in_progress.
 
-1. Read the `brief.md` file inside $ARGUMENTS FULLY (no limit/offset)
-2. Read the `research.md` file inside $ARGUMENTS FULLY (no limit/offset)
-
-Mark "Step 1: Read project files" as completed. Proceed to Step 2.
+Read `$ARGUMENTS/brief.md` and `$ARGUMENTS/research.md` FULLY (no limit/offset).
 
 ## Step 2: Validate Research
-Mark "Step 2: Validate research" as in_progress.
 
-**VALIDATE RESEARCH COMPLETENESS**:
-- Locate the "## Open Questions" section in the research.md file you just read
-- Examine the content under this section carefully
+Locate "## Open Questions" in research.md.
+
+**Valid states** (proceed):
+- Section contains "None", "[None identified]", "N/A", or is empty
+- Section doesn't exist
+- All `**Answer**:` fields are filled
 
-**VALID STATES** (proceed to Step 3):
-✅ Section contains "None", "[None identified]", "N/A", or is empty
-✅ Section doesn't exist at all
-✅ Section contains questions BUT all `**Answer**:` fields are filled (not empty, not placeholder text like "_[Human fills this in]_")
+**Invalid state** (stop immediately):
+- Questions with unfilled `**Answer**:` fields
 
-**INVALID STATE** (stop immediately):
-❌ Section contains questions with unfilled `**Answer**:` fields (empty or placeholder text)
-❌ Section contains unstructured questions without Answer fields
-- If INVALID state is detected, **STOP IMMEDIATELY** and report:
+If invalid, report:
+```
+CANNOT PROCEED WITH PLANNING
 
-  ```
-  ❌ CANNOT PROCEED WITH PLANNING
+The research.md file has unanswered open questions.
 
-  The research.md file has unanswered open questions that must be addressed before planning can begin.
+Unanswered Questions Found:
+[List each question]
 
-  Unanswered Questions Found:
-  [List each question title and its Question field]
+Action Required:
+1. Review $ARGUMENTS/research.md "## Open Questions"
+2. Fill in the **Answer**: field for each question
+3. Re-run /project:plan
+```
 
-  Action Required:
-  1. Review $ARGUMENTS/research.md "## Open Questions" section
-  2. Fill in the **Answer**: field for each question
-  3. Re-run /project:plan
+**IMPORTANT**: NEVER modify research.md during validation.
 
-  Planning has been aborted.
-  ```
+## Step 3: Discover Skills
 
-**IMPORTANT**: NEVER modify, delete, or replace any existing sections in research.md during validation.
-Only READ and VALIDATE. The research.md file is a historical record and must be preserved as-is.
+Read `.claude/skills/*/SKILL.md` files (first 10 lines each) to map skills to applicable tasks.
 
-Mark "Step 2: Validate research" as completed. Proceed to Step 3.
+## Step 4: Create Tasks
 
-## Step 3: Discover Skills
-Mark "Step 3: Discover skills" as in_progress.
+### Determine Task List
 
-**DISCOVER APPLICABLE SKILLS**:
-- Read all skill descriptions by examining `.claude/skills/*/SKILL.md` files (read only the frontmatter description, first 10 lines of each)
-- For each skill, determine if it applies to ANY task in this project based on brief.md requirements
-- Create a mental map of: skill name → when it applies (e.g., "container-view-pattern → when creating React components")
-- You will use this mapping in Step 5 to annotate each task with its applicable skills
+Each task must be small enough to have a **single, specific verification**.
+- Ask: "Can I prove this task is done with ONE command or check?"
+- Exception: `ui-recording` tasks may verify per-platform (web/iOS/Android)
 
-Mark "Step 3: Discover skills" as completed. Proceed to Step 4.
+**Properly-sized tasks:**
+- "Add logout button to header" → single Playwright test
+- "Add unit tests for UserService" → single coverage command
+- "Create API endpoint for user profile" → single curl command
 
-## Step 4: Create Task List
-Mark "Step 4: Create task list" as in_progress.
+**Too large (split these):**
+- "Build authentication system" → split into login, logout, session, etc.
+- "Add user management feature" → split into list, create, edit, etc.
 
-1. Determine a list of tasks required to complete the project
-2. **CRITICAL: Each task must be small enough to have a single, specific verification**
-   - If a task would require multiple verifications, split it into smaller tasks
-   - Ask: "Can I prove this task is done with ONE command or check?"
-   - **Exception for multi-platform UI recordings**: Tasks with `ui-recording` verification may have one proof command per platform (web/iOS/Android) since the same UI feature must be verified on each target platform
-   - Examples of properly-sized tasks:
-     - ✅ "Add logout button to header" → single Playwright test verifies button exists and works
-     - ✅ "Add unit tests for UserService" → single coverage command shows UserService coverage
-     - ✅ "Create API endpoint for user profile" → single curl command returns expected response
-     - ❌ "Build authentication system" → too large, needs multiple verifications (split into login, logout, session, etc.)
-     - ❌ "Add user management feature" → too large (split into list users, create user, edit user, etc.)
-3. Write that list of tasks to `progress.md` inside $ARGUMENTS
+### Create Tasks with TaskCreate
 
-Mark "Step 4: Create task list" as completed. Proceed to Step 5.
+For each task, use **TaskCreate** with:
 
-## Step 5: Create Task Files
-Mark "Step 5: Create task files" as in_progress.
+**subject**: Task name in imperative form (e.g., "Add logout button to header")
 
-For each task in `progress.md`, create a new file called `tasks/000<step-number>-<task-name>.md`
+**activeForm**: Present continuous form (e.g., "Adding logout button to header")
 
-**For each task, create a file using this template:**
+**description**: Full task specification in markdown:
 
 ```markdown
-# Task: [Task Name]
-
 **Type:** Bug | Task | Epic | Story
-**Parent:** [Parent Task Name, or "None"]
 
 ## Description
-
-[Write a clear description based on task type:
-- **Bug**: Describe the bug, symptoms, and root cause analysis approach
-- **Story**: Use Gherkin BDD format (Given/When/Then)
-- **Task**: Straightforward description with clear goal
-- **Epic**: Goal overview with list of sub-tasks]
+[Clear description based on type:
+- Bug: Symptoms, root cause approach
+- Story: Gherkin BDD format (Given/When/Then)
+- Task: Straightforward with clear goal
+- Epic: Goal overview with sub-tasks]
 
 ## Acceptance Criteria
-
-[Specific, testable criteria that define "done" for this task]
-
 - [ ] Criterion 1
 - [ ] Criterion 2
-- [ ] Criterion 3
 
 ## Relevant Research
+[Extract from research.md: code references, patterns, architecture constraints]
 
-[Extract and summarize relevant sections from research.md, including:
-- Code references (file:line) that will be modified or referenced
-- Patterns to follow from the codebase
-- Architecture constraints that apply
-- Any resolved questions that affect this task]
-
-## Applicable Skills
-
-Invoke these skills before writing implementation code:
-
-- `/coding-philosophy` - Always required for all code
-- [Add other skills from Step 3 that apply to THIS SPECIFIC task]
+## Skills to Invoke
+- `/coding-philosophy` - Always required
+- [Other applicable skills from Step 3]
 
 ## Implementation Details
-
-[Specific implementation guidance:
-- Files to create or modify
-- Functions/classes to implement
-- Integration points with existing code
-- Edge cases to handle]
+[Files to modify, functions to implement, edge cases]
 
 ## Testing Requirements
-
 ### Unit Tests
-[List specific unit tests required. Reference patterns from research.md]
-
-- [ ] `describe('X')/it('should Y')`: Test description
-- [ ] `describe('X')/it('should Y')`: Test description
+- [ ] `describe('X')/it('should Y')`: Description
 
 ### Integration Tests
-[List integration tests required, or "N/A - no integration points"]
-
-- [ ] Test description
+[Or "N/A - no integration points"]
 
 ### E2E Tests
-[List e2e tests required, or "N/A - no user-facing changes"]
-
-- [ ] Test scenario description
-
-## Documentation Requirements
-
-### Code Documentation (JSDoc)
-[List functions/types needing JSDoc, or "N/A"]
-
-- [ ] `functionName` - @param, @returns, @throws
-- [ ] `TypeName` - @description
-
-### Database Comments
-[List tables/columns needing comments, or "N/A - no database changes"]
-
-- [ ] `table.column` - purpose description
-
-### GraphQL Descriptions
-[List types/fields needing descriptions, or "N/A - no GraphQL changes"]
-
-- [ ] `Type.field` - purpose description
+[Or "N/A - no user-facing changes"]
 
 ## Verification
+**Type:** `ui-recording` | `test-coverage` | `api-test` | `manual-check` | `documentation`
 
-### Type
-[One of: `ui-recording` | `test-coverage` | `api-test` | `manual-check` | `documentation`]
-
-### Proof Command
+**Proof Command:**
 ```bash
-[Single command to verify task completion - must be specific to THIS task]
+[Single command to verify completion]
 ```
 
-<!-- For ui-recording on multi-platform apps, provide one command per platform:
-#### Web
-```bash
-bun run playwright:test e2e/feature.spec.ts --grep "specific test" --trace on
+**Expected Output:**
+[What success looks like]
 ```
 
-#### iOS
-```bash
-maestro test .maestro/flows/feature-test.yaml --platform ios
+**metadata**:
+```json
+{
+  "project": "<project-name>",
+  "type": "bug|task|epic|story",
+  "skills": ["/coding-philosophy", ...],
+  "verification": {
+    "type": "test-coverage|ui-recording|api-test|manual-check|documentation",
+    "command": "the proof command",
+    "expected": "what success looks like"
+  }
+}
 ```
 
-#### Android
-```bash
-maestro test .maestro/flows/feature-test.yaml --platform android
-```
--->
+### Set Up Dependencies
 
-<!-- For api-test, create a documented bash script at scripts/verify/<task-name>.sh:
-- Script must support -h and --help flags with usage documentation
-- Script must handle authentication if required
-- Script must return exit code 0 on success, non-zero on failure
-- Script must output clear success/failure message
-
-Example:
-```bash
-./scripts/verify/user-profile-api.sh --help
-./scripts/verify/user-profile-api.sh
-```
--->
-
-### Expected Output
-[What the proof command output should show to confirm success]
-
-## Implementation Steps
-
-### Step 0: Setup Tracking
-Use TodoWrite to create task tracking todos:
-- Invoke skills
-- Write failing tests
-- Write implementation
-- Verify implementation
-- Update documentation
-- Commit changes
-
-⚠️ **CRITICAL**: DO NOT STOP until all todos are marked completed.
-
-### Step 1: Invoke Skills
-Mark "Invoke skills" as in_progress.
-
-1. Mark this task as "in progress" in `progress.md`
-2. Invoke each skill listed in "Applicable Skills" using the Skill tool
-
-Mark "Invoke skills" as completed.
-
-### Step 2: Write Failing Tests
-Mark "Write failing tests" as in_progress.
-
-1. Write unit tests based on Testing Requirements
-2. Write integration tests based on Testing Requirements
-3. Run tests to confirm they fail (TDD)
-
-Mark "Write failing tests" as completed.
-
-### Step 3: Write Implementation
-Mark "Write implementation" as in_progress.
-
-Implement code following Implementation Details until tests pass.
-
-Mark "Write implementation" as completed.
-
-### Step 4: Verify Implementation
-Mark "Verify implementation" as in_progress.
-
-1. Run the Proof Command from Verification section
-2. Confirm output matches Expected Output
-3. If verification fails, fix and re-verify
-
-Mark "Verify implementation" as completed.
-
-### Step 5: Update Documentation
-Mark "Update documentation" as in_progress.
-
-Complete all items in Documentation Requirements section.
-
-Mark "Update documentation" as completed.
-
-### Step 6: Commit Changes
-Mark "Commit changes" as in_progress.
-
-1. Run `/git:commit`
-2. Mark this task as "completed" in `progress.md`
-3. Record any learnings in `findings.md`
-
-Mark "Commit changes" as completed.
-```
-
----
+After creating all tasks, use **TaskUpdate** with `addBlockedBy` to establish task order where needed.
 
 **Verification Type Reference:**
 
-| Type | When to Use | Example Command |
-|------|-------------|-----------------|
-| `ui-recording` | UI/UX changes visible to users | Web: `bun run playwright:test ...`, iOS/Android: `maestro test ...` |
-| `test-coverage` | New code with tests | `bun run test:cov -- --collectCoverageFrom='src/path/to/file.ts'` |
-| `api-test` | New API endpoints | `./scripts/verify/<task-name>.sh` (documented script with -h/--help) |
-| `documentation` | Docs, README updates | `cat path/to/doc.md` |
-| `manual-check` | Config, setup, infrastructure | Command showing the config/state exists |
+| Type | When to Use | Example |
+|------|-------------|---------|
+| `ui-recording` | UI/UX changes | `bun run playwright:test ...` |
+| `test-coverage` | New code with tests | `bun run test:cov -- --collectCoverageFrom='...'` |
+| `api-test` | New API endpoints | `./scripts/verify/<task-name>.sh` |
+| `documentation` | Docs, README | `cat path/to/doc.md` |
+| `manual-check` | Config, setup | Command showing config exists |
 
-Mark "Step 5: Create task files" as completed. Proceed to Step 6.
+## Step 5: Report
 
-## Step 6: Commit Plan
-Mark "Step 6: Commit plan" as in_progress.
+Report: "Planning complete - X tasks created for project <project-name>"
 
-Run /git:commit
-
-Mark "Step 6: Commit plan" as completed.
-
-Report: "📋 Planning complete - X tasks created"
+Use **TaskList** to show the created tasks.
 
 ---
 
-IMPORTANT: Each task should contain all the necessary information from `brief.md` and `research.md` and any other support files necessary to complete the task in isolation. Tasks should be completely independent of one another and be as small in scope as possible.
-
-IMPORTANT: If, at the end of a task, the pre-commit blocks you because it is dependent on another task, complete the other task first and then commit.
+**IMPORTANT**: Each task description should contain all necessary information from `brief.md` and `research.md` to complete in isolation. Tasks should be independent and as small in scope as possible.

package/all/copy-overwrite/.claude/commands/project/reduce-max-lines-per-function.md

@@ -0,0 +1,76 @@
+---
+description: Reduce max lines per function threshold and fix violations
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+argument-hint: <max-lines-per-function-value>
+model: sonnet
+---
+
+# Reduce Max Lines Per Function
+
+Target threshold: $ARGUMENTS lines per function
+
+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
+
+Read the eslint thresholds config (`eslint.thresholds.json` or similar).
+
+### Step 2: Update Threshold
+
+Set the `maxLinesPerFunction` threshold to $ARGUMENTS (e.g., `"maxLinesPerFunction": $ARGUMENTS`).
+
+### Step 3: Identify Violations
+
+Run lint to find all functions exceeding the new threshold. Note file path, function name, and current line count.
+
+If no violations, report success and exit.
+
+### Step 4: Create Task List
+
+Create a task for each function needing refactoring, ordered by line count (highest first).
+
+Each task should have:
+- **subject**: "Reduce lines in [function-name]" (imperative form)
+- **description**: File path and line number, function name, current line count, target threshold, refactoring strategies
+- **activeForm**: "Reducing lines in [function-name]" (present continuous)
+- **metadata**: `{ "project": "<active-project>" }` if project context exists
+
+Refactoring strategies:
+- **Extract functions**: Break function into smaller named functions
+- **Early returns**: Reduce nesting with guard clauses
+- **Extract conditions**: Move complex boolean logic into named variables
+- **Use lookup tables**: Replace complex switch/if-else chains with object maps
+- **Consolidate logic**: Merge similar code paths
+
+### Step 5: Parallel Execution
+
+Launch **up to 5 sub-agents** using the `code-simplifier` subagent to refactor in parallel.
+
+### Step 6: Iterate
+
+Check for remaining pending tasks. Re-run lint to verify.
+
+If violations remain, repeat from Step 3.
+
+Continue until all functions meet or are under $ARGUMENTS lines.
+
+### Step 7: Report
+
+```
+Max lines per function reduction complete:
+- Target threshold: $ARGUMENTS
+- Functions refactored: [count]
+- Functions reduced: [list with line counts]
+```