tlc-claude-code 0.6.4 → 0.7.1

package/export.md

@@ -0,0 +1,456 @@
+# /tlc:export - Multi-Tool Support
+
+Export TLC rules and context for other AI coding tools.
+
+## Usage
+
+```
+/tlc:export [format]
+```
+
+Formats:
+- `agents` - AGENTS.md universal format
+- `cursor` - Cursor rules
+- `copilot` - GitHub Copilot instructions
+- `continue` - Continue.dev config
+- `cody` - Sourcegraph Cody
+- `aider` - Aider conventions
+- `all` - All formats
+
+## AGENTS.md Universal Format
+
+The `AGENTS.md` file is a universal standard for AI agent instructions:
+
+```
+> /tlc:export agents
+
+Creating AGENTS.md...
+
+This file tells AI tools how to work with your project.
+
+---
+# AGENTS.md
+
+## Project Overview
+
+This is a Node.js/Express API with React frontend.
+Test framework: mocha/chai/sinon
+
+## Coding Standards
+
+### Test-First Development
+
+ALWAYS write tests before implementation:
+
+1. Create test file first
+2. Write failing tests
+3. Implement until tests pass
+4. Refactor if needed
+
+### Test Location
+
+Tests go next to source files:
+```
+src/
+  auth/
+    login.js
+    login.test.js
+```
+
+### Test Framework
+
+Use mocha with chai assertions:
+```javascript
+const { expect } = require('chai');
+const sinon = require('sinon');
+
+describe('login', () => {
+  it('returns user on valid credentials', async () => {
+    // Test code
+  });
+});
+```
+
+## Task Management
+
+Tasks are tracked in `.planning/phases/{N}-PLAN.md`:
+
+```markdown
+### Task 1: Description [status]
+
+status markers:
+- [ ] = available
+- [>@user] = claimed
+- [x@user] = completed
+```
+
+Before starting work:
+1. Check PLAN.md for available tasks
+2. Claim task by updating marker to [>@yourname]
+3. Work on the task
+4. Mark complete when done [x@yourname]
+
+## File Conventions
+
+| Pattern | Purpose |
+|---------|---------|
+| `*.test.js` | Test files |
+| `*.spec.js` | Alternative test files |
+| `.planning/` | TLC planning files |
+| `PROJECT.md` | Project overview |
+| `CLAUDE.md` | Claude-specific instructions |
+
+## Commands
+
+When working on this project:
+
+- Run tests: `npm test`
+- Run single test: `npm test -- --grep "test name"`
+- Watch mode: `npm run test:watch`
+
+## Current State
+
+Check `.planning/ROADMAP.md` for project status.
+Check current phase PLAN.md for active tasks.
+---
+
+Created AGENTS.md in project root.
+```
+
+## Cursor Rules
+
+```
+> /tlc:export cursor
+
+Creating .cursorrules...
+
+---
+# Cursor Rules for TLC Project
+
+## Test-First Development
+
+When implementing new features:
+1. First, create or update test file
+2. Write tests that fail
+3. Then implement the code
+4. Verify tests pass
+
+## File Patterns
+
+Tests: `{name}.test.js` next to source
+Planning: `.planning/phases/{N}-PLAN.md`
+
+## Testing
+
+Framework: mocha + chai + sinon
+
+Example:
+```javascript
+const { expect } = require('chai');
+describe('feature', () => {
+  it('does something', () => {
+    expect(result).to.equal(expected);
+  });
+});
+```
+
+Run: `npm test`
+
+## Task Workflow
+
+Before coding:
+1. Read current task from PLAN.md
+2. Understand requirements
+3. Write tests first
+4. Then implement
+
+## Code Style
+
+- Use async/await over callbacks
+- Prefer named exports
+- Keep functions small (<30 lines)
+- Document public APIs
+---
+
+Created .cursorrules
+```
+
+## GitHub Copilot
+
+```
+> /tlc:export copilot
+
+Creating .github/copilot-instructions.md...
+
+---
+# Copilot Instructions
+
+## Project Context
+
+Node.js Express API with React frontend.
+Testing: mocha, chai, sinon, proxyquire
+
+## Test-First Approach
+
+Always suggest tests before implementation.
+
+When asked to implement a feature:
+1. First suggest test cases
+2. Then implement the code
+
+## Preferred Patterns
+
+### Tests
+```javascript
+const { expect } = require('chai');
+const sinon = require('sinon');
+
+describe('module', () => {
+  afterEach(() => sinon.restore());
+
+  it('should do something', async () => {
+    // Arrange
+    const stub = sinon.stub();
+
+    // Act
+    const result = await fn();
+
+    // Assert
+    expect(result).to.deep.equal(expected);
+  });
+});
+```
+
+### Async Functions
+```javascript
+async function getData() {
+  try {
+    const result = await fetch(url);
+    return result.json();
+  } catch (error) {
+    throw new ApiError('Failed to fetch', { cause: error });
+  }
+}
+```
+
+## Files to Reference
+
+- PROJECT.md - Project overview
+- .planning/ROADMAP.md - Current progress
+- .planning/phases/*-PLAN.md - Current tasks
+---
+
+Created .github/copilot-instructions.md
+```
+
+## Continue.dev
+
+```
+> /tlc:export continue
+
+Creating .continue/config.json and rules...
+
+---
+{
+  "models": [],
+  "customCommands": [
+    {
+      "name": "test",
+      "description": "Write tests for selected code",
+      "prompt": "Write mocha/chai tests for this code. Include edge cases."
+    },
+    {
+      "name": "tlc",
+      "description": "TLC workflow guidance",
+      "prompt": "Based on the TLC workflow, what should I do next? Check PLAN.md for current tasks."
+    }
+  ],
+  "contextProviders": [
+    {
+      "name": "planning",
+      "params": {
+        "files": [
+          "PROJECT.md",
+          ".planning/ROADMAP.md",
+          ".planning/phases/*-PLAN.md"
+        ]
+      }
+    }
+  ],
+  "docs": [
+    {
+      "title": "TLC Workflow",
+      "startUrl": "https://github.com/your/tlc-docs"
+    }
+  ]
+}
+---
+
+Created .continue/config.json
+Created .continue/rules/tlc.md
+```
+
+## Sourcegraph Cody
+
+```
+> /tlc:export cody
+
+Creating .cody/config.json...
+
+---
+{
+  "contextFilters": {
+    "include": [
+      "**/*.js",
+      "**/*.ts",
+      "**/*.test.js",
+      "PROJECT.md",
+      ".planning/**/*.md"
+    ],
+    "exclude": [
+      "**/node_modules/**",
+      "**/dist/**"
+    ]
+  },
+  "codebase": {
+    "testFramework": "mocha",
+    "testPattern": "*.test.{js,ts}"
+  }
+}
+---
+
+Created .cody/config.json
+Created .cody/instructions.md
+```
+
+## Aider
+
+```
+> /tlc:export aider
+
+Creating .aider.conf.yml...
+
+---
+# Aider Configuration for TLC
+
+# Always include these files for context
+read:
+  - PROJECT.md
+  - .planning/ROADMAP.md
+
+# Test-first conventions
+conventions:
+  - "Write tests before implementation"
+  - "Tests go in {name}.test.js next to source"
+  - "Use mocha/chai for testing"
+
+# Lint/format settings
+auto-lint: true
+lint-cmd: npm run lint
+
+# Test command
+test-cmd: npm test
+---
+
+Created .aider.conf.yml
+```
+
+## Export All
+
+```
+> /tlc:export all
+
+Exporting to all formats...
+
+Created:
+  ✓ AGENTS.md (universal)
+  ✓ .cursorrules (Cursor)
+  ✓ .github/copilot-instructions.md (Copilot)
+  ✓ .continue/config.json (Continue)
+  ✓ .cody/config.json (Cody)
+  ✓ .aider.conf.yml (Aider)
+
+All AI tools can now understand your TLC workflow!
+```
+
+## Keeping in Sync
+
+When project changes, re-export:
+
+```
+> /tlc:export --update
+
+Updating AI tool configurations...
+
+Changes detected:
+  - Test framework: jest → mocha
+  - New phase added to roadmap
+
+Updated:
+  ✓ AGENTS.md
+  ✓ .cursorrules
+  ✓ .github/copilot-instructions.md
+```
+
+## Configuration
+
+In `.tlc.json`:
+
+```json
+{
+  "export": {
+    "autoUpdate": true,
+    "formats": ["agents", "cursor", "copilot"],
+    "customRules": [
+      "Always use TypeScript strict mode",
+      "Prefer functional components in React"
+    ]
+  }
+}
+```
+
+## IDE Integration
+
+### VS Code
+
+With exported files, VS Code extensions will:
+- Copilot: Follow instructions in `.github/copilot-instructions.md`
+- Continue: Use `.continue/config.json`
+- Cody: Use `.cody/instructions.md`
+
+### Cursor
+
+Cursor automatically reads `.cursorrules` from project root.
+
+### JetBrains
+
+JetBrains IDEs with AI Assistant read `AGENTS.md`.
+
+## MCP Integration
+
+For tools supporting Model Context Protocol:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "tlc": {
+        "command": "tlc-mcp-server",
+        "args": ["--project", "."]
+      }
+    }
+  }
+}
+```
+
+This provides:
+- Task list from PLAN.md
+- Bug list from BUGS.md
+- Project context from PROJECT.md
+
+## Notes
+
+- AGENTS.md is the universal format (works with most tools)
+- Tool-specific files add extra features
+- Re-export after major changes
+- Commit these files to share with team

package/help.md

@@ -36,14 +36,54 @@ Launches the visual dashboard. Detects where you are, shows what's next.
 | `/tlc:build` | Write tests → implement → verify |
 | `/tlc:verify` | Human acceptance testing |
 
-### Utility
+### Quality & Testing
 
 | Command | What It Does |
 |---------|--------------|
 | `/tlc:status` | Test pass/fail counts |
+| `/tlc:coverage` | Find untested code, write tests |
+| `/tlc:quality` | Test quality scoring and analysis |
+| `/tlc:edge-cases` | Generate edge case tests |
+| `/tlc:autofix` | Auto-fix failing tests |
+| `/tlc:config` | Configure test frameworks |
+
+### Utility
+
+| Command | What It Does |
+|---------|--------------|
 | `/tlc:quick` | One-off task with tests |
 | `/tlc:complete` | Tag release |
 | `/tlc:new-milestone` | Start next version |
+| `/tlc:bug` | Log a bug or feedback |
+| `/tlc:server` | Start dashboard server for QA |
+
+### Multi-User Collaboration
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:claim` | Claim a task (reserve for yourself) |
+| `/tlc:release` | Release a claimed task |
+| `/tlc:who` | Show who's working on what |
+
+### CI/CD & Integration
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:ci` | Generate CI/CD pipeline (GitHub Actions, GitLab, etc.) |
+| `/tlc:issues` | Sync with issue trackers (GitHub, Jira, Linear) |
+
+### Documentation
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:docs` | Generate project docs (API, architecture, onboarding) |
+
+### Multi-Tool & Deployment
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:export` | Export rules for Cursor, Copilot, Continue, Cody |
+| `/tlc:deploy` | VPS deployment with branch previews |
 
 ---
 
@@ -97,3 +137,46 @@ npx tlc-claude-code
 ```
 
 Lives in `.claude/commands/tlc/`
+
+---
+
+## Agents
+
+TLC includes specialized AI agents that handle research, planning, execution, and verification. Most are invoked automatically by commands.
+
+### Research Agents
+
+| Agent | Invoked By | Purpose |
+|-------|------------|---------|
+| `tlc-competitor-analyst` | `/tlc:new-project` | Competitive analysis |
+| `tlc-market-researcher` | `/tlc:new-project` | Market landscape, user needs |
+| `tlc-tech-researcher` | `/tlc:new-project`, `/tlc:plan` | Evaluate tech choices |
+| `tlc-oss-reviewer` | `/tlc:new-project` | Learn from open source |
+| `tlc-ux-researcher` | `/tlc:new-project` | UX patterns, accessibility |
+| `tlc-security-researcher` | `/tlc:plan` | Security best practices |
+| `tlc-api-analyst` | `/tlc:plan` | API design, integrations |
+| `tlc-architecture-analyst` | `/tlc:new-project` | System architecture |
+
+### Build Agents
+
+| Agent | Invoked By | Purpose |
+|-------|------------|---------|
+| `tlc-planner` | `/tlc:plan` | Create test-first plans |
+| `tlc-executor` | `/tlc:build` | Red → Green → Refactor |
+| `tlc-coverage-analyzer` | `/tlc:coverage` | Find untested code |
+| `tlc-verifier` | `/tlc:verify` | Goal-backward verification |
+| `tlc-integration-checker` | `/tlc:verify` | E2E flow verification |
+| `tlc-debugger` | Manual | Systematic debugging |
+
+### Manual Agent Invocation
+
+```
+Task(subagent_type="tlc-{agent}", prompt="...")
+```
+
+Example:
+```
+Task(subagent_type="tlc-competitor-analyst", prompt="Analyze CRM market competitors")
+```
+
+Agent definitions are in the `agents/` folder.

package/init.md

@@ -57,12 +57,11 @@ Look for test indicators:
 
 ### 4. Set Up Test Framework (if missing)
 
-If no tests found, set up based on detected stack:
+If no tests found, set up based on detected stack. TLC defaults to mocha for JavaScript/TypeScript:
 
 | Stack | Framework | Setup |
 |-------|-----------|-------|
-| Next.js / React | Vitest | `npm install -D vitest @testing-library/react` |
-| Node.js | Vitest | `npm install -D vitest` |
+| Next.js / React / Node.js | Mocha + Chai + Sinon | `npm install -D mocha chai sinon proxyquire` |
 | Python | pytest | `pip install pytest` or add to pyproject.toml |
 | Go | go test | Built-in, no setup needed |
 | Ruby | RSpec | `gem install rspec && rspec --init` |
@@ -70,11 +69,34 @@ If no tests found, set up based on detected stack:
 
 Create config file and test directory structure.
 
-Add test scripts to package.json / pyproject.toml / Makefile:
+For JavaScript/TypeScript, create `.mocharc.json`:
+```json
+{
+  "extension": ["js", "ts"],
+  "spec": "test/**/*.test.{js,ts}",
+  "require": ["ts-node/register"],
+  "timeout": 5000
+}
+```
+
+Create `.tlc.json`:
+```json
+{
+  "testFrameworks": {
+    "primary": "mocha",
+    "installed": ["mocha", "chai", "sinon", "proxyquire"],
+    "run": ["mocha"]
+  },
+  "testCommand": "npm test",
+  "testDirectory": "test"
+}
+```
+
+Add test scripts to package.json:
 ```json
 "scripts": {
-  "test": "vitest run",
-  "test:watch": "vitest"
+  "test": "mocha",
+  "test:watch": "mocha --watch"
 }
 ```
 
@@ -82,9 +104,36 @@ Add test scripts to package.json / pyproject.toml / Makefile:
 
 - Skip framework setup
 - Note existing test patterns for consistency
-- Report: "Found existing test framework: [vitest/jest/pytest/etc]"
+- Report: "Found existing test framework: [mocha/jest/vitest/pytest/etc]"
 - Report: "Found X existing test files"
 
+**Offer to add TLC default stack:**
+```
+Detected: jest (47 test files)
+
+Options:
+1) Keep jest only - use for all tests
+2) Add mocha alongside jest - new tests use mocha, keep existing jest
+3) Keep jest as primary - configure in .tlc.json
+
+Which approach? [1/2/3]:
+```
+
+If option 2 selected, create multi-framework config:
+```json
+{
+  "testFrameworks": {
+    "primary": "mocha",
+    "installed": ["mocha", "chai", "sinon", "proxyquire", "jest"],
+    "run": ["mocha", "jest"]
+  },
+  "commands": {
+    "mocha": "npx mocha 'test/**/*.test.js'",
+    "jest": "npx jest"
+  }
+}
+```
+
 ### 6. Analyze Existing Code Structure
 
 Scan the codebase and generate summary: