tlc-claude-code 0.9.6 → 0.9.8

package/server/lib/auto-database.js

@@ -5,6 +5,7 @@ const { execSync, spawn, spawnSync } = require('child_process');
 let pgServer = null;
 let pgliteInstance = null;
 let dockerContainer = null;
+let minioContainer = null;
 
 /**
  * Install Docker automatically with sudo prompt
@@ -152,6 +153,65 @@ function detectDatabaseNeed(projectDir) {
   return null;
 }
 
+/**
+ * Detect if project needs S3-compatible storage (MinIO)
+ */
+function detectStorageNeed(projectDir) {
+  // Check package.json for S3/storage dependencies
+  const pkgPath = path.join(projectDir, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // AWS S3 SDK indicators
+    if (allDeps['aws-sdk'] || allDeps['@aws-sdk/client-s3'] || allDeps['@aws-sdk/s3-request-presigner']) {
+      return 'minio';
+    }
+
+    // MinIO client
+    if (allDeps['minio']) {
+      return 'minio';
+    }
+
+    // Common S3-compatible libraries
+    if (allDeps['multer-s3'] || allDeps['s3-blob-store'] || allDeps['@smithy/node-http-handler']) {
+      return 'minio';
+    }
+  }
+
+  // Check for S3/storage environment variable references in code
+  const serverDir = path.join(projectDir, 'server');
+  const srcDir = path.join(projectDir, 'src');
+
+  const dirsToCheck = [serverDir, srcDir, projectDir];
+  for (const dir of dirsToCheck) {
+    if (fs.existsSync(dir)) {
+      try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+        for (const file of files) {
+          const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+          if (content.includes('S3_ENDPOINT') || content.includes('S3_BUCKET') ||
+              content.includes('MINIO_ENDPOINT') || content.includes('AWS_S3_') ||
+              content.includes('S3Client') || content.includes('new Minio')) {
+            return 'minio';
+          }
+        }
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if S3/MinIO is already configured
+ */
+function hasStorageConfig() {
+  return !!(process.env.S3_ENDPOINT || process.env.MINIO_ENDPOINT || process.env.AWS_ENDPOINT_URL_S3);
+}
+
 /**
  * Check if DATABASE_URL is already set
  */
@@ -697,6 +757,244 @@ async function provisionPostgres(projectDir, logger) {
   return await provisionPGlite(projectDir, logger);
 }
 
+/**
+ * Provision MinIO using Docker
+ */
+async function provisionDockerMinio(projectDir, logger) {
+  const containerName = 'tlc-minio';
+  const apiPort = 9000;
+  const consolePort = 9001;
+  const accessKey = 'minioadmin';
+  const secretKey = 'minioadmin';
+  const defaultBucket = 'uploads';
+
+  // Check if container already exists and is running
+  try {
+    const status = execSync(`docker inspect -f '{{.State.Running}}' ${containerName} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+    if (status === 'true') {
+      logger('Using existing MinIO container');
+      return getMinioEnvVars(apiPort, accessKey, secretKey, defaultBucket);
+    }
+  } catch {
+    // Container doesn't exist, create it
+  }
+
+  // Remove existing stopped container if any
+  try {
+    execSync(`docker rm -f ${containerName} 2>/dev/null`, { stdio: 'ignore' });
+  } catch {
+    // Ignore
+  }
+
+  logger('Starting MinIO container...');
+
+  // Create data directory for persistence
+  const dataDir = path.join(projectDir, '.tlc', 'minio-data');
+  const tlcDir = path.join(projectDir, '.tlc');
+  if (!fs.existsSync(tlcDir)) {
+    fs.mkdirSync(tlcDir, { recursive: true });
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf-8');
+      if (!content.includes('.tlc')) {
+        fs.appendFileSync(gitignorePath, '\n# TLC local data\n.tlc/\n');
+      }
+    }
+  }
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  // Start MinIO container
+  const dockerCmd = [
+    'docker', 'run', '-d',
+    '--name', containerName,
+    '-e', `MINIO_ROOT_USER=${accessKey}`,
+    '-e', `MINIO_ROOT_PASSWORD=${secretKey}`,
+    '-p', `${apiPort}:9000`,
+    '-p', `${consolePort}:9001`,
+    '-v', `${dataDir}:/data`,
+    'minio/minio:latest',
+    'server', '/data', '--console-address', ':9001'
+  ].join(' ');
+
+  execSync(dockerCmd, { stdio: 'inherit' });
+  minioContainer = containerName;
+
+  // Wait for MinIO to be ready
+  logger('Waiting for MinIO to start...');
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync(`docker exec ${containerName} curl -sf http://127.0.0.1:9000/minio/health/live`, { stdio: 'ignore', timeout: 2000 });
+      break;
+    } catch {
+      await new Promise(r => setTimeout(r, 1000));
+    }
+  }
+
+  // Create default bucket
+  await createMinioBucket(containerName, defaultBucket, logger);
+
+  logger(`MinIO ready: http://127.0.0.1:${apiPort} (console: http://127.0.0.1:${consolePort})`);
+
+  return getMinioEnvVars(apiPort, accessKey, secretKey, defaultBucket);
+}
+
+/**
+ * Create a bucket in MinIO
+ */
+async function createMinioBucket(containerName, bucketName, logger, useSudo = false) {
+  const sudoPrefix = useSudo ? 'sudo ' : '';
+  try {
+    // Use mc (MinIO Client) inside the container to create bucket
+    execSync(
+      `${sudoPrefix}docker exec ${containerName} mc alias set local http://127.0.0.1:9000 minioadmin minioadmin`,
+      { stdio: 'ignore', timeout: 5000 }
+    );
+    execSync(
+      `${sudoPrefix}docker exec ${containerName} mc mb --ignore-existing local/${bucketName}`,
+      { stdio: 'ignore', timeout: 5000 }
+    );
+    logger(`Created bucket: ${bucketName}`);
+  } catch (err) {
+    // Bucket might already exist or mc not available, that's OK
+    logger(`Bucket setup: ${bucketName} (may already exist)`);
+  }
+}
+
+/**
+ * Get MinIO environment variables
+ */
+function getMinioEnvVars(port, accessKey, secretKey, bucket) {
+  return {
+    S3_ENDPOINT: `http://127.0.0.1:${port}`,
+    S3_ACCESS_KEY: accessKey,
+    S3_SECRET_KEY: secretKey,
+    S3_BUCKET: bucket,
+    S3_REGION: 'us-east-1',
+    S3_FORCE_PATH_STYLE: 'true',
+    // Also set AWS-style vars for broader compatibility
+    AWS_ENDPOINT_URL_S3: `http://127.0.0.1:${port}`,
+    AWS_ACCESS_KEY_ID: accessKey,
+    AWS_SECRET_ACCESS_KEY: secretKey,
+    AWS_REGION: 'us-east-1'
+  };
+}
+
+/**
+ * Provision MinIO with sudo (for fresh Docker installs)
+ */
+async function provisionDockerMinioWithSudo(projectDir, logger) {
+  const containerName = 'tlc-minio';
+  const apiPort = 9000;
+  const consolePort = 9001;
+  const accessKey = 'minioadmin';
+  const secretKey = 'minioadmin';
+  const defaultBucket = 'uploads';
+
+  // Check if container already exists and is running
+  try {
+    const status = execSync(`sudo docker inspect -f '{{.State.Running}}' ${containerName} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+    if (status === 'true') {
+      logger('Using existing MinIO container');
+      return getMinioEnvVars(apiPort, accessKey, secretKey, defaultBucket);
+    }
+  } catch {
+    // Container doesn't exist
+  }
+
+  // Remove existing stopped container
+  try {
+    execSync(`sudo docker rm -f ${containerName} 2>/dev/null`, { stdio: 'ignore' });
+  } catch {
+    // Ignore
+  }
+
+  logger('Starting MinIO container...');
+
+  // Create data directory
+  const dataDir = path.join(projectDir, '.tlc', 'minio-data');
+  const tlcDir = path.join(projectDir, '.tlc');
+  if (!fs.existsSync(tlcDir)) {
+    fs.mkdirSync(tlcDir, { recursive: true });
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf-8');
+      if (!content.includes('.tlc')) {
+        fs.appendFileSync(gitignorePath, '\n# TLC local data\n.tlc/\n');
+      }
+    }
+  }
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  // Start MinIO container with sudo
+  execSync(
+    `sudo docker run -d --name ${containerName} -e MINIO_ROOT_USER=${accessKey} -e MINIO_ROOT_PASSWORD=${secretKey} -p ${apiPort}:9000 -p ${consolePort}:9001 -v ${dataDir}:/data minio/minio:latest server /data --console-address :9001`,
+    { stdio: 'inherit' }
+  );
+  minioContainer = containerName;
+
+  // Wait for MinIO to be ready
+  logger('Waiting for MinIO to start...');
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync(`sudo docker exec ${containerName} curl -sf http://127.0.0.1:9000/minio/health/live`, { stdio: 'ignore', timeout: 2000 });
+      break;
+    } catch {
+      await new Promise(r => setTimeout(r, 1000));
+    }
+  }
+
+  // Create default bucket
+  await createMinioBucket(containerName, defaultBucket, logger, true);
+
+  logger(`MinIO ready: http://127.0.0.1:${apiPort} (console: http://127.0.0.1:${consolePort})`);
+
+  return getMinioEnvVars(apiPort, accessKey, secretKey, defaultBucket);
+}
+
+/**
+ * Provision MinIO - try Docker, with fallback handling
+ */
+async function provisionMinio(projectDir, logger) {
+  // Try Docker first
+  if (isDockerAvailable()) {
+    try {
+      return await provisionDockerMinio(projectDir, logger);
+    } catch (err) {
+      logger(`Docker MinIO failed: ${err.message}`);
+      throw err;
+    }
+  } else if (isDockerInstalled()) {
+    // Docker is installed but not running - try to start it
+    const started = await startDockerService(logger);
+    if (started) {
+      try {
+        return await provisionDockerMinio(projectDir, logger);
+      } catch (err) {
+        logger(`Docker MinIO failed: ${err.message}`);
+        throw err;
+      }
+    }
+  }
+
+  // Try with sudo if Docker was just installed
+  if (isDockerInstalled()) {
+    logger('Trying MinIO with elevated permissions...');
+    try {
+      return await provisionDockerMinioWithSudo(projectDir, logger);
+    } catch (err) {
+      logger(`Docker MinIO with sudo failed: ${err.message}`);
+      throw err;
+    }
+  }
+
+  // No fallback for MinIO - it requires Docker
+  throw new Error('MinIO requires Docker. Please install Docker to use S3-compatible storage.');
+}
+
 /**
  * Stop the database if running
  */
@@ -727,35 +1025,52 @@ async function stopDatabase() {
 }
 
 /**
- * Auto-provision database if needed
+ * Auto-provision database and storage if needed
  * Returns environment variables to add
  */
 async function autoProvision(projectDir, logger = console.log) {
-  const dbType = detectDatabaseNeed(projectDir);
+  const envVars = {};
 
-  if (!dbType) {
-    return {}; // No database needed
-  }
-
-  if (hasDatabaseUrl()) {
-    logger('Using existing DATABASE_URL');
-    return {}; // Already configured
+  // Check for database needs
+  const dbType = detectDatabaseNeed(projectDir);
+  if (dbType) {
+    if (hasDatabaseUrl()) {
+      logger('Using existing DATABASE_URL');
+    } else {
+      logger(`Detected ${dbType} database requirement`);
+      if (dbType === 'postgres') {
+        const databaseUrl = await provisionPostgres(projectDir, logger);
+        envVars.DATABASE_URL = databaseUrl;
+      } else {
+        logger(`Auto-provisioning for ${dbType} not yet supported`);
+      }
+    }
   }
 
-  logger(`Detected ${dbType} database requirement`);
-
-  if (dbType === 'postgres') {
-    const databaseUrl = await provisionPostgres(projectDir, logger);
-    return { DATABASE_URL: databaseUrl };
+  // Check for storage needs
+  const storageType = detectStorageNeed(projectDir);
+  if (storageType) {
+    if (hasStorageConfig()) {
+      logger('Using existing S3/MinIO configuration');
+    } else {
+      logger(`Detected ${storageType} storage requirement`);
+      if (storageType === 'minio') {
+        try {
+          const storageEnv = await provisionMinio(projectDir, logger);
+          Object.assign(envVars, storageEnv);
+        } catch (err) {
+          logger(`Storage provisioning failed: ${err.message}`);
+        }
+      }
+    }
   }
 
-  // For other database types, we could add support later
-  logger(`Auto-provisioning for ${dbType} not yet supported`);
-  return {};
+  return envVars;
 }
 
 module.exports = {
   detectDatabaseNeed,
+  detectStorageNeed,
   autoProvision,
   stopDatabase
 };

package/server/lib/autofix-command.js

@@ -0,0 +1,134 @@
+/**
+ * AutoFix Command - CLI interface for automatic test failure recovery
+ */
+
+const {
+  parseTestFailure,
+  matchErrorPattern,
+  generateFixProposal,
+} = require('./autofix-engine.js');
+
+/**
+ * Analyze test output and categorize failures
+ * @param {string} testOutput - Raw test runner output
+ * @returns {Object} Analysis result with failures and proposals
+ */
+function analyzeFailures(testOutput) {
+  const failures = [];
+  const fixable = [];
+  const unfixable = [];
+
+  // Split output by FAIL markers
+  const failureBlocks = testOutput.split(/(?=FAIL\s+)/);
+
+  for (const block of failureBlocks) {
+    if (!block.includes('FAIL')) continue;
+
+    const failure = parseTestFailure(block);
+    if (!failure) continue;
+
+    // Match error pattern and generate proposal
+    const pattern = matchErrorPattern(failure.error);
+    const proposal = generateFixProposal(failure, pattern);
+
+    const fullFailure = {
+      ...failure,
+      pattern,
+      proposal,
+    };
+
+    failures.push(fullFailure);
+
+    if (proposal.confidence === 'high' || proposal.confidence === 'medium') {
+      fixable.push(fullFailure);
+    } else {
+      unfixable.push(fullFailure);
+    }
+  }
+
+  return {
+    failures,
+    fixable,
+    unfixable,
+    total: failures.length,
+  };
+}
+
+/**
+ * Format progress indicator for CLI output
+ * @param {number} current - Current item number
+ * @param {number} total - Total items
+ * @param {string} message - Current action description
+ * @returns {string} Formatted progress string
+ */
+function formatFixProgress(current, total, message) {
+  const pct = Math.round((current / total) * 100);
+  const bar = '█'.repeat(Math.round(pct / 5)) + '░'.repeat(20 - Math.round(pct / 5));
+
+  return [
+    `[${bar}] ${current}/${total} (${pct}%)`,
+    `  ${message}`,
+  ].join('\n');
+}
+
+/**
+ * Format summary of fix attempts
+ * @param {Object} results - Fix results
+ * @returns {string} Formatted summary
+ */
+function formatFixSummary(results) {
+  const lines = [];
+
+  lines.push('');
+  lines.push('AutoFix Summary');
+  lines.push('═══════════════');
+  lines.push('');
+
+  if (results.total === 0) {
+    lines.push('No test failures found.');
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  // Stats
+  lines.push(`Total:  ${results.total}`);
+  lines.push(`fixed:  ${results.fixed} ✓`);
+  lines.push(`failed: ${results.failed} ✗`);
+  lines.push('');
+
+  // Fixed tests
+  if (results.fixed > 0) {
+    lines.push('Successfully fixed:');
+    for (const detail of results.details.filter(d => d.status === 'fixed')) {
+      lines.push(`  ✓ ${detail.testName}`);
+      lines.push(`    ${detail.description}`);
+    }
+    lines.push('');
+  }
+
+  // Failed tests
+  if (results.failed > 0) {
+    lines.push('Could not fix:');
+    for (const detail of results.details.filter(d => d.status === 'failed')) {
+      lines.push(`  ✗ ${detail.testName}`);
+      lines.push(`    Reason: ${detail.reason}`);
+    }
+    lines.push('');
+  }
+
+  // Commit prompt
+  if (results.fixed > 0) {
+    lines.push('Commit fixes?');
+    lines.push('  1) Yes - commit all fixes');
+    lines.push('  2) No - review changes first');
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  analyzeFailures,
+  formatFixProgress,
+  formatFixSummary,
+};

package/server/lib/autofix-command.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import {
+  analyzeFailures,
+  formatFixProgress,
+  formatFixSummary,
+} from './autofix-command.js';
+
+describe('autofix-command', () => {
+  describe('analyzeFailures', () => {
+    it('parses multiple test failures', () => {
+      const testOutput = `
+ FAIL  src/auth.test.ts > login > rejects invalid password
+TypeError: Cannot read properties of null (reading 'email')
+    at src/auth.test.ts:15:20
+
+ FAIL  src/user.test.ts > getUser > returns user object
+AssertionError: expected undefined to equal 'test@test.com'
+    at src/user.test.ts:25:10
+      `;
+
+      const result = analyzeFailures(testOutput);
+
+      expect(result.failures).toHaveLength(2);
+      expect(result.failures[0].testName).toContain('rejects invalid password');
+      expect(result.failures[1].testName).toContain('returns user object');
+    });
+
+    it('includes fix proposals for each failure', () => {
+      const testOutput = `
+ FAIL  src/auth.test.ts > login > rejects invalid password
+TypeError: Cannot read properties of null (reading 'email')
+    at src/auth.test.ts:15:20
+      `;
+
+      const result = analyzeFailures(testOutput);
+
+      expect(result.failures[0]).toHaveProperty('proposal');
+      expect(result.failures[0].proposal.description).toContain('null check');
+    });
+
+    it('returns empty array for passing tests', () => {
+      const testOutput = `
+ ✓ src/auth.test.ts > login > accepts valid password
+ ✓ src/user.test.ts > getUser > returns user object
+
+ Test Files  1 passed
+ Tests       2 passed
+      `;
+
+      const result = analyzeFailures(testOutput);
+
+      expect(result.failures).toHaveLength(0);
+    });
+
+    it('categorizes failures by fixability', () => {
+      const testOutput = `
+ FAIL  src/auth.test.ts > login > rejects invalid password
+TypeError: Cannot read properties of null (reading 'email')
+    at src/auth.test.ts:15:20
+
+ FAIL  src/weird.test.ts > some test > unknown error
+Some random error without a known pattern
+    at src/weird.test.ts:10:5
+      `;
+
+      const result = analyzeFailures(testOutput);
+
+      expect(result.fixable.length).toBeGreaterThanOrEqual(1);
+      expect(result.unfixable.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('formatFixProgress', () => {
+    it('formats progress indicator', () => {
+      const output = formatFixProgress(2, 5, 'Fixing null check in auth.ts');
+
+      expect(output).toContain('2');
+      expect(output).toContain('5');
+      expect(output).toContain('auth.ts');
+    });
+
+    it('shows percentage', () => {
+      const output = formatFixProgress(1, 4, 'Working...');
+
+      expect(output).toContain('25%') || expect(output).toContain('1/4');
+    });
+  });
+
+  describe('formatFixSummary', () => {
+    it('shows success count with checkmarks', () => {
+      const results = {
+        total: 4,
+        fixed: 3,
+        failed: 1,
+        details: [
+          { testName: 'test1', status: 'fixed', description: 'Added null check' },
+          { testName: 'test2', status: 'fixed', description: 'Added import' },
+          { testName: 'test3', status: 'fixed', description: 'Fixed return' },
+          { testName: 'test4', status: 'failed', reason: 'Unknown pattern' },
+        ],
+      };
+
+      const output = formatFixSummary(results);
+
+      expect(output).toContain('3');
+      expect(output).toContain('fixed');
+      expect(output).toContain('1');
+      expect(output).toContain('failed');
+    });
+
+    it('lists unfixable tests with reasons', () => {
+      const results = {
+        total: 2,
+        fixed: 0,
+        failed: 2,
+        details: [
+          { testName: 'complex test', status: 'failed', reason: 'Unknown pattern' },
+          { testName: 'another test', status: 'failed', reason: 'Timeout issue' },
+        ],
+      };
+
+      const output = formatFixSummary(results);
+
+      expect(output).toContain('complex test');
+      expect(output).toContain('Unknown pattern');
+    });
+
+    it('shows commit prompt when fixes applied', () => {
+      const results = {
+        total: 2,
+        fixed: 2,
+        failed: 0,
+        details: [
+          { testName: 'test1', status: 'fixed', description: 'Fix 1' },
+          { testName: 'test2', status: 'fixed', description: 'Fix 2' },
+        ],
+      };
+
+      const output = formatFixSummary(results);
+
+      expect(output).toContain('commit') || expect(output).toContain('Commit');
+    });
+
+    it('shows no changes message when nothing to fix', () => {
+      const results = {
+        total: 0,
+        fixed: 0,
+        failed: 0,
+        details: [],
+      };
+
+      const output = formatFixSummary(results);
+
+      expect(output).toContain('No') || expect(output).toContain('0');
+    });
+  });
+});