tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/release/release-pipeline.test.js

@@ -0,0 +1,262 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createRequire } from 'node:module';
+import fsp from 'node:fs/promises';
+
+const require = createRequire(import.meta.url);
+
+let runRelease;
+let ciWatcher;
+let versionBumper;
+let changelogGenerator;
+let healthChecker;
+
+describe('release/release-pipeline', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    ciWatcher = require('./ci-watcher.js');
+    versionBumper = require('./version-bumper.js');
+    changelogGenerator = require('./changelog-generator.js');
+    healthChecker = require('./health-checker.js');
+
+    vi.spyOn(fsp, 'readFile').mockImplementation(async (filePath) => {
+      if (String(filePath).endsWith('package.json')) {
+        return JSON.stringify({ name: 'tlc-server', version: '0.1.2' });
+      }
+
+      const error = new Error('missing');
+      error.code = 'ENOENT';
+      throw error;
+    });
+    vi.spyOn(fsp, 'mkdir').mockResolvedValue(undefined);
+    vi.spyOn(fsp, 'writeFile').mockResolvedValue(undefined);
+
+    vi.spyOn(ciWatcher, 'watchCi').mockResolvedValue('green');
+    vi.spyOn(versionBumper, 'determineNextVersion').mockReturnValue('0.2.0');
+    vi.spyOn(versionBumper, 'applyVersionBump').mockResolvedValue({ version: '0.2.0' });
+    vi.spyOn(changelogGenerator, 'generateChangelog')
+      .mockReturnValue('## v0.2.0 - 2026-03-31\n\n- Release notes');
+    vi.spyOn(changelogGenerator, 'prependToChangelog')
+      .mockReturnValue('# Changelog\n\n## v0.2.0 - 2026-03-31\n\n- Release notes\n');
+    vi.spyOn(healthChecker, 'checkHealth').mockResolvedValue({
+      ok: true,
+      attempts: 1,
+      status: 200,
+      error: null,
+    });
+    vi.spyOn(healthChecker, 'rollback').mockResolvedValue({
+      ok: true,
+      branch: 'main',
+      previousSha: 'abc123',
+    });
+
+    ({ runRelease } = require('./release-pipeline.js'));
+  });
+
+  it('runs the full release pipeline and records a successful completion', async () => {
+    const exec = vi.fn(async (command) => {
+      if (command === 'git rev-parse HEAD') {
+        return { stdout: 'abc123\n' };
+      }
+
+      if (command === 'git log -20 --pretty=format:%H%x09%s') {
+        return {
+          stdout: [
+            '1111111\tfeat: add automated release pipeline',
+            '2222222\tfix: handle flaky health polling',
+          ].join('\n'),
+        };
+      }
+
+      return { stdout: '' };
+    });
+    const fetch = vi.fn();
+
+    const result = await runRelease({
+      branch: 'main',
+      config: {
+        deploy: { healthUrl: 'https://example.com/health' },
+        publish: { npm: true },
+      },
+      exec,
+      fetch,
+    });
+
+    expect(ciWatcher.watchCi).toHaveBeenCalledWith({ branch: 'main', exec });
+    expect(versionBumper.determineNextVersion).toHaveBeenCalledWith({
+      currentVersion: '0.1.2',
+      commits: [
+        { sha: '1111111', message: 'feat: add automated release pipeline' },
+        { sha: '2222222', message: 'fix: handle flaky health polling' },
+      ],
+    });
+    expect(changelogGenerator.generateChangelog).toHaveBeenCalledWith({
+      version: 'v0.2.0',
+      date: expect.stringMatching(/^\d{4}-\d{2}-\d{2}$/),
+      commits: [
+        { sha: '1111111', message: 'feat: add automated release pipeline' },
+        { sha: '2222222', message: 'fix: handle flaky health polling' },
+      ],
+    });
+    expect(versionBumper.applyVersionBump).toHaveBeenCalledWith({
+      version: '0.2.0',
+      packageJsonPath: expect.stringContaining('/server/package.json'),
+      fs: expect.objectContaining({
+        readFile: expect.any(Function),
+        writeFile: expect.any(Function),
+      }),
+    });
+    expect(changelogGenerator.prependToChangelog).toHaveBeenCalledWith({
+      changelogPath: expect.stringContaining('/server/CHANGELOG.md'),
+      content: '## v0.2.0 - 2026-03-31\n\n- Release notes',
+      fs: expect.any(Object),
+    });
+    expect(exec).toHaveBeenCalledWith(expect.stringContaining("git add"));
+    expect(exec).toHaveBeenCalledWith("git commit -m 'chore(release): v0.2.0'");
+    expect(exec).toHaveBeenCalledWith('git tag v0.2.0');
+    expect(exec).toHaveBeenCalledWith("git push origin 'main'");
+    expect(exec).toHaveBeenCalledWith('git push origin v0.2.0');
+    expect(exec).toHaveBeenCalledWith('npm publish');
+    expect(healthChecker.checkHealth).toHaveBeenCalledWith({
+      healthUrl: 'https://example.com/health',
+      fetch,
+    });
+    expect(healthChecker.rollback).not.toHaveBeenCalled();
+    expect(fsp.mkdir).toHaveBeenCalledWith(expect.stringContaining('/server/.tlc'), { recursive: true });
+    expect(fsp.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining('/server/.tlc/.agent-completions.json'),
+      expect.stringContaining('"status": "released"'),
+      'utf8'
+    );
+    expect(result).toEqual({
+      ok: true,
+      status: 'released',
+      branch: 'main',
+      version: '0.2.0',
+      ciStatus: 'green',
+      published: true,
+      health: {
+        ok: true,
+        attempts: 1,
+        status: 200,
+        error: null,
+      },
+      summary: 'Release completed for v0.2.0',
+    });
+  });
+
+  it('returns a stuck summary when CI does not go green', async () => {
+    const exec = vi.fn().mockResolvedValue({ stdout: 'abc123\n' });
+    const fetch = vi.fn();
+
+    ciWatcher.watchCi.mockResolvedValue('stuck');
+
+    const result = await runRelease({
+      branch: 'release/next',
+      config: {
+        deploy: { healthUrl: 'https://example.com/health' },
+        publish: { npm: false },
+      },
+      exec,
+      fetch,
+    });
+
+    expect(versionBumper.determineNextVersion).not.toHaveBeenCalled();
+    expect(healthChecker.checkHealth).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      ok: false,
+      status: 'stuck',
+      branch: 'release/next',
+      ciStatus: 'stuck',
+      summary: 'Release halted because CI is stuck',
+    });
+    expect(fsp.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining('/server/.tlc/.agent-completions.json'),
+      expect.stringContaining('"status": "stuck"'),
+      'utf8'
+    );
+  });
+
+  it('rolls back when the post-release health check fails', async () => {
+    const exec = vi.fn(async (command) => {
+      if (command === 'git rev-parse HEAD') {
+        return { stdout: 'deadbeef\n' };
+      }
+
+      if (command === 'git log -20 --pretty=format:%H%x09%s') {
+        return {
+          stdout: '3333333\tfix: patch release regression',
+        };
+      }
+
+      return { stdout: '' };
+    });
+    const fetch = vi.fn();
+
+    healthChecker.checkHealth.mockResolvedValue({
+      ok: false,
+      attempts: 3,
+      status: null,
+      error: 'connection refused',
+    });
+    healthChecker.rollback.mockResolvedValue({
+      ok: true,
+      branch: 'main',
+      previousSha: 'deadbeef',
+    });
+
+    const result = await runRelease({
+      branch: 'main',
+      config: {
+        deploy: { healthUrl: 'https://example.com/health' },
+        publish: { npm: false },
+      },
+      exec,
+      fetch,
+    });
+
+    expect(healthChecker.rollback).toHaveBeenCalledWith({
+      branch: 'main',
+      previousSha: 'deadbeef',
+      exec,
+    });
+    expect(result).toEqual({
+      ok: false,
+      status: 'rolled_back',
+      branch: 'main',
+      version: '0.2.0',
+      ciStatus: 'green',
+      published: false,
+      health: {
+        ok: false,
+        attempts: 3,
+        status: null,
+        error: 'connection refused',
+      },
+      rollback: {
+        ok: true,
+        branch: 'main',
+        previousSha: 'deadbeef',
+      },
+      summary: 'Release rolled back after failing health checks for v0.2.0',
+    });
+    expect(fsp.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining('/server/.tlc/.agent-completions.json'),
+      expect.stringContaining('"status": "rolled_back"'),
+      'utf8'
+    );
+  });
+
+  it('validates that deploy.healthUrl is configured', async () => {
+    await expect(runRelease({
+      branch: 'main',
+      config: {
+        deploy: {},
+        publish: { npm: false },
+      },
+      exec: vi.fn(),
+      fetch: vi.fn(),
+    })).rejects.toThrow('config.deploy.healthUrl is required');
+  });
+});

package/server/lib/release/version-bumper.js

@@ -0,0 +1,183 @@
+/**
+ * Determine the next semantic version from conventional commits and apply it
+ * to a package.json file through injected filesystem helpers.
+ */
+
+const SEMVER_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)$/;
+const BREAKING_CHANGE_PATTERN = /^BREAKING[ -]CHANGE:/m;
+const HEADER_PATTERN = /^([a-z]+)(\([^)]+\))?(!)?:\s+(.+)$/i;
+
+/**
+ * Parse a simple semver string.
+ *
+ * @param {string} version
+ * @returns {{major: number, minor: number, patch: number}}
+ */
+function parseVersion(version) {
+  if (typeof version !== 'string') {
+    throw new TypeError('currentVersion must be a semver string');
+  }
+
+  const match = version.trim().match(SEMVER_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid semver version: ${version}`);
+  }
+
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+
+/**
+ * Normalize a commit item into a message string.
+ *
+ * @param {string|object} commit
+ * @returns {string}
+ */
+function getCommitMessage(commit) {
+  if (typeof commit === 'string') {
+    return commit;
+  }
+
+  if (commit && typeof commit.message === 'string') {
+    return commit.message;
+  }
+
+  if (commit && typeof commit.subject === 'string') {
+    return commit.subject;
+  }
+
+  return '';
+}
+
+/**
+ * Determine the bump level represented by a single commit.
+ *
+ * @param {string} message
+ * @returns {'major'|'minor'|'patch'|null}
+ */
+function getCommitBump(message) {
+  const normalized = message.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  if (BREAKING_CHANGE_PATTERN.test(normalized)) {
+    return 'major';
+  }
+
+  const header = normalized.split('\n', 1)[0];
+  const match = header.match(HEADER_PATTERN);
+  if (!match) {
+    return null;
+  }
+
+  const type = match[1].toLowerCase();
+  const breaking = Boolean(match[3]);
+
+  if (breaking) {
+    return 'major';
+  }
+
+  if (type === 'feat') {
+    return 'minor';
+  }
+
+  if (type === 'fix' || type === 'perf') {
+    return 'patch';
+  }
+
+  return null;
+}
+
+/**
+ * Bump a parsed version by a bump level.
+ *
+ * @param {{major: number, minor: number, patch: number}} version
+ * @param {'major'|'minor'|'patch'|null} bump
+ * @returns {string}
+ */
+function bumpVersion(version, bump) {
+  if (bump === 'major') {
+    return `${version.major + 1}.0.0`;
+  }
+
+  if (bump === 'minor') {
+    return `${version.major}.${version.minor + 1}.0`;
+  }
+
+  if (bump === 'patch') {
+    return `${version.major}.${version.minor}.${version.patch + 1}`;
+  }
+
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+
+/**
+ * Determine the next semantic version from a list of conventional commits.
+ *
+ * @param {{currentVersion: string, commits: Array<string|{message?: string, subject?: string}>}} params
+ * @returns {string}
+ */
+function determineNextVersion({ currentVersion, commits }) {
+  const version = parseVersion(currentVersion);
+
+  if (!Array.isArray(commits)) {
+    throw new TypeError('commits must be an array');
+  }
+
+  let highestBump = null;
+
+  for (const commit of commits) {
+    const bump = getCommitBump(getCommitMessage(commit));
+
+    if (bump === 'major') {
+      highestBump = 'major';
+      break;
+    }
+
+    if (bump === 'minor') {
+      highestBump = highestBump === 'patch' ? 'minor' : 'minor';
+      continue;
+    }
+
+    if (bump === 'patch' && highestBump === null) {
+      highestBump = 'patch';
+    }
+  }
+
+  return bumpVersion(version, highestBump);
+}
+
+/**
+ * Update the version field in a package.json file.
+ *
+ * @param {{version: string, packageJsonPath: string, fs: {readFile: Function, writeFile: Function}}} params
+ * @returns {Promise<object>}
+ */
+async function applyVersionBump({ version, packageJsonPath, fs }) {
+  parseVersion(version);
+
+  if (!packageJsonPath || typeof packageJsonPath !== 'string') {
+    throw new TypeError('packageJsonPath must be a string');
+  }
+
+  if (!fs || typeof fs.readFile !== 'function' || typeof fs.writeFile !== 'function') {
+    throw new TypeError('fs must provide readFile and writeFile functions');
+  }
+
+  const packageJson = await fs.readFile(packageJsonPath, 'utf8');
+  const packageData = JSON.parse(packageJson);
+  packageData.version = version;
+
+  await fs.writeFile(packageJsonPath, `${JSON.stringify(packageData, null, 2)}\n`, 'utf8');
+
+  return packageData;
+}
+
+module.exports = {
+  determineNextVersion,
+  applyVersionBump,
+};

package/server/lib/release/version-bumper.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi } from 'vitest';
+import versionBumper from './version-bumper.js';
+
+const { determineNextVersion, applyVersionBump } = versionBumper;
+
+describe('version-bumper', () => {
+  describe('determineNextVersion', () => {
+    it('returns the same version when no release-worthy commits are present', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: ['docs: update release notes', 'chore: refresh snapshots'],
+      });
+
+      expect(nextVersion).toBe('1.2.3');
+    });
+
+    it('bumps patch for fix commits', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: ['fix: handle missing session state'],
+      });
+
+      expect(nextVersion).toBe('1.2.4');
+    });
+
+    it('treats perf commits as patch releases', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: ['perf: reduce websocket reconnect churn'],
+      });
+
+      expect(nextVersion).toBe('1.2.4');
+    });
+
+    it('bumps minor for feat commits', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: ['feat(api): add release audit endpoint', 'fix: log errors'],
+      });
+
+      expect(nextVersion).toBe('1.3.0');
+    });
+
+    it('bumps major for bang syntax breaking changes', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: ['feat!: remove deprecated release payload'],
+      });
+
+      expect(nextVersion).toBe('2.0.0');
+    });
+
+    it('bumps major for BREAKING CHANGE footers', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: [
+          {
+            message: [
+              'refactor: simplify release config loading',
+              '',
+              'BREAKING CHANGE: release config now requires explicit tier names',
+            ].join('\n'),
+          },
+        ],
+      });
+
+      expect(nextVersion).toBe('2.0.0');
+    });
+
+    it('accepts versions with a leading v', () => {
+      const nextVersion = determineNextVersion({
+        currentVersion: 'v1.2.3',
+        commits: ['fix: repair preview URL generation'],
+      });
+
+      expect(nextVersion).toBe('1.2.4');
+    });
+
+    it('throws for invalid inputs', () => {
+      expect(() => determineNextVersion({
+        currentVersion: '1.2',
+        commits: [],
+      })).toThrow(/invalid semver/i);
+
+      expect(() => determineNextVersion({
+        currentVersion: '1.2.3',
+        commits: 'fix: nope',
+      })).toThrow(/commits must be an array/i);
+    });
+  });
+
+  describe('applyVersionBump', () => {
+    it('writes the bumped version back to package.json through injected fs', async () => {
+      const fs = {
+        readFile: vi.fn().mockResolvedValue('{"name":"tlc-server","version":"0.1.2"}'),
+        writeFile: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const updated = await applyVersionBump({
+        version: '0.2.0',
+        packageJsonPath: '/tmp/package.json',
+        fs,
+      });
+
+      expect(updated).toEqual({
+        name: 'tlc-server',
+        version: '0.2.0',
+      });
+      expect(fs.readFile).toHaveBeenCalledWith('/tmp/package.json', 'utf8');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        '/tmp/package.json',
+        '{\n  "name": "tlc-server",\n  "version": "0.2.0"\n}\n',
+        'utf8'
+      );
+    });
+
+    it('validates inputs before writing', async () => {
+      const fs = {
+        readFile: vi.fn(),
+        writeFile: vi.fn(),
+      };
+
+      await expect(applyVersionBump({
+        version: '1.0',
+        packageJsonPath: '/tmp/package.json',
+        fs,
+      })).rejects.toThrow(/invalid semver/i);
+
+      await expect(applyVersionBump({
+        version: '1.0.0',
+        packageJsonPath: '',
+        fs,
+      })).rejects.toThrow(/packageJsonPath must be a string/i);
+
+      await expect(applyVersionBump({
+        version: '1.0.0',
+        packageJsonPath: '/tmp/package.json',
+        fs: {},
+      })).rejects.toThrow(/fs must provide readFile and writeFile/i);
+    });
+  });
+});

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

@@ -92,6 +92,7 @@ describe('routing-preamble integration', () => {
     expect(runPreamble({ commandName: 'build' }).result).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [],
     });
@@ -110,6 +111,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'personal-config',
       warnings: [expect.stringMatching(/models/i)],
     });
@@ -128,6 +130,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex', 'claude'],
       strategy: 'single',
+      mode: 'exec',
       source: 'personal-config',
       warnings: [],
     });
@@ -151,6 +154,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['claude'],
       strategy: 'parallel',
+      mode: 'inline',
       source: 'project-override',
       warnings: [expect.stringMatching(/models/i), expect.stringMatching(/models/i)],
     });
@@ -174,6 +178,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'inline',
       source: 'project-override',
       warnings: [],
     });
@@ -198,6 +203,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['local-model'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'flag-override',
       warnings: [expect.stringMatching(/models/i), expect.stringMatching(/models/i)],
     });
@@ -222,6 +228,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'personal-config',
       providers,
       warnings: [expect.stringMatching(/models/i)],
@@ -237,6 +244,7 @@ describe('routing-preamble integration', () => {
     expect(result).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [expect.stringContaining(path.join(homeDir, '.tlc', 'config.json'))],
     });
@@ -252,6 +260,7 @@ describe('routing-preamble integration', () => {
     expect(result).toEqual({
       models: ['claude'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'shipped-defaults',
       warnings: [expect.stringContaining(path.join(cwd, '.tlc.json'))],
     });
@@ -272,6 +281,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex'],
       strategy: 'single',
+      mode: 'interactive',
       source: 'personal-config',
       warnings: [expect.stringMatching(/models/i)],
     });
@@ -290,6 +300,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex'],
       strategy: 'parallel',
+      mode: 'inline',
       source: 'personal-config',
       warnings: [expect.stringMatching(/models/i)],
     });
@@ -312,6 +323,7 @@ describe('routing-preamble integration', () => {
     ).toEqual({
       models: ['codex', 'claude'],
       strategy: 'parallel',
+      mode: 'interactive',
       source: 'personal-config',
       warnings: [],
     });