npm - @codyswann/lisa - Versions diffs - 1.66.3 → 1.67.0 - Mend

@codyswann/lisa 1.66.3 → 1.67.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/plugins/src/base/rules/README.md DELETED Viewed

@@ -1,240 +0,0 @@
-# Claude Code Configuration
-This directory contains Claude Code configuration files that customize AI-assisted development workflows.
-## Directory Structure
-```
-.claude/
-├── settings.json              # Main Claude Code settings
-├── settings.local.json        # Local overrides (gitignored)
-├── settings.local.json.example # Template for local settings
-├── agents/                    # Custom agent definitions
-├── hooks/                     # Automation hooks
-├── rules/                     # Always-on governance rules
-└── skills/                    # Skill definitions (colon-namespaced)
-```
-## Settings
-### Environment Variables
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `BASH_DEFAULT_TIMEOUT_MS` | 1800000 (30 min) | Default timeout for bash commands |
-| `BASH_MAX_TIMEOUT_MS` | 7200000 (2 hours) | Maximum allowed timeout |
-### Hooks
-| Event | Hook | Purpose |
-|-------|------|---------|
-| `SessionStart` | `install-pkgs.sh` | Install dependencies when session starts |
-| `PostToolUse` | `format-on-edit.sh` | Auto-format files after Write/Edit operations |
-| `Notification` | `notify-ntfy.sh` | Send notifications via ntfy.sh |
-| `Stop` | `notify-ntfy.sh` | Notify when session ends |
-## Plugins
-The `enabledPlugins` section in `settings.json` references Claude Code plugins. These extend Claude Code functionality with additional capabilities.
-### Plugin Sources
-| Source | Description | Registration |
-|--------|-------------|--------------|
-| `claude-plugins-official` | Official Anthropic plugins | Built-in, no registration needed |
-| `cc-marketplace` | Community marketplace | Available at [Claude Code Marketplace](https://marketplace.claude.ai) |
-### Enabled Plugins
-| Plugin | Source | Purpose |
-|--------|--------|---------|
-| `typescript-lsp` | `claude-plugins-official` | TypeScript language server integration |
-| `safety-net` | `cc-marketplace` | Backup and safety features |
-| `code-simplifier` | `claude-plugins-official` | Code complexity reduction suggestions |
-| `code-review` | `claude-plugins-official` | Automated code review capabilities |
-| `playwright` | `claude-plugins-official` | Playwright test integration |
-### Installing Plugins
-1. **Official plugins** are available by default in Claude Code
-2. **Marketplace plugins** can be installed via the Claude Code settings UI
-3. **Third-party plugins** require following their installation instructions
-### Plugin Availability
-Not all plugins may be available in all Claude Code installations:
-- Some plugins require specific Claude Code versions
-- Marketplace plugins require marketplace access
-- Enterprise installations may restrict available plugins
-If a plugin is not available, Claude Code will ignore it gracefully.
-## Local Settings Override
-Create `settings.local.json` to override settings for your local environment:
-```json
-{
-  "env": {
-    "CUSTOM_API_KEY": "your-key-here"
-  },
-  "hooks": {
-    "PostToolUse": []
-  },
-  "enabledPlugins": {
-    "playwright": false
-  }
-}
-```
-This file should be:
-- Added to `.gitignore`
-- Never committed to version control
-- Used for machine-specific settings
-## Agents
-Custom agent definitions in `agents/` provide specialized AI personas for different tasks:
-| Agent | Purpose |
-|-------|---------|
-| `agent-architect.md` | Agent file design and optimization |
-| `architecture-specialist.md` | Implementation design, dependency mapping, pattern evaluation |
-| `git-history-analyzer.md` | Git history analysis |
-| `hooks-expert.md` | Claude Code hooks expertise |
-| `implementer.md` | Code implementation with TDD enforcement |
-| `learner.md` | Post-implementation learning and skill creation |
-| `performance-specialist.md` | N+1 queries, algorithmic complexity, memory leaks |
-| `product-specialist.md` | User flows, acceptance criteria, UX validation |
-| `quality-specialist.md` | Code correctness, coding philosophy, test coverage review |
-| `security-specialist.md` | Threat modeling (STRIDE), OWASP Top 10, auth/secrets review |
-| `skill-evaluator.md` | Skill quality assessment |
-| `slash-command-architect.md` | Command design |
-| `test-specialist.md` | Test strategy, test writing, coverage analysis |
-| `web-search-researcher.md` | Web research tasks |
-## Skills
-Skills use colon-namespaced directories (e.g., `plan:create/`) and are invoked via `/skill-name` in Claude Code.
-### Plan Skills
-| Skill | Purpose |
-|-------|---------|
-| `plan:create` | Create implementation plans from ticket URLs, file paths, or text descriptions |
-| `plan:implement` | Execute an existing plan with an Agent Team |
-| `plan:add-test-coverage` | Increase test coverage to a target threshold |
-| `plan:fix-linter-error` | Fix all violations of specific ESLint rules |
-| `plan:local-code-review` | Review local branch changes against main |
-| `plan:lower-code-complexity` | Reduce cognitive complexity threshold |
-| `plan:reduce-max-lines` | Reduce max file lines threshold |
-| `plan:reduce-max-lines-per-function` | Reduce max function lines threshold |
-### Git Skills
-| Skill | Purpose |
-|-------|---------|
-| `git:commit` | Create conventional commits for current changes |
-| `git:commit-and-submit-pr` | Commit changes and create/update a pull request |
-| `git:submit-pr` | Push changes and create or update a pull request |
-| `git:prune` | Prune local branches deleted on remote |
-### Integration Skills
-| Skill | Purpose |
-|-------|---------|
-| `jira:create` | Create JIRA epics, stories, and tasks |
-| `jira:verify` | Verify JIRA ticket meets organizational standards |
-| `jira:sync` | Sync plan progress to linked JIRA tickets |
-| `sonarqube:check` | Check SonarQube/SonarCloud quality gate failures |
-| `sonarqube:fix` | Fix SonarQube quality gate failures |
-| `pull-request:review` | Check and implement PR review comments |
-| `security:zap-scan` | Run OWASP ZAP baseline security scan |
-### Utility Skills
-| Skill | Purpose |
-|-------|---------|
-| `tasks:load` | Load tasks from project directory into session |
-| `tasks:sync` | Export session tasks to project directory |
-| `skill-creator` | Guide for creating new skills |
-| `agent-design-best-practices` | Best practices for designing agent files |
-| `jsdoc-best-practices` | JSDoc documentation standards |
-See each skill's `SKILL.md` for detailed documentation.
-## Customization
-### Adding Custom Skills
-Skills contain implementation logic and use hyphen-separated naming:
-```bash
-mkdir -p .claude/skills/my-namespace-my-skill
-cat > .claude/skills/my-namespace-my-skill/SKILL.md << 'EOF'
----
-name: my-namespace-my-skill
-description: "What this skill does"
----
-# My Skill
-Instructions for the skill...
-EOF
-```
-### Adding Custom Commands
-Commands are user-facing pass-throughs to skills. Directory nesting creates colon-separated names in the UI (e.g., `my-namespace/my-skill.md` becomes `/my-namespace:my-skill`):
-```bash
-mkdir -p .claude/commands/my-namespace
-cat > .claude/commands/my-namespace/my-skill.md << 'EOF'
----
-description: "What this command does"
-allowed-tools: ["Skill"]
-argument-hint: "<arguments>"
----
-Use the /my-namespace-my-skill skill to do the thing. $ARGUMENTS
-EOF
-```
-### Adding Custom Agents
-```bash
-cat > .claude/agents/my-agent.md << 'EOF'
-# My Agent
-## Role
-Specialized for specific tasks...
-## Capabilities
-- Capability 1
-- Capability 2
-## Instructions
-How to behave...
-EOF
-```
-## Troubleshooting
-### Hooks Not Running
-1. Check file permissions: `chmod +x .claude/hooks/*.sh`
-2. Verify `$CLAUDE_PROJECT_DIR` is set correctly
-3. Check hook timeout settings
-### Plugins Not Loading
-1. Verify plugin is installed in your Claude Code installation
-2. Check marketplace access if using marketplace plugins
-3. Review Claude Code logs for plugin errors
-### Skills Not Found
-1. Ensure skill directory contains a `SKILL.md` file with correct frontmatter
-2. Restart Claude Code to reload skills
-3. Check for syntax errors in skill definition

package/plugins/src/base/rules/coding-philosophy.md DELETED Viewed

@@ -1,428 +0,0 @@
-# Coding Philosophy
-This rule enforces the core coding philosophy: **immutability**, **predictable structure**, **functional transformations**, **test-driven development**, **clean deletion**, and **simplicity**.
-## Guiding Principles: YAGNI + SOLID + DRY + KISS
-Follow these software engineering principles, **deferring to Occam's Razor/KISS whenever principles conflict**:
-### KISS (Keep It Simple, Stupid) - The Tiebreaker
-When principles conflict, **always choose the simpler solution**.
-```typescript
-// KISS: Simple direct approach
-const isAdmin = user.role === "admin";
-// Over-engineered: Abstraction without value
-const isAdmin = RoleChecker.getInstance().checkRole(user, RoleTypes.ADMIN);
-```
-### YAGNI (You Ain't Gonna Need It)
-Don't build features, abstractions, or flexibility you don't need **right now**.
-```typescript
-// Correct: Solve today's problem
-const formatDate = (date: Date) => date.toISOString().split("T")[0];
-// Wrong: Building for hypothetical future needs
-const formatDate = (date: Date, format?: string, locale?: string, timezone?: string) => {
-  // 50 lines handling cases that may never be used
-};
-```
-### DRY (Don't Repeat Yourself) - With KISS Constraint
-Extract duplication only when:
-1. The same logic appears **3+ times**
-2. The abstraction is **simpler** than the duplication
-3. The extracted code has a **clear single purpose**
-### SOLID Principles - Applied Pragmatically
-| Principle                 | Apply When                                    | Skip When                               |
-| ------------------------- | --------------------------------------------- | --------------------------------------- |
-| **S**ingle Responsibility | Function does 2+ unrelated things             | Splitting adds complexity               |
-| **O**pen/Closed           | Extension points have clear use cases         | No foreseeable extensions               |
-| **L**iskov Substitution   | Using inheritance hierarchies                 | Using composition (preferred)           |
-| **I**nterface Segregation | Consumers need different subsets              | Interface is already small              |
-| **D**ependency Inversion  | Testing requires mocking external services    | Direct dependency is simpler            |
-### Decision Framework
-When unsure, ask in order:
-1. **Do I need this now?** (YAGNI) - If no, don't build it
-2. **Is there a simpler way?** (KISS) - Choose the simpler option
-3. **Am I repeating myself 3+ times?** (DRY) - Extract if the abstraction is simpler
-4. **Does this function do one thing?** (SOLID-SRP) - Split only if clearer
----
-## Core Principles
-### 1. Immutability First
-Never mutate data. Always create new references.
-```typescript
-// Correct - spread creates new object
-const updated = { ...user, name: "New Name" };
-// Incorrect - mutation
-user.name = "New Name";
-```
-### 2. Function Structure Ordering
-All functions, hooks, and components follow a strict ordering:
-```text
-1. Variable definitions and derived state (const, useState, useMemo, useCallback)
-2. Side effects (useEffect, function calls with no return value)
-3. Return statement
-```
-### 3. Functional Transformations
-Use `map`, `filter`, `reduce` instead of imperative loops and mutations.
-```typescript
-// Correct - functional transformation
-const names = users.map(u => u.name);
-// Incorrect - imperative mutation
-const names = [];
-users.forEach(u => names.push(u.name));
-```
-### 4. Test-Driven Development (TDD)
-**Always write failing tests before implementation code.** This is mandatory, not optional.
-```text
-TDD Cycle:
-1. RED: Write a failing test that defines expected behavior
-2. GREEN: Write the minimum code to make the test pass
-3. REFACTOR: Clean up while keeping tests green
-```
-### 5. Clean Deletion
-**Delete old code completely.** No deprecation warnings, migration shims, or backward-compatibility layers unless explicitly requested.
-```typescript
-// Correct: Remove the old code entirely
-const calculateScore = (player: Player): number => player.stats.overall;
-// Wrong: Keeping deprecated versions around
-/** @deprecated Use calculateScore instead */
-const getPlayerScore = (player: Player): number => calculateScore(player);
-```
-**Clean deletion rules:**
-- When replacing code, delete the old version completely
-- Never create `V2`, `New`, or `Old` suffixed functions/variables
-- Never add `@deprecated` comments - just remove the code
-- Never write migration code unless explicitly asked
-- Trust git history for recovery if needed
----
-## Quick Reference
-### Variable Declaration
-| Pattern | Status    | Example                       |
-| ------- | --------- | ----------------------------- |
-| `const` | Required  | `const value = calculate();`  |
-| `let`   | Forbidden | Use ternary or reduce instead |
-| `var`   | Forbidden | Never use                     |
-### Array Operations
-| Instead of              | Use                                          |
-| ----------------------- | -------------------------------------------- |
-| `arr.push(item)`        | `[...arr, item]`                             |
-| `arr.pop()`             | `arr.slice(0, -1)`                           |
-| `arr.splice(i, 1)`      | `arr.filter((_, idx) => idx !== i)`          |
-| `arr.sort()`            | `[...arr].sort()`                            |
-| `arr[i] = value`        | `arr.map((v, idx) => idx === i ? value : v)` |
-| `forEach` with mutation | `reduce` or `map`                            |
-### Object Operations
-| Instead of                | Use                           |
-| ------------------------- | ----------------------------- |
-| `obj.key = value`         | `{ ...obj, key: value }`      |
-| `delete obj.key`          | `({ key: _, ...rest } = obj)` |
-| `Object.assign(obj, ...)` | `{ ...obj, ...other }`        |
-### Building Lookup Objects
-```typescript
-// Correct - reduce with spread
-const lookup = items.reduce(
-  (acc, item) => ({ ...acc, [item.id]: item }),
-  {} as Record<string, Item>
-);
-// Incorrect - forEach with Map.set
-const lookup = new Map();
-items.forEach(item => lookup.set(item.id, item));
-```
-### Conditional Values
-```typescript
-// Correct - ternary expression
-const status = isComplete ? "done" : "pending";
-// Incorrect - let with reassignment
-let status = "pending";
-if (isComplete) {
-  status = "done";
-}
-```
----
-## Hook Structure Example
-```typescript
-export const usePlayerData = (playerId: string) => {
-  // 1. VARIABLES & STATE (first)
-  const [isLoading, setIsLoading] = useState(true);
-  const { data } = useQuery(GetPlayerDocument, { variables: { playerId } });
-  const playerName = useMemo(() => data?.player?.name ?? "Unknown", [data]);
-  const handleRefresh = useCallback(() => {
-    refetch();
-  }, [refetch]);
-  // 2. SIDE EFFECTS (second)
-  useEffect(() => {
-    console.log("Player loaded:", playerName);
-  }, [playerName]);
-  // 3. RETURN (last)
-  return { playerName, isLoading, handleRefresh };
-};
-```
-## Container Component Example
-```typescript
-const PlayerCardContainer: React.FC<Props> = ({ playerId }) => {
-  // 1. VARIABLES & STATE
-  const { data, loading } = useQuery(GetPlayerDocument, { variables: { playerId } });
-  const { colors } = useTheme();
-  const formattedStats = useMemo(
-    () => data?.stats?.map(s => ({ ...s, display: formatStat(s) })) ?? [],
-    [data?.stats]
-  );
-  const handlePress = useCallback(() => {
-    router.push(`/players/${playerId}`);
-  }, [playerId]);
-  // 2. SIDE EFFECTS (none in this example)
-  // 3. RETURN
-  return (
-    <PlayerCardView
-      stats={formattedStats}
-      colors={colors}
-      loading={loading}
-      onPress={handlePress}
-    />
-  );
-};
-```
-## Utility Function Example
-```typescript
-export const calculateTeamRankings = (
-  players: readonly Player[]
-): readonly TeamRanking[] => {
-  // 1. VARIABLES & DERIVED VALUES
-  const validPlayers = players.filter(p => p.team && p.score != null);
-  const teamScores = validPlayers.reduce(
-    (acc, player) => ({
-      ...acc,
-      [player.team.id]: {
-        teamId: player.team.id,
-        totalScore: (acc[player.team.id]?.totalScore ?? 0) + player.score,
-        count: (acc[player.team.id]?.count ?? 0) + 1,
-      },
-    }),
-    {} as Record<string, { teamId: string; totalScore: number; count: number }>
-  );
-  const rankings = Object.values(teamScores).map(t => ({
-    teamId: t.teamId,
-    avgScore: t.totalScore / t.count,
-  }));
-  const sorted = [...rankings].sort((a, b) => b.avgScore - a.avgScore);
-  // 2. NO SIDE EFFECTS IN PURE FUNCTIONS
-  // 3. RETURN
-  return sorted;
-};
-```
----
-## Anti-Patterns to Avoid
-### Never use `let` for conditional assignment
-```typescript
-// Wrong
-let result;
-if (condition) {
-  result = valueA;
-} else {
-  result = valueB;
-}
-// Correct
-const result = condition ? valueA : valueB;
-```
-### Never mutate arrays
-```typescript
-// Wrong
-const items = [];
-data.forEach(d => items.push(transform(d)));
-// Correct
-const items = data.map(d => transform(d));
-```
-### Never use Map when Record suffices
-```typescript
-// Wrong
-const lookup = new Map<string, User>();
-users.forEach(u => lookup.set(u.id, u));
-const user = lookup.get(userId);
-// Correct
-const lookup = users.reduce(
-  (acc, u) => ({ ...acc, [u.id]: u }),
-  {} as Record<string, User>
-);
-const user = lookup[userId];
-```
-### Never sort in place
-```typescript
-// Wrong - mutates original
-const sorted = items.sort((a, b) => a.value - b.value);
-// Correct - creates new array
-const sorted = [...items].sort((a, b) => a.value - b.value);
-```
-### Never place useEffect before variable definitions
-```typescript
-// Wrong
-useEffect(() => {
-  /* ... */
-}, [value]);
-const value = useMemo(() => calculate(), [dep]);
-// Correct
-const value = useMemo(() => calculate(), [dep]);
-useEffect(() => {
-  /* ... */
-}, [value]);
-```
----
-## Immutable Patterns Reference
-### Building Lookup Objects with Reduce
-```typescript
-const colorMap =
-  edges?.reduce(
-    (acc, edge) => (edge.color ? { ...acc, [edge.tagId]: edge.color } : acc),
-    {} as Record<string, string>
-  ) ?? {};
-```
-### Accumulating Multiple Properties
-```typescript
-const teamGprAccumulator = validPlayers.reduce(
-  (acc, player) => {
-    const teamId = player.team?.id;
-    if (!teamId) return acc;
-    const existing = acc[teamId];
-    return {
-      ...acc,
-      [teamId]: {
-        teamId,
-        teamName: player.team.name,
-        gprSum: (existing?.gprSum ?? 0) + player.gpr,
-        playerCount: (existing?.playerCount ?? 0) + 1,
-      },
-    };
-  },
-  {} as Record<string, { teamId: string; teamName: string; gprSum: number; playerCount: number }>
-);
-```
-### Nested Object Updates
-```typescript
-const updated = {
-  ...state,
-  user: {
-    ...state.user,
-    profile: {
-      ...state.user.profile,
-      avatar: newAvatar,
-    },
-  },
-};
-```
-### Conditional Property Addition
-```typescript
-const result = {
-  ...baseObj,
-  ...(condition && { optionalProp: value }),
-};
-```
-### Ternary Chain for Multiple Conditions
-```typescript
-const priority = score > 90 ? "high" : score > 70 ? "medium" : "low";
-```
-### Readonly Types for Function Parameters
-```typescript
-export const calculateTeamGprRank = (
-  leaguePlayers: readonly (PlayerWithScores | null | undefined)[],
-  myTeamId: string | null | undefined
-): number | null => {
-  // ...
-};
-```