@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/dist/lib/platform/github-release-notes.js

@@ -0,0 +1,96 @@
+import { createGitHubClient } from './github-client.js';
+function normalizeGitHubActor(actor) {
+    const name = String(actor.name || '').trim();
+    const email = actor.email ? String(actor.email).trim() : null;
+    const platformLogin = actor.user?.login?.trim().toLowerCase() || null;
+    const noReplyLogin = email
+        ? /^(?:\d+\+)?([^@]+)@users\.noreply\.github\.com$/i.exec(email)?.[1]?.toLowerCase() || null
+        : null;
+    const login = platformLogin || noReplyLogin;
+    return {
+        name,
+        email,
+        login,
+        bot: Boolean(login?.endsWith('[bot]')),
+        resolution: platformLogin ? 'platform-user' : noReplyLogin ? 'platform-noreply' : 'unresolved'
+    };
+}
+function failure(error) {
+    return {
+        status: error.retryable ? 'blocked' : 'failed',
+        changed: false,
+        operation: null,
+        url: null,
+        error
+    };
+}
+function publishGitHubReleaseNotes(input, options = {}) {
+    const client = options.client ?? createGitHubClient();
+    const inspected = client.json(['release', 'view', input.tag, '--repo', input.repository, '--json', 'url'], { cwd: options.cwd });
+    if (!inspected.ok && inspected.error.code !== 'RESOURCE_NOT_FOUND')
+        return failure(inspected.error);
+    const exists = inspected.ok;
+    const operation = exists ? 'release:update-notes' : 'release:create';
+    if (input.dryRun) {
+        return {
+            status: 'planned',
+            changed: false,
+            operation,
+            url: inspected.ok ? inspected.value.url || null : null,
+            error: null
+        };
+    }
+    const args = exists
+        ? ['release', 'edit', input.tag, '--repo', input.repository, '--notes-file', input.notesFile]
+        : ['release', 'create', input.tag, '--repo', input.repository, '--title', input.title, '--notes-file', input.notesFile];
+    const written = client.text(args, { cwd: options.cwd, method: exists ? 'PATCH' : 'POST' });
+    if (!written.ok)
+        return failure(written.error);
+    return {
+        status: 'applied',
+        changed: true,
+        operation,
+        url: written.value || (inspected.ok ? inspected.value.url || null : null),
+        error: null
+    };
+}
+function fetchGitHubReleaseNoteData(input, options = {}) {
+    const client = options.client ?? createGitHubClient();
+    const releases = client.json(['release', 'list', '--repo', input.repository, '--limit', String(input.historyLimit + 10), '--json', 'tagName,isDraft,isPrerelease'], { cwd: options.cwd });
+    if (!releases.ok)
+        return failure(releases.error);
+    const history = [];
+    for (const item of releases.value.filter((entry) => !entry.isDraft && !entry.isPrerelease).slice(0, input.historyLimit)) {
+        const viewed = client.json(['release', 'view', String(item.tagName), '--repo', input.repository, '--json', 'body,url'], { cwd: options.cwd });
+        if (!viewed.ok)
+            return failure(viewed.error);
+        history.push({ tag: String(item.tagName), body: String(viewed.value.body || ''), url: viewed.value.url || null });
+    }
+    const prs = client.json(['pr', 'list', '--repo', input.repository, '--state', 'merged', '--base', input.branch, '--limit', '1000', '--json', 'number,title,body,url,mergedAt,labels,author,closingIssuesReferences'], { cwd: options.cwd });
+    if (!prs.ok)
+        return failure(prs.error);
+    const authors = new Map();
+    for (const oid of input.commitOids) {
+        const query = `query($owner:String!,$name:String!,$oid:GitObjectID!){repository(owner:$owner,name:$name){object(oid:$oid){... on Commit{authors(first:100){nodes{name email user{login}} pageInfo{hasNextPage}}}}}}`;
+        const [owner, name] = input.repository.split('/');
+        const result = client.json([
+            'api', 'graphql', '-f', `query=${query}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `oid=${oid}`
+        ], { cwd: options.cwd });
+        if (!result.ok)
+            return failure(result.error);
+        const connection = result.value.data?.repository?.object?.authors;
+        if (connection?.pageInfo?.hasNextPage) {
+            return failure({ code: 'RELEASE_NOTES_AUTHORS_TRUNCATED', message: `Commit authors exceeded the supported page size for ${oid}`, retryable: false });
+        }
+        authors.set(oid, (connection?.nodes || []).map(normalizeGitHubActor));
+    }
+    const fromTime = Date.parse(input.fromTime);
+    const toTime = Date.parse(input.toTime);
+    const pullRequests = prs.value.filter((item) => {
+        const mergedAt = Date.parse(String(item.mergedAt || ''));
+        return Number.isFinite(mergedAt) && mergedAt > fromTime && mergedAt <= toTime;
+    });
+    return { status: 'no-op', changed: false, history, pullRequests, authors, error: null };
+}
+export { fetchGitHubReleaseNoteData, normalizeGitHubActor, publishGitHubReleaseNotes };
+//# sourceMappingURL=github-release-notes.js.map

package/dist/lib/platform/issue-comments.js

@@ -0,0 +1,409 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { createGitHubClient } from './github-client.js';
+import { resolvePlatformContext } from './context.js';
+import { platformResult } from './types.js';
+const MARKERS = {
+    task: (taskId) => `<!-- sync-issue:${taskId}:task -->`,
+    artifact: (taskId, stem) => `<!-- sync-issue:${taskId}:${stem} -->`,
+    artifactChunk: (taskId, stem, part, total) => `<!-- sync-issue:${taskId}:${stem}:${part}/${total} -->`,
+    summary: (taskId) => `<!-- sync-issue:${taskId}:summary -->`,
+    cancel: (taskId) => `<!-- sync-issue:${taskId}:cancel -->`
+};
+const ARTIFACT_TITLES = {
+    analysis: '需求分析',
+    'review-analysis': '需求分析审查',
+    plan: '技术方案',
+    'review-plan': '技术方案审查',
+    code: '实现报告',
+    'review-code': '代码审查',
+    'manual-validation': '人工验证报告'
+};
+function normalizeCommentContent(content) {
+    return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+function splitFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+    if (!match)
+        return { frontmatter: null, body: content };
+    return { frontmatter: match[1], body: content.slice(match[0].length).replace(/^\r?\n/, '') };
+}
+function footer(agent, taskId) {
+    return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
+}
+function renderTaskComment(content, taskId, agent) {
+    const split = splitFrontmatter(content);
+    const taskBody = split.frontmatter === null
+        ? split.body
+        : `<details><summary>元数据 (frontmatter)</summary>\n\n\`\`\`yaml\n---\n${split.frontmatter}\n---\n\`\`\`\n\n</details>\n\n${split.body}`;
+    return normalizeCommentContent([
+        MARKERS.task(taskId),
+        '## 任务文件',
+        '',
+        `> **${agent}** · ${taskId}`,
+        '',
+        taskBody.replace(/\n+$/, ''),
+        '',
+        footer(agent, taskId)
+    ].join('\n'));
+}
+function artifactIdentity(artifact) {
+    const stem = path.basename(artifact, '.md');
+    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation)(?:-r(\d+))?$/);
+    if (!match)
+        throw new Error(`unsupported artifact '${artifact}'`);
+    const base = ARTIFACT_TITLES[match[1]];
+    const round = match[2] ? Number(match[2]) : 1;
+    return { stem, title: `${base}（Round ${round}）` };
+}
+function chunkByUtf8(content, maxBytes) {
+    if (maxBytes <= 0)
+        throw new Error('comment byte limit is too small');
+    const chunks = [];
+    let remaining = content;
+    while (remaining) {
+        if (Buffer.byteLength(remaining, 'utf8') <= maxBytes) {
+            chunks.push(remaining);
+            break;
+        }
+        let bytes = 0;
+        let index = 0;
+        let newlineIndex = -1;
+        for (const character of remaining) {
+            const size = Buffer.byteLength(character, 'utf8');
+            if (bytes + size > maxBytes)
+                break;
+            bytes += size;
+            index += character.length;
+            if (character === '\n')
+                newlineIndex = index;
+        }
+        const cut = newlineIndex > 0 ? newlineIndex : index;
+        if (cut === 0)
+            throw new Error('comment byte limit cannot fit one Unicode code point');
+        chunks.push(remaining.slice(0, cut));
+        remaining = remaining.slice(cut);
+    }
+    return chunks.length > 0 ? chunks : [''];
+}
+function buildArtifactChunk(taskId, stem, title, agent, content, part, total, chunked, backfill) {
+    const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
+    const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
+    const timelineHint = backfill ? '> 历史产物补发' : null;
+    const body = normalizeCommentContent([
+        marker,
+        heading,
+        ...(timelineHint ? ['', timelineHint] : []),
+        '',
+        `> **${agent}** · ${taskId}`,
+        '',
+        content,
+        '',
+        footer(agent, taskId)
+    ].join('\n'));
+    return { marker, body, content, part, total };
+}
+function chunkArtifactComment(input) {
+    const byteLimit = input.byteLimit || 60_000;
+    const identity = artifactIdentity(input.artifact);
+    const single = buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, input.body, 1, 1, false, Boolean(input.backfill));
+    if (Buffer.byteLength(single.body, 'utf8') <= byteLimit)
+        return [single];
+    let total = 2;
+    let pieces = [];
+    for (;;) {
+        const probe = buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, '', total, total, true, Boolean(input.backfill));
+        const available = byteLimit - Buffer.byteLength(probe.body, 'utf8');
+        pieces = chunkByUtf8(input.body, available);
+        if (pieces.length === total)
+            break;
+        total = pieces.length;
+    }
+    return pieces.map((content, index) => {
+        const chunk = buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, content, index + 1, total, true, Boolean(input.backfill));
+        if (Buffer.byteLength(chunk.body, 'utf8') > byteLimit)
+            throw new Error('rendered comment exceeds byte limit');
+        return chunk;
+    });
+}
+function findMarkerComments(comments, marker) {
+    return comments.filter((comment) => normalizeCommentContent(String(comment.body || '')).split('\n', 1)[0] === marker);
+}
+function flattenComments(value) {
+    if (!Array.isArray(value))
+        return [];
+    const flattened = value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
+    return flattened.filter((entry) => Boolean(entry && typeof entry === 'object' && typeof entry.id === 'number' && typeof entry.body === 'string'));
+}
+function issueNumberFromTask(content) {
+    const value = parseTaskFrontmatter(content).issue_number;
+    const number = Number(value);
+    return Number.isInteger(number) && number > 0 ? number : null;
+}
+function listRemoteComments(client, repo, issue, cwd) {
+    const result = client.json([
+        'api', '--paginate', '--slurp', `repos/${repo}/issues/${issue}/comments?per_page=100`
+    ], { cwd });
+    return result.ok ? { ok: true, value: flattenComments(result.value) } : result;
+}
+function contextFields(context) {
+    return {
+        platform: context.platform,
+        capabilities: context.capabilities
+    };
+}
+function hasResolvedPlatformContext(context) {
+    return context.status === 'degraded' || (context.status === 'no-op' && context.error === null);
+}
+function bodyEnvelope(marker, title, taskId, agent, body) {
+    return normalizeCommentContent([
+        marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '', body.replace(/\n+$/, ''), '', footer(agent, taskId)
+    ].join('\n'));
+}
+function resolveArtifactBody(taskDir, artifact) {
+    if (path.basename(artifact) !== artifact || !artifact.endsWith('.md'))
+        throw new Error('artifact must be a canonical markdown filename');
+    artifactIdentity(artifact);
+    const artifactPath = path.join(taskDir, artifact);
+    const stat = fs.lstatSync(artifactPath);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('artifact must be a regular file');
+    const realTaskDir = fs.realpathSync(taskDir);
+    const realArtifact = fs.realpathSync(artifactPath);
+    if (path.dirname(realArtifact) !== realTaskDir)
+        throw new Error('artifact must stay inside the task directory');
+    return fs.readFileSync(realArtifact, 'utf8');
+}
+function expectedComments(taskId, taskContent, taskDir, options) {
+    if (options.kind === 'task') {
+        const body = renderTaskComment(taskContent, taskId, options.agent);
+        return [{ marker: MARKERS.task(taskId), body, content: taskContent, part: 1, total: 1 }];
+    }
+    if (options.kind === 'artifact') {
+        if (!options.artifact)
+            throw new Error('artifact sync requires an artifact filename');
+        return chunkArtifactComment({
+            taskId,
+            artifact: options.artifact,
+            agent: options.agent,
+            body: resolveArtifactBody(taskDir, options.artifact),
+            backfill: options.backfill
+        });
+    }
+    if (options.body === undefined)
+        throw new Error(`${options.kind} sync requires a body`);
+    const marker = options.kind === 'summary' ? MARKERS.summary(taskId) : MARKERS.cancel(taskId);
+    const title = options.kind === 'summary' ? '交付摘要' : '任务取消';
+    const body = bodyEnvelope(marker, title, taskId, options.agent, options.body);
+    return [{ marker, body, content: options.body, part: 1, total: 1 }];
+}
+function markerPrefix(taskId, options) {
+    if (options.kind === 'task')
+        return `<!-- sync-issue:${taskId}:task`;
+    if (options.kind === 'summary')
+        return `<!-- sync-issue:${taskId}:summary`;
+    if (options.kind === 'cancel')
+        return `<!-- sync-issue:${taskId}:cancel`;
+    const stem = path.basename(options.artifact || '', '.md');
+    return `<!-- sync-issue:${taskId}:${stem}`;
+}
+function relatedComments(comments, prefix) {
+    const base = `${prefix} -->`;
+    const chunkNamespace = `${prefix}:`;
+    return comments.filter((comment) => {
+        const first = normalizeCommentContent(comment.body).split('\n', 1)[0] || '';
+        return first === base || (first.startsWith(chunkNamespace) && first.endsWith(' -->'));
+    });
+}
+function validateRelatedMarkerSet(comments, prefix) {
+    const markers = comments.map((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] || '');
+    if (new Set(markers).size !== markers.length)
+        return { ok: false, code: 'COMMENT_MARKER_CONFLICT' };
+    const base = `${prefix} -->`;
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const chunkPattern = new RegExp(`^${escaped}:(\\d+)\\/(\\d+) -->$`);
+    const hasBase = markers.includes(base);
+    const chunks = markers.map((marker) => marker.match(chunkPattern)).filter((match) => Boolean(match));
+    if (markers.some((marker) => marker !== base && !chunkPattern.test(marker)))
+        return { ok: false, code: 'COMMENT_MARKER_CONFLICT' };
+    if (hasBase && chunks.length > 0)
+        return { ok: false, code: 'COMMENT_MARKER_CONFLICT' };
+    if (chunks.length === 0)
+        return { ok: true, code: null };
+    const totals = new Set(chunks.map((match) => Number(match[2])));
+    if (totals.size !== 1)
+        return { ok: false, code: 'COMMENT_MARKER_CONFLICT' };
+    const total = Number(chunks[0][2]);
+    const parts = chunks.map((match) => Number(match[1])).sort((left, right) => left - right);
+    const complete = total > 0 && parts.length === total && parts.every((part, index) => part === index + 1);
+    return complete ? { ok: true, code: null } : { ok: false, code: 'COMMENT_MARKER_CONFLICT' };
+}
+function writeComment(client, repo, issue, cwd, body, id) {
+    const endpoint = id ? `repos/${repo}/issues/comments/${id}` : `repos/${repo}/issues/${issue}/comments`;
+    return client.json(['api', endpoint, '-X', id ? 'PATCH' : 'POST', '--input', '-'], { cwd, method: id ? 'PATCH' : 'POST', input: JSON.stringify({ body }) });
+}
+function syncPlatformComment(taskRef, options) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok) {
+        return platformResult('failed', {
+            error: { code: resolved.code, message: resolved.message, retryable: false }
+        });
+    }
+    const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const issue = issueNumberFromTask(taskContent);
+    if (!issue) {
+        return platformResult('no-op', {
+            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+        });
+    }
+    const context = resolvePlatformContext({ cwd: resolved.repoRoot, client: options.client });
+    if (!hasResolvedPlatformContext(context))
+        return context;
+    const client = options.client || createGitHubClient();
+    const listed = listRemoteComments(client, context.platform.repository, issue, resolved.repoRoot);
+    if (!listed.ok) {
+        return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
+            ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
+        });
+    }
+    let desired;
+    try {
+        desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
+    }
+    catch (error) {
+        return platformResult('failed', {
+            ...contextFields(context),
+            resource: { kind: 'issue', number: issue },
+            error: { code: 'COMMENT_PAYLOAD_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false }
+        });
+    }
+    const existing = relatedComments(listed.value, markerPrefix(resolved.taskId, options));
+    if (!validateRelatedMarkerSet(existing, markerPrefix(resolved.taskId, options)).ok) {
+        return platformResult('failed', {
+            ...contextFields(context),
+            resource: { kind: 'issue', number: issue },
+            error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple comments use the same registered marker', retryable: false }
+        });
+    }
+    // Backfill only supplies missing artifact comments; valid existing marker sets stay untouched.
+    if (options.kind === 'artifact' && options.backfill && existing.length > 0) {
+        const operations = existing.map((comment) => ({
+            name: `comment:${normalizeCommentContent(comment.body).split('\n', 1)[0]}`,
+            status: 'no-op',
+            reasonCode: 'BACKFILL_ALREADY_PRESENT'
+        }));
+        return platformResult('no-op', {
+            ...contextFields(context),
+            changed: false,
+            resource: { kind: 'issue', number: issue },
+            operations,
+            comment: {
+                kind: options.kind,
+                marker: desired[0].marker,
+                ids: existing.map((comment) => comment.id),
+                parts: existing.length
+            },
+            error: null
+        });
+    }
+    const repo = context.platform.repository;
+    const operations = [];
+    const ids = [];
+    for (const item of desired) {
+        const current = existing.find((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === item.marker);
+        if (current && normalizeCommentContent(current.body) === normalizeCommentContent(item.body)) {
+            ids.push(current.id);
+            operations.push({ name: `comment:${item.marker}`, status: 'no-op', reasonCode: null });
+            continue;
+        }
+        const written = writeComment(client, repo, issue, resolved.repoRoot, item.body, current?.id);
+        if (!written.ok) {
+            if (!current && written.error.retryable) {
+                const reconciled = listRemoteComments(client, repo, issue, resolved.repoRoot);
+                const found = reconciled.ok ? findMarkerComments(reconciled.value, item.marker) : [];
+                if (found.length === 1) {
+                    ids.push(found[0].id);
+                    operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: 'CREATE_RECONCILED' });
+                    continue;
+                }
+            }
+            return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+                ...contextFields(context),
+                resource: { kind: 'issue', number: issue },
+                operations,
+                error: written.error
+            });
+        }
+        ids.push(current?.id || written.value.id || 0);
+        operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: null });
+    }
+    const desiredMarkers = new Set(desired.map((item) => item.marker));
+    const stale = existing.filter((comment) => !desiredMarkers.has(normalizeCommentContent(comment.body).split('\n', 1)[0]));
+    for (const comment of stale) {
+        const deleted = client.text(['api', `repos/${repo}/issues/comments/${comment.id}`, '-X', 'DELETE'], {
+            cwd: resolved.repoRoot, method: 'DELETE'
+        });
+        if (!deleted.ok) {
+            return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+                ...contextFields(context),
+                resource: { kind: 'issue', number: issue },
+                operations,
+                error: deleted.error
+            });
+        }
+        operations.push({ name: `comment:${comment.id}`, status: 'applied', reasonCode: 'STALE_CHUNK_DELETED' });
+    }
+    const changed = operations.some((operation) => operation.status === 'applied');
+    return platformResult(changed ? 'applied' : 'no-op', {
+        ...contextFields(context),
+        changed,
+        resource: { kind: 'issue', number: issue },
+        operations,
+        comment: { kind: options.kind, marker: desired[0].marker, ids, parts: desired.length },
+        error: null
+    });
+}
+function listPlatformComments(issue, cwd = process.cwd(), client = createGitHubClient()) {
+    const context = resolvePlatformContext({ cwd, client });
+    if (!hasResolvedPlatformContext(context))
+        return context;
+    const result = listRemoteComments(client, context.platform.repository, issue, cwd);
+    if (!result.ok) {
+        return platformResult(result.error.retryable ? 'blocked' : 'failed', {
+            ...contextFields(context), resource: { kind: 'issue', number: issue }, error: result.error
+        });
+    }
+    return { ...platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null }), comments: result.value };
+}
+function checkPlatformCommentOwner(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const issue = issueNumberFromTask(content);
+    if (!issue)
+        return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false } });
+    const client = options.client || createGitHubClient();
+    const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
+    if (!hasResolvedPlatformContext(context))
+        return context;
+    const listed = listRemoteComments(client, context.platform.repository, issue, resolved.repoRoot);
+    if (!listed.ok)
+        return platformResult(listed.error.retryable ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
+    const matches = findMarkerComments(listed.value, MARKERS.task(resolved.taskId));
+    if (matches.length > 1)
+        return platformResult('failed', { ...contextFields(context), error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple task comments use the registered marker', retryable: false } });
+    const owner = matches[0]?.user?.login;
+    if (owner && owner !== context.platform.currentUser && !context.capabilities.triage) {
+        return platformResult('blocked', {
+            ...contextFields(context),
+            resource: { kind: 'issue', number: issue },
+            error: { code: 'COMMENT_OWNER_CONFLICT', message: `Task comment is owned by '${owner}'`, retryable: false }
+        });
+    }
+    return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null });
+}
+export { MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, syncPlatformComment, validateRelatedMarkerSet, writeComment };
+//# sourceMappingURL=issue-comments.js.map