tlc-claude-code 0.6.4 → 0.7.0

package/claim.md

@@ -0,0 +1,189 @@
+# /tlc:claim - Claim a Task
+
+Reserve a task so teammates know you're working on it.
+
+## Usage
+
+```
+/tlc:claim [task-number]
+```
+
+## Process
+
+### Step 1: Identify User
+
+Get current user identity:
+
+```bash
+# Check TLC_USER environment variable first
+if [ -n "$TLC_USER" ]; then
+  user=$TLC_USER
+else
+  # Fall back to git username, normalized to lowercase
+  user=$(git config user.name | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
+fi
+```
+
+### Step 2: Sync Latest State
+
+Pull latest changes to get current task claims:
+
+```bash
+git pull --rebase
+```
+
+If pull fails due to conflicts, abort and notify user to resolve manually.
+
+### Step 3: Find Current Phase Plan
+
+Locate the active phase PLAN.md:
+
+1. Read `.planning/ROADMAP.md`
+2. Find phase marked `[>]` or `[current]`
+3. Load `.planning/phases/{N}-*-PLAN.md`
+
+### Step 4: Parse Task Status
+
+Read task headings and their status markers:
+
+| Pattern | Status | Available |
+|---------|--------|-----------|
+| `### Task N: Title [ ]` | Available | Yes |
+| `### Task N: Title [>@user]` | Claimed | No (unless by you) |
+| `### Task N: Title [x@user]` | Completed | No |
+
+### Step 5: Show Available Tasks
+
+Display tasks with their status:
+
+```
+Phase 2: User Dashboard
+
+Tasks:
+  1. Create layout component [x@alice] (done)
+  2. Fetch data hook [ ] (available)
+  3. Add charts [>@bob] (bob is working)
+  4. Loading states [ ] (available)
+
+Available: 2, 4
+```
+
+### Step 6: Claim Task
+
+If task-number provided:
+- Verify task exists and is available
+- If not available, show error
+
+If not provided:
+- Prompt user to select from available tasks
+
+Update the task heading:
+
+```markdown
+### Task 2: Fetch data hook [ ]
+```
+
+becomes:
+
+```markdown
+### Task 2: Fetch data hook [>@alice]
+```
+
+### Step 7: Commit Claim
+
+```bash
+git add .planning/phases/{N}-PLAN.md
+git commit -m "claim: task {N} - {title} (@{user})"
+```
+
+### Step 8: Push
+
+Prompt to push:
+
+```
+Committed. Push now? (Y/n)
+```
+
+If yes:
+```bash
+git push
+```
+
+If push fails (someone else pushed):
+```
+Push failed - someone else updated the plan.
+Run: git pull --rebase
+Then try /tlc:claim again
+```
+
+## Example Session
+
+```
+> /tlc:claim 2
+
+Syncing latest...
+✓ Up to date
+
+Phase 1: Authentication
+
+Tasks:
+  1. Create user schema [x@bob] (done)
+  2. Add validation [ ] → [>@alice]
+  3. Write migrations [>@bob] (bob is working)
+  4. Integration tests [ ] (available)
+
+Claiming task 2: Add validation
+
+✓ Committed: claim: task 2 - Add validation (@alice)
+
+Push now? (Y/n) y
+✓ Pushed
+
+Task 2 is yours. Run /tlc:build to start.
+```
+
+## Error Handling
+
+**Task already claimed:**
+```
+Task 2 is being worked on by @bob.
+Available tasks: 4
+
+Choose a different task, or ask @bob to /tlc:release 2
+```
+
+**Task already completed:**
+```
+Task 2 was completed by @alice.
+Available tasks: 4
+```
+
+**No available tasks:**
+```
+All tasks in Phase 1 are claimed or completed.
+
+  [x@alice] 1. Create schema
+  [>@bob] 2. Add validation
+  [x@alice] 3. Write migrations
+  [>@bob] 4. Integration tests
+
+Wait for a task to be released, or help review completed work.
+```
+
+**Merge conflict on push:**
+```
+Push rejected - concurrent claim detected.
+
+Someone else claimed a task while you were claiming.
+Run: git pull --rebase
+
+If conflict on YOUR task: resolve and push
+If conflict on different task: auto-resolved, just push
+```
+
+## Notes
+
+- Claims are advisory - they don't prevent others from editing files
+- Claims help coordinate, not enforce
+- Use `/tlc:who` to see full team status
+- Use `/tlc:release` to give up a claim

package/config.md

@@ -0,0 +1,236 @@
+# /tlc:config - Configure Test Frameworks
+
+Manage test framework settings for your project.
+
+## Usage
+
+```
+/tlc:config
+```
+
+## Configuration File
+
+TLC stores test preferences in `.tlc.json` at the project root:
+
+```json
+{
+  "testFrameworks": {
+    "primary": "mocha",
+    "installed": ["mocha", "chai", "sinon", "proxyquire"],
+    "run": ["mocha"]
+  },
+  "testCommand": "npm test",
+  "testDirectory": "test"
+}
+```
+
+### Fields
+
+| Field | Description |
+|-------|-------------|
+| `primary` | Main test framework for new tests |
+| `installed` | All test libraries available in project |
+| `run` | Which frameworks to execute (subset of installed) |
+| `testCommand` | Command to run tests |
+| `testDirectory` | Where test files live |
+
+## Supported Frameworks
+
+### Default Stack (Recommended)
+
+TLC defaults to the mocha ecosystem for new projects:
+
+| Library | Purpose |
+|---------|---------|
+| **mocha** | Test runner |
+| **chai** | Assertions (expect, should, assert) |
+| **sinon** | Mocks, stubs, spies |
+| **proxyquire** | Module mocking/dependency injection |
+
+```bash
+npm install -D mocha chai sinon proxyquire @types/mocha @types/chai @types/sinon
+```
+
+### Alternative Frameworks
+
+| Framework | Use Case |
+|-----------|----------|
+| **vitest** | Vite projects, fast, ESM-native |
+| **jest** | React/Meta ecosystem, all-in-one |
+| **pytest** | Python projects |
+| **go test** | Go projects (built-in) |
+| **rspec** | Ruby projects |
+
+## Process
+
+### Step 1: Check for Existing Config
+
+Look for `.tlc.json` in project root.
+
+If exists, display current settings:
+```
+Current TLC Configuration:
+
+Test Framework: mocha
+Libraries: mocha, chai, sinon, proxyquire
+Run Command: npm test
+Test Directory: test/
+
+What would you like to do?
+1) View/edit frameworks to run
+2) Add a new framework
+3) Change primary framework
+4) Reset to defaults
+```
+
+### Step 2: First-Time Setup
+
+If no config exists, check for existing tests:
+
+1. **Detect installed frameworks** from package.json/dependencies
+2. **Detect test files** patterns in use
+3. **Propose configuration** based on findings
+
+```
+No TLC config found. Analyzing project...
+
+Detected:
+  - jest (installed)
+  - 47 test files using Jest patterns
+
+Options:
+1) Keep Jest as primary (detected)
+2) Add mocha alongside Jest
+3) Switch to mocha (TLC default)
+4) Custom configuration
+```
+
+### Step 3: Multi-Framework Setup
+
+When multiple frameworks coexist:
+
+```
+Multiple test frameworks detected:
+  - mocha: test/unit/*.test.js (23 files)
+  - jest: __tests__/*.spec.js (15 files)
+
+Configure which to run:
+  [x] mocha - run these tests
+  [x] jest - run these tests
+  [ ] Run all frameworks
+
+Test commands:
+  mocha: npx mocha 'test/**/*.test.js'
+  jest: npx jest
+  combined: npm test (runs both)
+```
+
+### Step 4: Save Configuration
+
+Write `.tlc.json`:
+
+```json
+{
+  "testFrameworks": {
+    "primary": "mocha",
+    "installed": ["mocha", "chai", "sinon", "proxyquire", "jest"],
+    "run": ["mocha", "jest"]
+  },
+  "commands": {
+    "mocha": "npx mocha 'test/**/*.test.js'",
+    "jest": "npx jest",
+    "all": "npm test"
+  },
+  "testDirectory": "test",
+  "patterns": {
+    "mocha": "test/**/*.test.js",
+    "jest": "__tests__/**/*.spec.js"
+  }
+}
+```
+
+### Step 5: Update package.json
+
+Ensure test scripts are configured:
+
+```json
+{
+  "scripts": {
+    "test": "npm run test:mocha && npm run test:jest",
+    "test:mocha": "mocha 'test/**/*.test.js'",
+    "test:jest": "jest",
+    "test:watch": "mocha --watch 'test/**/*.test.js'"
+  }
+}
+```
+
+## Example: Adding a Framework
+
+```
+> /tlc:config
+
+Current: mocha (primary)
+
+What would you like to do?
+> 2) Add a new framework
+
+Available frameworks to add:
+1) jest - All-in-one testing (React ecosystem)
+2) vitest - Fast, Vite-native
+3) Other (specify)
+
+> 1) jest
+
+Installing jest...
+npm install -D jest @types/jest
+
+Configure jest test location:
+> __tests__/
+
+Updated .tlc.json:
+  installed: mocha, chai, sinon, proxyquire, jest
+  run: mocha, jest
+
+Run which tests?
+1) All frameworks (mocha + jest)
+2) Only mocha
+3) Only jest
+4) Let me choose per-run
+
+> 1) All frameworks
+
+Done. Run 'npm test' to execute all test suites.
+```
+
+## Example: Project with Existing Jest
+
+```
+> /tlc:config
+
+Detected: jest (47 test files)
+
+Your project uses Jest. Options:
+
+1) Keep Jest only
+2) Add mocha for new tests, keep Jest for existing
+3) Migrate to mocha (will need to convert tests)
+
+> 2) Add mocha for new tests
+
+Setting up mocha alongside Jest...
+
+New tests will use: mocha + chai + sinon
+Existing tests remain: jest
+
+Updated scripts:
+  npm test        - runs both
+  npm run test:new - runs mocha only
+  npm run test:legacy - runs jest only
+```
+
+## Notes
+
+- TLC defaults to mocha for consistency across projects
+- Multiple frameworks can coexist when inheriting codebases
+- Use `run` array to control which frameworks execute
+- The `primary` framework is used for new test generation