tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/scaffolding/logger-scaffold.js

@@ -0,0 +1,196 @@
+const path = require('path');
+
+function scaffoldLogger({ projectDir, language, framework, fs }) {
+  void framework;
+
+  if (language !== 'javascript' && language !== 'typescript' && language !== 'python' && language !== 'go') {
+    return {
+      files: [],
+      dependencies: [],
+      skipped: true,
+      skipReason: 'unsupported language',
+    };
+  }
+
+  if (language === 'javascript' || language === 'typescript') {
+    if (hasExistingNodeLogger(projectDir, fs)) {
+      return createSkippedResult('existing logger dependency found in package.json');
+    }
+
+    return {
+      files: [
+        {
+          path: 'src/lib/logger.js',
+          content: createNodeLoggerContent(),
+        },
+      ],
+      dependencies: ['pino', 'pino-http'],
+      skipped: false,
+      skipReason: null,
+    };
+  }
+
+  if (language === 'python') {
+    if (hasExistingPythonLogger(projectDir, fs)) {
+      return createSkippedResult('existing logger dependency found in requirements.txt');
+    }
+
+    return {
+      files: [
+        {
+          path: 'src/logger.py',
+          content: createPythonLoggerContent(),
+        },
+      ],
+      dependencies: ['structlog'],
+      skipped: false,
+      skipReason: null,
+    };
+  }
+
+  return {
+    files: [
+      {
+        path: 'internal/logger/logger.go',
+        content: createGoLoggerContent(),
+      },
+    ],
+    dependencies: [],
+    skipped: false,
+    skipReason: null,
+  };
+}
+
+function createSkippedResult(reason) {
+  return {
+    files: [],
+    dependencies: [],
+    skipped: true,
+    skipReason: reason,
+  };
+}
+
+function hasExistingNodeLogger(projectDir, fs) {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+
+  if (!fs || !fs.existsSync || !fs.readFileSync || !fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = {
+      ...(packageJson.dependencies || {}),
+      ...(packageJson.devDependencies || {}),
+      ...(packageJson.peerDependencies || {}),
+      ...(packageJson.optionalDependencies || {}),
+    };
+
+    return ['pino', 'winston', 'bunyan'].some(name => Boolean(dependencies[name]));
+  } catch {
+    return false;
+  }
+}
+
+function hasExistingPythonLogger(projectDir, fs) {
+  const requirementsPath = path.join(projectDir, 'requirements.txt');
+
+  if (!fs || !fs.existsSync || !fs.readFileSync || !fs.existsSync(requirementsPath)) {
+    return false;
+  }
+
+  try {
+    const requirements = fs.readFileSync(requirementsPath, 'utf8');
+    return /(^|\n)\s*structlog(?:[<=>~!].*)?\s*($|\n)/i.test(requirements);
+  } catch {
+    return false;
+  }
+}
+
+function createNodeLoggerContent() {
+  return `const pino = require('pino');
+const pinoHttp = require('pino-http');
+
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  base: undefined,
+  timestamp: pino.stdTimeFunctions.isoTime,
+});
+
+function createChildLogger(bindings = {}) {
+  return logger.child(bindings);
+}
+
+function createRequestLogger() {
+  return pinoHttp({
+    logger,
+    genReqId(req) {
+      return req.id || req.headers['x-request-id'];
+    },
+    customSuccessMessage(req, res) {
+      return \`\${req.method} \${req.url} completed with \${res.statusCode}\`;
+    },
+    customErrorMessage(req, res, error) {
+      return \`\${req.method} \${req.url} failed with \${res.statusCode}: \${error.message}\`;
+    },
+  });
+}
+
+module.exports = {
+  logger,
+  createChildLogger,
+  createRequestLogger,
+};
+`;
+}
+
+function createPythonLoggerContent() {
+  return `import logging
+import sys
+
+import structlog
+
+
+logging.basicConfig(
+    format="%(message)s",
+    stream=sys.stdout,
+    level=logging.INFO,
+)
+
+structlog.configure(
+    processors=[
+        structlog.contextvars.merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.JSONRenderer(),
+    ],
+    wrapper_class=structlog.make_filtering_bound_logger(logging.INFO),
+    logger_factory=structlog.PrintLoggerFactory(file=sys.stdout),
+    cache_logger_on_first_use=True,
+)
+
+
+def get_logger(**bindings):
+    return structlog.get_logger().bind(**bindings)
+`;
+}
+
+function createGoLoggerContent() {
+  return `package logger
+
+import (
+	"log/slog"
+	"os"
+)
+
+func New() *slog.Logger {
+	return slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+}
+`;
+}
+
+module.exports = {
+  scaffoldLogger,
+};

package/server/lib/scaffolding/logger-scaffold.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'vitest';
+
+import { scaffoldLogger } from './logger-scaffold.js';
+
+function createFsMock(files = {}) {
+  return {
+    existsSync(targetPath) {
+      return Object.prototype.hasOwnProperty.call(files, targetPath);
+    },
+    readFileSync(targetPath) {
+      if (!this.existsSync(targetPath)) {
+        throw new Error(`ENOENT: ${targetPath}`);
+      }
+
+      return files[targetPath];
+    },
+  };
+}
+
+describe('scaffoldLogger', () => {
+  it('generates pino setup for Node.js projects', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'javascript',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.skipped).toBe(false);
+    expect(result.skipReason).toBeNull();
+    expect(result.dependencies).toEqual(['pino', 'pino-http']);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('src/lib/logger.js');
+    expect(result.files[0].content).toContain("const pino = require('pino');");
+    expect(result.files[0].content).toContain("const pinoHttp = require('pino-http');");
+    expect(result.files[0].content).toContain('const logger = pino(');
+    expect(result.files[0].content).toContain('function createChildLogger(bindings = {})');
+    expect(result.files[0].content).toContain('function createRequestLogger()');
+  });
+
+  it('generates structlog setup for Python projects', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'python',
+      framework: 'fastapi',
+      fs: createFsMock(),
+    });
+
+    expect(result.skipped).toBe(false);
+    expect(result.skipReason).toBeNull();
+    expect(result.dependencies).toEqual(['structlog']);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('src/logger.py');
+    expect(result.files[0].content).toContain('import logging');
+    expect(result.files[0].content).toContain('import structlog');
+    expect(result.files[0].content).toContain('structlog.configure(');
+    expect(result.files[0].content).toContain('def get_logger(**bindings):');
+  });
+
+  it('generates slog setup for Go projects', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'go',
+      framework: 'gin',
+      fs: createFsMock(),
+    });
+
+    expect(result.skipped).toBe(false);
+    expect(result.skipReason).toBeNull();
+    expect(result.dependencies).toEqual([]);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('internal/logger/logger.go');
+    expect(result.files[0].content).toContain('package logger');
+    expect(result.files[0].content).toContain('"log/slog"');
+    expect(result.files[0].content).toContain('slog.NewJSONHandler');
+  });
+
+  it('skips Node.js generation when pino already exists in package.json', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'typescript',
+      framework: 'express',
+      fs: createFsMock({
+        '/project/package.json': JSON.stringify({
+          dependencies: {
+            pino: '^9.0.0',
+          },
+        }),
+      }),
+    });
+
+    expect(result.skipped).toBe(true);
+    expect(result.skipReason).toContain('existing logger dependency');
+    expect(result.files).toEqual([]);
+  });
+
+  it('skips unsupported languages', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'ruby',
+      framework: 'rails',
+      fs: createFsMock(),
+    });
+
+    expect(result.skipped).toBe(true);
+    expect(result.skipReason).toBe('unsupported language');
+    expect(result.files).toEqual([]);
+    expect(result.dependencies).toEqual([]);
+  });
+
+  it('includes a child logger factory in generated Node.js logger', () => {
+    const result = scaffoldLogger({
+      projectDir: '/project',
+      language: 'javascript',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.files[0].content).toContain('return logger.child(bindings);');
+  });
+
+  it('returns the correct dependencies for each supported language', () => {
+    const nodeResult = scaffoldLogger({
+      projectDir: '/project',
+      language: 'javascript',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+    const pythonResult = scaffoldLogger({
+      projectDir: '/project',
+      language: 'python',
+      framework: 'fastapi',
+      fs: createFsMock(),
+    });
+    const goResult = scaffoldLogger({
+      projectDir: '/project',
+      language: 'go',
+      framework: 'gin',
+      fs: createFsMock(),
+    });
+
+    expect(nodeResult.dependencies).toEqual(['pino', 'pino-http']);
+    expect(pythonResult.dependencies).toEqual(['structlog']);
+    expect(goResult.dependencies).toEqual([]);
+  });
+});

package/server/lib/scaffolding/migration-detector.js

@@ -0,0 +1,78 @@
+const path = require('path');
+
+const ORM_ORDER = ['prisma', 'drizzle', 'typeorm', 'alembic', 'sql'];
+
+function normalizePath(filePath) {
+  return String(filePath || '').replace(/\\/g, '/');
+}
+
+function isTestFile(filePath) {
+  return /\.(test|spec)\.[^.]+$/i.test(path.basename(filePath));
+}
+
+function detectOrmType(filePath) {
+  const normalizedPath = normalizePath(filePath);
+
+  if (/^prisma\/migrations\/.+/.test(normalizedPath)) {
+    return 'prisma';
+  }
+
+  if (/^drizzle\/.+/.test(normalizedPath) || /(^|.+\/)drizzle\/[^/]+\.sql$/i.test(normalizedPath)) {
+    return 'drizzle';
+  }
+
+  if (/^migrations\/[^/]+\.(ts|js)$/i.test(normalizedPath)) {
+    return 'typeorm';
+  }
+
+  if (/^alembic\/versions\/.+/.test(normalizedPath)) {
+    return 'alembic';
+  }
+
+  if (/^migrations\/[^/]+\.sql$/i.test(normalizedPath) || /^db\/migrate\/[^/]+\.sql$/i.test(normalizedPath)) {
+    return 'sql';
+  }
+
+  return null;
+}
+
+function detectMigrations({ diffFiles = [] } = {}) {
+  const detectedFiles = [];
+  const detectedOrmTypes = new Set();
+
+  for (const diffFile of diffFiles) {
+    const normalizedPath = normalizePath(diffFile);
+
+    if (!normalizedPath || isTestFile(normalizedPath)) {
+      continue;
+    }
+
+    const ormType = detectOrmType(normalizedPath);
+    if (!ormType) {
+      continue;
+    }
+
+    detectedFiles.push(diffFile);
+    detectedOrmTypes.add(ormType);
+  }
+
+  if (detectedFiles.length === 0) {
+    return {
+      hasMigrations: false,
+      migrationFiles: [],
+      ormType: null,
+    };
+  }
+
+  const ormType = ORM_ORDER.find((candidate) => detectedOrmTypes.has(candidate)) || null;
+
+  return {
+    hasMigrations: true,
+    migrationFiles: detectedFiles,
+    ormType,
+  };
+}
+
+module.exports = {
+  detectMigrations,
+};

package/server/lib/scaffolding/migration-detector.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+
+const { detectMigrations } = require('./migration-detector');
+
+describe('migration-detector', () => {
+  it('detects Prisma migration with correct ormType', () => {
+    const result = detectMigrations({
+      diffFiles: ['prisma/migrations/20260330120000_init/migration.sql'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: ['prisma/migrations/20260330120000_init/migration.sql'],
+      ormType: 'prisma',
+    });
+  });
+
+  it('detects Drizzle migration', () => {
+    const result = detectMigrations({
+      diffFiles: ['src/drizzle/0002_add_users.sql'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: ['src/drizzle/0002_add_users.sql'],
+      ormType: 'drizzle',
+    });
+  });
+
+  it('detects TypeORM migration', () => {
+    const result = detectMigrations({
+      diffFiles: ['migrations/1711824000000-create-users.ts'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: ['migrations/1711824000000-create-users.ts'],
+      ormType: 'typeorm',
+    });
+  });
+
+  it('detects Alembic migration', () => {
+    const result = detectMigrations({
+      diffFiles: ['alembic/versions/abc123_create_users.py'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: ['alembic/versions/abc123_create_users.py'],
+      ormType: 'alembic',
+    });
+  });
+
+  it('detects raw SQL migration', () => {
+    const result = detectMigrations({
+      diffFiles: ['db/migrate/20260330121000_create_users.sql'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: ['db/migrate/20260330121000_create_users.sql'],
+      ormType: 'sql',
+    });
+  });
+
+  it('does not detect test files with migration in the name', () => {
+    const result = detectMigrations({
+      diffFiles: ['tests/migration-detector.test.js', 'specs/user-migration.spec.ts'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: false,
+      migrationFiles: [],
+      ormType: null,
+    });
+  });
+
+  it('returns false when there are no migration files', () => {
+    const result = detectMigrations({
+      diffFiles: ['src/index.js', 'README.md'],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: false,
+      migrationFiles: [],
+      ormType: null,
+    });
+  });
+
+  it('returns all matching migration files when multiple are present', () => {
+    const result = detectMigrations({
+      diffFiles: [
+        'prisma/migrations/20260330120000_init/migration.sql',
+        'prisma/migrations/20260330130000_add_users/migration.sql',
+      ],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: [
+        'prisma/migrations/20260330120000_init/migration.sql',
+        'prisma/migrations/20260330130000_add_users/migration.sql',
+      ],
+      ormType: 'prisma',
+    });
+  });
+
+  it('returns only migration files from a mixed file list', () => {
+    const result = detectMigrations({
+      diffFiles: [
+        'src/index.js',
+        'migrations/1711824000000-create-users.js',
+        'docs/migrations.md',
+        'db/migrate/20260330121000_create_users.sql',
+      ],
+    });
+
+    expect(result).toEqual({
+      hasMigrations: true,
+      migrationFiles: [
+        'migrations/1711824000000-create-users.js',
+        'db/migrate/20260330121000_create_users.sql',
+      ],
+      ormType: 'typeorm',
+    });
+  });
+});

package/server/lib/scaffolding/snapshot-manager.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const path = require('path');
+
+function quote(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+function formatDate(date = new Date()) {
+  return date.toISOString().slice(0, 10);
+}
+
+function sanitizeSegment(value) {
+  return String(value || 'unknown').replace(/[^a-zA-Z0-9._-]+/g, '-');
+}
+
+function getDbName(dbType, connectionString) {
+  if (dbType === 'sqlite') {
+    return sanitizeSegment(path.basename(connectionString, path.extname(connectionString)));
+  }
+
+  const parsed = new URL(connectionString);
+  return sanitizeSegment(parsed.pathname.replace(/^\/+/, '') || 'database');
+}
+
+function buildSnapshotPath({ dbType, connectionString, snapshotDir, gitRef }) {
+  const date = formatDate();
+  const dbName = getDbName(dbType, connectionString);
+  const filename = `${date}-${sanitizeSegment(gitRef)}-${dbName}.dump`;
+  return path.join(snapshotDir, filename);
+}
+
+function parseDbUrl(connectionString) {
+  const parsed = new URL(connectionString);
+  return {
+    host: parsed.hostname,
+    port: parsed.port,
+    user: decodeURIComponent(parsed.username || ''),
+    password: decodeURIComponent(parsed.password || ''),
+    dbName: parsed.pathname.replace(/^\/+/, ''),
+  };
+}
+
+async function takeSnapshot({ dbType, connectionString, snapshotDir, gitRef, exec, fs: fileSystem = fs }) {
+  const snapshotPath = buildSnapshotPath({ dbType, connectionString, snapshotDir, gitRef });
+
+  try {
+    if (dbType === 'postgresql') {
+      await exec(`pg_dump --format=custom -f ${quote(snapshotPath)} ${quote(connectionString)}`);
+    } else if (dbType === 'mysql') {
+      const { host, port, user, password, dbName } = parseDbUrl(connectionString);
+      await exec(
+        `mysqldump --host=${host} --port=${port || 3306} --user=${user} --password=${password} ${dbName} > ${quote(snapshotPath)}`
+      );
+    } else if (dbType === 'sqlite') {
+      fileSystem.copyFileSync(connectionString, snapshotPath);
+    } else {
+      throw new Error(`Unsupported dbType: ${dbType}`);
+    }
+
+    return { success: true, snapshotPath };
+  } catch (error) {
+    return { success: false, error, reason: error.message };
+  }
+}
+
+async function restoreSnapshot({ snapshotPath, dbType, connectionString, exec, fs: fileSystem = fs }) {
+  try {
+    if (dbType === 'postgresql') {
+      await exec(
+        `pg_restore --clean --if-exists --dbname=${quote(connectionString)} ${quote(snapshotPath)}`
+      );
+    } else if (dbType === 'mysql') {
+      const { host, port, user, password, dbName } = parseDbUrl(connectionString);
+      await exec(
+        `mysql --host=${host} --port=${port || 3306} --user=${user} --password=${password} ${dbName} < ${quote(snapshotPath)}`
+      );
+    } else if (dbType === 'sqlite') {
+      fileSystem.copyFileSync(snapshotPath, connectionString);
+    } else {
+      throw new Error(`Unsupported dbType: ${dbType}`);
+    }
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error, reason: error.message };
+  }
+}
+
+function parseSnapshotFilename(filename) {
+  const match = filename.match(/^(\d{4}-\d{2}-\d{2})-(.+)-([^-]+)\.dump$/);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    date: match[1],
+    gitRef: match[2],
+    dbName: match[3],
+  };
+}
+
+function listSnapshots({ snapshotDir, fs: fileSystem = fs }) {
+  return fileSystem
+    .readdirSync(snapshotDir)
+    .map((filename) => {
+      const parsed = parseSnapshotFilename(filename);
+      if (!parsed) {
+        return null;
+      }
+
+      const fullPath = path.join(snapshotDir, filename);
+      const stats = fileSystem.statSync(fullPath);
+
+      return {
+        path: fullPath,
+        date: parsed.date,
+        gitRef: parsed.gitRef,
+        dbName: parsed.dbName,
+        size: stats.size,
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.date.localeCompare(a.date) || b.path.localeCompare(a.path));
+}
+
+function enforceRetention({ snapshotDir, maxSnapshots = 10, fs: fileSystem = fs }) {
+  const snapshots = listSnapshots({ snapshotDir, fs: fileSystem });
+  const staleSnapshots = snapshots.slice(maxSnapshots).reverse();
+
+  for (const snapshot of staleSnapshots) {
+    fileSystem.unlinkSync(snapshot.path);
+  }
+
+  return staleSnapshots.map((snapshot) => snapshot.path);
+}
+
+module.exports = {
+  takeSnapshot,
+  restoreSnapshot,
+  listSnapshots,
+  enforceRetention,
+};