@markusylisiurunen/tau 0.3.60 → 0.3.62

package/dist/diff_tool/http_server.js

@@ -2,10 +2,12 @@ import { existsSync, readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { extname, join, normalize, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { buildDiffReviewBootstrapPrompt, buildDiffReviewBriefPrompt, buildDiffReviewCommentThreadPrompt, } from "./review_prompts.js";
+import { buildDiffReviewBootstrapPrompt, buildDiffReviewCommentThreadPrompt, buildDiffReviewGuideOperationsPrompt, buildDiffReviewGuidePrompt, parseDiffReviewGuideOperationsResponse, parseDiffReviewGuideResponse, } from "./review_prompts.js";
 import { DiffToolReviewStateStore } from "./review_state.js";
-import { DIFF_TOOL_CODE_THEMES } from "./shared_types.js";
+import { createDiffReviewScopeFingerprint, createDiffToolPersistedReviewStateDocument, parseDiffToolPersistedReviewStateDocument, } from "./review_state_persistence.js";
+import { DIFF_TOOL_CODE_THEMES, DIFF_TOOL_GUIDE_QUESTION_LIMIT, DIFF_TOOL_GUIDE_TOPIC_LIMIT, } from "./shared_types.js";
 const JSON_BODY_LIMIT_BYTES = 1024 * 1024;
+const DIFF_REVIEW_FORK_REASONING = "medium";
 const CONTENT_TYPE_BY_EXT = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
@@ -27,9 +29,17 @@ export class DiffToolHttpServer {
     removeSessionCloseListener;
     staticDir;
     reviewState;
+    storage;
+    onSubmit;
     context;
     files = [];
+    persistence;
+    stateMutationQueue = Promise.resolve();
+    submissionState = "active";
     bootstrapThreadPromise;
+    guideGenerationPromise;
+    guideOperationQueue = [];
+    guideOperationRunning = false;
     httpServerClosePromise;
     sessionClosing = false;
     server = createServer((request, response) => {
@@ -51,6 +61,8 @@ export class DiffToolHttpServer {
         });
         this.host = options.host ?? "127.0.0.1";
         this.port = options.port ?? 0;
+        this.storage = options.storage;
+        this.onSubmit = options.onSubmit;
         this.staticDir = resolveStaticDir();
         this.removeClientCloseListener = this.client.onClose(() => {
             if (this.closed) {
@@ -68,14 +80,27 @@ export class DiffToolHttpServer {
             await this.client.connect();
             this.context = await this.client.getContext();
             this.files = (await this.client.listFiles()).files;
+            if (this.storage) {
+                const diff = await this.client.getDiff();
+                const persistence = {
+                    storage: this.storage,
+                    scopeFingerprint: createDiffReviewScopeFingerprint(this.context, this.files, diff.patch),
+                };
+                await this.restoreReviewState(persistence);
+                this.persistence = persistence;
+            }
+            if (this.closed || this.sessionClosing) {
+                throw new Error("diff tool session closed during startup");
+            }
             await this.listen();
             const address = this.server.address();
             if (!address || typeof address === "string") {
                 throw new Error("failed to start diff tool http server");
             }
-            const url = `http://${this.host}:${String(address.port)}`;
+            const url = `http://${formatHttpUrlHost(this.host)}:${String(address.port)}/`;
             await this.client.setUiText({ text: url });
             void this.startBootstrapThread().catch(() => { });
+            void this.startGuideGeneration().catch(() => { });
             return {
                 url,
             };
@@ -118,6 +143,35 @@ export class DiffToolHttpServer {
             await this.close();
         }
     }
+    async restoreReviewState(persistence) {
+        const document = await persistence.storage.load();
+        if (document !== undefined) {
+            this.reviewState.replaceState(parseDiffToolPersistedReviewStateDocument(document, persistence.scopeFingerprint));
+            return;
+        }
+        await this.persistReviewState(this.reviewState.getState(), persistence);
+    }
+    async persistReviewState(state, persistence = this.persistence) {
+        if (!persistence)
+            return;
+        await persistence.storage.save(createDiffToolPersistedReviewStateDocument(persistence.scopeFingerprint, state));
+    }
+    async mutateReviewState(mutation, isApplied = () => true) {
+        const operation = this.stateMutationQueue.then(async () => {
+            const previousState = this.reviewState.getState();
+            const draft = this.reviewState.clone();
+            const result = mutation(draft);
+            if (!isApplied(result)) {
+                return { result, state: previousState };
+            }
+            const nextState = draft.getState();
+            await this.persistReviewState(nextState);
+            this.reviewState.replaceStatePreservingConcurrentLoading(nextState, previousState);
+            return { result, state: this.reviewState.getState() };
+        });
+        this.stateMutationQueue = operation.then(() => undefined, () => undefined);
+        return await operation;
+    }
     async listen() {
         await new Promise((resolve, reject) => {
             const onError = (error) => {
@@ -126,6 +180,10 @@ export class DiffToolHttpServer {
             };
             const onListening = () => {
                 this.server.off("error", onError);
+                if (this.closed || this.sessionClosing) {
+                    void this.closeHttpServer().then(() => reject(new Error("diff tool session closed during startup")), reject);
+                    return;
+                }
                 resolve();
             };
             this.server.once("error", onError);
@@ -186,6 +244,107 @@ export class DiffToolHttpServer {
     async getBootstrapThreadId() {
         return await this.startBootstrapThread();
     }
+    startGuideGeneration() {
+        if (this.guideGenerationPromise) {
+            return this.guideGenerationPromise;
+        }
+        const currentState = this.reviewState.getState();
+        if (currentState.guide.orientation.trim()) {
+            return Promise.resolve(currentState);
+        }
+        if (this.closed) {
+            return Promise.reject(new Error("diff tool http server is closed"));
+        }
+        this.reviewState.setGuideLoading(true);
+        const promise = this.generateGuide()
+            .catch((error) => {
+            this.reviewState.setGuideLoading(false);
+            throw error;
+        })
+            .finally(() => {
+            if (this.guideGenerationPromise === promise) {
+                this.guideGenerationPromise = undefined;
+            }
+        });
+        this.guideGenerationPromise = promise;
+        void promise.catch(() => { });
+        return promise;
+    }
+    async generateGuide() {
+        const result = await this.client.submitThreadMessage({
+            forkFromThreadId: await this.getBootstrapThreadId(),
+            message: buildDiffReviewGuidePrompt(),
+            reasoning: DIFF_REVIEW_FORK_REASONING,
+        });
+        const guide = parseDiffReviewGuideResponse(result.response);
+        const { state } = await this.mutateReviewState((draft) => draft.applyGuideResult(result, guide));
+        return state;
+    }
+    enqueueGuideOperation(operation) {
+        this.reviewState.setGuideLoading(true);
+        const queued = new Promise((resolve, reject) => {
+            this.guideOperationQueue.push({ operation, resolve, reject });
+        });
+        void this.drainGuideOperationQueue();
+        return queued;
+    }
+    async drainGuideOperationQueue() {
+        if (this.guideOperationRunning) {
+            return;
+        }
+        this.guideOperationRunning = true;
+        try {
+            if (this.guideGenerationPromise) {
+                await this.guideGenerationPromise;
+            }
+            while (this.guideOperationQueue.length > 0) {
+                const queued = this.guideOperationQueue.splice(0);
+                try {
+                    const result = await this.runGuideOperations(queued.map((entry) => entry.operation));
+                    for (const entry of queued) {
+                        entry.resolve(result);
+                    }
+                }
+                catch (error) {
+                    this.reviewState.setGuideLoading(false);
+                    for (const entry of queued) {
+                        entry.reject(error);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.reviewState.setGuideLoading(false);
+            for (const entry of this.guideOperationQueue.splice(0)) {
+                entry.reject(error);
+            }
+        }
+        finally {
+            this.guideOperationRunning = false;
+            if (this.guideOperationQueue.length > 0) {
+                void this.drainGuideOperationQueue();
+            }
+        }
+    }
+    async runGuideOperations(operations) {
+        const currentGuide = this.reviewState.getState().guide;
+        this.reviewState.setGuideLoading(true);
+        const message = buildDiffReviewGuideOperationsPrompt(operations, currentGuide);
+        const result = await this.client.submitThreadMessage(currentGuide.threadId
+            ? { threadId: currentGuide.threadId, message }
+            : {
+                forkFromThreadId: await this.getBootstrapThreadId(),
+                message,
+                reasoning: DIFF_REVIEW_FORK_REASONING,
+            });
+        const contents = parseDiffReviewGuideOperationsResponse(operations, result.response);
+        const { result: applied, state } = await this.mutateReviewState((draft) => draft.applyGuideOperationResults(result, operations, contents), (value) => value);
+        if (!applied) {
+            this.reviewState.setGuideLoading(false);
+            return { applied, state: this.reviewState.getState() };
+        }
+        return { applied, state };
+    }
     async handleRequest(request, response) {
         const method = request.method ?? "GET";
         const requestUrl = new URL(request.url ?? "/", `http://${request.headers.host ?? this.host}`);
@@ -213,8 +372,8 @@ export class DiffToolHttpServer {
         }
         if (method === "POST" && requestUrl.pathname === "/api/state") {
             const payload = parseStatePatch(await this.readJsonBody(request));
-            this.reviewState.updateState(payload);
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            const { state } = await this.mutateReviewState((draft) => draft.updateState(payload));
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread") {
@@ -223,9 +382,9 @@ export class DiffToolHttpServer {
                 this.sendJson(response, 400, { error: "invalid thread payload" });
                 return;
             }
-            const threadId = this.reviewState.createThread(payload);
+            const { result: threadId, state } = await this.mutateReviewState((draft) => draft.createThread(payload));
             this.sendJson(response, 200, {
-                state: this.reviewState.getState(),
+                state,
                 threadId,
             });
             return;
@@ -234,27 +393,27 @@ export class DiffToolHttpServer {
             const payload = await this.readJsonBody(request);
             const id = typeof payload.id === "string" ? payload.id.trim() : "";
             const text = typeof payload.text === "string" ? payload.text.trim() : "";
-            if (!this.reviewState.findThread(id)) {
-                this.sendJson(response, 404, { error: "thread not found" });
-                return;
-            }
             if (!text) {
                 this.sendJson(response, 400, { error: "reply text is required" });
                 return;
             }
-            this.reviewState.addReply(id, text);
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            const { result: added, state } = await this.mutateReviewState((draft) => draft.addReply(id, text), (result) => result);
+            if (!added) {
+                this.sendJson(response, 404, { error: "thread not found" });
+                return;
+            }
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread/delete") {
             const payload = await this.readJsonBody(request);
             const id = typeof payload.id === "string" ? payload.id.trim() : "";
-            const removed = this.reviewState.deleteThread(id);
+            const { result: removed, state } = await this.mutateReviewState((draft) => draft.deleteThread(id), (result) => result);
             if (!removed) {
                 this.sendJson(response, 404, { error: "thread not found" });
                 return;
             }
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread-message/delete") {
@@ -263,46 +422,54 @@ export class DiffToolHttpServer {
             const messageIndex = typeof payload.messageIndex === "number" && Number.isInteger(payload.messageIndex)
                 ? payload.messageIndex
                 : -1;
-            if (!this.reviewState.findThread(id)) {
+            const { result, state } = await this.mutateReviewState((draft) => {
+                if (!draft.findThread(id))
+                    return "thread-not-found";
+                return draft.deleteThreadMessage(id, messageIndex)
+                    ? "removed"
+                    : "message-not-found";
+            }, (result) => result === "removed");
+            if (result === "thread-not-found") {
                 this.sendJson(response, 404, { error: "thread not found" });
                 return;
             }
-            const removed = this.reviewState.deleteThreadMessage(id, messageIndex);
-            if (!removed) {
+            if (result === "message-not-found") {
                 this.sendJson(response, 400, { error: "message not found" });
                 return;
             }
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread/resolve") {
             const payload = await this.readJsonBody(request);
             const id = typeof payload.id === "string" ? payload.id.trim() : "";
-            if (!this.reviewState.findThread(id)) {
-                this.sendJson(response, 404, { error: "thread not found" });
-                return;
-            }
             if (typeof payload.resolved !== "boolean") {
                 this.sendJson(response, 400, { error: "resolved flag is required" });
                 return;
             }
-            this.reviewState.setThreadResolved(id, payload.resolved);
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            const resolved = payload.resolved;
+            const { result: updated, state } = await this.mutateReviewState((draft) => draft.setThreadResolved(id, resolved), (result) => result);
+            if (!updated) {
+                this.sendJson(response, 404, { error: "thread not found" });
+                return;
+            }
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread/collapse") {
             const payload = await this.readJsonBody(request);
             const id = typeof payload.id === "string" ? payload.id.trim() : "";
-            if (!this.reviewState.findThread(id)) {
-                this.sendJson(response, 404, { error: "thread not found" });
-                return;
-            }
             if (typeof payload.collapsed !== "boolean") {
                 this.sendJson(response, 400, { error: "collapsed flag is required" });
                 return;
             }
-            this.reviewState.setThreadCollapsed(id, payload.collapsed);
-            this.sendJson(response, 200, { state: this.reviewState.getState() });
+            const collapsed = payload.collapsed;
+            const { result: updated, state } = await this.mutateReviewState((draft) => draft.setThreadCollapsed(id, collapsed), (result) => result);
+            if (!updated) {
+                this.sendJson(response, 404, { error: "thread not found" });
+                return;
+            }
+            this.sendJson(response, 200, { state });
             return;
         }
         if (method === "POST" && requestUrl.pathname === "/api/thread-message") {
@@ -313,21 +480,35 @@ export class DiffToolHttpServer {
                 this.sendJson(response, 404, { error: "thread not found" });
                 return;
             }
+            if (thread.loading) {
+                this.sendJson(response, 409, { error: "thread message already in progress" });
+                return;
+            }
             const message = this.reviewState.buildThreadAgentMessage(id);
             if (!message) {
                 this.sendJson(response, 400, { error: "thread has no pending user message" });
                 return;
             }
+            const guideSnapshot = !thread.threadId &&
+                thread.anchor.kind === "detached" &&
+                !thread.messages.some((entry) => entry.role === "assistant")
+                ? this.reviewState.getState().guide
+                : undefined;
             this.reviewState.setThreadLoading(id, true);
             try {
                 const result = await this.client.submitThreadMessage(thread.threadId
                     ? { threadId: thread.threadId, message }
                     : {
                         forkFromThreadId: await this.getBootstrapThreadId(),
-                        message: buildDiffReviewCommentThreadPrompt(message),
+                        message: buildDiffReviewCommentThreadPrompt(message, guideSnapshot),
+                        reasoning: DIFF_REVIEW_FORK_REASONING,
                     });
-                this.reviewState.applyThreadResponse(id, result);
-                this.sendJson(response, 200, { state: this.reviewState.getState() });
+                const { result: applied, state } = await this.mutateReviewState((draft) => draft.applyThreadResponse(id, result), (result) => result);
+                if (!applied) {
+                    this.sendJson(response, 404, { error: "thread not found" });
+                    return;
+                }
+                this.sendJson(response, 200, { state });
             }
             catch (error) {
                 this.reviewState.setThreadLoading(id, false);
@@ -335,32 +516,83 @@ export class DiffToolHttpServer {
             }
             return;
         }
-        if (method === "POST" && requestUrl.pathname === "/api/brief/generate") {
+        if (method === "POST" && requestUrl.pathname === "/api/guide/generate") {
+            const state = await this.startGuideGeneration();
+            this.sendJson(response, 200, { state });
+            return;
+        }
+        if (method === "POST" && requestUrl.pathname === "/api/guide/operate") {
+            const operation = parseGuideOperation(await this.readJsonBody(request));
+            if (!operation) {
+                this.sendJson(response, 400, { error: "invalid guide operation" });
+                return;
+            }
             const currentState = this.reviewState.getState();
-            if (currentState.brief.loading) {
-                this.sendJson(response, 409, { error: "brief generation already in progress" });
+            if (operation.kind === "topic.add" &&
+                currentState.guide.topics.length >= DIFF_TOOL_GUIDE_TOPIC_LIMIT) {
+                this.sendJson(response, 409, { error: "guide topic limit reached" });
+                return;
+            }
+            if (operation.kind === "question.ask" &&
+                currentState.guide.questions.length >= DIFF_TOOL_GUIDE_QUESTION_LIMIT) {
+                this.sendJson(response, 409, { error: "guide question limit reached" });
+                return;
+            }
+            if (operation.kind === "topic.revise" &&
+                !currentState.guide.topics.some((topic) => topic.id === operation.topicId)) {
+                this.sendJson(response, 404, { error: "guide topic not found" });
+                return;
+            }
+            const { applied, state } = await this.enqueueGuideOperation(operation);
+            if (!applied) {
+                this.sendJson(response, 409, { error: "guide changed while it was being updated" });
+                return;
+            }
+            this.sendJson(response, 200, { state });
+            return;
+        }
+        if (method === "POST" && requestUrl.pathname === "/api/guide/comment") {
+            const payload = parseGuideCommentPayload(await this.readJsonBody(request));
+            if (!payload) {
+                this.sendJson(response, 400, { error: "invalid guide comment" });
                 return;
             }
-            this.reviewState.startBriefGeneration();
+            const currentState = this.reviewState.getState();
+            if (!guideCommentTargetExists(currentState, payload.target)) {
+                this.sendJson(response, 404, { error: "guide comment target not found" });
+                return;
+            }
+            const { state } = await this.mutateReviewState((draft) => draft.saveGuideComment(payload.target, payload.body));
+            this.sendJson(response, 200, { state });
+            return;
+        }
+        if (method === "POST" && requestUrl.pathname === "/api/review") {
+            await this.readJsonBody(request);
+            await this.stateMutationQueue;
+            if (this.submissionState !== "active") {
+                this.sendJson(response, 409, { error: "diff review has already been submitted" });
+                return;
+            }
+            this.submissionState = "submitting";
+            const review = this.reviewState.buildReviewText();
+            const context = this.context;
+            if (!context) {
+                this.submissionState = "active";
+                throw new Error("diff tool session context is unavailable");
+            }
             try {
-                const result = await this.client.submitThreadMessage({
-                    forkFromThreadId: await this.getBootstrapThreadId(),
-                    message: buildDiffReviewBriefPrompt(),
+                await this.onSubmit?.({
+                    review,
+                    context: { ...context, diffArgs: [...context.diffArgs] },
+                    files: this.files.map((file) => ({ ...file })),
                 });
-                this.reviewState.applyBriefResult(result);
-                this.sendJson(response, 200, { state: this.reviewState.getState() });
             }
             catch (error) {
-                this.reviewState.setBriefLoading(false);
+                this.submissionState = "active";
                 throw error;
             }
-            return;
-        }
-        if (method === "POST" && requestUrl.pathname === "/api/review") {
-            const payload = parseReviewPayload(await this.readJsonBody(request));
-            const result = await this.client.returnReview({
-                review: this.reviewState.buildReviewText(payload.message),
-            });
+            this.submissionState = "submitted";
+            const result = await this.client.returnReview({ review });
             this.sendJson(response, 200, result);
             return;
         }
@@ -445,10 +677,58 @@ export class DiffToolHttpServer {
         response.end(JSON.stringify(payload));
     }
 }
-function parseReviewPayload(payload) {
-    return typeof payload.message === "string" && payload.message.trim()
-        ? { message: payload.message }
-        : {};
+function formatHttpUrlHost(host) {
+    return host.includes(":") ? `[${host}]` : host;
+}
+function parseGuideOperation(payload) {
+    switch (payload.kind) {
+        case "topic.add": {
+            const request = typeof payload.request === "string" ? payload.request.trim() : "";
+            return request ? { kind: payload.kind, request } : undefined;
+        }
+        case "topic.revise": {
+            const topicId = typeof payload.topicId === "string" ? payload.topicId.trim() : "";
+            const request = typeof payload.request === "string" ? payload.request.trim() : "";
+            return topicId && request ? { kind: payload.kind, topicId, request } : undefined;
+        }
+        case "question.ask": {
+            const question = typeof payload.question === "string" ? payload.question.trim() : "";
+            return question ? { kind: payload.kind, question } : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function parseGuideCommentPayload(payload) {
+    const body = typeof payload.body === "string" ? payload.body.trim() : "";
+    const target = payload.target && typeof payload.target === "object" && !Array.isArray(payload.target)
+        ? payload.target
+        : undefined;
+    if (!body || !target) {
+        return undefined;
+    }
+    if (target.kind === "orientation") {
+        return { body, target: { kind: "orientation" } };
+    }
+    if (target.kind === "topic" && typeof target.topicId === "string" && target.topicId.trim()) {
+        return { body, target: { kind: "topic", topicId: target.topicId.trim() } };
+    }
+    if (target.kind === "question" &&
+        typeof target.questionId === "string" &&
+        target.questionId.trim()) {
+        return { body, target: { kind: "question", questionId: target.questionId.trim() } };
+    }
+    return undefined;
+}
+function guideCommentTargetExists(state, target) {
+    switch (target.kind) {
+        case "orientation":
+            return Boolean(state.guide.orientation);
+        case "topic":
+            return state.guide.topics.some((topic) => topic.id === target.topicId);
+        case "question":
+            return state.guide.questions.some((question) => question.id === target.questionId);
+    }
 }
 const codeThemes = new Set(DIFF_TOOL_CODE_THEMES);
 function parseStatePatch(payload) {
@@ -463,7 +743,6 @@ function parseStatePatch(payload) {
             codeThemes.has(payload.codeTheme)
             ? { codeTheme: payload.codeTheme }
             : {}),
-        ...(typeof payload.sidebarOpen === "boolean" ? { sidebarOpen: payload.sidebarOpen } : {}),
         ...(Array.isArray(payload.collapsedFileIds)
             ? {
                 collapsedFileIds: payload.collapsedFileIds.flatMap((value) => typeof value === "string" && value.trim() ? [value] : []),