tlc-claude-code 0.8.3 → 0.8.5

package/README.md

@@ -163,6 +163,12 @@ tlc init
 - **Bug submission** — Web form for QA
 - **Task board** — Who's working on what
 - **Multi-project** — Containers named `tlc-{project}-*` for simultaneous projects
+- **Hot reload** — Code changes apply instantly (no restart needed)
+
+**Rebuild when needed:**
+```bash
+tlc rebuild      # After package.json changes or to get a clean slate
+```
 
 **Requirements:** [Docker Desktop](https://www.docker.com/products/docker-desktop)
 
@@ -267,6 +273,7 @@ npm install -g tlc-claude-code
 # Then use anywhere:
 tlc              # Install slash commands to Claude Code
 tlc init         # Add Docker launcher to project (creates tlc-start.bat)
+tlc rebuild      # Full Docker rebuild (after package.json changes)
 tlc --help       # See all options
 ```
 

package/bin/rebuild.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * TLC Rebuild - Trigger full Docker rebuild
+ * Usage: tlc rebuild
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Find TLC installation directory
+function findTlcDir() {
+  const isWSL = process.platform === 'linux' && fs.existsSync('/mnt/c');
+
+  // Check common locations (adjust for WSL)
+  const locations = [
+    path.join(__dirname, '..'),  // Where this script lives (most reliable)
+  ];
+
+  if (isWSL) {
+    locations.push('/mnt/c/Code/TLC');
+    locations.push(path.join(require('os').homedir(), 'Code', 'TLC'));
+  } else {
+    locations.push('C:\\Code\\TLC');
+    locations.push(path.join(require('os').homedir(), 'Code', 'TLC'));
+  }
+
+  // Check npm global
+  try {
+    const { execSync } = require('child_process');
+    const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+    locations.push(path.join(globalRoot, 'tlc-claude-code'));
+  } catch (e) {
+    // Ignore
+  }
+
+  for (const loc of locations) {
+    if (fs.existsSync(path.join(loc, 'docker-compose.dev.yml'))) {
+      return loc;
+    }
+  }
+
+  return null;
+}
+
+// Get project name from current directory
+function getProjectName() {
+  const projectDir = process.cwd();
+  return path.basename(projectDir).toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+async function main() {
+  console.log('');
+  console.log('  TLC Rebuild');
+  console.log('  ===========');
+  console.log('');
+
+  const tlcDir = findTlcDir();
+  if (!tlcDir) {
+    console.error('  [ERROR] Could not find TLC installation');
+    console.error('  Make sure docker-compose.dev.yml exists');
+    process.exit(1);
+  }
+
+  const projectName = getProjectName();
+  const composePath = path.join(tlcDir, 'docker-compose.dev.yml');
+
+  console.log(`  TLC Dir: ${tlcDir}`);
+  console.log(`  Project: ${projectName}`);
+  console.log('');
+
+  // Set environment variables
+  process.env.PROJECT_DIR = process.cwd();
+  process.env.COMPOSE_PROJECT_NAME = projectName;
+
+  console.log('  [1/2] Stopping containers...');
+
+  // Run docker-compose down
+  const down = spawn('docker-compose', ['-f', composePath, 'down'], {
+    stdio: 'inherit',
+    shell: true,
+    env: process.env
+  });
+
+  down.on('close', (code) => {
+    if (code !== 0) {
+      console.error('  [ERROR] Failed to stop containers');
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log('  [2/2] Rebuilding and starting...');
+    console.log('');
+
+    // Run docker-compose up --build
+    const up = spawn('docker-compose', ['-f', composePath, 'up', '--build'], {
+      stdio: 'inherit',
+      shell: true,
+      env: process.env
+    });
+
+    up.on('close', (upCode) => {
+      process.exit(upCode || 0);
+    });
+  });
+}
+
+main();

package/bin/tlc.js

@@ -15,6 +15,9 @@ switch (command) {
   case 'init':
     require('./init.js');
     break;
+  case 'rebuild':
+    require('./rebuild.js');
+    break;
   case 'help':
   case '--help':
   case '-h':
@@ -24,6 +27,7 @@ switch (command) {
   Usage:
     tlc              Install TLC slash commands to Claude Code
     tlc init         Add Docker launcher to your project
+    tlc rebuild      Stop, rebuild, and restart Docker containers
 
   Options:
     --global, -g     Install commands globally (~/.claude/commands)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc": "./bin/tlc.js",
@@ -8,7 +8,8 @@
     "tlc-dashboard": "./dashboard/dist/index.js",
     "tlc-server": "./bin/server.js",
     "tlc-setup": "./bin/setup.js",
-    "tlc-init": "./bin/init.js"
+    "tlc-init": "./bin/init.js",
+    "tlc-rebuild": "./bin/rebuild.js"
   },
   "files": [
     "bin/",

package/server.md

@@ -1,110 +1,89 @@
 # /tlc:server - TLC Development Server
 
-Launch a unified development environment with live app preview, real-time logs, and team collaboration.
+Launch a Docker-based development environment with dashboard, database, and live reload.
 
 ## Instructions for Claude
 
-**DO NOT generate server code. Run the pre-built server from the TLC package.**
+### Step 1: Run tlc init
 
-### Step 1: Start Server
-
-Run this command in the user's project directory:
+Run this command in the user's project directory to create the Docker launcher:
 
 ```bash
-npx -p tlc-claude-code tlc-server
+npx tlc-claude-code init
 ```
 
-That's it. The server will:
-- Auto-detect the project type
-- Start the user's app
-- Open dashboard at http://localhost:3147
+This creates `tlc-start.bat` in the project folder.
 
-### Step 2: Show User the URLs
+### Step 2: Show User Instructions
 
 ```
-TLC Dev Server running!
+TLC Dev Server Setup Complete!
+
+Created: tlc-start.bat
+
+To start your dev environment:
+  1. Double-click tlc-start.bat (Windows)
+  2. Wait for Docker containers to start
 
-  Dashboard: http://localhost:3147
-  Share:     http://{local-ip}:3147
+Services:
+  Dashboard:  http://localhost:3147
+  App:        http://localhost:5000
+  DB Admin:   http://localhost:8080
+  Database:   localhost:5433
 
-Open dashboard in browser to see:
-  - Live app preview
-  - Real-time logs (App / Tests / Git)
-  - Task board
-  - Bug submission form
+Requirements: Docker Desktop (https://docker.com/products/docker-desktop)
+
+Other commands:
+  tlc rebuild    # Full rebuild after package.json changes
 ```
 
 ---
 
-## What the Server Does
+## What You Get
+
+| URL | Service |
+|-----|---------|
+| http://localhost:3147 | Dashboard - Logs, tasks, bugs |
+| http://localhost:5000 | App - Your running application |
+| http://localhost:8080 | DB Admin - Adminer database GUI |
+| localhost:5433 | PostgreSQL database |
+
+## Features
 
-- **Auto-detects** project type (Node, Python, Go, Ruby, Rust)
-- **Starts your app** using detected dev command
-- **Proxies** app at `/app/` to avoid CORS
-- **Streams logs** via WebSocket
-- **Shows tasks** from `.planning/phases/*-PLAN.md`
-- **Accepts bugs** via web form → `.planning/BUGS.md`
+- **Hot reload** - Code changes apply instantly
+- **Real-time logs** - App, tests, git activity
+- **Bug submission** - Web form for QA
+- **Task board** - Who's working on what
+- **Multi-project** - Run multiple projects simultaneously
 
 ## Configuration
 
-Override auto-detection in `.tlc.json`:
+Override settings in `.tlc.json`:
 
 ```json
 {
   "server": {
     "startCommand": "npm run dev",
-    "appPort": 3000,
-    "dashboardPort": 3147
+    "appPort": 3000
   }
 }
 ```
 
-## Supported Project Types
+## Rebuild
 
-| File | Detected As | Command |
-|------|-------------|---------|
-| `package.json` (next) | Next.js | `npm run dev` |
-| `package.json` (vite) | Vite | `npm run dev` |
-| `package.json` (express) | Express | `npm start` |
-| `pyproject.toml` | FastAPI | `uvicorn main:app --reload` |
-| `requirements.txt` | Flask | `flask run` |
-| `go.mod` | Go | `go run .` |
-| `Gemfile` (rails) | Rails | `rails server` |
-| `Cargo.toml` | Rust | `cargo run` |
+After changing `package.json` or dependencies:
 
-## Dashboard Features
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│  TLC Dev Server                              [Run Tests] [Restart] │
-├─────────────────────────────────────────────────────────────────┤
-│                          │                                      │
-│   ┌─────────────────┐    │    ┌────────────────────────────┐   │
-│   │  LIVE PREVIEW   │    │    │  LOGS  [App] [Tests] [Git] │   │
-│   │   (your app)    │    │    │  > Server started :3000    │   │
-│   └─────────────────┘    │    │  > GET /api/users 200 12ms │   │
-│                          │    └────────────────────────────┘   │
-│   ┌─────────────────┐    │    ┌────────────────────────────┐   │
-│   │  REPORT BUG     │    │    │  TASKS (from PLAN.md)      │   │
-│   │  [textarea]     │    │    │  ✓ Task 1 @alice           │   │
-│   │  [Submit]       │    │    │  → Task 2 @bob             │   │
-│   └─────────────────┘    │    │  ○ Task 3 (available)      │   │
-│                          │    └────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────┘
+```bash
+tlc rebuild
 ```
 
-## QA Workflow
-
-1. Engineer runs `/tlc:server`
-2. QA opens `http://192.168.x.x:3147` in browser
-3. QA tests app in live preview
-4. QA submits bugs via web form
-5. Bugs appear in `.planning/BUGS.md`
-6. Engineer fixes, app hot-reloads
-7. QA re-tests
+Or manually:
+```bash
+# Stop containers (Ctrl+C in the terminal)
+# Double-click tlc-start.bat again
+```
 
-## Notes
+## Requirements
 
-- Works on local network (share IP with QA)
-- For remote: `ngrok http 3147`
-- All data flows through git
+- [Docker Desktop](https://www.docker.com/products/docker-desktop)
+- Windows (macOS/Linux support coming soon)