engineering-memory 1.11.8 → 1.11.10

package/runtime/dist/src/runtime/task-branch-store.js

@@ -89,10 +89,26 @@ export class TaskBranchStore {
             throw new BridgeRecoveryError('The task has finished but its worktree reservation could not be released. Resume the task to retry cleanup.', 'session.resume');
         }
     }
+    async detach(expected, oid) {
+        const current = await this.read();
+        const changed = () => new BridgeRecoveryError(`The reservation of this folder changed after the question about ${expected.externalTaskId} was asked. Call task.branch again; its question shows which task holds the folder now.`, 'task.branch');
+        if (!current ||
+            current.oid !== oid ||
+            current.decision.projectId !== expected.projectId ||
+            current.decision.externalTaskId !== expected.externalTaskId ||
+            current.decision.taskId !== expected.taskId)
+            throw changed();
+        const result = await this.runner.run('git', ['update-ref', '--no-deref', '-d', decisionRef, oid], { cwd: this.repoRoot });
+        if (result.exitCode !== 0) {
+            if ((await this.read())?.oid !== oid)
+                throw changed();
+            throw new BridgeRecoveryError('Git could not move the task out of this folder. Retry task.branch; nothing was changed.', 'task.branch');
+        }
+    }
     assertSame(current, requested) {
         if (current.projectId !== requested.projectId ||
             current.externalTaskId !== requested.externalTaskId) {
-            throw new BridgeRecoveryError(`This worktree belongs to task ${current.externalTaskId}. Resume that task, or call task.branch with a new task branch name to allocate a separate worktree.`, 'task.branch');
+            throw new BridgeRecoveryError(`This folder is held by task ${current.externalTaskId}. Continue that task, or call task.branch for the new task: its question offers a separate worktree, or a new branch in this folder after asking whether ${current.externalTaskId} should move out.`, 'task.branch');
         }
         if (current.branch !== requested.branch) {
             throw new BridgeRecoveryError(`This task selected ${current.branch ?? 'detached HEAD'}. Return to that branch before continuing.`, 'task.branch');

package/runtime/dist/src/runtime/task-start.js

@@ -0,0 +1,281 @@
+import { sha256, stableStringify } from '../utilities/hash.js';
+export function suggestedBranchNames(externalTaskId) {
+    const slug = externalTaskId
+        .replace(/[^A-Za-z0-9._-]+/g, '-')
+        .replace(/\.{2,}/g, '.')
+        .replace(/-{2,}/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '')
+        .slice(0, 120)
+        .replace(/\.lock$/i, '') || 'task';
+    const name = 'feature/' + slug;
+    return [name, ...[2, 3, 4, 5, 6, 7, 8, 9].map((suffix) => name + '-' + suffix)];
+}
+export function sameHolder(left, right) {
+    if (!left || !right)
+        return left === right;
+    return ((left.taskId ?? left.externalTaskId) === (right.taskId ?? right.externalTaskId) &&
+        left.oid === right.oid &&
+        (left.generation ?? null) === (right.generation ?? null));
+}
+export function sourceLabel(base, currentBranch) {
+    if (base.kind === 'remote')
+        return base.remote + '/' + base.branch;
+    if (base.kind === 'local')
+        return base.ref;
+    if (base.kind === 'current')
+        return (currentBranch ?? 'HEAD') + (base.commit ? ' (' + base.commit.slice(0, 7) + ')' : '');
+    return base.kind;
+}
+export function configuredBase(preferences, role) {
+    const selected = preferences.branches[role];
+    return selected.answered && selected.remote && selected.branch
+        ? { kind: 'remote', remote: selected.remote, branch: selected.branch }
+        : null;
+}
+export function taskStartDefinition(facts) {
+    const tr = facts.language === 'tr';
+    const folder = facts.folder;
+    const keepOnly = facts.keepCurrent === true || !facts.currentCommit;
+    const here = !keepOnly && !folder.managed && !folder.heldBy && folder.clean;
+    const keep = keepOnly || (!folder.managed && !folder.heldBy && !folder.holder);
+    const holder = here && folder.holder ? holderIdentity(folder.holder) : null;
+    const currentLabel = sourceLabel({ kind: 'current', ...(facts.currentCommit ? { commit: facts.currentCommit } : {}) }, facts.currentBranch);
+    const binding = {
+        externalTaskId: facts.externalTaskId,
+        ...(facts.decisionAttempt ? { decisionAttempt: facts.decisionAttempt } : {}),
+        currentCommit: facts.currentCommit,
+        holder,
+    };
+    const questions = [
+        {
+            id: 'location',
+            message: tr ? 'Nerede başlasın?' : 'Where should it start?',
+            options: [
+                ...(keepOnly
+                    ? []
+                    : [{ id: 'worktree', label: tr ? 'Ayrı bir worktree’de' : 'In a separate worktree' }]),
+                ...(here
+                    ? [
+                        {
+                            id: 'here',
+                            label: holder
+                                ? tr
+                                    ? holder.externalTaskId + ' bu klasörden çıkarılsın, yeni branch burada açılsın'
+                                    : 'Move ' + holder.externalTaskId + ' out and start the new branch here'
+                                : tr
+                                    ? 'Bu klasörde yeni branch olarak'
+                                    : 'In this folder, as a new branch',
+                        },
+                    ]
+                    : []),
+                ...(keep
+                    ? [
+                        {
+                            id: 'keep_current',
+                            label: tr
+                                ? 'Burada, ' + currentLabel + ' üzerinde, yeni branch açmadan'
+                                : 'Here on ' + currentLabel + ', without a new branch',
+                        },
+                    ]
+                    : []),
+                { id: 'defer', label: tr ? 'Şimdilik başlatma' : 'Not now' },
+            ],
+        },
+    ];
+    if (!keepOnly && !facts.base) {
+        const roles = ['development', 'production', 'test']
+            .flatMap((role) => {
+            const base = configuredBase(facts.preferences, role);
+            return base ? [{ role, base }] : [];
+        })
+            .slice(0, 2);
+        const roleOption = ({ role, base }) => ({
+            id: role,
+            label: base.remote + '/' + base.branch + ' (' + role + ')',
+        });
+        binding.bases = {
+            current: {
+                kind: 'current',
+                ...(facts.currentCommit ? { commit: facts.currentCommit } : {}),
+            },
+            ...Object.fromEntries(roles.map(({ role, base }) => [role, base])),
+        };
+        questions.push({
+            id: 'base',
+            message: tr ? 'Hangi daldan başlasın?' : 'Which branch should it start from?',
+            options: [
+                ...roles.slice(0, 1).map(roleOption),
+                {
+                    id: 'current',
+                    label: tr ? 'Bu klasörün dalı: ' + currentLabel : 'This folder’s branch: ' + currentLabel,
+                },
+                ...roles.slice(1).map(roleOption),
+                { id: 'other', label: tr ? 'Başka bir uzak dal' : 'Another remote branch' },
+            ],
+            otherAsText: true,
+            textField: {
+                title: tr ? 'origin üzerindeki dal adı' : 'Branch name on origin',
+                maxLength: 255,
+                requiredForChoice: 'other',
+            },
+        });
+    }
+    else if (!keepOnly)
+        binding.base = resolvedBase(facts.base, facts);
+    if (!keepOnly && !facts.name) {
+        binding.suggestedName = facts.suggestedName;
+        questions.push({
+            id: 'name',
+            message: tr ? 'Yeni branch’in adı ne olsun?' : 'What should the new branch be called?',
+            options: [
+                { id: 'suggested', label: facts.suggestedName },
+                { id: 'custom', label: tr ? 'Başka bir ad' : 'Another name' },
+            ],
+            textField: {
+                title: tr ? 'Branch adı' : 'Branch name',
+                maxLength: 255,
+                requiredForChoice: 'custom',
+            },
+        });
+    }
+    else if (!keepOnly)
+        binding.name = facts.name;
+    const fixed = [
+        ...(here && folder.holder
+            ? [
+                tr
+                    ? folder.holder.externalTaskId +
+                        ' bu klasörü tutuyor (branch ' +
+                        (folder.holder.branch ?? 'detached HEAD') +
+                        ', son etkinlik ' +
+                        (folder.holder.lastCheckpointAt ?? 'bilinmiyor') +
+                        '). Çıkarılırsa görev açık kalır ve devam ederken ayrı bir worktree’de açılır.'
+                    : folder.holder.externalTaskId +
+                        ' holds this folder (branch ' +
+                        (folder.holder.branch ?? 'detached HEAD') +
+                        ', last activity ' +
+                        (folder.holder.lastCheckpointAt ?? 'unknown') +
+                        '). If it moves out, it stays open and continues in a separate worktree when resumed.',
+            ]
+            : []),
+        ...(binding.base
+            ? [
+                tr
+                    ? sourceLabel(binding.base, facts.currentBranch) + ' dalından başlar.'
+                    : 'It starts from ' + sourceLabel(binding.base, facts.currentBranch) + '.',
+            ]
+            : []),
+        ...(binding.name
+            ? [tr ? 'Yeni branch: ' + binding.name + '.' : 'New branch: ' + binding.name + '.']
+            : []),
+        ...(withheld(folder, keepOnly, tr) ? [withheld(folder, keepOnly, tr)] : []),
+    ];
+    const content = {
+        message: [
+            tr
+                ? facts.externalTaskId + ' nasıl başlasın? Sen cevaplayana kadar hiçbir şey oluşturulmaz.'
+                : facts.externalTaskId +
+                    ': how should this task start? Nothing is created until you answer.',
+            ...fixed,
+        ].join(' '),
+        language: facts.language,
+        questions,
+        terminalChoices: [
+            { questionId: 'location', choice: 'defer' },
+            ...(keep ? [{ questionId: 'location', choice: 'keep_current' }] : []),
+        ],
+        binding: JSON.parse(JSON.stringify(binding)),
+    };
+    return { questionnaireId: 'task-start-' + sha256(stableStringify(content)), ...content };
+}
+export function taskStartChoice(record) {
+    if (record.status !== 'answered' ||
+        !record.questionnaireId.startsWith('task-start-') ||
+        !record.answers ||
+        !record.binding)
+        return null;
+    const binding = record.binding;
+    const task = {
+        externalTaskId: binding.externalTaskId,
+        ...(binding.decisionAttempt ? { decisionAttempt: binding.decisionAttempt } : {}),
+    };
+    const location = record.answers.location?.choice;
+    if (location === 'defer')
+        return { status: 'deferred', ...task };
+    if (location === 'keep_current')
+        return {
+            status: 'start',
+            ...task,
+            base: {
+                kind: 'current',
+                ...(binding.currentCommit ? { commit: binding.currentCommit } : {}),
+            },
+            name: null,
+            keepCurrent: true,
+            inPlace: false,
+            holder: null,
+        };
+    if (location !== 'worktree' && location !== 'here')
+        return null;
+    const baseAnswer = record.answers.base;
+    const other = baseAnswer?.choice === 'other' ? baseAnswer.text?.replace(/^origin\//, '') : null;
+    const base = binding.base ??
+        (other
+            ? { kind: 'remote', remote: 'origin', branch: other }
+            : baseAnswer
+                ? binding.bases?.[baseAnswer.choice]
+                : undefined);
+    const nameAnswer = record.answers.name;
+    const name = binding.name ??
+        (nameAnswer?.choice === 'custom'
+            ? nameAnswer.text
+            : nameAnswer?.choice === 'suggested'
+                ? binding.suggestedName
+                : undefined);
+    if (!base || !name)
+        return null;
+    return {
+        status: 'start',
+        ...task,
+        base,
+        name,
+        keepCurrent: false,
+        inPlace: location === 'here',
+        holder: location === 'here' ? binding.holder : null,
+    };
+}
+function resolvedBase(base, facts) {
+    if (base.kind === 'current')
+        return {
+            kind: 'current',
+            ...((base.commit ?? facts.currentCommit)
+                ? { commit: base.commit ?? facts.currentCommit }
+                : {}),
+        };
+    if (base.kind === 'development' || base.kind === 'production' || base.kind === 'test')
+        return configuredBase(facts.preferences, base.kind) ?? base;
+    return base;
+}
+function holderIdentity(holder) {
+    return {
+        externalTaskId: holder.externalTaskId,
+        taskId: holder.taskId,
+        oid: holder.oid,
+        generation: holder.generation,
+    };
+}
+function withheld(folder, keepOnly, tr) {
+    if (keepOnly || folder.managed || (!folder.heldBy && folder.clean))
+        return null;
+    if (folder.heldBy)
+        return tr
+            ? folder.heldBy +
+                ' bu klasörde başka bir oturumda hâlâ çalışıyor; yeni branch burada açılamaz. O oturumda duraklatılırsa bu klasör de seçilebilir.'
+            : 'Task ' +
+                folder.heldBy +
+                ' is still running in another client in this folder, so the new branch cannot start here. Once it is paused there, this folder can be chosen too.';
+    return tr
+        ? 'Bu klasörde kaydedilmemiş değişiklikler var; yeni branch burada açılamaz.'
+        : 'This folder has uncommitted changes, so the new branch cannot start here.';
+}
+//# sourceMappingURL=task-start.js.map