tlc-claude-code 2.5.0 → 2.6.1

package/server/lib/orchestration/session-dispatcher.test.js

@@ -0,0 +1,215 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const { dispatchToOrchestrator } = require('./session-dispatcher.js');
+
+function makeTask(overrides = {}) {
+  return {
+    name: 'Task 1',
+    provider: 'codex',
+    prompt: 'Implement feature',
+    ...overrides,
+  };
+}
+
+describe('session-dispatcher', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length > 0) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  function makeActiveSessionsPath() {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-dispatcher-test-'));
+    tempDirs.push(tempDir);
+    return path.join(tempDir, '.tlc', '.active-sessions.json');
+  }
+
+  it('dispatches 3 tasks and creates 3 sessions', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const tasks = [
+      makeTask({ name: 'Task 1', provider: 'claude', prompt: 'Prompt 1' }),
+      makeTask({ name: 'Task 2', provider: 'codex', prompt: 'Prompt 2' }),
+      makeTask({ name: 'Task 3', provider: 'gemini', prompt: 'Prompt 3' }),
+    ];
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-2' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-3' }) });
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test/',
+      project: 'tlc',
+      tasks,
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(fetch).toHaveBeenCalledTimes(3);
+    expect(fetch).toHaveBeenNthCalledWith(1, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'claude',
+        prompt: 'Prompt 1',
+      }),
+    });
+    expect(fetch).toHaveBeenNthCalledWith(2, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'codex',
+        prompt: 'Prompt 2',
+      }),
+    });
+    expect(fetch).toHaveBeenNthCalledWith(3, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'gemini',
+        prompt: 'Prompt 3',
+      }),
+    });
+    expect(result).toEqual({
+      dispatched: 3,
+      sessions: [
+        { id: 'session-1', taskName: 'Task 1' },
+        { id: 'session-2', taskName: 'Task 2' },
+        { id: 'session-3', taskName: 'Task 3' },
+      ],
+      errors: [],
+    });
+  });
+
+  it('writes session IDs to the active sessions file', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-2' }) });
+
+    await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [
+        makeTask({ name: 'Task 1', prompt: 'Prompt 1' }),
+        makeTask({ name: 'Task 2', prompt: 'Prompt 2' }),
+      ],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    const written = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'));
+    expect(written).toHaveLength(2);
+    expect(written[0]).toEqual({
+      sessionId: 'session-1',
+      taskName: 'Task 1',
+      startedAt: expect.any(String),
+    });
+    expect(written[1]).toEqual({
+      sessionId: 'session-2',
+      taskName: 'Task 2',
+      startedAt: expect.any(String),
+    });
+  });
+
+  it('returns fallback when the orchestrator is unreachable', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi.fn().mockRejectedValue(new Error('connect ECONNREFUSED'));
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [makeTask()],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 0,
+      errors: ['orchestrator unreachable'],
+      fallback: true,
+    });
+    expect(fs.existsSync(activeSessionsPath)).toBe(false);
+  });
+
+  it('reports errors for partial failure', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: false, status: 500, json: async () => ({}) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-3' }) });
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [
+        makeTask({ name: 'Task 1', prompt: 'Prompt 1' }),
+        makeTask({ name: 'Task 2', prompt: 'Prompt 2' }),
+        makeTask({ name: 'Task 3', prompt: 'Prompt 3' }),
+      ],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 2,
+      sessions: [
+        { id: 'session-1', taskName: 'Task 1' },
+        { id: 'session-3', taskName: 'Task 3' },
+      ],
+      errors: ['Task 2: 500'],
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([
+      {
+        sessionId: 'session-1',
+        taskName: 'Task 1',
+        startedAt: expect.any(String),
+      },
+      {
+        sessionId: 'session-3',
+        taskName: 'Task 3',
+        startedAt: expect.any(String),
+      },
+    ]);
+  });
+
+  it('returns dispatched 0 for an empty task list', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi.fn();
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 0,
+      sessions: [],
+      errors: [],
+    });
+    expect(fetch).not.toHaveBeenCalled();
+    expect(fs.existsSync(activeSessionsPath)).toBe(false);
+  });
+});

package/server/lib/orchestration/session-status.js

@@ -0,0 +1,147 @@
+/**
+ * Format an elapsed duration from a session creation time.
+ * @param {string|Date|number} createdAt
+ * @returns {string}
+ */
+function formatElapsed(createdAt) {
+  const startedAt = new Date(createdAt).getTime();
+  if (Number.isNaN(startedAt)) {
+    return '-';
+  }
+
+  const diffMs = Math.max(0, Date.now() - startedAt);
+  const totalMinutes = Math.floor(diffMs / 60000);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+
+  return `${minutes}m`;
+}
+
+/**
+ * Convert a status string into title case.
+ * @param {string} status
+ * @returns {string}
+ */
+function titleCaseStatus(status) {
+  const value = String(status || '').trim();
+  if (!value) return 'Completed';
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+/**
+ * Build a summary for a completed session.
+ * @param {object} session
+ * @returns {string}
+ */
+function buildSummary(session) {
+  if (session.summary) {
+    return session.summary;
+  }
+
+  if (session.command) {
+    return `${titleCaseStatus(session.status)}: ${session.command}`;
+  }
+
+  return titleCaseStatus(session.status);
+}
+
+/**
+ * Format rows into an aligned CLI table.
+ * @param {string[]} headers
+ * @param {string[][]} rows
+ * @returns {string}
+ */
+function formatTable(headers, rows) {
+  const widths = headers.map((header, index) => {
+    const rowWidth = rows.reduce((max, row) => Math.max(max, String(row[index] || '').length), 0);
+    return Math.max(header.length, rowWidth);
+  });
+
+  const formatRow = (row) => row.map((cell, index) => String(cell || '').padEnd(widths[index])).join('  ');
+
+  return [
+    formatRow(headers),
+    widths.map((width) => '-'.repeat(width)).join('  '),
+    ...rows.map(formatRow),
+  ].join('\n');
+}
+
+/**
+ * Format attach hints for a set of sessions.
+ * @param {object[]} sessions
+ * @returns {string}
+ */
+function formatAttachHints(sessions) {
+  return sessions
+    .map((session) => `Attach: tlc-core attach ${session.id}`)
+    .join('\n');
+}
+
+/**
+ * Format orchestration session status for CLI output.
+ * @param {{ sessions?: object[] }} input
+ * @returns {string|null}
+ */
+function formatSessionStatus({ sessions } = {}) {
+  if (!Array.isArray(sessions) || sessions.length === 0) {
+    return null;
+  }
+
+  const running = [];
+  const completed = [];
+
+  for (const session of sessions) {
+    if (String(session.status).toLowerCase() === 'running') {
+      running.push(session);
+    } else {
+      completed.push(session);
+    }
+  }
+
+  const sections = [];
+
+  if (running.length > 0) {
+    sections.push([
+      'Running Sessions',
+      formatTable(
+        ['ID', 'Project', 'Status', 'Elapsed', 'Task'],
+        running.map((session) => [
+          session.id || '-',
+          session.project || '-',
+          session.status || '-',
+          formatElapsed(session.created_at),
+          session.command || '-',
+        ])
+      ),
+      formatAttachHints(running),
+    ].join('\n'));
+  }
+
+  if (completed.length > 0) {
+    sections.push([
+      'Completed Sessions',
+      formatTable(
+        ['ID', 'Project', 'Status', 'Summary'],
+        completed.map((session) => [
+          session.id || '-',
+          session.project || '-',
+          session.status || '-',
+          buildSummary(session),
+        ])
+      ),
+      formatAttachHints(completed),
+    ].join('\n'));
+  }
+
+  return sections.join('\n\n');
+}
+
+module.exports = {
+  formatSessionStatus,
+  formatElapsed,
+  buildSummary,
+};

package/server/lib/orchestration/session-status.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { formatSessionStatus } = require('./session-status.js');
+
+describe('session-status', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-03-30T12:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('formats running sessions with elapsed time', () => {
+    const output = formatSessionStatus({
+      sessions: [
+        {
+          id: 'sess-101',
+          project: 'alpha',
+          status: 'running',
+          created_at: '2026-03-30T11:15:00Z',
+          command: 'Implement API',
+        },
+      ],
+    });
+
+    expect(output).toContain('Running Sessions');
+    expect(output).toContain('sess-101');
+    expect(output).toContain('alpha');
+    expect(output).toContain('Implement API');
+    expect(output).toContain('45m');
+    expect(output).toContain('Attach: tlc-core attach sess-101');
+  });
+
+  it('formats completed sessions with summary', () => {
+    const output = formatSessionStatus({
+      sessions: [
+        {
+          id: 'sess-202',
+          project: 'beta',
+          status: 'completed',
+          created_at: '2026-03-30T10:00:00Z',
+          command: 'Add tests',
+        },
+      ],
+    });
+
+    expect(output).toContain('Completed Sessions');
+    expect(output).toContain('sess-202');
+    expect(output).toContain('beta');
+    expect(output).toContain('Completed: Add tests');
+    expect(output).toContain('Attach: tlc-core attach sess-202');
+  });
+
+  it('mixes running and completed sections in one output', () => {
+    const output = formatSessionStatus({
+      sessions: [
+        {
+          id: 'sess-run',
+          project: 'gamma',
+          status: 'running',
+          created_at: '2026-03-30T11:50:00Z',
+          command: 'Refactor worker',
+        },
+        {
+          id: 'sess-done',
+          project: 'delta',
+          status: 'failed',
+          created_at: '2026-03-30T10:30:00Z',
+          command: 'Fix flaky test',
+        },
+      ],
+    });
+
+    expect(output).toContain('Running Sessions');
+    expect(output).toContain('Completed Sessions');
+    expect(output).toContain('10m');
+    expect(output).toContain('Failed: Fix flaky test');
+  });
+
+  it('returns null for empty sessions', () => {
+    expect(formatSessionStatus({ sessions: [] })).toBeNull();
+    expect(formatSessionStatus({ sessions: null })).toBeNull();
+  });
+
+  it('formats aligned tables', () => {
+    const output = formatSessionStatus({
+      sessions: [
+        {
+          id: 's-1',
+          project: 'short',
+          status: 'running',
+          created_at: '2026-03-30T11:00:00Z',
+          command: 'Task A',
+        },
+        {
+          id: 'session-222',
+          project: 'much-longer-project',
+          status: 'running',
+          created_at: '2026-03-30T11:30:00Z',
+          command: 'Task B',
+        },
+      ],
+    });
+
+    const lines = output.split('\n');
+    const header = lines.find((line) => line.startsWith('ID'));
+    const firstRow = lines.find((line) => line.startsWith('s-1'));
+    const secondRow = lines.find((line) => line.startsWith('session-222'));
+
+    expect(header).toBeTruthy();
+    expect(firstRow).toBeTruthy();
+    expect(secondRow).toBeTruthy();
+
+    const projectStart = header.indexOf('Project');
+    const statusStart = header.indexOf('Status');
+    const elapsedStart = header.indexOf('Elapsed');
+    const taskStart = header.indexOf('Task');
+
+    expect(firstRow.slice(projectStart, projectStart + 'short'.length)).toBe('short');
+    expect(secondRow.slice(projectStart, projectStart + 'much-longer-project'.length)).toBe('much-longer-project');
+    expect(firstRow.slice(statusStart, statusStart + 'running'.length)).toBe('running');
+    expect(secondRow.slice(statusStart, statusStart + 'running'.length)).toBe('running');
+    expect(firstRow.slice(elapsedStart, elapsedStart + '1h 0m'.length)).toBe('1h 0m');
+    expect(secondRow.slice(elapsedStart, elapsedStart + '30m'.length)).toBe('30m');
+    expect(firstRow.slice(taskStart, taskStart + 'Task A'.length)).toBe('Task A');
+    expect(secondRow.slice(taskStart, taskStart + 'Task B'.length)).toBe('Task B');
+  });
+});

package/server/lib/release/agent-runner-updates.js

@@ -0,0 +1,24 @@
+const DOCKERFILE_ADDITIONS = [
+  'RUN apt-get update && apt-get install -y --no-install-recommends gh openssh-client && rm -rf /var/lib/apt/lists/*',
+].join('\n');
+
+const ENTRYPOINT_ADDITIONS = [
+  'if [ -n "$GH_TOKEN" ]; then',
+  '  printf "%s" "$GH_TOKEN" | gh auth login --with-token',
+  'fi',
+  'git config --global user.name "TLC Agent Runner"',
+  'git config --global user.email "agent-runner@tlc.local"',
+].join('\n');
+
+export function getDockerfileAdditions() {
+  return DOCKERFILE_ADDITIONS;
+}
+
+export function getEntrypointAdditions() {
+  return ENTRYPOINT_ADDITIONS;
+}
+
+export default {
+  getDockerfileAdditions,
+  getEntrypointAdditions,
+};

package/server/lib/release/agent-runner-updates.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { getDockerfileAdditions, getEntrypointAdditions } from './agent-runner-updates.js';
+
+describe('agent-runner-updates', () => {
+  it('returns Dockerfile additions for gh CLI and openssh-client', () => {
+    expect(getDockerfileAdditions()).toBe(
+      'RUN apt-get update && apt-get install -y --no-install-recommends gh openssh-client && rm -rf /var/lib/apt/lists/*'
+    );
+  });
+
+  it('returns entrypoint additions for GH_TOKEN auth and git identity config', () => {
+    expect(getEntrypointAdditions()).toBe(
+      [
+        'if [ -n "$GH_TOKEN" ]; then',
+        '  printf "%s" "$GH_TOKEN" | gh auth login --with-token',
+        'fi',
+        'git config --global user.name "TLC Agent Runner"',
+        'git config --global user.email "agent-runner@tlc.local"',
+      ].join('\n')
+    );
+  });
+});

package/server/lib/release/changelog-generator.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const DEFAULT_TITLE = '# Changelog';
+
+const GROUPS = [
+  { key: 'feat', heading: 'Features', match: /^feat(?:\(.+\))?!?:\s*/i },
+  { key: 'fix', heading: 'Fixes', match: /^fix(?:\(.+\))?!?:\s*/i },
+  { key: 'perf', heading: 'Performance', match: /^perf(?:\(.+\))?!?:\s*/i },
+  { key: 'refactor', heading: 'Refactors', match: /^refactor(?:\(.+\))?!?:\s*/i },
+  { key: 'docs', heading: 'Documentation', match: /^docs(?:\(.+\))?!?:\s*/i },
+  { key: 'test', heading: 'Tests', match: /^test(?:\(.+\))?!?:\s*/i },
+  { key: 'build', heading: 'Build', match: /^build(?:\(.+\))?!?:\s*/i },
+  { key: 'ci', heading: 'CI', match: /^ci(?:\(.+\))?!?:\s*/i },
+  { key: 'chore', heading: 'Chores', match: /^chore(?:\(.+\))?!?:\s*/i },
+];
+
+function normalizeCommit(commit) {
+  if (!commit) {
+    return null;
+  }
+
+  if (typeof commit === 'string') {
+    return {
+      sha: '',
+      message: commit.trim(),
+    };
+  }
+
+  if (typeof commit.message !== 'string') {
+    return null;
+  }
+
+  return {
+    sha: typeof commit.sha === 'string' ? commit.sha : '',
+    message: commit.message.trim(),
+  };
+}
+
+function stripPrefix(message, group) {
+  if (!group) {
+    return message;
+  }
+
+  return message.replace(group.match, '').trim();
+}
+
+function formatCommit(commit, group) {
+  const cleanedMessage = stripPrefix(commit.message, group);
+  const shortSha = commit.sha ? commit.sha.slice(0, 7) : '';
+  return shortSha
+    ? `- ${cleanedMessage} (\`${shortSha}\`)`
+    : `- ${cleanedMessage}`;
+}
+
+function buildReleaseHeading(version, date) {
+  const versionLabel = version || 'Unreleased';
+  return date ? `## ${versionLabel} - ${date}` : `## ${versionLabel}`;
+}
+
+function generateChangelog({ commits = [], version, date } = {}) {
+  const normalizedCommits = commits
+    .map(normalizeCommit)
+    .filter(commit => commit && commit.message);
+
+  const sections = [];
+  const remainingCommits = [...normalizedCommits];
+
+  for (const group of GROUPS) {
+    const matches = remainingCommits.filter(commit => group.match.test(commit.message));
+    if (matches.length === 0) {
+      continue;
+    }
+
+    sections.push(`### ${group.heading}`);
+    sections.push(...matches.map(commit => formatCommit(commit, group)));
+    sections.push('');
+
+    for (const match of matches) {
+      const index = remainingCommits.indexOf(match);
+      if (index >= 0) {
+        remainingCommits.splice(index, 1);
+      }
+    }
+  }
+
+  if (remainingCommits.length > 0) {
+    sections.push('### Other');
+    sections.push(...remainingCommits.map(commit => formatCommit(commit)));
+    sections.push('');
+  }
+
+  const lines = [buildReleaseHeading(version, date), ''];
+  if (sections.length === 0) {
+    lines.push('- No changes recorded');
+  } else {
+    lines.push(...sections);
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+function prependToChangelog({ changelogPath, content, fs }) {
+  if (!changelogPath) {
+    throw new Error('changelogPath is required');
+  }
+
+  if (!fs || typeof fs.readFileSync !== 'function' || typeof fs.writeFileSync !== 'function') {
+    throw new Error('fs with readFileSync and writeFileSync is required');
+  }
+
+  const normalizedContent = String(content || '').trim();
+  if (!normalizedContent) {
+    throw new Error('content is required');
+  }
+
+  let existing = '';
+  try {
+    existing = fs.readFileSync(changelogPath, 'utf8');
+  } catch (error) {
+    if (!error || error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  let nextContent;
+  if (!existing) {
+    nextContent = `${DEFAULT_TITLE}\n\n${normalizedContent}\n`;
+  } else if (existing.startsWith(`${DEFAULT_TITLE}\n`)) {
+    const remainder = existing.slice(DEFAULT_TITLE.length).replace(/^\s*/, '');
+    nextContent = `${DEFAULT_TITLE}\n\n${normalizedContent}${remainder ? `\n\n${remainder.trimStart()}` : '\n'}`;
+  } else {
+    nextContent = `${normalizedContent}\n\n${existing.trimStart()}`;
+  }
+
+  fs.writeFileSync(changelogPath, nextContent, 'utf8');
+  return nextContent;
+}
+
+module.exports = {
+  generateChangelog,
+  prependToChangelog,
+};