claude-code-starter 0.0.1

package/.claude/commands/analyze.md

@@ -0,0 +1,49 @@
+---
+name: analyze
+description: Deep analysis of a specific area
+arguments:
+  - name: area
+    description: The area or topic to analyze
+    required: true
+---
+
+# /analyze - Deep Analysis
+
+Analyze a specific area of the codebase.
+
+## Instructions
+
+1. **Determine scope**
+   What does the user want analyzed?
+   - A file or directory
+   - A feature or system
+   - A bug or issue
+   - Architecture question
+
+2. **Gather context**
+   - Find relevant files
+   - Read key code sections
+   - Check related tests
+   - Look at dependencies
+
+3. **Analyze by type:**
+
+   **Code Analysis**
+   - Structure and organization
+   - Dependencies and data flow
+   - Patterns used
+   - Potential issues
+
+   **Bug Analysis**
+   - Reproduce the issue
+   - Trace the code path
+   - Identify root cause
+   - Suggest fixes
+
+   **Architecture Analysis**
+   - Component relationships
+   - Data flow
+   - External dependencies
+
+4. **Report findings**
+   Provide clear, actionable insights with `file:line` references.

package/.claude/commands/done.md

@@ -0,0 +1,44 @@
+---
+name: done
+description: Mark current task complete
+---
+
+# /done - Mark Task Complete
+
+Finish the current task.
+
+## Instructions
+
+1. **Verify completion**
+   - Did tests pass (if applicable)?
+   - Was the objective achieved?
+   - Any follow-up items?
+
+2. **Update task.md:**
+
+```markdown
+# Current Task
+
+## Status: Completed
+
+**Task:** [completed task description]
+
+## Summary
+
+[What was accomplished]
+
+## Files Changed
+
+- [list of modified files]
+
+## Follow-up
+
+- [Any items for future tasks, or "None"]
+
+## Decisions
+
+[Key decisions that were made]
+```
+
+3. **Confirm to user**
+   Report completion and any follow-up items.

package/.claude/commands/status.md

@@ -0,0 +1,36 @@
+---
+name: status
+description: Show current task and session state
+---
+
+# /status - Show Current State
+
+Show what you're working on.
+
+## Instructions
+
+1. **Read state**
+   - `.claude/state/task.md`
+
+2. **Report:**
+
+```
+## Current Status
+
+**Task:** [task name or "None"]
+**Status:** [In Progress / Completed / Ready]
+
+### Progress
+[Summary of what's done vs remaining]
+
+### Decisions Made
+[Key decisions, if any]
+
+### Next Steps
+[What should happen next]
+```
+
+3. **Suggest actions**
+   - If no task: suggest `/task`
+   - If complete: suggest `/done`
+   - If stuck: suggest next steps

package/.claude/commands/task.md

@@ -0,0 +1,53 @@
+---
+name: task
+description: Start or switch to a new task
+arguments:
+  - name: description
+    description: What you want to work on
+    required: true
+---
+
+# /task - Start or Switch Task
+
+Start a new task or switch focus.
+
+## Instructions
+
+1. **Check current state**
+   - Read `.claude/state/task.md`
+   - If task in progress, ask if user wants to save progress first
+
+2. **Update task.md with:**
+
+```markdown
+# Current Task
+
+## Status: In Progress
+
+**Task:** [user's description]
+
+## Context
+
+[Brief context about what this involves]
+
+## Next Steps
+
+1. [First step]
+2. [Second step]
+3. ...
+
+## Decisions
+
+(None yet)
+```
+
+3. **Confirm and start**
+   Tell user the task is set and begin working on it.
+
+## Example
+
+```
+/task Add user authentication
+```
+
+Creates a new task and begins planning/implementation.

package/.claude/settings.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://claude.ai/schemas/claude-code-settings.json",
+  "permissions": {
+    "allow": [
+      "Read(**)",
+      "Edit(**)",
+      "Write(.claude/**)",
+      "Bash(git:*)",
+      "Bash(npm:*)",
+      "Bash(yarn:*)",
+      "Bash(pnpm:*)",
+      "Bash(bun:*)",
+      "Bash(node:*)",
+      "Bash(npx:*)",
+      "Bash(tsc:*)",
+      "Bash(jest:*)",
+      "Bash(vitest:*)",
+      "Bash(eslint:*)",
+      "Bash(prettier:*)",
+      "Bash(python:*)",
+      "Bash(pip:*)",
+      "Bash(cargo:*)",
+      "Bash(go:*)",
+      "Bash(make:*)",
+      "Bash(docker:*)",
+      "Bash(ls:*)",
+      "Bash(mkdir:*)",
+      "Bash(cat:*)",
+      "Bash(echo:*)"
+    ],
+    "deny": []
+  }
+}

package/.claude/skills/pattern-discovery.md

@@ -0,0 +1,67 @@
+---
+name: pattern-discovery
+description: Analyze existing codebase to discover and document patterns
+globs: ["src/**/*", "lib/**/*", "app/**/*", "components/**/*", "pages/**/*", "api/**/*", "services/**/*", "utils/**/*", "helpers/**/*"]
+---
+
+# Pattern Discovery
+
+When starting work on a project, analyze the existing code to understand its patterns.
+
+## Discovery Process
+
+### 1. Check for Existing Documentation
+```
+Look for:
+- README.md, CONTRIBUTING.md
+- docs/ folder
+- Code comments and JSDoc/TSDoc
+- .editorconfig, .prettierrc, eslint config
+```
+
+### 2. Analyze Project Structure
+```
+Questions to answer:
+- How are files organized? (by feature, by type, flat?)
+- Where does business logic live?
+- Where are tests located?
+- How are configs managed?
+```
+
+### 3. Detect Code Patterns
+```
+Look at 3-5 similar files to find:
+- Naming conventions (camelCase, snake_case, PascalCase)
+- Import organization (grouped? sorted? relative vs absolute?)
+- Export style (named, default, barrel files?)
+- Error handling approach
+- Logging patterns
+- Comment style
+```
+
+### 4. Identify Architecture
+```
+Common patterns to detect:
+- MVC / MVVM / Clean Architecture
+- Repository pattern
+- Service layer
+- Dependency injection
+- Event-driven
+- Functional vs OOP
+```
+
+## When No Code Exists
+
+If starting a new project:
+
+1. Ask about preferred patterns
+2. Check package.json/config files for framework hints
+3. Use sensible defaults for detected stack
+4. Document decisions in `.claude/state/task.md`
+
+## Important
+
+- **Match existing patterns** - don't impose new ones
+- **When in doubt, check similar files** in the codebase
+- **Document as you discover** - note patterns in task state
+- **Ask if unclear** - better to ask than assume

package/.claude/skills/systematic-debugging.md

@@ -0,0 +1,119 @@
+---
+name: systematic-debugging
+description: Language-agnostic debugging methodology
+globs: ["**/*.log", "**/error*", "**/debug*", "**/logs/**/*", "src/**/*", "lib/**/*", "app/**/*"]
+---
+
+# Systematic Debugging
+
+A 4-phase approach that works for any language or framework.
+
+## Phase 1: Reproduce
+
+**Goal**: Reliably trigger the bug.
+
+1. Get exact steps from user/logs
+2. Note the environment (versions, OS, configs)
+3. Determine if consistent or intermittent
+4. Find minimal reproduction case
+
+```
+Questions to ask:
+- "What exactly happens vs what should happen?"
+- "When did it start? What changed?"
+- "Does it happen every time?"
+```
+
+## Phase 2: Locate
+
+**Goal**: Find where the bug originates.
+
+### With Error/Stack Trace
+- Read stack trace from bottom to top
+- Find first file in project code (not dependencies)
+- That's usually the bug location
+
+### Without Error (Silent Failure)
+- Add logging at key points
+- Use binary search: log at middle, narrow down
+- Check inputs/outputs at each step
+
+### Data Issues
+- Log the actual data vs expected
+- Check data transformations
+- Verify API responses match expectations
+
+## Phase 3: Diagnose
+
+**Goal**: Understand WHY it's broken.
+
+### Common Causes (Any Language)
+
+**Data Issues**
+- Null/undefined/nil access
+- Wrong data type
+- Missing or malformed data
+- Encoding issues
+
+**Timing Issues**
+- Race conditions
+- Async operations completing out of order
+- Stale data/cache
+
+**Logic Errors**
+- Off-by-one errors
+- Wrong comparison operators
+- Missing edge cases
+- Incorrect boolean logic
+
+**Environment Issues**
+- Missing environment variables
+- Wrong file paths
+- Permission issues
+- Version mismatches
+
+### Diagnostic Questions
+1. What are the exact inputs?
+2. What's the expected output?
+3. Where does actual diverge from expected?
+4. What assumptions might be wrong?
+
+## Phase 4: Fix
+
+**Goal**: Apply minimal, correct fix.
+
+### Fix Criteria
+- Addresses root cause, not symptom
+- Doesn't break other functionality
+- Handles related edge cases
+- Is the simplest solution that works
+
+### Verification Checklist
+- [ ] Original bug is fixed
+- [ ] Related tests pass
+- [ ] No new issues introduced
+- [ ] Edge cases handled
+- [ ] Fix makes sense to explain
+
+## Quick Reference
+
+| Symptom | Check First |
+|---------|-------------|
+| "undefined" errors | Data flow, null checks |
+| Intermittent failures | Async/timing, race conditions |
+| Works locally, fails in prod | Environment, configs |
+| Works for some users | User-specific data, permissions |
+| Slow performance | N+1 queries, loops, memory |
+| Silent failures | Error handling, logging |
+
+## Debug Without Debugger
+
+When you can't use a debugger:
+
+```
+1. Strategic logging at entry/exit points
+2. Log input/output of suspect functions
+3. Add timestamps for timing issues
+4. Log state before/after mutations
+5. Use conditional logging for specific cases
+```

package/.claude/skills/testing-methodology.md

@@ -0,0 +1,112 @@
+---
+name: testing-methodology
+description: Language-agnostic testing approach
+globs: ["**/*.test.*", "**/*.spec.*", "**/*_test.*", "__tests__/**/*", "tests/**/*", "test/**/*"]
+---
+
+# Testing Methodology
+
+A framework-agnostic approach to writing effective tests.
+
+## First: Check Existing Tests
+
+Before writing tests:
+1. Find existing test files in the project
+2. Study their structure and style
+3. Match the existing patterns exactly
+4. Use the same testing framework
+
+## Test Structure (AAA Pattern)
+
+Works in any language:
+
+```
+Test: [what you're testing]
+
+  Arrange:
+    - Set up test data
+    - Configure mocks/stubs
+    - Prepare dependencies
+
+  Act:
+    - Execute the code under test
+    - Capture the result
+
+  Assert:
+    - Verify the result matches expected
+    - Check side effects if any
+```
+
+## What to Test
+
+### Always Test
+- Core business logic
+- Data transformations
+- Edge cases and boundaries
+- Error handling paths
+- Public API contracts
+
+### Sometimes Test
+- Integration points
+- Complex UI interactions
+- Database operations
+
+### Rarely Test
+- Framework code
+- Simple getters/setters
+- Configuration
+- Third-party libraries
+
+## Test Naming
+
+Be descriptive about:
+1. What is being tested
+2. Under what conditions
+3. What is expected
+
+```
+Good: "creates user when email is valid"
+Bad: "test1" or "user test"
+```
+
+## Mocking Strategy
+
+### Mock When
+- External services (APIs, databases)
+- Time-dependent code
+- Random/non-deterministic behavior
+- Slow operations
+
+### Don't Mock
+- The code you're testing
+- Simple utility functions
+- When you can use real implementations
+
+## Test Data
+
+### Good Test Data
+- Minimal but complete
+- Clearly shows the test case
+- Uses realistic values
+- Isolated per test
+
+### Bad Test Data
+- Shared between tests
+- Uses magic numbers without context
+- Overly complex for the test case
+
+## Coverage Philosophy
+
+Focus on:
+- **Critical paths**: What breaks the app if it fails?
+- **Complex logic**: Where are bugs likely?
+- **Regression prevention**: What broke before?
+
+Don't chase percentages - chase confidence.
+
+## Test Maintenance
+
+- Delete tests that don't add value
+- Update tests when requirements change
+- Keep tests fast (< 100ms unit tests)
+- Make failures easy to diagnose

package/.claude/state/task.md

@@ -0,0 +1,13 @@
+# Current Task
+
+## Status: Ready
+
+No active task. Start one with `/task <description>`.
+
+## Context
+
+_Project context will appear here._
+
+## Decisions
+
+_Key decisions are recorded here._

package/CLAUDE.md

@@ -0,0 +1,32 @@
+# Claude Code Starter
+
+## Start Here
+
+Check `.claude/state/task.md` for your current task.
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| `/task <desc>` | Start or switch to a new task |
+| `/status` | Show current task state |
+| `/done` | Mark current task complete |
+| `/analyze <area>` | Deep-dive into specific code |
+
+## Rules
+
+1. **State First** - Always read `.claude/state/task.md` when resuming
+2. **One Task** - Focus on one thing at a time
+3. **Test Before Done** - Run tests before marking complete
+4. **Update State** - Keep task.md current as you work
+
+## Skills
+
+Reference these for specialized workflows:
+- `.claude/skills/pattern-discovery.md` - Finding codebase patterns
+- `.claude/skills/systematic-debugging.md` - Debugging approach
+- `.claude/skills/testing-methodology.md` - Testing strategy
+
+## File References
+
+Use `path/to/file.ts:123` format when referencing code.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cassiano Montanari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.