rivet-design 0.18.2 → 0.18.3

package/dist/agent-variants/WorktreeOrchestrator.js

@@ -1233,6 +1233,9 @@ class AgentVariantsOrchestrator {
             sourceVariantId: args.source.variantId,
             targetVariantId: append.workItemId,
         });
+        if (this.store.getProjectContext(args.sessionId).kind === 'existing') {
+            await this.prepareArtifactBase(args.sessionId);
+        }
         this.emitChange();
         return {
             workItemId: append.workItemId,
@@ -1281,6 +1284,9 @@ class AgentVariantsOrchestrator {
             assetBase,
             hasAssets,
         });
+        if (args.projectContext.kind === 'existing') {
+            await this.prepareArtifactBase(created.sessionId);
+        }
         this.emitChange();
         return {
             sessionId: created.sessionId,
@@ -2402,6 +2408,7 @@ class AgentVariantsOrchestrator {
             throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', variantSnapshot?.actions?.commit?.reason ??
                 'Variant is not committable');
         }
+        await this.settleHistoryPersists();
         const input = this.store.getWorkItemInput(args.sessionId, args.variantId);
         const projectContext = this.store.getProjectContext(args.sessionId);
         if (projectContext.kind === 'fresh') {
@@ -2585,18 +2592,26 @@ class AgentVariantsOrchestrator {
         else {
             const env = await this.resolveEnv(args.sessionId);
             const record = resources.worktrees.get(args.variantId);
-            if (!record) {
+            const saved = record
+                ? null
+                : await this.getSavedVariant({
+                    projectPath: env.projectPath,
+                    sessionId: args.sessionId,
+                    variantId: args.variantId,
+                });
+            const diff = record?.diff ?? saved?.diff;
+            if (!record && !saved) {
                 throw new errors_1.AgentVariantsError('WORK_ITEM_NOT_FOUND', `Unknown variantId ${args.variantId} for session ${args.sessionId}`);
             }
-            if (record.diff === undefined) {
+            if (diff === undefined) {
                 throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Variant ${args.variantId} has no captured diff yet — wait for report_variant_complete(succeeded) first`);
             }
-            changedFilesCount = countDiffFiles(record.diff);
+            changedFilesCount = countDiffFiles(diff);
             if (!this.worktrees.applyDiffToProject) {
                 throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'WorktreeManager does not support applying diffs to the project tree');
             }
             try {
-                await this.worktrees.applyDiffToProject(record.diff, env.projectPath);
+                await this.worktrees.applyDiffToProject(diff, env.projectPath);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -2604,7 +2619,7 @@ class AgentVariantsOrchestrator {
             }
             payload = {
                 kind: 'diff-applied',
-                diff: record.diff,
+                diff,
                 target: input.target,
                 changedFilesCount,
                 note: "Variant diff applied to the user's working tree (uncommitted).",
@@ -3312,7 +3327,12 @@ class AgentVariantsOrchestrator {
                     const workspacePath = projectContext.kind === 'fresh'
                         ? projectContext.workspacePath
                         : undefined;
+                    const assignedWorkspace = resources.workspaceManager.getAssignedWorkspace(workItemId);
+                    const assignedArtifactBase = assignedWorkspace?.kind === 'artifact_directory'
+                        ? assignedWorkspace.rootPath
+                        : undefined;
                     let dir = resolvedAssetBase ??
+                        assignedArtifactBase ??
                         (workspacePath
                             ? path_1.default.join(workspacePath, `.rivet-preview-${workItemId}`)
                             : undefined);
@@ -3345,22 +3365,19 @@ class AgentVariantsOrchestrator {
                         briefId: input.briefId,
                         entryPath: 'index.html',
                         assetBase: dir,
-                        hasAssets: Boolean(resolvedAssetBase),
+                        hasAssets: Boolean(resolvedAssetBase || assignedArtifactBase),
                     };
                     resources.staticPreviews.set(workItemId, record);
-                    const assignedWorkspace = resources.workspaceManager.getAssignedWorkspace(workItemId);
                     if (assignedWorkspace?.kind === 'artifact_directory' &&
                         assignedWorkspace.rootPath !== record.assetBase) {
                         resources.workspaceManager.removeArtifactWorkspace(workItemId);
                     }
-                    if (this.store.getProjectContext(sessionId).kind === 'fresh') {
-                        this.trackHistoryPersist(this.persistCompletedFreshVariant({
-                            sessionId,
-                            workItemId,
-                        }).catch((err) => {
-                            log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
-                        }));
-                    }
+                    this.trackHistoryPersist(this.persistCompletedArtifactVariant({
+                        sessionId,
+                        workItemId,
+                    }).catch((err) => {
+                        log.warn(`persistCompletedArtifactVariant failed for ${sessionId}/${workItemId}`, err);
+                    }));
                     const leasedAt = resources.leasedAt.get(workItemId);
                     trackStaticPreviewCompleted(this.telemetry, {
                         sessionId,
@@ -3409,11 +3426,11 @@ class AgentVariantsOrchestrator {
             }));
         }
         else {
-            this.trackHistoryPersist(this.persistCompletedFreshVariant({
+            this.trackHistoryPersist(this.persistCompletedArtifactVariant({
                 sessionId,
                 workItemId,
             }).catch((err) => {
-                log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
+                log.warn(`persistCompletedArtifactVariant failed for ${sessionId}/${workItemId}`, err);
             }));
         }
         if (!isFresh) {
@@ -3452,7 +3469,11 @@ class AgentVariantsOrchestrator {
             projectContext: this.store.getProjectContext(args.sessionId),
         });
         const previousRecord = resources.staticPreviews.get(input.variantId);
-        const dir = resolvedAssetBase ?? previousRecord?.assetBase;
+        const refinementWorkspace = resources.workspaceManager.getAssignedWorkspace(args.workItemId);
+        const assignedArtifactBase = refinementWorkspace?.kind === 'artifact_directory'
+            ? refinementWorkspace.rootPath
+            : undefined;
+        const dir = resolvedAssetBase ?? assignedArtifactBase ?? previousRecord?.assetBase;
         if (dir) {
             try {
                 fs_1.default.mkdirSync(dir, { recursive: true });
@@ -3472,10 +3493,11 @@ class AgentVariantsOrchestrator {
                 briefId: targetInput.briefId,
                 entryPath: 'index.html',
                 assetBase: dir,
-                hasAssets: Boolean(resolvedAssetBase) || Boolean(previousRecord?.hasAssets),
+                hasAssets: Boolean(resolvedAssetBase) ||
+                    Boolean(assignedArtifactBase) ||
+                    Boolean(previousRecord?.hasAssets),
             });
         }
-        const refinementWorkspace = resources.workspaceManager.getAssignedWorkspace(args.workItemId);
         if (refinementWorkspace?.kind === 'artifact_directory' &&
             dir === refinementWorkspace.rootPath) {
             resources.workspaceManager.promoteArtifactWorkspace({
@@ -3484,13 +3506,13 @@ class AgentVariantsOrchestrator {
             });
         }
         try {
-            await this.persistCompletedFreshVariant({
+            await this.persistCompletedArtifactVariant({
                 sessionId: args.sessionId,
                 workItemId: input.variantId,
             });
         }
         catch (err) {
-            log.warn(`persistCompletedFreshVariant failed for refined variant ${input.variantId} (session ${args.sessionId}); preview already swapped`, err);
+            log.warn(`persistCompletedArtifactVariant failed for refined variant ${input.variantId} (session ${args.sessionId}); preview already swapped`, err);
         }
     }
     get devServerManager() {
@@ -3510,6 +3532,69 @@ class AgentVariantsOrchestrator {
             await Promise.allSettled([...this.pendingHistoryPersists]);
         }
     }
+    async getSavedVariant(args) {
+        const saved = await this.variantHistory.getVariant(args);
+        if (saved)
+            return saved;
+        const origin = this.resolveHistoryParentVariant(args.sessionId, args.variantId);
+        if (!origin ||
+            (origin.sessionId === args.sessionId &&
+                origin.variantId === args.variantId))
+            return null;
+        return this.variantHistory.getVariant({
+            projectPath: args.projectPath,
+            ...origin,
+        });
+    }
+    async isHistoryDurableForRestart() {
+        await this.settleHistoryPersists();
+        const sessions = new Set(this.resources.keys());
+        if (this.activeSessionId)
+            sessions.add(this.activeSessionId);
+        for (const sessionId of sessions) {
+            if (!this.store.hasSession(sessionId))
+                continue;
+            if (!contracts_1.TERMINAL_STAGES.has(this.store.getStage(sessionId)))
+                return false;
+            const context = this.store.getProjectContext(sessionId);
+            const projectPath = context.kind === 'fresh'
+                ? context.workspacePath
+                : (await this.resolveEnv(sessionId)).projectPath;
+            for (const variant of this.getVariants(sessionId)) {
+                if (variant.status === 'pending' || variant.status === 'running')
+                    return false;
+                if (variant.status !== 'succeeded')
+                    continue;
+                const saved = await this.getSavedVariant({
+                    projectPath,
+                    sessionId,
+                    variantId: variant.workItemId,
+                });
+                if (!saved ||
+                    (!saved.hasStaticPreview &&
+                        !saved.diff?.trim() &&
+                        !saved.files?.length))
+                    return false;
+                const resources = this.resources.get(sessionId);
+                const preview = resources?.staticPreviews.get(variant.workItemId) ??
+                    this.getStaticPreviewByBriefId(sessionId, variant.briefId);
+                if (preview) {
+                    const currentHtml = await fs_1.default.promises.readFile(path_1.default.join(preview.assetBase, preview.entryPath), 'utf8');
+                    const savedHtml = await this.variantHistory.readStaticPreview({
+                        projectPath,
+                        sessionId: saved.manifest.sessionId,
+                        variantId: saved.manifest.variantId,
+                    });
+                    if (currentHtml !== savedHtml)
+                        return false;
+                }
+                const diff = resources?.worktrees.get(variant.workItemId)?.diff;
+                if (diff && saved.diff !== diff)
+                    return false;
+            }
+        }
+        return true;
+    }
     async persistCompletedExistingVariant(args) {
         const projectContext = this.store.getProjectContext(args.sessionId);
         if (projectContext.kind !== 'existing')
@@ -3689,11 +3774,65 @@ class AgentVariantsOrchestrator {
         });
         return 'registered';
     }
-    async persistCompletedFreshVariant(args) {
+    async prepareArtifactBase(sessionId) {
+        const { projectPath } = await this.resolveEnv(sessionId);
+        return this.variantHistory.store.putBase({
+            projectPath,
+            sessionId: `${sessionId}-artifacts`,
+            baseDir: projectPath,
+        });
+    }
+    async createArtifactDiff(args) {
+        const base = await this.prepareArtifactBase(args.sessionId);
+        const env = await this.resolveEnv(args.sessionId);
+        const entryPath = env.framework === 'static' ? env.entryPath : 'index.html';
+        const entryFile = path_1.default.resolve(args.sourceDir, entryPath);
+        if (!isStrictlyInside(entryFile, args.sourceDir)) {
+            throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'Artifact entry must be inside its project directory.');
+        }
+        const isEntryMapped = entryFile !== path_1.default.join(args.sourceDir, 'index.html');
+        if (isEntryMapped) {
+            fs_1.default.mkdirSync(path_1.default.dirname(entryFile), { recursive: true });
+            fs_1.default.copyFileSync(path_1.default.join(args.sourceDir, 'index.html'), entryFile);
+        }
+        const store = this.variantHistory.store;
+        const tree = await store.putTree({
+            projectPath: args.projectPath,
+            sourceDir: args.sourceDir,
+            ref: store.variantRef(args.sessionId, args.workItemId),
+            message: 'rivet artifact',
+        });
+        const gitRoot = (await this.worktrees.getGitRoot?.()) ?? args.projectPath;
+        const relative = path_1.default.relative(gitRoot, args.projectPath);
+        if (relative === '..' ||
+            relative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(relative)) {
+            throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'Artifact project must be inside its Git root.');
+        }
+        const files = fs_1.default
+            .readdirSync(args.sourceDir, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => path_1.default
+            .relative(args.sourceDir, path_1.default.join(entry.parentPath, entry.name))
+            .split(path_1.default.sep)
+            .join('/'))
+            .filter((file) => !isEntryMapped || file !== 'index.html');
+        return store.diffFiles({
+            projectPath: args.projectPath,
+            fromRef: base.commitSha,
+            toRef: tree.commitSha,
+            files,
+            pathPrefix: relative ? `${relative.split(path_1.default.sep).join('/')}/` : '',
+        });
+    }
+    async persistCompletedArtifactVariant(args) {
         const projectContext = this.store.getProjectContext(args.sessionId);
-        if (projectContext.kind !== 'fresh')
-            return;
-        const historyProjectPath = projectContext.workspacePath;
+        const historyProjectPath = projectContext.kind === 'fresh'
+            ? projectContext.workspacePath
+            : (await this.resolveEnv(args.sessionId)).projectPath;
+        const contextRoots = projectContext.kind === 'fresh'
+            ? [projectContext.workspacePath, projectContext.workspaceRoot]
+            : [historyProjectPath];
         const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
         const sessionPrompt = this.store.getPrompt(args.sessionId);
         const designArtifact = resolveDesignArtifact(input.designContextEntry);
@@ -3713,14 +3852,16 @@ class AgentVariantsOrchestrator {
                 stagedHtml = fs_1.default.readFileSync(path_1.default.join(staticPreview.assetBase, 'index.html'), 'utf8');
             }
             catch (err) {
-                log.warn(`persistCompletedFreshVariant: could not read index.html for ${args.workItemId}`, err);
+                log.warn(`persistCompletedArtifactVariant: could not read index.html for ${args.workItemId}`, err);
             }
             fs_1.default.writeFileSync(path_1.default.join(tmpStagingDir, 'index.html'), stagedHtml, 'utf8');
-            fs_1.default.writeFileSync(path_1.default.join(tmpStagingDir, 'brief.md'), `# ${input.briefLabel}\n\n${input.briefBody}\n`, 'utf8');
+            if (projectContext.kind === 'fresh') {
+                fs_1.default.writeFileSync(path_1.default.join(tmpStagingDir, 'brief.md'), `# ${input.briefLabel}\n\n${input.briefBody}\n`, 'utf8');
+            }
             sourceDir = tmpStagingDir;
         }
         if (!sourceDir) {
-            log.warn(`persistCompletedFreshVariant: no source for ${args.workItemId} (session ${args.sessionId}); skipping`);
+            log.warn(`persistCompletedArtifactVariant: no source for ${args.workItemId} (session ${args.sessionId}); skipping`);
             return;
         }
         const changedFilesCount = staticPreview ? 1 : countWorktreeFiles(sourceDir);
@@ -3759,6 +3900,14 @@ class AgentVariantsOrchestrator {
                     },
                 };
         try {
+            const diff = projectContext.kind === 'existing'
+                ? await this.createArtifactDiff({
+                    sessionId: args.sessionId,
+                    workItemId: args.workItemId,
+                    sourceDir,
+                    projectPath: historyProjectPath,
+                })
+                : undefined;
             await this.variantHistory.persistVariant({
                 projectPath: historyProjectPath,
                 sessionId: args.sessionId,
@@ -3768,20 +3917,18 @@ class AgentVariantsOrchestrator {
                 brief: input.briefBody,
                 references: input.references,
                 referenceContext: input.context,
-                referenceContextRoots: [
-                    projectContext.workspacePath,
-                    projectContext.workspaceRoot,
-                ]
+                referenceContextRoots: contextRoots
                     .filter((projectPath) => Boolean(projectPath))
                     .map((projectPath) => path_1.default.join(this.variantHistory.store.storage.resolve(projectPath)
                     .dataDirectory, 'variant-context')),
                 sessionPrompt,
                 runLabel: input.runLabel ?? this.store.getRunLabel(args.sessionId),
-                kind: 'project-created',
+                kind: projectContext.kind === 'fresh' ? 'project-created' : 'diff',
+                ...(diff !== undefined ? { diff } : {}),
                 sourceDir,
                 preview,
-                changedFilesCount,
-                projectKind: 'fresh',
+                changedFilesCount: diff === undefined ? changedFilesCount : countDiffFiles(diff),
+                projectKind: projectContext.kind,
                 designMarkdown: designArtifact?.markdown,
                 designSource: designArtifact?.source,
                 snapshotDir: sourceDir,
@@ -3814,7 +3961,7 @@ class AgentVariantsOrchestrator {
             .filter((variant) => variant.status === 'succeeded');
         for (const variant of variants) {
             try {
-                await this.persistCompletedFreshVariant({
+                await this.persistCompletedArtifactVariant({
                     sessionId,
                     workItemId: variant.workItemId,
                 });
@@ -3834,10 +3981,17 @@ class AgentVariantsOrchestrator {
             const status = isChosen
                 ? 'committed'
                 : 'rejected';
+            const saved = isChosen
+                ? await this.getSavedVariant({
+                    projectPath: args.projectPath,
+                    sessionId: args.sessionId,
+                    variantId: workItemId,
+                })
+                : null;
             await this.variantHistory.markStatus({
                 projectPath: args.projectPath,
-                sessionId: args.sessionId,
-                variantId: workItemId,
+                sessionId: saved?.manifest.sessionId ?? args.sessionId,
+                variantId: saved?.manifest.variantId ?? workItemId,
                 status,
                 destinationPath: isChosen ? args.destinationPath : undefined,
                 runnablePath: args.runnablePaths?.get(workItemId),