tlc-claude-code 1.2.28 → 1.2.29

package/README.md

@@ -58,10 +58,12 @@ No manual testing. No "does this work?" No vibes.
 ### Then Just Run
 
 ```bash
-/tlc
+/tlc:next
 ```
 
-TLC knows where you are and what's next.
+Shows what's next, asks "Proceed? [Y/n]", then executes. That's it.
+
+Or use `/tlc` for the full dashboard.
 
 ---
 
@@ -70,6 +72,8 @@ TLC knows where you are and what's next.
 ### For Solo Developers
 
 - **Test-first by default** — Claude writes tests before code
+- **Auto-parallelization** — Up to 10 agents run independent tasks simultaneously
+- **`/tlc:next`** — One command to progress. No decisions needed.
 - **Smart dashboard** — See progress, run actions
 - **Coverage gaps** — Find and fix untested code
 - **Auto-fix** — Automatically repair failing tests
@@ -95,10 +99,11 @@ TLC knows where you are and what's next.
 
 | Command | What It Does |
 |---------|--------------|
-| `/tlc` | **Smart entry point — knows what's next** |
+| `/tlc:next` | **Just do it — shows next action, asks once, executes** |
+| `/tlc` | Smart dashboard — full status view |
 | `/tlc:new-project` | Start new project with roadmap |
 | `/tlc:init` | Add TLC to existing codebase |
-| `/tlc:build` | Write tests → implement → verify |
+| `/tlc:build` | Write tests → implement (auto-parallelizes up to 10 agents) |
 | `/tlc:coverage` | Find and fix untested code |
 | `/tlc:quality` | Test quality scoring |
 | `/tlc:autofix` | Auto-repair failing tests |

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "tlc-claude-code",
-  "version": "1.2.28",
+  "version": "1.2.29",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc": "./bin/tlc.js",
-    "tlc-claude-code": "./bin/install.js"
+    "tlc-claude-code": "./bin/install.js",
+    "tlc-docs": "./scripts/project-docs.js"
   },
   "files": [
     "bin/",
@@ -16,6 +17,8 @@
     "server/package.json",
     "server/package-lock.json",
     "server/setup.sh",
+    "scripts/",
+    "templates/",
     "docker-compose.dev.yml",
     "start-dev.ps1",
     "start-dev.sh",
@@ -26,7 +29,11 @@
   ],
   "scripts": {
     "build": "cd dashboard && npm run build",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "docs": "node scripts/docs-update.js",
+    "docs:check": "node scripts/docs-update.js --check",
+    "docs:screenshots": "node scripts/generate-screenshots.js",
+    "docs:capture": "node scripts/capture-screenshots.js"
   },
   "repository": {
     "type": "git",
@@ -41,5 +48,9 @@
     "testing"
   ],
   "author": "Jurgen Calleja",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "playwright": "^1.58.1",
+    "text-to-image": "^8.0.1"
+  }
 }

package/scripts/capture-screenshots.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Capture real screenshots using Playwright
+ *
+ * Usage:
+ *   node scripts/capture-screenshots.js          # All screenshots
+ *   node scripts/capture-screenshots.js dashboard # Dashboard only
+ *   node scripts/capture-screenshots.js terminal  # Terminal mockups only
+ */
+
+const { chromium } = require('playwright');
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const OUTPUT_DIR = path.join(__dirname, '../docs/wiki/images');
+const DASHBOARD_URL = process.env.TLC_DASHBOARD_URL || 'http://localhost:3147';
+
+// Ensure output directory exists
+if (!fs.existsSync(OUTPUT_DIR)) {
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+/**
+ * Check if dashboard is running
+ */
+async function isDashboardRunning() {
+  try {
+    const response = await fetch(DASHBOARD_URL);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start dashboard server
+ */
+async function startDashboard() {
+  return new Promise((resolve, reject) => {
+    console.log('Starting TLC dashboard...');
+    const proc = spawn('node', ['server/index.js'], {
+      cwd: path.join(__dirname, '..'),
+      detached: true,
+      stdio: 'ignore',
+    });
+    proc.unref();
+
+    // Wait for server to be ready
+    let attempts = 0;
+    const check = setInterval(async () => {
+      attempts++;
+      if (await isDashboardRunning()) {
+        clearInterval(check);
+        resolve(proc);
+      } else if (attempts > 30) {
+        clearInterval(check);
+        reject(new Error('Dashboard failed to start'));
+      }
+    }, 1000);
+  });
+}
+
+/**
+ * Capture dashboard screenshots
+ */
+async function captureDashboard(browser) {
+  console.log('\nCapturing dashboard screenshots...');
+
+  const page = await browser.newPage();
+  await page.setViewportSize({ width: 1280, height: 800 });
+
+  try {
+    // Main dashboard
+    await page.goto(DASHBOARD_URL, { waitUntil: 'networkidle' });
+    await page.waitForTimeout(1000);
+    await page.screenshot({
+      path: path.join(OUTPUT_DIR, 'dashboard-overview.png'),
+      fullPage: false,
+    });
+    console.log('  ✓ dashboard-overview.png');
+
+    // Try to navigate to different tabs if they exist
+    const tabs = ['tasks', 'logs', 'team', 'settings'];
+    for (const tab of tabs) {
+      try {
+        const tabSelector = `[data-tab="${tab}"], [href="#${tab}"], button:has-text("${tab}")`;
+        const tabElement = await page.$(tabSelector);
+        if (tabElement) {
+          await tabElement.click();
+          await page.waitForTimeout(500);
+          await page.screenshot({
+            path: path.join(OUTPUT_DIR, `dashboard-${tab}.png`),
+            fullPage: false,
+          });
+          console.log(`  ✓ dashboard-${tab}.png`);
+        }
+      } catch (e) {
+        // Tab might not exist, skip
+      }
+    }
+  } catch (error) {
+    console.log(`  ⚠ Dashboard capture failed: ${error.message}`);
+  } finally {
+    await page.close();
+  }
+}
+
+/**
+ * Generate terminal-style screenshots using text-to-image
+ */
+async function captureTerminal() {
+  console.log('\nGenerating terminal screenshots...');
+
+  // Import the generator script
+  const generateScript = path.join(__dirname, 'generate-screenshots.js');
+  if (fs.existsSync(generateScript)) {
+    require(generateScript);
+  } else {
+    console.log('  ⚠ generate-screenshots.js not found, skipping terminal screenshots');
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const mode = process.argv[2] || 'all';
+  console.log(`Screenshot capture mode: ${mode}`);
+
+  let browser;
+  let dashboardStarted = false;
+
+  try {
+    if (mode === 'all' || mode === 'dashboard') {
+      // Check if dashboard is running
+      const running = await isDashboardRunning();
+
+      if (!running) {
+        console.log('Dashboard not running. Starting...');
+        try {
+          await startDashboard();
+          dashboardStarted = true;
+        } catch (e) {
+          console.log('Could not start dashboard, will use terminal mockups only');
+        }
+      }
+
+      if (await isDashboardRunning()) {
+        browser = await chromium.launch({ headless: true });
+        await captureDashboard(browser);
+      }
+    }
+
+    if (mode === 'all' || mode === 'terminal') {
+      await captureTerminal();
+    }
+
+    console.log('\n✓ Screenshot capture complete!');
+  } catch (error) {
+    console.error('Screenshot capture failed:', error.message);
+    process.exit(1);
+  } finally {
+    if (browser) {
+      await browser.close();
+    }
+  }
+}
+
+main();

package/scripts/docs-update.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * Documentation maintenance script
+ *
+ * Automatically:
+ * - Updates version references in docs
+ * - Checks for missing command documentation
+ * - Validates internal links
+ * - Regenerates screenshots if needed
+ *
+ * Usage:
+ *   node scripts/docs-update.js           # Full update
+ *   node scripts/docs-update.js --check   # Check only, no changes
+ *   node scripts/docs-update.js --screenshots # Regenerate screenshots
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const DOCS_DIR = path.join(ROOT, 'docs/wiki');
+const COMMANDS_DIR = path.join(ROOT, '.claude/commands/tlc');
+const PACKAGE_JSON = path.join(ROOT, 'package.json');
+
+const args = process.argv.slice(2);
+const checkOnly = args.includes('--check');
+const screenshotsOnly = args.includes('--screenshots');
+
+/**
+ * Get current version from package.json
+ */
+function getVersion() {
+  const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf-8'));
+  return pkg.version;
+}
+
+/**
+ * Get all command files
+ */
+function getCommands() {
+  if (!fs.existsSync(COMMANDS_DIR)) return [];
+
+  return fs.readdirSync(COMMANDS_DIR)
+    .filter(f => f.endsWith('.md'))
+    .map(f => {
+      const content = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf-8');
+      const name = f.replace('.md', '');
+      const titleMatch = content.match(/^#\s+(.+)/m);
+      const title = titleMatch ? titleMatch[1] : name;
+
+      return { name, title, file: f };
+    });
+}
+
+/**
+ * Check command-reference.md for missing commands
+ */
+function checkCommandDocs() {
+  const commandRefPath = path.join(DOCS_DIR, 'command-reference.md');
+  if (!fs.existsSync(commandRefPath)) {
+    console.log('⚠ command-reference.md not found');
+    return { missing: [], outdated: [] };
+  }
+
+  const content = fs.readFileSync(commandRefPath, 'utf-8');
+  const commands = getCommands();
+
+  const missing = commands.filter(cmd => {
+    const pattern = new RegExp(`/tlc:${cmd.name}[^a-z]`, 'i');
+    return !pattern.test(content) && cmd.name !== 'tlc';
+  });
+
+  return { missing, total: commands.length };
+}
+
+/**
+ * Update version references in docs
+ */
+function updateVersions() {
+  const version = getVersion();
+  const versionPattern = /v\d+\.\d+\.\d+/g;
+
+  let updated = 0;
+
+  const files = fs.readdirSync(DOCS_DIR)
+    .filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    const filepath = path.join(DOCS_DIR, file);
+    let content = fs.readFileSync(filepath, 'utf-8');
+
+    const matches = content.match(versionPattern);
+    if (matches) {
+      const oldContent = content;
+      content = content.replace(versionPattern, `v${version}`);
+
+      if (content !== oldContent && !checkOnly) {
+        fs.writeFileSync(filepath, content);
+        updated++;
+      }
+    }
+  }
+
+  return updated;
+}
+
+/**
+ * Check for broken internal links
+ */
+function checkLinks() {
+  const broken = [];
+
+  const files = fs.readdirSync(DOCS_DIR)
+    .filter(f => f.endsWith('.md'));
+
+  const existingPages = files.map(f => f.replace('.md', ''));
+
+  for (const file of files) {
+    const filepath = path.join(DOCS_DIR, file);
+    const content = fs.readFileSync(filepath, 'utf-8');
+
+    // Find markdown links
+    const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let match;
+
+    while ((match = linkPattern.exec(content)) !== null) {
+      const [, , link] = match;
+
+      // Check internal links (no http/https)
+      if (!link.startsWith('http') && !link.startsWith('#')) {
+        const targetPage = link.replace(/\.md$/, '').replace(/^\//, '');
+
+        if (!existingPages.includes(targetPage) &&
+            !fs.existsSync(path.join(DOCS_DIR, link)) &&
+            !link.startsWith('images/')) {
+          broken.push({ file, link });
+        }
+      }
+    }
+  }
+
+  return broken;
+}
+
+/**
+ * Check screenshots exist
+ */
+function checkScreenshots() {
+  const imagesDir = path.join(DOCS_DIR, 'images');
+  const missing = [];
+
+  if (!fs.existsSync(imagesDir)) {
+    return { missing: ['images directory not found'], existing: 0 };
+  }
+
+  const files = fs.readdirSync(DOCS_DIR)
+    .filter(f => f.endsWith('.md'));
+
+  const existingImages = fs.readdirSync(imagesDir)
+    .filter(f => f.endsWith('.png') || f.endsWith('.jpg'));
+
+  for (const file of files) {
+    const filepath = path.join(DOCS_DIR, file);
+    const content = fs.readFileSync(filepath, 'utf-8');
+
+    // Find image references
+    const imagePattern = /!\[([^\]]*)\]\(images\/([^)]+)\)/g;
+    let match;
+
+    while ((match = imagePattern.exec(content)) !== null) {
+      const [, , imagePath] = match;
+      if (!existingImages.includes(imagePath)) {
+        missing.push({ file, image: imagePath });
+      }
+    }
+  }
+
+  return { missing, existing: existingImages.length };
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  console.log('TLC Documentation Maintenance\n');
+  console.log('═'.repeat(50));
+
+  const version = getVersion();
+  console.log(`\nVersion: ${version}`);
+
+  // Screenshots only mode
+  if (screenshotsOnly) {
+    console.log('\nRegenerating screenshots...');
+    require('./generate-screenshots.js');
+    return;
+  }
+
+  // Check commands
+  console.log('\n📚 Commands');
+  const { missing, total } = checkCommandDocs();
+  console.log(`  ${total} commands found`);
+  if (missing.length > 0) {
+    console.log(`  ⚠ ${missing.length} missing from command-reference.md:`);
+    missing.forEach(cmd => console.log(`    - /tlc:${cmd.name}`));
+  } else {
+    console.log('  ✓ All commands documented');
+  }
+
+  // Check versions
+  console.log('\n🏷️ Versions');
+  const updated = updateVersions();
+  if (checkOnly) {
+    console.log(`  ${updated > 0 ? '⚠' : '✓'} ${updated} files need version update`);
+  } else {
+    console.log(`  ✓ ${updated} files updated to v${version}`);
+  }
+
+  // Check links
+  console.log('\n🔗 Links');
+  const brokenLinks = checkLinks();
+  if (brokenLinks.length > 0) {
+    console.log(`  ⚠ ${brokenLinks.length} broken links:`);
+    brokenLinks.forEach(({ file, link }) => console.log(`    ${file}: ${link}`));
+  } else {
+    console.log('  ✓ All internal links valid');
+  }
+
+  // Check screenshots
+  console.log('\n📸 Screenshots');
+  const { missing: missingImages, existing } = checkScreenshots();
+  console.log(`  ${existing} screenshots found`);
+  if (missingImages.length > 0) {
+    console.log(`  ⚠ ${missingImages.length} missing screenshots:`);
+    missingImages.forEach(({ file, image }) => console.log(`    ${file}: ${image}`));
+  } else {
+    console.log('  ✓ All referenced screenshots exist');
+  }
+
+  // Summary
+  console.log('\n' + '═'.repeat(50));
+
+  const issues = missing.length + brokenLinks.length + missingImages.length;
+  if (issues > 0) {
+    console.log(`\n⚠ ${issues} issue(s) found`);
+    if (!checkOnly) {
+      console.log('Run with --check to see issues without making changes');
+    }
+  } else {
+    console.log('\n✓ Documentation is up to date!');
+  }
+}
+
+main().catch(console.error);