@fitlab-ai/agent-infra 0.9.8 → 0.9.10

package/templates/.trae/skills/update-agent-infra.zh-CN.md

@@ -0,0 +1,8 @@
+---
+description: "更新项目 AI 协作配置"
+disable-model-invocation: true
+---
+
+读取并执行 `.agents/skills/update-agent-infra/SKILL.md` 中的 update-agent-infra 技能。
+
+严格按照技能中定义的所有步骤执行，包括先从 `templates/` 渲染，再应用 managed/merged 更新策略。

package/dist/lib/task/commit-finalization.js

@@ -1,305 +0,0 @@
-import { execFileSync, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { locateActivityLog, appendActivityEntry, pairEntries, parseCommitAttemptStarted } from './activity-log.js';
-import { commitIntentPath, digest, readCommitIntent } from './commit-intent.js';
-import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.js';
-import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewedGitTree } from './review-fingerprint.js';
-const SHA_RE = /^[a-f0-9]{40,64}$/;
-function git(repoRoot, args) {
-    return execFileSync('git', args, {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe']
-    }).trim();
-}
-function commitExists(repoRoot, value) {
-    return SHA_RE.test(value) && spawnSync('git', ['cat-file', '-e', `${value}^{commit}`], {
-        cwd: repoRoot,
-        stdio: 'ignore'
-    }).status === 0;
-}
-function isAncestor(repoRoot, ancestor, descendant) {
-    return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
-        cwd: repoRoot,
-        stdio: 'ignore'
-    }).status === 0;
-}
-function hasMatchingApprovedReview(taskDir, beforeRound, baseline, tree) {
-    const entries = fs.readdirSync(taskDir);
-    for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
-        const file = path.join(taskDir, artifactName('review-code', round));
-        if (!fs.existsSync(file))
-            continue;
-        const content = fs.readFileSync(file, 'utf8');
-        const summary = parseReviewSummary(content);
-        if (summary.ok
-            && summary.summary.verdict === 'Approved'
-            && extractReviewBaseline(content) === baseline
-            && extractReviewedSnapshotTree(content) === tree)
-            return true;
-    }
-    return false;
-}
-function outcome(disposition, overrides = {}) {
-    return {
-        disposition,
-        code: null,
-        message: disposition,
-        currentHead: '',
-        committedHead: null,
-        commitNote: null,
-        activityNote: null,
-        needsAnchor: false,
-        needsLog: false,
-        intent: null,
-        intentDigest: null,
-        attempt: null,
-        ...overrides
-    };
-}
-function invalid(message, currentHead = '', code = 'COMMIT_FINALIZATION_EVIDENCE_INVALID', overrides = {}) {
-    return outcome('invalid', { code, message, currentHead, ...overrides });
-}
-function inspectCommitFinalization(taskDir, repoRoot, taskId) {
-    let currentHead;
-    let taskContent;
-    let metadata;
-    try {
-        currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
-        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-        metadata = parseTypedTaskFrontmatter(taskContent);
-    }
-    catch (error) {
-        return invalid(error instanceof Error ? error.message : String(error));
-    }
-    const activity = locateActivityLog(taskContent);
-    if (!activity)
-        return invalid('task activity log is missing or ambiguous', currentHead);
-    const commitRows = pairEntries(activity.entries).filter((row) => row.step === 'Commit');
-    const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
-    const file = commitIntentPath(taskDir);
-    if (!fs.existsSync(file)) {
-        if (openRows.length === 1) {
-            const attempt = parseCommitAttemptStarted(openRows[0].note);
-            if (attempt && attempt.baseline === currentHead) {
-                return outcome('retryable-start', {
-                    message: 'a structured Commit attempt can be safely reused',
-                    currentHead,
-                    attempt
-                });
-            }
-        }
-        if (openRows.length > 0) {
-            return outcome('orphaned-start', {
-                code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
-                message: 'an open Commit activity entry exists without a commit intent',
-                currentHead
-            });
-        }
-        return outcome('idle', { message: 'no active commit finalization exists', currentHead });
-    }
-    let raw;
-    let intent;
-    try {
-        raw = fs.readFileSync(file, 'utf8');
-        intent = readCommitIntent(taskDir, taskId);
-    }
-    catch (error) {
-        return invalid(error instanceof Error ? error.message : String(error), currentHead);
-    }
-    const intentDigest = digest(raw);
-    const shared = { currentHead, intent, intentDigest, committedHead: intent.committedHead };
-    if (!commitExists(repoRoot, intent.baselineHead)) {
-        return invalid('commit intent baseline is not a valid Git commit', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'prepared') {
-        if (intent.committedHead !== null || intent.pushEvidence !== null) {
-            return invalid('prepared commit intent contains commit or push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-        }
-        if (currentHead !== intent.baselineHead || openRows.length !== 1) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'prepared commit intent does not match HEAD and exactly one open Commit entry'
-            });
-        }
-        return outcome('prepared', { ...shared, message: 'prepared commit intent can be safely retried' });
-    }
-    if (!intent.committedHead || !commitExists(repoRoot, intent.committedHead)) {
-        return invalid('committed intent head is missing or invalid', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'committed' && intent.pushEvidence !== null) {
-        return invalid('committed intent contains premature push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'pushed'
-        && (intent.pushEvidence === null
-            || intent.pushEvidence.head !== intent.committedHead
-            || !intent.pushEvidence.remote
-            || !intent.pushEvidence.ref)) {
-        return invalid('pushed intent evidence is missing or inconsistent', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (currentHead !== intent.committedHead || !isAncestor(repoRoot, intent.baselineHead, intent.committedHead)) {
-        return outcome('conflict', {
-            ...shared,
-            code: 'COMMIT_FINALIZATION_CONFLICT',
-            message: 'repository HEAD or ancestry conflicts with the commit intent'
-        });
-    }
-    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-    const pushOnlyRetry = intent.phase === 'pushed'
-        && intent.baselineHead === intent.committedHead
-        && matchingDone.length === 1
-        && openRows.length === 1;
-    const review = findAuthoritativeReviewCodeArtifact(taskDir);
-    let needsAnchor = false;
-    if (review.ok && review.path) {
-        let reviewContent;
-        try {
-            reviewContent = fs.readFileSync(review.path, 'utf8');
-        }
-        catch (error) {
-            return invalid(error instanceof Error ? error.message : String(error), currentHead, 'COMMIT_FINALIZATION_EVIDENCE_MISSING', shared);
-        }
-        const summary = parseReviewSummary(reviewContent);
-        const reviewBaseline = extractReviewBaseline(reviewContent);
-        const reviewTree = extractReviewedSnapshotTree(reviewContent);
-        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
-            return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-        }
-        const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-        const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
-        if (!matchingCurrentReview
-            && !hasMatchingApprovedReview(taskDir, review.round, intent.baselineHead, committedTree)) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'review baseline or snapshot tree conflicts with the committed intent'
-            });
-        }
-        const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-        if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'task review anchor conflicts with the committed intent'
-            });
-        }
-        needsAnchor = anchor !== intent.committedHead;
-    }
-    const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
-    if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
-        return outcome('conflict', {
-            ...shared,
-            code: 'COMMIT_FINALIZATION_CONFLICT',
-            message: 'Commit activity identity is missing, duplicated, or ambiguous',
-            commitNote
-        });
-    }
-    return outcome('recoverable', {
-        ...shared,
-        message: 'commit finalization can be recovered',
-        commitNote,
-        activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
-        needsAnchor,
-        needsLog
-    });
-}
-function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
-    if (inspection.disposition !== 'recoverable'
-        || !inspection.committedHead
-        || !inspection.commitNote
-        || !inspection.activityNote) {
-        throw new Error('commit finalization task mutations require a recoverable inspection');
-    }
-    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-    const frontmatter = { assigned_to: agent };
-    if (inspection.needsAnchor)
-        frontmatter.last_reviewed_commit = inspection.committedHead;
-    const mutations = [{
-            kind: 'frontmatter',
-            set: frontmatter
-        }];
-    if (inspection.needsLog) {
-        const activity = locateActivityLog(taskContent);
-        if (!activity)
-            throw new Error('task activity log is missing or ambiguous');
-        mutations.push({
-            kind: 'section',
-            aliases: ['活动日志', 'Activity Log'],
-            heading: activity.heading,
-            body: appendActivityEntry(activity, {
-                time: timestamp,
-                step: 'Commit',
-                agent,
-                note: inspection.activityNote
-            })
-        });
-    }
-    return { mutations, commitNote: inspection.commitNote };
-}
-function inspectCreatePrCommitGate(taskDir, repoRoot, taskId) {
-    const lifecycle = inspectCommitFinalization(taskDir, repoRoot, taskId);
-    if (lifecycle.disposition !== 'idle') {
-        const pending = lifecycle.disposition === 'prepared' || lifecycle.disposition === 'recoverable';
-        return {
-            allowed: false,
-            code: pending ? 'COMMIT_FINALIZATION_PENDING' : lifecycle.code ?? 'COMMIT_FINALIZATION_CONFLICT',
-            message: pending ? 'commit finalization must complete before creating a pull request' : lifecycle.message,
-            disposition: lifecycle.disposition,
-            action: 'rerun-commit'
-        };
-    }
-    const review = findAuthoritativeReviewCodeArtifact(taskDir);
-    if (!review.ok || !review.path) {
-        return { allowed: true, code: null, message: 'no review-code history requires an anchor', disposition: 'idle', action: 'continue' };
-    }
-    try {
-        const content = fs.readFileSync(review.path, 'utf8');
-        const summary = parseReviewSummary(content);
-        if (!summary.ok || summary.summary.verdict !== 'Approved') {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
-                message: 'latest authoritative review-code is not approved',
-                disposition: 'idle',
-                action: 'rerun-review-code'
-            };
-        }
-        const task = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
-        const currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
-        const anchor = String(task.last_reviewed_commit ?? '').trim();
-        if (!anchor || !commitExists(repoRoot, anchor)) {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
-                message: 'approved review snapshot is not anchored to a Git commit',
-                disposition: 'idle',
-                action: 'rerun-commit'
-            };
-        }
-        if (anchor !== currentHead || extractReviewedSnapshotTree(content) !== git(repoRoot, ['rev-parse', 'HEAD^{tree}'])) {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'approved review anchor or tree does not match repository HEAD',
-                disposition: 'idle',
-                action: 'rerun-review-code'
-            };
-        }
-        return { allowed: true, code: null, message: 'commit finalization evidence is complete', disposition: 'idle', action: 'continue' };
-    }
-    catch (error) {
-        return {
-            allowed: false,
-            code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
-            message: error instanceof Error ? error.message : String(error),
-            disposition: 'idle',
-            action: 'rerun-review-code'
-        };
-    }
-}
-export { inspectCommitFinalization, inspectCreatePrCommitGate, planCommitTaskFinalization };
-//# sourceMappingURL=commit-finalization.js.map

package/dist/lib/task/commit-intent.js

@@ -1,165 +0,0 @@
-import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-class CommitIntentError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = 'CommitIntentError';
-        this.code = code;
-    }
-}
-function commitIntentPath(taskDir) {
-    return path.join(taskDir, 'commit-intent.json');
-}
-function digest(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function serialize(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function atomicWrite(file, value) {
-    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        fs.writeFileSync(temp, serialize(value), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
-        const handle = fs.openSync(temp, 'r+');
-        try {
-            fs.fsyncSync(handle);
-        }
-        finally {
-            fs.closeSync(handle);
-        }
-        fs.renameSync(temp, file);
-        fs.chmodSync(file, 0o600);
-        try {
-            const directory = fs.openSync(path.dirname(file), 'r');
-            try {
-                fs.fsyncSync(directory);
-            }
-            finally {
-                fs.closeSync(directory);
-            }
-        }
-        catch (error) {
-            const code = error.code;
-            if (!['EACCES', 'EISDIR', 'EINVAL', 'EPERM'].includes(code ?? ''))
-                throw error;
-        }
-    }
-    finally {
-        if (fs.existsSync(temp))
-            fs.unlinkSync(temp);
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function keysEqual(value, expected) {
-    return Object.keys(value).sort().join('\0') === [...expected].sort().join('\0');
-}
-function validPushEvidence(value) {
-    return value === null || (isRecord(value)
-        && keysEqual(value, ['remote', 'ref', 'head'])
-        && ['remote', 'ref', 'head'].every((key) => typeof value[key] === 'string' && value[key] !== ''));
-}
-function validOrchestration(value) {
-    if (value === null)
-        return true;
-    if (!isRecord(value) || !keysEqual(value, [
-        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest',
-        'completionUpdatedAt', 'plannedReceipt'
-    ]))
-        return false;
-    return [
-        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest', 'completionUpdatedAt'
-    ].every((key) => typeof value[key] === 'string' && value[key] !== '') && isRecord(value.plannedReceipt);
-}
-function parseIntent(raw, taskId) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent is not valid JSON');
-    }
-    if (!isRecord(value) || !keysEqual(value, [
-        'schemaVersion', 'taskId', 'mode', 'phase', 'tokenDigest', 'baselineHead', 'committedHead',
-        'pushEvidence', 'orchestration', 'createdAt', 'updatedAt'
-    ])) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has an invalid schema');
-    }
-    if (value.schemaVersion !== 1
-        || value.taskId !== taskId
-        || !['standalone', 'orchestrated'].includes(String(value.mode))
-        || !['prepared', 'committed', 'pushed'].includes(String(value.phase))
-        || typeof value.tokenDigest !== 'string'
-        || !/^[a-f0-9]{64}$/.test(value.tokenDigest)
-        || typeof value.baselineHead !== 'string'
-        || (value.committedHead !== null && typeof value.committedHead !== 'string')
-        || !validPushEvidence(value.pushEvidence)
-        || !validOrchestration(value.orchestration)
-        || typeof value.createdAt !== 'string'
-        || typeof value.updatedAt !== 'string'
-        || (value.mode === 'standalone') !== (value.orchestration === null)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has invalid field values');
-    }
-    return value;
-}
-function tokenMatches(actualDigest, token) {
-    const actual = Buffer.from(actualDigest, 'hex');
-    const supplied = Buffer.from(digest(token), 'hex');
-    return actual.length === supplied.length && timingSafeEqual(actual, supplied);
-}
-function readCommitIntent(taskDir, taskId, token) {
-    const file = commitIntentPath(taskDir);
-    const intent = parseIntent(fs.readFileSync(file, 'utf8'), taskId);
-    if (token !== undefined && !tokenMatches(intent.tokenDigest, token)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_TOKEN_MISMATCH', 'commit intent token does not match');
-    }
-    return intent;
-}
-function createCommitIntent(taskDir, input, options = {}) {
-    const file = commitIntentPath(taskDir);
-    if (fs.existsSync(file)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists');
-    }
-    const token = (options.token ?? (() => randomBytes(32).toString('base64url')))();
-    const intent = Object.freeze({ schemaVersion: 1, ...input, tokenDigest: digest(token) });
-    atomicWrite(file, intent);
-    return { intent, token };
-}
-function updateCommitIntent(taskDir, taskId, token, updates) {
-    const current = readCommitIntent(taskDir, taskId, token);
-    const nextPhase = updates.phase ?? current.phase;
-    const transitions = {
-        prepared: ['prepared', 'committed', 'pushed'],
-        committed: ['committed', 'pushed'],
-        pushed: ['pushed']
-    };
-    if (!transitions[current.phase].includes(nextPhase)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_STATE_INVALID', `cannot move commit intent from ${current.phase} to ${nextPhase}`);
-    }
-    const updated = Object.freeze({ ...current, ...updates, phase: nextPhase });
-    atomicWrite(commitIntentPath(taskDir), updated);
-    return updated;
-}
-function removeCommitIntent(taskDir, taskId, token) {
-    readCommitIntent(taskDir, taskId, token);
-    fs.unlinkSync(commitIntentPath(taskDir));
-}
-function removeCommitIntentByDigest(taskDir, taskId, expectedDigest) {
-    const file = commitIntentPath(taskDir);
-    const raw = fs.readFileSync(file);
-    parseIntent(raw.toString('utf8'), taskId);
-    const actual = digest(raw);
-    const expected = Buffer.from(expectedDigest, 'hex');
-    const observed = Buffer.from(actual, 'hex');
-    if (!/^[a-f0-9]{64}$/.test(expectedDigest)
-        || expected.length !== observed.length
-        || !timingSafeEqual(expected, observed)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit intent changed after recovery inspection');
-    }
-    fs.unlinkSync(file);
-}
-export { CommitIntentError, commitIntentPath, createCommitIntent, digest, readCommitIntent, removeCommitIntent, removeCommitIntentByDigest, serialize, updateCommitIntent };
-//# sourceMappingURL=commit-intent.js.map