tlc-claude-code 1.5.3 → 1.5.4

package/.claude/commands/tlc/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/.claude/commands/tlc/cleanup.md

@@ -0,0 +1,187 @@
+# /tlc:cleanup - Automatic Standards Cleanup
+
+Automatically fix all coding standards violations. No prompts - just fixes everything and commits.
+
+## What This Does
+
+1. Ensures CLAUDE.md and CODING-STANDARDS.md exist
+2. Runs full audit to find all issues
+3. Fixes each issue automatically:
+   - Extracts hardcoded config to environment variables
+   - Migrates flat folders to entity-based structure
+   - Extracts inline interfaces to types/ files
+   - Replaces magic strings with constants
+   - Adds missing JSDoc comments
+4. Commits after each module/entity
+5. Reports results when done
+
+## Usage
+
+```
+/tlc:cleanup
+```
+
+## Process
+
+### Step 1: Inject Standards
+
+```javascript
+const { injectStandards } = require('./lib/standards/standards-injector');
+const results = await injectStandards(projectPath);
+```
+
+Creates CLAUDE.md and CODING-STANDARDS.md if missing.
+
+### Step 2: Run Audit
+
+```javascript
+const { auditProject } = require('./lib/standards/audit-checker');
+const auditResults = await auditProject(projectPath);
+```
+
+### Step 3: Fix Issues (No Prompts)
+
+For each issue type, apply fixes automatically:
+
+#### Hardcoded URLs/Ports
+```javascript
+// Before
+fetch('http://localhost:3000/api');
+
+// After
+fetch(process.env.API_URL || 'http://localhost:3000' + '/api');
+```
+
+#### Flat Folders
+```
+src/services/user.service.ts → src/user/user.service.ts
+src/services/product.service.ts → src/product/product.service.ts
+```
+
+All imports are updated automatically.
+
+#### Inline Interfaces
+```javascript
+// Before (user.service.ts)
+interface UserData { id: string; }
+export class UserService { }
+
+// After (user.service.ts)
+import { UserData } from './types/user-data';
+export class UserService { }
+
+// New file (types/user-data.ts)
+export interface UserData { id: string; }
+```
+
+#### Magic Strings
+```javascript
+// Before
+if (status === 'active') { }
+
+// After
+import { STATUS_ACTIVE } from './constants/status';
+if (status === STATUS_ACTIVE) { }
+
+// New file (constants/status.ts)
+export const STATUS_ACTIVE = 'active';
+```
+
+#### Missing JSDoc
+```javascript
+// Before
+export function getUser(id: string): User { }
+
+// After
+/**
+ * Gets a user by ID
+ * @param id - The user ID
+ * @returns The user
+ */
+export function getUser(id: string): User { }
+```
+
+### Step 4: Commit After Each Module
+
+After fixing all issues in an entity/module:
+
+```bash
+git add src/user/
+git commit -m "refactor(user): apply coding standards
+
+- Extract UserData interface to types/
+- Replace magic strings with constants
+- Add missing JSDoc
+"
+```
+
+### Step 5: Report Results
+
+```
+TLC Cleanup Complete
+═══════════════════════════════════════════════════════════════
+
+Standards Injected:
+  ✓ CLAUDE.md (created)
+  ✓ CODING-STANDARDS.md (created)
+
+Issues Fixed: 11
+  - 4 hardcoded URLs extracted to env vars
+  - 3 flat folders migrated
+  - 2 inline interfaces extracted
+  - 2 magic strings replaced
+
+Commits Created: 4
+  - refactor(user): apply coding standards
+  - refactor(product): apply coding standards
+  - refactor(order): apply coding standards
+  - refactor(config): extract environment variables
+
+All checks now pass. Run /tlc:audit to verify.
+```
+
+## Example
+
+```
+> /tlc:cleanup
+
+TLC Cleanup - Automatic Standards Fix
+═══════════════════════════════════════════════════════════════
+
+Injecting standards files...
+  ✓ Created CLAUDE.md
+  ✓ Created CODING-STANDARDS.md
+
+Running audit...
+  Found 11 issues to fix
+
+Fixing issues...
+  [1/11] Extracting http://localhost:3000 to API_URL...
+  [2/11] Extracting port 3000 to PORT...
+  [3/11] Migrating src/services/user.service.ts...
+  [4/11] Migrating src/services/product.service.ts...
+  [5/11] Extracting interface UserData...
+  [6/11] Replacing magic string 'active'...
+  [7/11] Adding JSDoc to getUser()...
+  ...
+
+Committing changes...
+  ✓ refactor(user): apply coding standards
+  ✓ refactor(product): apply coding standards
+  ✓ refactor(config): extract environment variables
+
+═══════════════════════════════════════════════════════════════
+CLEANUP COMPLETE - 11 issues fixed, 3 commits created
+═══════════════════════════════════════════════════════════════
+```
+
+## When to Use
+
+- **New project**: Run once after `tlc init` to establish standards
+- **Imported project**: Run after importing a Replit or external project
+- **Quick fix**: When you just want everything fixed without reviewing
+
+## See Also
+
+- `/tlc:audit` - Check without fixing
+- `/tlc:refactor` - Fix step-by-step with previews

package/.claude/commands/tlc/complete.md

@@ -0,0 +1,160 @@
+# /tlc:complete - Complete Milestone
+
+Archive current milestone and tag the release.
+
+## What This Does
+
+1. Verifies all phases complete
+2. Runs full test suite
+3. Creates git tag
+4. Archives milestone files
+5. Prepares for next version
+
+## Usage
+
+```
+/tlc:complete
+```
+
+## Process
+
+### Step 1: Check All Phases Complete
+
+Read `.planning/ROADMAP.md` and verify:
+- All phases marked `[x]` or `[completed]`
+- All phases have `{N}-VERIFIED.md`
+
+If incomplete:
+```
+Cannot complete milestone.
+
+Incomplete phases:
+  - Phase 4: Reports (not verified)
+  - Phase 5: Settings (not built)
+
+Run /tlc to continue building.
+```
+
+### Step 2: Run Full Test Suite
+
+```bash
+npm test
+```
+
+- ✅ All pass → Continue
+- ❌ Any fail → Block completion
+
+```
+Cannot complete milestone.
+
+3 tests failing:
+  - user.test.ts: login timeout
+  - api.test.ts: invalid response
+
+Fix tests before completing.
+```
+
+### Step 3: Confirm Completion
+
+```
+Milestone: v1.0
+
+Summary:
+  - 5 phases completed
+  - 47 tests passing
+  - All phases verified
+
+Ready to tag release? (Y/n)
+```
+
+### Step 4: Create Git Tag
+
+```bash
+git tag -a v1.0 -m "Release v1.0
+
+Phases:
+- Phase 1: Authentication
+- Phase 2: User Dashboard
+- Phase 3: Reports
+- Phase 4: Settings
+- Phase 5: Admin Panel
+
+Tests: 47 passing"
+```
+
+### Step 5: Archive Milestone
+
+Move planning files:
+```
+.planning/
+├── archive/
+│   └── v1.0/
+│       ├── ROADMAP.md
+│       ├── phases/
+│       │   ├── 1-PLAN.md
+│       │   ├── 1-VERIFIED.md
+│       │   └── ...
+│       └── SUMMARY.md
+└── (clean for next milestone)
+```
+
+Create `.planning/archive/v1.0/SUMMARY.md`:
+```markdown
+# v1.0 Release Summary
+
+Released: {date}
+Tag: v1.0
+
+## Phases
+
+1. Authentication - User login, registration, sessions
+2. User Dashboard - Main interface, data display
+3. Reports - Export, PDF generation
+4. Settings - User preferences
+5. Admin Panel - User management
+
+## Stats
+
+- Total tests: 47
+- Duration: {X days/weeks}
+- Commits: {N}
+
+## Notes
+
+{Any release notes}
+```
+
+### Step 6: Complete
+
+```
+✅ Milestone v1.0 complete!
+
+Tag created: v1.0
+Files archived to .planning/archive/v1.0/
+
+Next steps:
+1) Push tag: git push origin v1.0
+2) Start next version: /tlc:new-milestone v2.0
+```
+
+## Example
+
+```
+> /tlc:complete
+
+Checking milestone status...
+
+✅ All 5 phases verified
+✅ 47 tests passing
+
+Ready to complete v1.0? (Y/n) > y
+
+Creating tag v1.0...
+Archiving planning files...
+
+✅ Milestone v1.0 complete!
+
+Push to remote? (Y/n) > y
+
+Done! Start v2.0 with /tlc:new-milestone
+```