querysub 0.680.0 → 0.682.0

package/src/diagnostics/logs/errorTickets/tickets.ts

@@ -9,7 +9,7 @@ import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
 import { assertIsManagementUser } from "../../managementPages";
 import { getSyncedController } from "../../../library-components/SyncedController";
 import { AutoFixerControllerBase } from "./autoFixerController";
-import { Ticket, TicketComment, TicketPatchStatus, TicketState } from "./ticketTypes";
+import { AutoFixerRunStatus, Ticket, TicketComment, TicketPatchStatus, TicketState } from "./ticketTypes";
 
 const TICKET_CACHE_POLL_INTERVAL = timeInMinute * 5;
 
@@ -107,27 +107,30 @@ class TicketService {
         });
     }
 
-    public async setPatchStatus(id: string, commentId: string, status: TicketPatchStatus): Promise<void> {
+    // One ticket write for the whole batch, so a hot reload mid-apply can't leave half the statuses recorded.
+    public async setPatchStatuses(id: string, commentIds: string[], status: TicketPatchStatus): Promise<void> {
         await mutateTicket(id, ticket => {
-            let comment = ticket.comments.find(c => c.id === commentId);
-            if (!comment) {
-                throw new Error(`Comment ${commentId} not found in ticket ${id}`);
-            }
-            if (comment.kind !== "patch") {
-                throw new Error(`Comment ${commentId} is not a patch comment`);
+            for (let commentId of commentIds) {
+                let comment = ticket.comments.find(c => c.id === commentId);
+                if (!comment) {
+                    throw new Error(`Comment ${commentId} not found in ticket ${id}`);
+                }
+                if (comment.kind !== "patch") {
+                    throw new Error(`Comment ${commentId} is not a patch comment`);
+                }
+                comment.patchStatus = status;
+                comment.patchStatusTime = Date.now();
             }
-            comment.patchStatus = status;
-            comment.patchStatusTime = Date.now();
         });
     }
 
-    // Routes to a registered autofixer node, which does the filesystem work. On success we record the applied status.
-    public async applyPatch(id: string, commentId: string): Promise<void> {
+    // Routes to a registered autofixer node, which validates the whole batch, records the applied statuses (via setPatchStatuses), and writes every file — in that order, so its own hot reload happens after everything else is durable.
+    public async applyPatches(id: string, commentIds: string[]): Promise<void> {
         let errors: string[] = [];
         let applied = false;
         for (let nodeId of Array.from(TicketService.autoFixerNodes)) {
             try {
-                await AutoFixerControllerBase.nodes[nodeId].applyPatch(id, commentId);
+                await AutoFixerControllerBase.nodes[nodeId].applyPatches(id, commentIds);
                 applied = true;
                 break;
             } catch (e) {
@@ -136,11 +139,10 @@ class TicketService {
         }
         if (!applied) {
             if (TicketService.autoFixerNodes.size === 0) {
-                throw new Error(`No autofixer is connected, so the patch cannot be applied. Run \`yarn autofix\` in the repository the patch targets.`);
+                throw new Error(`No autofixer is connected, so patches cannot be applied. Run \`yarn autofix\` in the repository the patches target, or trigger an AI run from the ticket page to register this server.`);
             }
-            throw new Error(`Failed to apply patch on all connected autofixer nodes:\n${errors.join("\n")}`);
+            throw new Error(`Failed to apply patches on all connected autofixer nodes:\n${errors.join("\n")}`);
         }
-        await this.setPatchStatus(id, commentId, "applied");
     }
 
     private static autoFixerNodes = new Set<string>();
@@ -190,8 +192,8 @@ export const TicketServiceBase = SocketFunction.register(
         addComment: {},
         updateCommentText: {},
         deleteComment: {},
-        setPatchStatus: {},
-        applyPatch: {},
+        setPatchStatuses: {},
+        applyPatches: {},
         registerAutoFixerSERVICE: {},
         watchTicketsSERVICE: {},
     }),
@@ -244,12 +246,32 @@ class TicketData {
         await TicketServiceBase.nodes[await getTicketServiceNode()].deleteComment(id, commentId);
     }
 
-    public async setPatchStatus(id: string, commentId: string, status: TicketPatchStatus): Promise<void> {
-        await TicketServiceBase.nodes[await getTicketServiceNode()].setPatchStatus(id, commentId, status);
+    public async setPatchStatuses(id: string, commentIds: string[], status: TicketPatchStatus): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].setPatchStatuses(id, commentIds, status);
+    }
+
+    // Patches touch source code, which lives on THIS node (the server the browser is connected to) — never on the ticket service node, which manages tickets, not source. The import is dynamic for the same reason as the AI methods below: this file is loaded in the browser, and autoFixer pulls in node-only modules.
+    public async applyPatches(id: string, commentIds: string[]): Promise<void> {
+        let { applyPatches } = await import("./autoFixer");
+        await applyPatches(id, commentIds);
+    }
+
+    // The AI investigation methods deliberately run on THIS node (the server the browser is connected to), not the ticket service node — in debug mode that is the local dev server, which has the repos checked out and can spawn claude. The autofixer module is imported dynamically because it pulls in node-only modules, and this file is also loaded in the browser.
+    public async startAIInvestigation(ticketId: string, model?: string): Promise<void> {
+        let { startTicketInvestigation } = await import("./autoFixer");
+        await startTicketInvestigation(ticketId, model);
+    }
+
+    public async stopAIInvestigation(ticketId: string): Promise<void> {
+        let { requestStopTicketInvestigation } = await import("./autoFixer");
+        requestStopTicketInvestigation(ticketId);
     }
 
-    public async applyPatch(id: string, commentId: string): Promise<void> {
-        await TicketServiceBase.nodes[await getTicketServiceNode()].applyPatch(id, commentId);
+    public async getAIStatus(): Promise<AutoFixerRunStatus> {
+        let { getAutoFixerRunStatus, ensureDefaultModelProbed } = await import("./autoFixer");
+        // The probe is async and slow the first time — kick it off and let a later status poll pick up the resolved default.
+        ensureDefaultModelProbed();
+        return getAutoFixerRunStatus();
     }
 
     // Live updates: browser → this HTTP node → ticket service node, with change notifications flowing back down the same two hops.
@@ -312,8 +334,11 @@ export const TicketDataBase = SocketFunction.register(
         addComment: {},
         updateCommentText: {},
         deleteComment: {},
-        setPatchStatus: {},
-        applyPatch: {},
+        setPatchStatuses: {},
+        applyPatches: {},
+        startAIInvestigation: {},
+        stopAIInvestigation: {},
+        getAIStatus: {},
         watchTicketsHTTP: {},
         receiveTicketsChangedHTTP: {},
         receiveTicketsChangedBrowser: {},

package/src/diagnostics/statsDefinitions.tsx

@@ -133,7 +133,6 @@ export function getQuerysubStatsSync(): StatDefinition[] {
     let state = callState();
 
     let perFn = state.perFunctionStats;
-    let avgFn = (s: { count: number; sum: number }) => s.count && s.sum / s.count || 0;
 
     let callStatDefs: StatDefinition[] = [
         makeCallStatSync({
@@ -142,38 +141,28 @@ export function getQuerysubStatsSync(): StatDefinition[] {
             getFnValue: fn => fn.totalCalls,
         }),
         makeCallStatSync({
-            perFn, category: "Calls", title: "Rejected reruns", emoji: "⚠️",
+            perFn, category: "Calls", title: "Max rejected reruns (one call)", emoji: "⚠️",
             threshold: 10,
-            getFnValue: fn => fn.totalFullReruns,
+            getFnValue: fn => fn.maxFullReruns,
         }),
         makeCallStatSync({
-            perFn, category: "Calls", title: "Rerun to sync data", emoji: "♻️",
+            perFn, category: "Calls", title: "Max reruns to sync data (one call)", emoji: "♻️",
             threshold: 10,
-            getFnValue: fn => fn.totalInternalReruns,
-        }),
-        makeCallStatSync({
-            perFn, category: "Calls", title: "Calls with multiple resyncs", emoji: "🔦",
-            threshold: 10,
-            getFnValue: fn => fn.callsWithMultipleInternalRuns,
-        }),
-        makeCallStatSync({
-            perFn, category: "Calls", title: "Calls with multiple rejections", emoji: "📈",
-            threshold: 10,
-            getFnValue: fn => fn.callsWithCascadingRuns,
+            getFnValue: fn => fn.maxInternalReruns,
         }),
     ];
 
     let timingStatDefs: StatDefinition[] = [
         makeCallStatSync({
-            perFn, category: "Timing", title: "Average evaluation time", emoji: "💫",
+            perFn, category: "Timing", title: "Max evaluation time (one call)", emoji: "💫",
             threshold: 100,
-            getFnValue: fn => avgFn(fn.evalTimeStats),
+            getFnValue: fn => fn.maxEvalTime,
             formatValue: formatTime,
         }),
         makeCallStatSync({
-            perFn, category: "Timing", title: "Average full time (sync, etc)", emoji: "🕒",
+            perFn, category: "Timing", title: "Max full time (sync, etc, one call)", emoji: "🕒",
             threshold: 1000,
-            getFnValue: fn => avgFn(fn.totalTimeStats),
+            getFnValue: fn => fn.maxTotalTime,
             formatValue: formatTime,
         }),
     ];

package/src/library-components/URLParam.ts

@@ -11,6 +11,7 @@ import { logErrors } from "../errors";
 import { canHaveChildren } from "socket-function/src/types";
 import { URLOverride } from "./ATag";
 import { LOCAL_DOMAIN } from "../0-path-value-core/PathRouterConstants";
+import { isValueProxy2 } from "../2-proxy/pathValueProxy";
 
 export interface URLParam<T = unknown> {
     value: T;
@@ -84,7 +85,9 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLPa
     if (config?.storage === "localStorage") {
         localStorageKeys.add(urlKey);
     }
+    let defaultSet = false;
     async function setDefaults() {
+        defaultSet = true;
         let { Querysub } = await import("../4-querysub/Querysub");
         Querysub.localCommit(() => {
             data().defaults[urlKey] = defaultValue;
@@ -93,7 +96,7 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLPa
             }
         });
     }
-    setTimeout(setDefaults);
+    setImmediate(setDefaults);
     function deleteKeys(obj: any) {
         if (!canHaveChildren(obj)) return;
         for (let key in obj) {
@@ -107,18 +110,23 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLPa
         urlKey,
         default: defaultValue,
         get value() {
+            let resultValue: T | undefined = undefined;
             if (!proxyWatcher.inWatcher()) {
                 // NOTE: This makes async functions a bit easier, although... async functions
                 //  are almost never needed.
-                return Querysub.localRead(() => {
+                resultValue = Querysub.localRead(() => {
                     return data().params[urlKey] as T;
                 });
             } else {
                 // Makes the access faster, by skipping schema checks
-                return noAtomicSchema(() => {
+                resultValue = noAtomicSchema(() => {
                     return data().params[urlKey] as T;
                 });
             }
+            if (!defaultSet && (resultValue === undefined || isValueProxy2(resultValue))) {
+                resultValue = defaultValue;
+            }
+            return resultValue;
         },
         set value(value: T) {
             let resetTargets = resetLinks.get(urlKey);