tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/github/config.test.js

@@ -0,0 +1,385 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  loadGitHubConfig,
+  isGitHubEnabled,
+  detectAndSuggestConfig,
+  writeGitHubConfig,
+  getDefaultConfig,
+  queueSyncAction,
+  flushSyncQueue,
+  loadSyncQueue,
+} from './config.js';
+
+// ---------------------------------------------------------------------------
+// Mock fs helpers
+// ---------------------------------------------------------------------------
+
+function createMockFs(files = {}) {
+  return {
+    existsSync: vi.fn((path) => path in files),
+    readFileSync: vi.fn((path, _encoding) => {
+      if (!(path in files)) {
+        const err = new Error(`ENOENT: no such file or directory, open '${path}'`);
+        err.code = 'ENOENT';
+        throw err;
+      }
+      return files[path];
+    }),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// loadGitHubConfig
+// ---------------------------------------------------------------------------
+
+describe('loadGitHubConfig', () => {
+  it('reads valid config', () => {
+    const tlcJson = JSON.stringify({
+      project: 'MyProject',
+      github: {
+        autoSync: true,
+        owner: 'myorg',
+        repo: 'myrepo',
+        project: 'My Board',
+      },
+    });
+    const fs = createMockFs({ '/proj/.tlc.json': tlcJson });
+
+    const result = loadGitHubConfig('/proj', { fs });
+
+    expect(result.config).toBeTruthy();
+    expect(result.config.autoSync).toBe(true);
+    expect(result.config.owner).toBe('myorg');
+    expect(result.config.repo).toBe('myrepo');
+    expect(result.warnings).toEqual([]);
+  });
+
+  it('returns null when no github section', () => {
+    const tlcJson = JSON.stringify({ project: 'NoGitHub' });
+    const fs = createMockFs({ '/proj/.tlc.json': tlcJson });
+
+    const result = loadGitHubConfig('/proj', { fs });
+
+    expect(result.config).toBeNull();
+    expect(result.warnings).toEqual([]);
+  });
+
+  it('warns on missing project field', () => {
+    const tlcJson = JSON.stringify({
+      project: 'Test',
+      github: {
+        autoSync: true,
+        owner: 'myorg',
+        repo: 'myrepo',
+        // project field missing
+      },
+    });
+    const fs = createMockFs({ '/proj/.tlc.json': tlcJson });
+
+    const result = loadGitHubConfig('/proj', { fs });
+
+    expect(result.config).toBeTruthy();
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings[0]).toContain('project');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isGitHubEnabled
+// ---------------------------------------------------------------------------
+
+describe('isGitHubEnabled', () => {
+  it('returns true when autoSync is true', () => {
+    const tlcJson = JSON.stringify({
+      github: { autoSync: true },
+    });
+    const fs = createMockFs({ '/proj/.tlc.json': tlcJson });
+
+    expect(isGitHubEnabled('/proj', { fs })).toBe(true);
+  });
+
+  it('returns false when no config', () => {
+    const fs = createMockFs({}); // no .tlc.json file
+
+    expect(isGitHubEnabled('/proj', { fs })).toBe(false);
+  });
+
+  it('returns false when autoSync is false', () => {
+    const tlcJson = JSON.stringify({
+      github: { autoSync: false },
+    });
+    const fs = createMockFs({ '/proj/.tlc.json': tlcJson });
+
+    expect(isGitHubEnabled('/proj', { fs })).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// detectAndSuggestConfig
+// ---------------------------------------------------------------------------
+
+describe('detectAndSuggestConfig', () => {
+  it('detects repo and project', () => {
+    const ghClient = {
+      detectRepo: vi.fn().mockReturnValue({ owner: 'myorg', repo: 'myrepo', url: 'https://github.com/myorg/myrepo' }),
+      checkAuth: vi.fn().mockReturnValue({ authenticated: true, user: 'octocat', scopes: ['repo', 'project'] }),
+    };
+    const ghProjects = {
+      discoverProject: vi.fn().mockReturnValue({
+        projectId: 'PVT_123',
+        title: 'myrepo',
+        number: 1,
+        fields: [
+          { id: 'F1', name: 'Status', type: 'single_select', options: [{ id: 'O1', name: 'Backlog' }] },
+          { id: 'F2', name: 'Sprint', type: 'single_select', options: [] },
+        ],
+      }),
+    };
+    const fs = createMockFs({});
+
+    const result = detectAndSuggestConfig({ ghClient, ghProjects, projectDir: '/proj', fs });
+
+    expect(result.owner).toBe('myorg');
+    expect(result.repo).toBe('myrepo');
+    expect(result.project).toBeTruthy();
+    expect(result.suggestedConfig).toBeTruthy();
+    expect(result.suggestedConfig.autoSync).toBe(true);
+  });
+
+  it('detects missing project scope', () => {
+    const ghClient = {
+      detectRepo: vi.fn().mockReturnValue({ owner: 'myorg', repo: 'myrepo', url: 'https://github.com/myorg/myrepo' }),
+      checkAuth: vi.fn().mockReturnValue({ authenticated: true, user: 'octocat', scopes: ['repo'] }),
+    };
+    const ghProjects = {};
+    const fs = createMockFs({});
+
+    const result = detectAndSuggestConfig({ ghClient, ghProjects, projectDir: '/proj', fs });
+
+    expect(result.needsScope).toBe(true);
+    expect(result.command).toContain('gh auth refresh');
+    expect(result.command).toContain('project');
+  });
+
+  it('returns suggestedConfig with defaults', () => {
+    const ghClient = {
+      detectRepo: vi.fn().mockReturnValue({ owner: 'org', repo: 'repo', url: 'https://github.com/org/repo' }),
+      checkAuth: vi.fn().mockReturnValue({ authenticated: true, user: 'user', scopes: ['repo', 'project'] }),
+    };
+    const ghProjects = {
+      discoverProject: vi.fn().mockReturnValue({
+        projectId: 'PVT_456',
+        title: 'repo',
+        number: 2,
+        fields: [],
+      }),
+    };
+    const fs = createMockFs({});
+
+    const result = detectAndSuggestConfig({ ghClient, ghProjects, projectDir: '/proj', fs });
+
+    expect(result.suggestedConfig).toBeTruthy();
+    expect(result.suggestedConfig.statusMapping).toBeTruthy();
+    expect(result.suggestedConfig.statusMapping.todo).toBe('Backlog');
+    expect(result.suggestedConfig.phasePrefix).toBe('Phase');
+  });
+
+  it('handles no repo gracefully', () => {
+    const ghClient = {
+      detectRepo: vi.fn().mockReturnValue(null),
+      checkAuth: vi.fn(),
+    };
+    const ghProjects = {};
+    const fs = createMockFs({});
+
+    const result = detectAndSuggestConfig({ ghClient, ghProjects, projectDir: '/proj', fs });
+
+    expect(result.error).toBeTruthy();
+    expect(result.error).toContain('repo');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// writeGitHubConfig
+// ---------------------------------------------------------------------------
+
+describe('writeGitHubConfig', () => {
+  it('preserves existing .tlc.json content', () => {
+    const existing = JSON.stringify({
+      project: 'MyProject',
+      version: '1.0.0',
+      quality: { coverageThreshold: 80 },
+    });
+    const fs = createMockFs({ '/proj/.tlc.json': existing });
+
+    const githubConfig = { autoSync: true, owner: 'org', repo: 'repo' };
+    const result = writeGitHubConfig('/proj', githubConfig, { fs });
+
+    expect(result.written).toBe(true);
+    expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const writtenContent = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(writtenContent.project).toBe('MyProject');
+    expect(writtenContent.version).toBe('1.0.0');
+    expect(writtenContent.quality.coverageThreshold).toBe(80);
+    expect(writtenContent.github.autoSync).toBe(true);
+    expect(writtenContent.github.owner).toBe('org');
+  });
+
+  it('creates github section if missing', () => {
+    const existing = JSON.stringify({ project: 'Bare' });
+    const fs = createMockFs({ '/proj/.tlc.json': existing });
+
+    const githubConfig = { autoSync: true };
+    const result = writeGitHubConfig('/proj', githubConfig, { fs });
+
+    expect(result.written).toBe(true);
+    const writtenContent = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(writtenContent.github).toEqual({ autoSync: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getDefaultConfig
+// ---------------------------------------------------------------------------
+
+describe('getDefaultConfig', () => {
+  it('returns expected defaults', () => {
+    const defaults = getDefaultConfig();
+
+    expect(defaults.autoSync).toBe(true);
+    expect(defaults.phasePrefix).toBe('Phase');
+    expect(defaults.sprintField).toBe('Sprint');
+    expect(defaults.statusField).toBe('Status');
+    expect(defaults.statusMapping).toEqual({
+      todo: 'Backlog',
+      in_progress: 'In progress',
+      in_review: 'In review',
+      done: 'Done',
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// queueSyncAction + loadSyncQueue
+// ---------------------------------------------------------------------------
+
+describe('queueSyncAction', () => {
+  it('creates queue file', () => {
+    const fs = createMockFs({});
+
+    queueSyncAction('/proj', { type: 'create_issue', payload: { title: 'Bug' }, timestamp: '2026-01-01T00:00:00Z' }, { fs });
+
+    expect(fs.mkdirSync).toHaveBeenCalled();
+    expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+    const written = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(written).toHaveLength(1);
+    expect(written[0].type).toBe('create_issue');
+    expect(written[0].payload.title).toBe('Bug');
+  });
+
+  it('appends to existing queue', () => {
+    const existingQueue = JSON.stringify([
+      { type: 'close_issue', payload: { number: 1 }, timestamp: '2026-01-01T00:00:00Z' },
+    ]);
+    const fs = createMockFs({ '/proj/.tlc/.github-sync-queue.json': existingQueue });
+
+    queueSyncAction('/proj', { type: 'create_issue', payload: { title: 'New' }, timestamp: '2026-01-02T00:00:00Z' }, { fs });
+
+    const written = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(written).toHaveLength(2);
+    expect(written[0].type).toBe('close_issue');
+    expect(written[1].type).toBe('create_issue');
+  });
+});
+
+describe('loadSyncQueue', () => {
+  it('returns empty array when no file', () => {
+    const fs = createMockFs({});
+
+    const result = loadSyncQueue('/proj', { fs });
+
+    expect(result).toEqual([]);
+  });
+
+  it('returns queued actions', () => {
+    const queue = JSON.stringify([
+      { type: 'create_issue', payload: { title: 'A' }, timestamp: '2026-01-01T00:00:00Z' },
+      { type: 'close_issue', payload: { number: 5 }, timestamp: '2026-01-01T01:00:00Z' },
+    ]);
+    const fs = createMockFs({ '/proj/.tlc/.github-sync-queue.json': queue });
+
+    const result = loadSyncQueue('/proj', { fs });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].type).toBe('create_issue');
+    expect(result[1].payload.number).toBe(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// flushSyncQueue
+// ---------------------------------------------------------------------------
+
+describe('flushSyncQueue', () => {
+  it('replays and clears successful actions', () => {
+    const queue = JSON.stringify([
+      { type: 'create_issue', payload: { owner: 'o', repo: 'r', title: 'Bug', body: 'desc' }, timestamp: '2026-01-01T00:00:00Z' },
+      { type: 'close_issue', payload: { owner: 'o', repo: 'r', number: 3 }, timestamp: '2026-01-01T01:00:00Z' },
+    ]);
+    const fs = createMockFs({ '/proj/.tlc/.github-sync-queue.json': queue });
+    const ghClient = {
+      createIssue: vi.fn().mockReturnValue({ number: 10, url: 'https://github.com/o/r/issues/10' }),
+      closeIssue: vi.fn().mockReturnValue({ closed: true }),
+    };
+    const ghProjects = {};
+
+    const result = flushSyncQueue('/proj', { ghClient, ghProjects, fs });
+
+    expect(result.flushed).toBe(2);
+    expect(result.failed).toBe(0);
+    expect(result.remaining).toBe(0);
+
+    // Should write empty queue (or remove file)
+    const written = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(written).toHaveLength(0);
+  });
+
+  it('retains failed actions', () => {
+    const queue = JSON.stringify([
+      { type: 'create_issue', payload: { owner: 'o', repo: 'r', title: 'Good', body: 'ok' }, timestamp: '2026-01-01T00:00:00Z' },
+      { type: 'create_issue', payload: { owner: 'o', repo: 'r', title: 'Bad', body: 'fail' }, timestamp: '2026-01-01T01:00:00Z' },
+    ]);
+    const fs = createMockFs({ '/proj/.tlc/.github-sync-queue.json': queue });
+    const ghClient = {
+      createIssue: vi.fn()
+        .mockReturnValueOnce({ number: 10, url: 'https://github.com/o/r/issues/10' })
+        .mockReturnValueOnce({ error: 'API error', code: 'GH_API_ERROR' }),
+    };
+    const ghProjects = {};
+
+    const result = flushSyncQueue('/proj', { ghClient, ghProjects, fs });
+
+    expect(result.flushed).toBe(1);
+    expect(result.failed).toBe(1);
+    expect(result.remaining).toBe(1);
+
+    const written = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+    expect(written).toHaveLength(1);
+    expect(written[0].payload.title).toBe('Bad');
+  });
+
+  it('returns correct counts', () => {
+    const fs = createMockFs({}); // no queue file
+    const ghClient = {};
+    const ghProjects = {};
+
+    const result = flushSyncQueue('/proj', { ghClient, ghProjects, fs });
+
+    expect(result.flushed).toBe(0);
+    expect(result.failed).toBe(0);
+    expect(result.remaining).toBe(0);
+  });
+});

package/server/lib/github/gh-client.js

@@ -0,0 +1,303 @@
+/**
+ * GitHub Client — wraps `gh` CLI for issue and PR operations
+ * Phase 97 Task 1
+ *
+ * All functions accept `{ exec }` for dependency injection,
+ * defaulting to child_process.execSync.
+ */
+
+const { execSync } = require('child_process');
+
+const EXEC_OPTS = { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] };
+
+/**
+ * Escape a string for safe use inside single-quoted shell arguments.
+ * Wraps in single quotes and escapes any embedded single quotes.
+ * @param {string} str
+ * @returns {string}
+ */
+function shellEscape(str) {
+  if (str == null) return "''";
+  return "'" + String(str).replace(/'/g, "'\\''") + "'";
+}
+
+/**
+ * Extract error message from a caught error
+ * @param {Error} error
+ * @returns {string}
+ */
+function extractMessage(error) {
+  return error.stderr?.toString() || error.message;
+}
+
+/**
+ * Classify an error into a structured response
+ * @param {string} message - Error message text
+ * @param {string} context - Human-readable context for logging
+ * @param {Object} [meta] - Additional metadata to log
+ * @returns {{ error: string, code: string }}
+ */
+function classifyError(message, context, meta = {}) {
+  if (message.includes('command not found') || message.includes('not found: gh') || message.includes('ENOENT')) {
+    return { error: 'gh CLI not found', code: 'GH_NOT_FOUND' };
+  }
+  if (message.includes('auth') || message.includes('login')) {
+    return { error: 'gh not authenticated', code: 'GH_AUTH_REQUIRED' };
+  }
+  console.error(`[TLC] GitHub ${context} failed: ${message}`, meta);
+  return { error: message, code: 'GH_API_ERROR' };
+}
+
+/**
+ * Check GitHub CLI authentication status
+ * @param {Object} [options]
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ authenticated: boolean, user?: string, scopes?: string[], error?: string, code?: string }}
+ */
+function checkAuth({ exec = execSync } = {}) {
+  try {
+    const raw = exec('gh auth status --json', EXEC_OPTS);
+    const data = JSON.parse(raw);
+    const scopes = Array.isArray(data.scopes) ? data.scopes
+      : typeof data.scopes === 'string' ? data.scopes.split(',').map(s => s.trim())
+      : [];
+    return {
+      authenticated: true,
+      user: data.user,
+      scopes,
+    };
+  } catch (error) {
+    const message = extractMessage(error);
+    const result = classifyError(message, 'checkAuth', {});
+    return { authenticated: false, ...result };
+  }
+}
+
+/**
+ * Create a GitHub issue
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {string} options.title - Issue title
+ * @param {string} options.body - Issue body
+ * @param {string[]} [options.labels] - Labels to add
+ * @param {string[]} [options.assignees] - Assignees to add
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ number: number, url: string } | { error: string, code: string }}
+ */
+function createIssue({ owner, repo, title, body, labels, assignees, exec = execSync }) {
+  if (!owner || !repo || !title) {
+    return { error: 'Missing required parameters: owner, repo, title', code: 'INVALID_PARAMS' };
+  }
+  try {
+    let cmd = `gh issue create --repo ${shellEscape(owner + '/' + repo)} --title ${shellEscape(title)} --body ${shellEscape(body || '')}`;
+    if (labels && labels.length > 0) {
+      cmd += ` --label ${shellEscape(labels.join(','))}`;
+    }
+    if (assignees && assignees.length > 0) {
+      cmd += ` --assignee ${shellEscape(assignees.join(','))}`;
+    }
+    cmd += ' --json number,url,id';
+    const raw = exec(cmd, EXEC_OPTS);
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'createIssue', { owner, repo, title });
+  }
+}
+
+/**
+ * Close a GitHub issue
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number} options.number - Issue number
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ closed: boolean } | { error: string, code: string }}
+ */
+function closeIssue({ owner, repo, number, exec = execSync }) {
+  if (!owner || !repo || number == null) {
+    return { error: 'Missing required parameters: owner, repo, number', code: 'INVALID_PARAMS' };
+  }
+  try {
+    const cmd = `gh issue close ${Number(number)} --repo ${shellEscape(owner + '/' + repo)}`;
+    exec(cmd, EXEC_OPTS);
+    return { closed: true };
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'closeIssue', { owner, repo, number });
+  }
+}
+
+/**
+ * List GitHub issues
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {string[]} [options.labels] - Filter by labels
+ * @param {string} [options.state='open'] - Issue state filter
+ * @param {number} [options.limit=100] - Maximum issues to return
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {Array | { error: string, code: string }}
+ */
+function listIssues({ owner, repo, labels, state = 'open', limit = 100, exec = execSync }) {
+  if (!owner || !repo) {
+    return { error: 'Missing required parameters: owner, repo', code: 'INVALID_PARAMS' };
+  }
+  try {
+    let cmd = `gh issue list --repo ${shellEscape(owner + '/' + repo)} --state ${shellEscape(state)} --json number,title,state,labels,assignees --limit ${Number(limit)}`;
+    if (labels && labels.length > 0) {
+      cmd += ` --label ${shellEscape(labels.join(','))}`;
+    }
+    const raw = exec(cmd, EXEC_OPTS);
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'listIssues', { owner, repo, state });
+  }
+}
+
+/**
+ * Assign users to a GitHub issue
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number} options.number - Issue number
+ * @param {string[]} options.assignees - Users to assign
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ assigned: boolean } | { error: string, code: string }}
+ */
+function assignIssue({ owner, repo, number, assignees, exec = execSync }) {
+  if (!owner || !repo || number == null || !assignees || assignees.length === 0) {
+    return { error: 'Missing required parameters: owner, repo, number, assignees', code: 'INVALID_PARAMS' };
+  }
+  try {
+    const cmd = `gh issue edit ${Number(number)} --repo ${shellEscape(owner + '/' + repo)} --add-assignee ${shellEscape(assignees.join(','))}`;
+    exec(cmd, EXEC_OPTS);
+    return { assigned: true };
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'assignIssue', { owner, repo, number });
+  }
+}
+
+/**
+ * Add labels to a GitHub issue
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number} options.number - Issue number
+ * @param {string[]} options.labels - Labels to add
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ labeled: boolean } | { error: string, code: string }}
+ */
+function addLabels({ owner, repo, number, labels, exec = execSync }) {
+  if (!owner || !repo || number == null || !labels || labels.length === 0) {
+    return { error: 'Missing required parameters: owner, repo, number, labels', code: 'INVALID_PARAMS' };
+  }
+  try {
+    const cmd = `gh issue edit ${Number(number)} --repo ${shellEscape(owner + '/' + repo)} --add-label ${shellEscape(labels.join(','))}`;
+    exec(cmd, EXEC_OPTS);
+    return { labeled: true };
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'addLabels', { owner, repo, number });
+  }
+}
+
+/**
+ * Create a pull request
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {string} options.title - PR title
+ * @param {string} options.body - PR body
+ * @param {string} options.base - Base branch
+ * @param {string} options.head - Head branch
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ number: number, url: string } | { error: string, code: string }}
+ */
+function createPr({ owner, repo, title, body, base, head, exec = execSync }) {
+  if (!owner || !repo || !title || !base || !head) {
+    return { error: 'Missing required parameters: owner, repo, title, base, head', code: 'INVALID_PARAMS' };
+  }
+  try {
+    const cmd = `gh pr create --repo ${shellEscape(owner + '/' + repo)} --title ${shellEscape(title)} --body ${shellEscape(body || '')} --base ${shellEscape(base)} --head ${shellEscape(head)} --json number,url`;
+    const raw = exec(cmd, EXEC_OPTS);
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'createPr', { owner, repo, title });
+  }
+}
+
+/**
+ * Link a PR to issues by appending Closes references to the PR body
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number} options.prNumber - PR number
+ * @param {number[]} options.issueNumbers - Issue numbers to link
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ linked: boolean } | { error: string, code: string }}
+ */
+function linkPrToIssue({ owner, repo, prNumber, issueNumbers, exec = execSync }) {
+  if (!owner || !repo || prNumber == null || !issueNumbers || issueNumbers.length === 0) {
+    return { error: 'Missing required parameters: owner, repo, prNumber, issueNumbers', code: 'INVALID_PARAMS' };
+  }
+  try {
+    // Fetch current PR body
+    const viewCmd = `gh pr view ${Number(prNumber)} --repo ${shellEscape(owner + '/' + repo)} --json body`;
+    const viewRaw = exec(viewCmd, EXEC_OPTS);
+    const { body: currentBody } = JSON.parse(viewRaw);
+
+    // Build new body with Closes references
+    const closesRefs = issueNumbers.map(n => `Closes #${Number(n)}`).join(', ');
+    const existingBody = currentBody || '';
+    const newBody = existingBody
+      ? `${existingBody}\n\n${closesRefs}`
+      : closesRefs;
+
+    // Update PR body
+    const editCmd = `gh pr edit ${Number(prNumber)} --repo ${shellEscape(owner + '/' + repo)} --body ${shellEscape(newBody)}`;
+    exec(editCmd, EXEC_OPTS);
+    return { linked: true };
+  } catch (error) {
+    const message = extractMessage(error);
+    return classifyError(message, 'linkPrToIssue', { owner, repo, prNumber });
+  }
+}
+
+/**
+ * Detect the current repository from git context
+ * @param {Object} [options]
+ * @param {Function} [options.exec] - Injected exec function
+ * @returns {{ owner: string, repo: string, url: string } | null}
+ */
+function detectRepo({ exec = execSync } = {}) {
+  try {
+    const raw = exec('gh repo view --json owner,name,url', EXEC_OPTS);
+    const data = JSON.parse(raw);
+    return {
+      owner: data.owner?.login || data.owner,
+      repo: data.name,
+      url: data.url,
+    };
+  } catch (error) {
+    const message = extractMessage(error);
+    console.error(`[TLC] GitHub detectRepo failed: ${message}`);
+    return null;
+  }
+}
+
+module.exports = {
+  checkAuth,
+  createIssue,
+  closeIssue,
+  listIssues,
+  assignIssue,
+  addLabels,
+  createPr,
+  linkPrToIssue,
+  detectRepo,
+};