@fitlab-ai/agent-infra 0.8.4 → 0.9.0

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

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

@@ -0,0 +1,183 @@
+import { computeInLabels } from './metadata-labels.js';
+const DEFAULT_REQUIREMENT_SECTION_ANCHORS = [
+    { level: 2, heading: '需求' },
+    { level: 2, heading: 'Requirements' }
+];
+const TYPE_MAP = {
+    bug: 'Bug', bugfix: 'Bug', feature: 'Feature', enhancement: 'Feature'
+};
+function desiredIssueType(taskType) {
+    return TYPE_MAP[taskType] || 'Task';
+}
+function normalizeOption(value) {
+    return { '紧急': 'Urgent', '高': 'High', '中': 'Medium', '低': 'Low' }[value] || value;
+}
+function versionParts(value) {
+    const match = /^(\d+)\.(\d+)\.(x|\d+)$/.exec(value);
+    return match ? [Number(match[1]), Number(match[2]), match[3] === 'x' ? null : Number(match[3])] : null;
+}
+function chooseMilestone(mode, milestones, current = null) {
+    if (mode === 'none')
+        return null;
+    const parsed = milestones.map((title) => ({ title, parts: versionParts(title) })).filter((item) => item.parts);
+    if (mode === 'initial') {
+        const lines = parsed.filter((item) => item.parts[2] === null).sort((a, b) => a.parts[0] - b.parts[0] || a.parts[1] - b.parts[1]);
+        return lines[0]?.title || (milestones.includes('General Backlog') ? 'General Backlog' : current);
+    }
+    const currentParts = current ? versionParts(current) : null;
+    if (currentParts && currentParts[2] !== null)
+        return current;
+    const line = currentParts?.[2] === null ? currentParts.slice(0, 2) : null;
+    const versions = parsed.filter((item) => item.parts[2] !== null && (!line || (item.parts[0] === line[0] && item.parts[1] === line[1]))).sort((a, b) => b.parts[0] - a.parts[0] || b.parts[1] - a.parts[1] || b.parts[2] - a.parts[2]);
+    return versions[0]?.title || current;
+}
+function checkboxPattern(text) {
+    const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^(\\s*[-*+]\\s+\\[)([ xX])(\\]\\s+${escaped}\\s*)$`, 'gm');
+}
+function hasCheckedRequirement(body, text) {
+    return [...body.matchAll(checkboxPattern(text))].some((match) => match[2]?.toLowerCase() === 'x');
+}
+function visibleHeadings(body) {
+    const headings = [];
+    let fence = null;
+    for (const match of body.matchAll(/[^\r\n]*(?:\r\n|\n|$)/g)) {
+        const raw = match[0];
+        if (!raw)
+            break;
+        const line = raw.replace(/\r?\n$/, '');
+        const fenceMatch = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+        if (fenceMatch) {
+            const marker = fenceMatch[1][0];
+            const length = fenceMatch[1].length;
+            if (!fence)
+                fence = { marker, length };
+            else if (fence.marker === marker && length >= fence.length)
+                fence = null;
+            continue;
+        }
+        if (fence)
+            continue;
+        const headingMatch = /^(#{1,6})[ \t]+(.+?)[ \t]*$/.exec(line);
+        if (!headingMatch)
+            continue;
+        const heading = headingMatch[2].replace(/[ \t]+#+[ \t]*$/, '').trim();
+        headings.push({
+            level: headingMatch[1].length,
+            heading,
+            start: match.index,
+            end: match.index + raw.length
+        });
+    }
+    return headings;
+}
+function resolveRequirementSection(body, anchors = DEFAULT_REQUIREMENT_SECTION_ANCHORS) {
+    const allowed = new Set(anchors.map((anchor) => `${anchor.level}\0${anchor.heading}`));
+    const headings = visibleHeadings(body);
+    const candidates = headings.flatMap((heading, index) => {
+        if (!allowed.has(`${heading.level}\0${heading.heading}`))
+            return [];
+        const next = headings.slice(index + 1).find((item) => item.level <= heading.level);
+        return [{ bodyStart: heading.end, bodyEnd: next?.start ?? body.length }];
+    });
+    if (candidates.length === 0)
+        return { status: 'missing', code: 'NO_REQUIREMENTS_ANCHOR' };
+    if (candidates.length > 1)
+        return { status: 'ambiguous', code: 'REQUIREMENTS_ANCHOR_AMBIGUOUS' };
+    return { status: 'found', ...candidates[0] };
+}
+function syncRequirementCheckboxes(body, requirements, anchors = DEFAULT_REQUIREMENT_SECTION_ANCHORS) {
+    if (new Set(requirements.map((requirement) => requirement.text)).size !== requirements.length) {
+        return { status: 'failed', code: 'REQUIREMENT_IDENTITY_AMBIGUOUS' };
+    }
+    const resolution = resolveRequirementSection(body, anchors);
+    if (resolution.status === 'missing')
+        return { status: 'skipped', changed: false, body, code: resolution.code };
+    if (resolution.status === 'ambiguous')
+        return { status: 'failed', code: resolution.code };
+    const section = body.slice(resolution.bodyStart, resolution.bodyEnd);
+    const matches = requirements.map((requirement) => ({
+        requirement,
+        count: [...section.matchAll(checkboxPattern(requirement.text))].length
+    }));
+    if (matches.some((match) => match.count > 1)) {
+        return { status: 'failed', code: 'REQUIREMENT_IDENTITY_AMBIGUOUS' };
+    }
+    let nextSection = section;
+    const missing = [];
+    for (const { requirement, count } of matches) {
+        const pattern = checkboxPattern(requirement.text);
+        if (count === 1)
+            nextSection = nextSection.replace(pattern, `$1${requirement.checked ? 'x' : ' '}$3`);
+        else
+            missing.push(requirement);
+    }
+    if (missing.length > 0) {
+        const newline = body.includes('\r\n') ? '\r\n' : '\n';
+        const separator = nextSection.length === 0 || nextSection.endsWith('\n') ? '' : newline;
+        const suffix = resolution.bodyEnd < body.length ? newline : '';
+        nextSection += `${separator}${missing.map((item) => `- [${item.checked ? 'x' : ' '}] ${item.text}`).join(newline)}${suffix}`;
+    }
+    const next = body.slice(0, resolution.bodyStart) + nextSection + body.slice(resolution.bodyEnd);
+    return { status: 'synced', changed: next !== body, body: next };
+}
+function planIssueMetadata(input) {
+    const operations = [];
+    const { snapshot, desired, capabilities } = input;
+    if (desired.status !== undefined || desired.state === 'closed') {
+        if (!capabilities.triage)
+            operations.push({ name: 'labels:status', status: 'skipped', reasonCode: 'TRIAGE_REQUIRED' });
+        else {
+            const retained = snapshot.labels.filter((label) => !label.startsWith('status:'));
+            const target = desired.state === 'closed' || desired.status === 'none' || desired.status === undefined
+                ? null
+                : `status: ${desired.status}`;
+            if (target && !input.repositoryLabels?.has(target)) {
+                operations.push({ name: 'labels:status', status: 'skipped', reasonCode: 'LABEL_UNAVAILABLE' });
+            }
+            else if (target)
+                retained.push(target);
+            const value = [...new Set(retained)].sort();
+            const current = [...snapshot.labels].sort();
+            if (!target || input.repositoryLabels?.has(target)) {
+                operations.push(current.join('\0') === value.join('\0')
+                    ? { name: 'labels:status', status: 'no-op', reasonCode: null }
+                    : { name: 'labels:status', status: 'planned', reasonCode: null, value });
+            }
+        }
+    }
+    if (desired.assignees !== undefined) {
+        const value = desired.assignees === 'none' ? [] : input.currentUser ? [input.currentUser] : [];
+        operations.push([...snapshot.assignees].sort().join('\0') === value.join('\0')
+            ? { name: 'assignees', status: 'no-op', reasonCode: null }
+            : { name: 'assignees', status: 'planned', reasonCode: null, value });
+    }
+    if (desired.milestone !== undefined) {
+        if (!capabilities.triage)
+            operations.push({ name: 'milestone', status: 'skipped', reasonCode: 'TRIAGE_REQUIRED' });
+        else {
+            const value = chooseMilestone(desired.milestone, input.milestones || [], snapshot.milestone);
+            operations.push(value === snapshot.milestone
+                ? { name: 'milestone', status: 'no-op', reasonCode: null }
+                : { name: 'milestone', status: 'planned', reasonCode: null, value });
+        }
+    }
+    if (desired.requirements !== undefined) {
+        const synced = syncRequirementCheckboxes(snapshot.body, desired.requirements, input.requirementAnchors);
+        operations.push(synced.status === 'failed'
+            ? { name: 'requirements', status: 'failed', reasonCode: synced.code }
+            : synced.status === 'skipped'
+                ? { name: 'requirements', status: 'skipped', reasonCode: synced.code }
+                : synced.changed
+                    ? { name: 'requirements', status: 'planned', reasonCode: null, value: synced.body }
+                    : { name: 'requirements', status: 'no-op', reasonCode: null });
+    }
+    if (desired.state !== undefined) {
+        operations.push(desired.state === snapshot.state
+            ? { name: 'state', status: 'no-op', reasonCode: null }
+            : { name: 'state', status: 'planned', reasonCode: null, value: desired.state });
+    }
+    return { operations };
+}
+export { DEFAULT_REQUIREMENT_SECTION_ANCHORS, chooseMilestone, computeInLabels, desiredIssueType, hasCheckedRequirement, normalizeOption, planIssueMetadata, resolveRequirementSection, syncRequirementCheckboxes };
+//# sourceMappingURL=issue-metadata.js.map