tlc-claude-code 2.5.0 → 2.6.1

package/server/lib/routing-preamble.js

@@ -37,8 +37,13 @@ function buildProgram(commandName) {
     "  };",
     "}",
     "function resolveRouting(options) {",
+    "  const MODES = {",
+    "    'build': 'interactive', 'quick': 'interactive', 'autofix': 'interactive',",
+    "    'edge-cases': 'exec', 'review': 'exec', 'coverage': 'exec',",
+    "  };",
     "  let models = ['claude'];",
     "  let strategy = 'single';",
+    "  let mode = MODES[options.command] || 'inline';",
     "  let source = 'shipped-defaults';",
     "  let providers;",
     "  const warnings = [];",
@@ -62,6 +67,9 @@ function buildProgram(commandName) {
     "      if (personalRouting.strategy) {",
     "        strategy = personalRouting.strategy;",
     "      }",
+    "      if (personalRouting.mode) {",
+    "        mode = personalRouting.mode;",
+    "      }",
     "      source = 'personal-config';",
     "    }",
     "  }",
@@ -82,7 +90,10 @@ function buildProgram(commandName) {
     "      if (overrideEntry.strategy) {",
     "        strategy = overrideEntry.strategy;",
     "      }",
-      "      source = 'project-override';",
+    "      if (overrideEntry.mode) {",
+    "        mode = overrideEntry.mode;",
+    "      }",
+    "      source = 'project-override';",
     "    }",
     "  }",
     "  if (options.flagModel) {",
@@ -90,7 +101,7 @@ function buildProgram(commandName) {
     "    strategy = 'single';",
     "    source = 'flag-override';",
     "  }",
-    "  const result = { models, strategy, source, warnings };",
+    "  const result = { models, strategy, mode, source, warnings };",
     "  if (providers) {",
     "    result.providers = providers;",
     "  }",

package/server/lib/routing-preamble.test.js

@@ -49,6 +49,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [],
     });
@@ -67,6 +68,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['codex', 'claude'],
       strategy: 'parallel',
+      mode: 'exec',
       source: 'personal-config',
       warnings: [],
     });
@@ -90,6 +92,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['gemini'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'project-override',
       warnings: [],
     });
@@ -108,6 +111,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'personal-config',
       warnings: [expect.stringMatching(/models/i)],
     });
@@ -126,6 +130,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['codex', 'claude'],
       strategy: 'parallel',
+      mode: 'interactive',
       source: 'personal-config',
       warnings: [],
     });
@@ -150,6 +155,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'personal-config',
       providers,
       warnings: [],
@@ -175,6 +181,7 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['local-model'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'flag-override',
       warnings: [],
     });
@@ -198,6 +205,7 @@ describe('routing-preamble', () => {
     expect(JSON.parse(output)).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [expect.stringContaining(path.join(homeDir, '.tlc', 'config.json'))],
     });
@@ -220,6 +228,7 @@ describe('routing-preamble', () => {
     expect(JSON.parse(output)).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [expect.stringContaining(path.join(cwd, '.tlc.json'))],
     });
@@ -248,6 +257,7 @@ describe('routing-preamble', () => {
     expect(JSON.parse(output)).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'inline',
       source: 'project-override',
       warnings: [expect.stringMatching(/models/i)],
     });
@@ -259,8 +269,47 @@ describe('routing-preamble', () => {
     expect(result).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'inline',
       source: 'shipped-defaults',
       warnings: [],
     });
   });
+
+  it('personal config can override mode', () => {
+    const result = runGeneratedScript({
+      commandName: 'build',
+      homeConfig: {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single', mode: 'exec' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      mode: 'exec',
+      source: 'personal-config',
+      warnings: [],
+    });
+  });
+
+  it('project override can override mode', () => {
+    const result = runGeneratedScript({
+      commandName: 'review',
+      projectConfig: {
+        task_routing_override: {
+          review: { models: ['claude'], strategy: 'single', mode: 'interactive' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      mode: 'interactive',
+      source: 'project-override',
+      warnings: [],
+    });
+  });
 });

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

@@ -0,0 +1,139 @@
+const path = require('path');
+
+function isFile(fsImpl, targetPath) {
+  try {
+    return fsImpl.statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(fsImpl, targetPath) {
+  try {
+    return fsImpl.statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listFiles(fsImpl, targetDir) {
+  try {
+    return fsImpl.readdirSync(targetDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function readFile(fsImpl, filePath) {
+  try {
+    return fsImpl.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function makeWorkflow(projectDir, workflowPath, contents) {
+  const normalized = String(contents || '').toLowerCase();
+
+  return {
+    path: path.relative(projectDir, workflowPath).replace(/\\/g, '/'),
+    hasTest: /\b(test|tests|jest|vitest|mocha|pytest|rspec|go test|cargo test|npm test|pnpm test|yarn test)\b/.test(normalized),
+    hasDeploy: /\b(deploy|deployment|release|publish|ship|helm upgrade|kubectl apply|terraform apply)\b/.test(normalized),
+    hasCoverage: /\b(coverage|codecov|coveralls|lcov|nyc|cobertura)\b/.test(normalized),
+  };
+}
+
+function collectGithubWorkflows(projectDir, fsImpl) {
+  const workflowsDir = path.join(projectDir, '.github', 'workflows');
+  const entries = listFiles(fsImpl, workflowsDir);
+
+  return entries
+    .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
+    .map((entry) => {
+      const workflowPath = path.join(workflowsDir, entry.name);
+      return makeWorkflow(projectDir, workflowPath, readFile(fsImpl, workflowPath));
+    })
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function collectCircleciWorkflows(projectDir, fsImpl) {
+  const circleDir = path.join(projectDir, '.circleci');
+  if (!isDirectory(fsImpl, circleDir)) {
+    return [];
+  }
+
+  const entries = listFiles(fsImpl, circleDir).filter((entry) => entry.isFile());
+  if (entries.length === 0) {
+    return [
+      {
+        path: '.circleci/',
+        hasTest: false,
+        hasDeploy: false,
+        hasCoverage: false,
+      },
+    ];
+  }
+
+  return entries
+    .map((entry) => {
+      const workflowPath = path.join(circleDir, entry.name);
+      return makeWorkflow(projectDir, workflowPath, readFile(fsImpl, workflowPath));
+    })
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function detectCI({ projectDir, fs: fsImpl }) {
+  const githubWorkflows = collectGithubWorkflows(projectDir, fsImpl);
+  const jenkinsPath = path.join(projectDir, 'Jenkinsfile');
+  const gitlabPath = path.join(projectDir, '.gitlab-ci.yml');
+  const circleciWorkflows = collectCircleciWorkflows(projectDir, fsImpl);
+
+  let platform = 'none';
+  let workflows = [];
+
+  if (githubWorkflows.length > 0) {
+    platform = 'github-actions';
+    workflows = githubWorkflows;
+  } else if (isFile(fsImpl, jenkinsPath)) {
+    platform = 'jenkins';
+    workflows = [makeWorkflow(projectDir, jenkinsPath, readFile(fsImpl, jenkinsPath))];
+  } else if (isFile(fsImpl, gitlabPath)) {
+    platform = 'gitlab';
+    workflows = [makeWorkflow(projectDir, gitlabPath, readFile(fsImpl, gitlabPath))];
+  } else if (circleciWorkflows.length > 0) {
+    platform = 'circleci';
+    workflows = circleciWorkflows;
+  }
+
+  if (platform === 'none') {
+    return {
+      platform,
+      workflows: [],
+      gaps: ['no-ci'],
+    };
+  }
+
+  const gaps = [];
+
+  if (!workflows.some((workflow) => workflow.hasTest)) {
+    gaps.push('missing-test-step');
+  }
+
+  if (!workflows.some((workflow) => workflow.hasDeploy)) {
+    gaps.push('missing-deploy-step');
+  }
+
+  if (!workflows.some((workflow) => workflow.hasCoverage)) {
+    gaps.push('missing-coverage-upload');
+  }
+
+  return {
+    platform,
+    workflows,
+    gaps,
+  };
+}
+
+module.exports = {
+  detectCI,
+};

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

@@ -0,0 +1,198 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { detectCI } = require('./ci-detector');
+
+function makeTempProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ci-detector-test-'));
+}
+
+function writeFile(projectDir, relativePath, contents = '') {
+  const filePath = path.join(projectDir, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+}
+
+function makeDir(projectDir, relativePath) {
+  fs.mkdirSync(path.join(projectDir, relativePath), { recursive: true });
+}
+
+const tempDirs = [];
+
+function createProject() {
+  const projectDir = makeTempProject();
+  tempDirs.push(projectDir);
+  return projectDir;
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('detectCI', () => {
+  it('returns no-ci when no CI config exists', () => {
+    const projectDir = createProject();
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'none',
+      workflows: [],
+      gaps: ['no-ci'],
+    });
+  });
+
+  it('detects GitHub Actions workflows and aggregates missing gaps across files', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      '.github/workflows/test.yml',
+      [
+        'name: Test',
+        'jobs:',
+        '  test:',
+        '    steps:',
+        '      - run: npm test',
+        '      - run: npx vitest --coverage',
+      ].join('\n')
+    );
+    writeFile(
+      projectDir,
+      '.github/workflows/deploy.yml',
+      [
+        'name: Deploy',
+        'jobs:',
+        '  deploy:',
+        '    steps:',
+        '      - run: npm run deploy',
+        '      - uses: codecov/codecov-action@v4',
+      ].join('\n')
+    );
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'github-actions',
+      workflows: [
+        {
+          path: '.github/workflows/deploy.yml',
+          hasTest: false,
+          hasDeploy: true,
+          hasCoverage: true,
+        },
+        {
+          path: '.github/workflows/test.yml',
+          hasTest: true,
+          hasDeploy: false,
+          hasCoverage: true,
+        },
+      ],
+      gaps: [],
+    });
+  });
+
+  it('detects Jenkinsfile and reports missing coverage upload', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      'Jenkinsfile',
+      [
+        'pipeline {',
+        '  stages {',
+        '    stage("Test") { steps { sh "npm test" } }',
+        '    stage("Deploy") { steps { sh "npm run deploy" } }',
+        '  }',
+        '}',
+      ].join('\n')
+    );
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'jenkins',
+      workflows: [
+        {
+          path: 'Jenkinsfile',
+          hasTest: true,
+          hasDeploy: true,
+          hasCoverage: false,
+        },
+      ],
+      gaps: ['missing-coverage-upload'],
+    });
+  });
+
+  it('detects GitLab CI and reports missing deploy and coverage steps', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      '.gitlab-ci.yml',
+      [
+        'stages:',
+        '  - test',
+        'test:',
+        '  script:',
+        '    - pytest',
+      ].join('\n')
+    );
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'gitlab',
+      workflows: [
+        {
+          path: '.gitlab-ci.yml',
+          hasTest: true,
+          hasDeploy: false,
+          hasCoverage: false,
+        },
+      ],
+      gaps: ['missing-deploy-step', 'missing-coverage-upload'],
+    });
+  });
+
+  it('detects CircleCI from the directory and workflow file', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      '.circleci/config.yml',
+      [
+        'version: 2.1',
+        'jobs:',
+        '  build:',
+        '    steps:',
+        '      - run: yarn test',
+        '      - run: yarn coverage',
+      ].join('\n')
+    );
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'circleci',
+      workflows: [
+        {
+          path: '.circleci/config.yml',
+          hasTest: true,
+          hasDeploy: false,
+          hasCoverage: true,
+        },
+      ],
+      gaps: ['missing-deploy-step'],
+    });
+  });
+
+  it('treats an empty .circleci directory as CI with all gaps missing', () => {
+    const projectDir = createProject();
+    makeDir(projectDir, '.circleci');
+
+    expect(detectCI({ projectDir, fs })).toEqual({
+      platform: 'circleci',
+      workflows: [
+        {
+          path: '.circleci/',
+          hasTest: false,
+          hasDeploy: false,
+          hasCoverage: false,
+        },
+      ],
+      gaps: ['missing-test-step', 'missing-deploy-step', 'missing-coverage-upload'],
+    });
+  });
+});