engineering-memory 1.11.14 → 1.11.16

package/runtime/dist/src/runtime/worktree-pool.js

@@ -9,6 +9,9 @@ import { sha256 } from '../utilities/hash.js';
 import { localMutex } from '../utilities/local-mutex.js';
 import { NativeCommandRunner } from '../utilities/process.js';
 import { BridgeRecoveryError } from './recovery-error.js';
+import { planWorktreeFiles, createWorktreeStage, stageWorktreeFiles, publishWorktreeFiles, discardStagedWorktreeFiles, } from './worktree-preparation.js';
+import { WorktreeFileIssue, WorktreeFileStatus, } from './worktree-readiness-types.js';
+import { openWorktreeInEditor, WorktreeEditorStatus } from './worktree-editor.js';
 const allocationSchema = z.object({
     projectId: z.string().min(1),
     repoFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
@@ -42,6 +45,37 @@ const allocationSchema = z.object({
     deliveryOutcome: z.enum(['delivered', 'cancelled']).optional(),
     cancelledAt: z.string().optional(),
     preservedRef: z.string().optional(),
+    sourceRepoRoot: z.string().optional(),
+    sourceMainRoot: z.string().optional(),
+    preparedPaths: z.array(z.string()).optional(),
+    preparationSources: z.record(z.string(), z.string()).optional(),
+    preparationStage: z
+        .object({
+        directory: z.string(),
+        repoRoot: z.string(),
+        count: z.number().int().min(0).max(100),
+        identity: z.string(),
+    })
+        .optional(),
+    editorGeneration: z.string().optional(),
+    editorResult: z
+        .object({ status: z.nativeEnum(WorktreeEditorStatus), detail: z.string().optional() })
+        .optional(),
+    readiness: z
+        .object({
+        files: z.object({
+            status: z.nativeEnum(WorktreeFileStatus),
+            copied: z.number().int().nonnegative(),
+            unchanged: z.number().int().nonnegative(),
+            externalDependencies: z.number().int().nonnegative().optional(),
+            problems: z.array(z.object({ path: z.string(), reason: z.nativeEnum(WorktreeFileIssue) })),
+        }),
+        editor: z.object({
+            status: z.nativeEnum(WorktreeEditorStatus),
+            detail: z.string().optional(),
+        }),
+    })
+        .optional(),
 });
 const registrySchema = z.object({
     schemaVersion: z.literal(1),
@@ -230,6 +264,8 @@ export class WorktreePool {
                 const old = structuredClone(entry);
                 await this.releaseReservation(old);
                 const next = await this.entry(input, commonDir, old.repoRoot, old.slot, true, old.root ?? (await this.legacyDocumentsDirectory()), old.layout ?? 1);
+                next.preparedPaths = old.preparedPaths;
+                next.preparationStage = old.preparationStage;
                 project.entries[project.entries.indexOf(entry)] = next;
                 entry = next;
                 await this.save(registry);
@@ -260,6 +296,138 @@ export class WorktreePool {
             return structuredClone(entry);
         });
     }
+    async prepare(allocation) {
+        if (!allocation.managed || allocation.phase !== 'working')
+            return allocation;
+        return localMutex(key(this.stateRoot) + '/prepare/' + key(allocation.repoRoot), async () => {
+            const current = await this.transaction(async (registry) => {
+                const entry = this.owned(registry, allocation.projectId, allocation.repoRoot, allocation.generation);
+                await this.assertIdentity(entry);
+                if (!entry.sourceRepoRoot) {
+                    entry.sourceRepoRoot = await this.git.mainWorktree(entry.repoRoot);
+                    entry.sourceMainRoot = entry.sourceRepoRoot;
+                    await this.save(registry);
+                }
+                return structuredClone(entry);
+            });
+            let files;
+            try {
+                if (current.preparationStage) {
+                    await this.transaction(async (registry) => {
+                        const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                        if (entry.preparationStage) {
+                            if (entry.preparationStage.repoRoot !== entry.repoRoot)
+                                throw new Error('Unknown staging owner');
+                            await discardStagedWorktreeFiles(entry.preparationStage);
+                            delete entry.preparationStage;
+                            await this.save(registry);
+                        }
+                    });
+                }
+                const plan = await planWorktreeFiles(current.sourceRepoRoot, current.sourceMainRoot ?? current.sourceRepoRoot, current.repoRoot, current.preparedPaths ?? [], current.preparationSources);
+                await this.transaction(async (registry) => {
+                    const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                    entry.preparationSources = plan.sources;
+                    entry.readiness = {
+                        files: { status: WorktreeFileStatus.Attention, copied: 0, unchanged: 0, problems: [] },
+                        editor: entry.editorResult ?? { status: WorktreeEditorStatus.Skipped },
+                    };
+                    entry.preparedPaths = [
+                        ...new Set([...(entry.preparedPaths ?? []), ...plan.files.map((file) => file.path)]),
+                    ];
+                    await this.save(registry);
+                });
+                if (plan.problems.length) {
+                    files = {
+                        status: WorktreeFileStatus.Attention,
+                        copied: 0,
+                        unchanged: 0,
+                        problems: plan.problems,
+                    };
+                }
+                else if (!plan.files.length) {
+                    files = { status: WorktreeFileStatus.NotNeeded, copied: 0, unchanged: 0, problems: [] };
+                }
+                else {
+                    const stage = await this.transaction(async (registry) => {
+                        const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                        await this.assertIdentity(entry);
+                        const created = await createWorktreeStage(plan);
+                        entry.preparationStage = {
+                            directory: created.directory,
+                            repoRoot: created.repoRoot,
+                            count: created.count,
+                            identity: created.identity,
+                        };
+                        await this.save(registry);
+                        return created;
+                    });
+                    try {
+                        await stageWorktreeFiles(stage);
+                        files = await this.transaction(async (registry) => {
+                            const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                            await this.assertIdentity(entry);
+                            const result = await publishWorktreeFiles(stage);
+                            try {
+                                await discardStagedWorktreeFiles(stage);
+                            }
+                            catch {
+                                result.status = WorktreeFileStatus.Attention;
+                                result.problems.push({ path: '.', reason: WorktreeFileIssue.Failed });
+                            }
+                            entry.readiness = {
+                                files: result,
+                                editor: entry.editorResult ?? { status: WorktreeEditorStatus.Skipped },
+                            };
+                            if (!result.problems.some((item) => item.path === '.' && item.reason === WorktreeFileIssue.Failed))
+                                delete entry.preparationStage;
+                            await this.save(registry);
+                            return result;
+                        });
+                    }
+                    finally {
+                        await discardStagedWorktreeFiles(stage);
+                    }
+                }
+            }
+            catch {
+                files = {
+                    status: WorktreeFileStatus.Attention,
+                    copied: 0,
+                    unchanged: 0,
+                    problems: [{ path: '.', reason: WorktreeFileIssue.Failed }],
+                };
+            }
+            const launch = await this.transaction(async (registry) => {
+                const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                const needed = entry.editorGeneration !== entry.generation;
+                if (needed) {
+                    entry.editorGeneration = entry.generation;
+                    entry.editorResult = {
+                        status: WorktreeEditorStatus.Skipped,
+                        detail: 'An editor launch was started; its visual result is not verified.',
+                    };
+                }
+                entry.readiness = {
+                    files,
+                    editor: entry.editorResult ?? { status: WorktreeEditorStatus.Skipped },
+                };
+                await this.save(registry);
+                return needed;
+            });
+            if (launch) {
+                await this.assertOwnership(current.projectId, current.repoRoot, current.generation);
+                const editor = await openWorktreeInEditor(current.repoRoot);
+                await this.transaction(async (registry) => {
+                    const entry = this.owned(registry, current.projectId, current.repoRoot, current.generation);
+                    entry.editorResult = editor;
+                    entry.readiness = { files, editor };
+                    await this.save(registry);
+                });
+            }
+            return this.transaction(async (registry) => structuredClone(this.owned(registry, current.projectId, current.repoRoot, current.generation)));
+        });
+    }
     async list(projectId, policy) {
         return this.transaction(async (registry) => {
             const result = [];
@@ -465,19 +633,27 @@ export class WorktreePool {
         });
     }
     async forgetUnreadable(projectId, externalTaskId, generation) {
-        return this.transaction(async (registry) => {
+        const candidate = await this.transaction(async (registry) => registry.projects[projectId]?.entries.find((entry) => entry.externalTaskId === externalTaskId && entry.generation === generation));
+        if (!candidate)
+            throw refuse('This is no longer the same registry entry for that task. List the checkouts again with worktree.list before forgetting one.');
+        return localMutex(key(this.stateRoot) + '/prepare/' + key(candidate.repoRoot), () => this.transaction(async (registry) => {
             const project = registry.projects[projectId];
             const entry = project?.entries.find((e) => e.externalTaskId === externalTaskId && e.generation === generation);
-            if (!project || !entry)
+            if (!project || !entry || key(entry.repoRoot) !== key(candidate.repoRoot))
                 throw refuse('This is no longer the same registry entry for that task. List the checkouts again with worktree.list before forgetting one.');
             if (await this.ownedElsewhere(entry))
                 throw refuse('Another live client still owns this task. Stop or pause it there first; worktree.list shows the checkout meanwhile.');
             if (!(await this.unreadable(entry)))
                 throw new BridgeRecoveryError('This checkout can still be read as a Git worktree, so it is not forgotten. Settle its delivery and free it with worktree.release.', 'worktree.release');
+            if (entry.preparationStage) {
+                if (entry.preparationStage.repoRoot !== entry.repoRoot)
+                    throw refuse('Unknown staging owner; the task record is preserved.');
+                await discardStagedWorktreeFiles(entry.preparationStage);
+            }
             project.entries = project.entries.filter((e) => e !== entry);
             await this.save(registry);
             return structuredClone(entry);
-        });
+        }));
     }
     async unreadable(entry) {
         if (!(await pathExists(entry.repoRoot)))
@@ -661,6 +837,8 @@ export class WorktreePool {
             repoFingerprint: input.repoFingerprint,
             commonDir,
             repoRoot,
+            sourceRepoRoot: await canonicalPath(input.repoRoot),
+            sourceMainRoot: await this.git.mainWorktree(input.repoRoot),
             slot,
             managed,
             externalTaskId: input.externalTaskId,