tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/scaffolding/ci-scaffolder.js

@@ -0,0 +1,347 @@
+'use strict';
+
+const path = require('path');
+const yaml = require('js-yaml');
+
+function scaffoldCI({ projectDir, platform, gaps, testCommand, deployTarget, fs }) {
+  const warnings = [];
+  const resolvedFs = fs || require('fs');
+  const resolvedPlatform = platform || 'github-actions';
+  const resolvedGaps = Array.isArray(gaps) ? gaps : ['no-ci'];
+
+  if (resolvedPlatform !== 'github-actions') {
+    return {
+      files: [],
+      warnings: [`CI scaffolding for platform "${resolvedPlatform}" is not supported.`],
+    };
+  }
+
+  const resolvedTestCommand = resolveTestCommand({
+    projectDir,
+    testCommand,
+    fs: resolvedFs,
+    warnings,
+  });
+
+  const workflowFiles = listGitHubWorkflowFiles(projectDir, resolvedFs);
+
+  if (resolvedGaps.includes('no-ci') || workflowFiles.length === 0) {
+    return {
+      files: [
+        {
+          path: '.github/workflows/ci.yml',
+          content: dumpWorkflow(
+            createWorkflow({
+              testCommand: resolvedTestCommand,
+              deployTarget,
+            })
+          ),
+        },
+      ],
+      warnings,
+    };
+  }
+
+  const targetWorkflow = pickWorkflowFile(workflowFiles);
+  const workflowPath = path.join(projectDir, targetWorkflow);
+  const workflow = loadWorkflow(workflowPath, resolvedFs, warnings);
+
+  applyMissingSteps({
+    workflow,
+    gaps: resolvedGaps,
+    testCommand: resolvedTestCommand,
+    deployTarget,
+  });
+
+  return {
+    files: [
+      {
+        path: targetWorkflow,
+        content: dumpWorkflow(workflow),
+      },
+    ],
+    warnings,
+  };
+}
+
+function resolveTestCommand({ projectDir, testCommand, fs, warnings }) {
+  const tlcPath = path.join(projectDir, '.tlc.json');
+  const config = readJson(fs, tlcPath, warnings);
+  const frameworks = config && typeof config === 'object' ? config.testFrameworks : null;
+
+  const configuredCommand = getCommandFromFrameworks(frameworks);
+  if (configuredCommand) {
+    return configuredCommand;
+  }
+
+  if (typeof testCommand === 'string' && testCommand.trim()) {
+    return testCommand.trim();
+  }
+
+  if (typeof config?.testCommand === 'string' && config.testCommand.trim()) {
+    return config.testCommand.trim();
+  }
+
+  return 'npm test';
+}
+
+function getCommandFromFrameworks(testFrameworks) {
+  if (!testFrameworks || typeof testFrameworks !== 'object') {
+    return '';
+  }
+
+  if (typeof testFrameworks.command === 'string' && testFrameworks.command.trim()) {
+    return testFrameworks.command.trim();
+  }
+
+  if (typeof testFrameworks.testCommand === 'string' && testFrameworks.testCommand.trim()) {
+    return testFrameworks.testCommand.trim();
+  }
+
+  if (typeof testFrameworks.run === 'string' && testFrameworks.run.trim()) {
+    return testFrameworks.run.trim();
+  }
+
+  if (Array.isArray(testFrameworks.run) && testFrameworks.run.length > 0) {
+    return testFrameworks.run.map(part => String(part)).join(' ').trim();
+  }
+
+  const primary = typeof testFrameworks.primary === 'string' ? testFrameworks.primary.trim().toLowerCase() : '';
+  if (!primary) {
+    return '';
+  }
+
+  const commands = {
+    vitest: 'npx vitest run',
+    jest: 'npx jest',
+    mocha: 'npx mocha',
+    pytest: 'pytest',
+    'go-test': 'go test ./...',
+  };
+
+  return commands[primary] || '';
+}
+
+function readJson(fs, filePath, warnings) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error && error.code !== 'ENOENT') {
+      warnings.push(`Failed to parse ${filePath}: ${error.message}`);
+    }
+    return null;
+  }
+}
+
+function listGitHubWorkflowFiles(projectDir, fs) {
+  const workflowsDir = path.join(projectDir, '.github', 'workflows');
+
+  try {
+    return fs.readdirSync(workflowsDir)
+      .filter(name => /\.ya?ml$/i.test(name))
+      .map(name => path.posix.join('.github/workflows', name))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function pickWorkflowFile(workflowFiles) {
+  return workflowFiles.find(filePath => /ci|test|build/i.test(path.basename(filePath))) || workflowFiles[0];
+}
+
+function loadWorkflow(workflowPath, fs, warnings) {
+  try {
+    const content = fs.readFileSync(workflowPath, 'utf8');
+    const parsed = yaml.load(content);
+
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch (error) {
+    warnings.push(`Failed to parse ${workflowPath}: ${error.message}`);
+  }
+
+  return { name: 'CI', on: { push: {}, pull_request: {} }, jobs: {} };
+}
+
+function createWorkflow({ testCommand, deployTarget }) {
+  return {
+    name: 'CI',
+    on: {
+      push: {
+        branches: ['main', 'master'],
+      },
+      pull_request: {
+        branches: ['main', 'master'],
+      },
+    },
+    jobs: {
+      test: createTestJob(testCommand, true),
+      deploy: createDeployJob(deployTarget),
+    },
+  };
+}
+
+function applyMissingSteps({ workflow, gaps, testCommand, deployTarget }) {
+  if (!workflow.jobs || typeof workflow.jobs !== 'object' || Array.isArray(workflow.jobs)) {
+    workflow.jobs = {};
+  }
+
+  if (gaps.includes('missing-test-step')) {
+    workflow.jobs.test = createTestJob(testCommand, true);
+  } else if (gaps.includes('missing-coverage-upload')) {
+    workflow.jobs.test = ensureTestJob(workflow.jobs.test, testCommand);
+    ensureCoverageStep(workflow.jobs.test);
+  }
+
+  if (gaps.includes('missing-deploy-step')) {
+    workflow.jobs.deploy = createDeployJob(deployTarget);
+  }
+}
+
+function ensureTestJob(job, testCommand) {
+  if (!job || typeof job !== 'object' || Array.isArray(job)) {
+    return createTestJob(testCommand, false);
+  }
+
+  if (!Array.isArray(job.steps)) {
+    job.steps = [];
+  }
+
+  if (!job['runs-on']) {
+    job['runs-on'] = 'ubuntu-latest';
+  }
+
+  if (!job.steps.some(step => step && step.uses === 'actions/checkout@v4')) {
+    job.steps.unshift({
+      name: 'Checkout code',
+      uses: 'actions/checkout@v4',
+    });
+  }
+
+  if (!job.steps.some(step => step && step.uses === 'actions/setup-node@v4')) {
+    job.steps.splice(1, 0, {
+      name: 'Setup Node.js',
+      uses: 'actions/setup-node@v4',
+      with: {
+        'node-version': '20',
+        cache: 'npm',
+      },
+    });
+  }
+
+  if (!job.steps.some(step => step && /install dependencies/i.test(step.name || '') || /npm ci/.test(step.run || ''))) {
+    job.steps.push({
+      name: 'Install dependencies',
+      run: 'npm ci',
+    });
+  }
+
+  if (!job.steps.some(step => step && /run tests/i.test(step.name || '') || (step.run || '') === testCommand)) {
+    job.steps.push({
+      name: 'Run tests',
+      run: testCommand,
+    });
+  }
+
+  return job;
+}
+
+function ensureCoverageStep(job) {
+  if (!Array.isArray(job.steps)) {
+    job.steps = [];
+  }
+
+  if (job.steps.some(step => step && /codecov\/codecov-action@v\d+/.test(step.uses || ''))) {
+    return;
+  }
+
+  job.steps.push({
+    name: 'Upload coverage',
+    uses: 'codecov/codecov-action@v4',
+  });
+}
+
+function createTestJob(testCommand, withCoverage) {
+  const steps = [
+    {
+      name: 'Checkout code',
+      uses: 'actions/checkout@v4',
+    },
+    {
+      name: 'Setup Node.js',
+      uses: 'actions/setup-node@v4',
+      with: {
+        'node-version': '20',
+        cache: 'npm',
+      },
+    },
+    {
+      name: 'Install dependencies',
+      run: 'npm ci',
+    },
+    {
+      name: 'Run tests',
+      run: testCommand,
+    },
+  ];
+
+  if (withCoverage) {
+    steps.push({
+      name: 'Upload coverage',
+      uses: 'codecov/codecov-action@v4',
+    });
+  }
+
+  return {
+    'runs-on': 'ubuntu-latest',
+    steps,
+  };
+}
+
+function createDeployJob(deployTarget) {
+  return {
+    'runs-on': 'ubuntu-latest',
+    needs: ['test'],
+    if: "github.ref == 'refs/heads/main'",
+    steps: [
+      {
+        name: 'Checkout code',
+        uses: 'actions/checkout@v4',
+      },
+      {
+        name: 'Deploy',
+        run: createDeployCommand(deployTarget),
+      },
+    ],
+  };
+}
+
+function createDeployCommand(deployTarget) {
+  switch (deployTarget) {
+    case 'docker-compose':
+      return [
+        'IMAGE_NAME="${IMAGE_NAME:-ghcr.io/${{ github.repository }}/${{ github.event.repository.name }}}:${{ github.sha }}"',
+        'docker build -t "$IMAGE_NAME" .',
+        'docker push "$IMAGE_NAME"',
+      ].join('\n');
+    case 'k8s':
+      return 'kubectl apply -f k8s/';
+    default:
+      return 'npm run deploy';
+  }
+}
+
+function dumpWorkflow(workflow) {
+  return yaml.dump(workflow, {
+    noRefs: true,
+    lineWidth: -1,
+    sortKeys: false,
+  });
+}
+
+module.exports = {
+  scaffoldCI,
+};

package/server/lib/scaffolding/ci-scaffolder.test.js

@@ -0,0 +1,157 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { scaffoldCI } = require('./ci-scaffolder.js');
+
+const tempDirs = [];
+
+function createProject() {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ci-scaffolder-test-'));
+  tempDirs.push(projectDir);
+  return projectDir;
+}
+
+function writeFile(projectDir, relativePath, content) {
+  const filePath = path.join(projectDir, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('scaffoldCI', () => {
+  it('generates a GitHub Actions CI workflow for projects without CI', () => {
+    const projectDir = createProject();
+    writeFile(projectDir, '.tlc.json', JSON.stringify({
+      testFrameworks: {
+        run: ['npx', 'vitest', 'run'],
+      },
+    }, null, 2));
+
+    const result = scaffoldCI({
+      projectDir,
+      platform: 'github-actions',
+      gaps: ['no-ci'],
+      deployTarget: 'docker-compose',
+      fs,
+    });
+
+    expect(result.warnings).toEqual([]);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('.github/workflows/ci.yml');
+    expect(result.files[0].content).toContain('name: CI');
+    expect(result.files[0].content).toContain('run: npx vitest run');
+    expect(result.files[0].content).toContain('codecov/codecov-action@v4');
+    expect(result.files[0].content).toContain('docker push "$IMAGE_NAME"');
+  });
+
+  it('falls back to the provided testCommand when .tlc.json does not define one', () => {
+    const projectDir = createProject();
+    writeFile(projectDir, '.tlc.json', JSON.stringify({
+      testFrameworks: {
+        primary: 'vitest',
+      },
+    }, null, 2));
+
+    const result = scaffoldCI({
+      projectDir,
+      platform: 'github-actions',
+      gaps: ['no-ci'],
+      testCommand: 'npm run test:ci',
+      deployTarget: 'k8s',
+      fs,
+    });
+
+    expect(result.files[0].content).toContain('run: npx vitest run');
+    expect(result.files[0].content).toContain('kubectl apply -f k8s/');
+  });
+
+  it('only adds missing GitHub Actions steps when CI already exists', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      '.github/workflows/existing.yml',
+      [
+        'name: Existing',
+        'on: push',
+        'jobs:',
+        '  test:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - name: Run tests',
+        '        run: npm test',
+      ].join('\n')
+    );
+
+    const result = scaffoldCI({
+      projectDir,
+      platform: 'github-actions',
+      gaps: ['missing-deploy-step', 'missing-coverage-upload'],
+      deployTarget: 'docker-compose',
+      fs,
+    });
+
+    expect(result.warnings).toEqual([]);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('.github/workflows/existing.yml');
+    expect(result.files[0].content).toContain('run: npm test');
+    expect(result.files[0].content).toContain('codecov/codecov-action@v4');
+    expect(result.files[0].content).toContain('deploy:');
+    expect(result.files[0].content).toContain('docker push "$IMAGE_NAME"');
+    expect(result.files[0].content.match(/name: Run tests/g)).toHaveLength(1);
+  });
+
+  it('adds a new test job when the existing workflow is missing one', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      '.github/workflows/deploy.yml',
+      [
+        'name: Deploy only',
+        'on: push',
+        'jobs:',
+        '  deploy:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - run: npm run deploy',
+      ].join('\n')
+    );
+
+    const result = scaffoldCI({
+      projectDir,
+      platform: 'github-actions',
+      gaps: ['missing-test-step'],
+      testCommand: 'npm run test:ci',
+      deployTarget: 'k8s',
+      fs,
+    });
+
+    expect(result.files[0].content).toContain('test:');
+    expect(result.files[0].content).toContain('run: npm run test:ci');
+    expect(result.files[0].content).not.toContain('kubectl apply -f k8s/');
+  });
+
+  it('returns a warning for unsupported CI platforms', () => {
+    const projectDir = createProject();
+
+    const result = scaffoldCI({
+      projectDir,
+      platform: 'gitlab',
+      gaps: ['no-ci'],
+      fs,
+    });
+
+    expect(result.files).toEqual([]);
+    expect(result.warnings).toEqual([
+      'CI scaffolding for platform "gitlab" is not supported.',
+    ]);
+  });
+});

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

@@ -0,0 +1,135 @@
+const path = require('path');
+
+function isDirectory(fsImpl, targetPath) {
+  try {
+    return fsImpl.statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function isFile(fsImpl, targetPath) {
+  try {
+    return fsImpl.statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function collectDeploymentManifestEvidence({ projectDir, fs: fsImpl }) {
+  const evidence = [];
+  const ignoredDirs = new Set(['.git', 'node_modules']);
+  const pending = [projectDir];
+
+  while (pending.length > 0) {
+    const currentDir = pending.pop();
+    let entries = [];
+
+    try {
+      entries = fsImpl.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!ignoredDirs.has(entry.name)) {
+          pending.push(fullPath);
+        }
+        continue;
+      }
+
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      if (!/\.(ya?ml)$/i.test(entry.name)) {
+        continue;
+      }
+
+      try {
+        const contents = fsImpl.readFileSync(fullPath, 'utf8');
+        if (/\bkind:\s*Deployment\b/.test(contents)) {
+          evidence.push(`kind: Deployment in ${path.relative(projectDir, fullPath)}`);
+        }
+      } catch {
+        // Ignore unreadable files and continue scanning.
+      }
+    }
+  }
+
+  evidence.sort();
+  return evidence;
+}
+
+function detectDeployTarget({ projectDir, fs: fsImpl }) {
+  const evidence = [];
+  const composeEvidence = [];
+  const k8sEvidence = [];
+  const dockerfileEvidence = [];
+
+  for (const composeFile of ['docker-compose.yml', 'docker-compose.yaml']) {
+    if (isFile(fsImpl, path.join(projectDir, composeFile))) {
+      composeEvidence.push(composeFile);
+    }
+  }
+
+  for (const k8sDir of ['helm', 'charts', 'k8s']) {
+    if (isDirectory(fsImpl, path.join(projectDir, k8sDir))) {
+      k8sEvidence.push(`${k8sDir}/`);
+    }
+  }
+
+  k8sEvidence.push(...collectDeploymentManifestEvidence({ projectDir, fs: fsImpl }));
+
+  if (isFile(fsImpl, path.join(projectDir, 'Dockerfile'))) {
+    dockerfileEvidence.push('Dockerfile');
+  }
+
+  evidence.push(...composeEvidence, ...k8sEvidence, ...dockerfileEvidence);
+
+  if (composeEvidence.length > 0 && k8sEvidence.length > 0) {
+    evidence.push('multiple deployment targets detected');
+    return {
+      target: 'unknown',
+      confidence: 'low',
+      evidence,
+    };
+  }
+
+  if (composeEvidence.length > 0) {
+    return {
+      target: 'docker-compose',
+      confidence: 'high',
+      evidence,
+    };
+  }
+
+  if (k8sEvidence.length > 0) {
+    return {
+      target: 'k8s',
+      confidence: 'high',
+      evidence,
+    };
+  }
+
+  if (dockerfileEvidence.length > 0) {
+    return {
+      target: 'vps',
+      confidence: 'medium',
+      evidence,
+    };
+  }
+
+  return {
+    target: 'unknown',
+    confidence: 'low',
+    evidence: [],
+  };
+}
+
+module.exports = {
+  detectDeployTarget,
+};